Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
5944 mandeep.dh 1 
#
2 
# Autogenerated by Thrift Compiler (0.7.0)
3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
8 
import shop2020.thriftpy.generic.GenericService
9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
12 
from thrift.protocol import TBinaryProtocol, TProtocol
13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
20 
  def addItem(self, item):
21 
    """
22 
    Availability and inventory attributes
23 
 
24 
    Parameters:
25 
     - item
26 
    """
27 
    pass
28 
 
29 
  def updateItem(self, item):
30 
    """
31 
    Parameters:
32 
     - item
33 
    """
34 
    pass
35 
 
36 
  def isActive(self, itemId):
37 
    """
38 
    Checks if the item given to the corresponding itemId is active. If it's active,
39 
    whether it's risky and if it's risky, its inventory position.
40 
 
41 
    Parameters:
42 
     - itemId
43 
    """
44 
    pass
45 
 
7438 amit.gupta 46 
  def getItemsStatus(self, itemIds):
47 
    """
48 
    Parameters:
49 
     - itemIds
50 
    """
51 
    pass
52 
 
5944 mandeep.dh 53 
  def getItemStatusDescription(self, itemId):
54 
    """
55 
    Parameters:
56 
     - itemId
57 
    """
58 
    pass
59 
 
60 
  def startItemOn(self, item_id, timestamp):
61 
    """
62 
    Parameters:
63 
     - item_id
64 
     - timestamp
65 
    """
66 
    pass
67 
 
68 
  def retireItemOn(self, item_id, timestamp):
69 
    """
70 
    Parameters:
71 
     - item_id
72 
     - timestamp
73 
    """
74 
    pass
75 
 
76 
  def changeItemStatus(self, item_id, timestamp, newstatus):
77 
    """
78 
    Parameters:
79 
     - item_id
80 
     - timestamp
81 
     - newstatus
82 
    """
83 
    pass
84 
 
85 
  def getItem(self, item_id):
86 
    """
87 
    Parameters:
88 
     - item_id
89 
    """
90 
    pass
91 
 
92 
  def getItemsByCatalogId(self, catalog_item_id):
93 
    """
94 
    Parameters:
95 
     - catalog_item_id
96 
    """
97 
    pass
98 
 
99 
  def getValidItemsByCatalogId(self, catalog_item_id):
100 
    """
101 
    Parameters:
102 
     - catalog_item_id
103 
    """
104 
    pass
105 
 
106 
  def getAllItems(self, isActive):
107 
    """
108 
    Parameters:
109 
     - isActive
110 
    """
111 
    pass
112 
 
113 
  def getAllItemsByStatus(self, itemStatus):
114 
    """
115 
    Parameters:
116 
     - itemStatus
117 
    """
118 
    pass
119 
 
9253 rajveer 120 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber, isAndroid):
5944 mandeep.dh 121 
    """
122 
    Parameters:
123 
     - entityId
124 
     - category
125 
     - brand
126 
     - modelName
127 
     - modelNumber
9253 rajveer 128 
     - isAndroid
5944 mandeep.dh 129 
    """
130 
    pass
131 
 
132 
  def getAllItemsInRange(self, offset, limit):
133 
    """
134 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
135 
 
136 
    Parameters:
137 
     - offset
138 
     - limit
139 
    """
140 
    pass
141 
 
142 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
143 
    """
144 
    Gets at most 'limit' items starting at the given offset in the given status. Returns an empty list if there are no more items at the given offset.
145 
 
146 
    Parameters:
147 
     - itemStatus
148 
     - offset
149 
     - limit
150 
    """
151 
    pass
152 
 
153 
  def getItemCountByStatus(self, useStatus, itemStatus):
154 
    """
155 
    Gets a count of all items by status
156 
 
157 
    Parameters:
158 
     - useStatus
159 
     - itemStatus
160 
    """
161 
    pass
162 
 
163 
  def getBestSellers(self, ):
164 
    pass
165 
 
166 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
167 
    """
168 
    Parameters:
169 
     - beginIndex
170 
     - totalItems
171 
     - brand
172 
     - category
173 
    """
174 
    pass
175 
 
176 
  def getBestSellersCount(self, ):
177 
    pass
178 
 
179 
  def getBestDeals(self, ):
180 
    pass
181 
 
182 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
183 
    """
184 
    Parameters:
185 
     - beginIndex
186 
     - totalItems
187 
     - brand
188 
     - category
189 
    """
190 
    pass
191 
 
192 
  def getBestDealsCount(self, ):
193 
    pass
194 
 
195 
  def getComingSoon(self, ):
196 
    pass
197 
 
198 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
199 
    """
200 
    Parameters:
201 
     - beginIndex
202 
     - totalItems
203 
     - brand
204 
     - category
205 
    """
206 
    pass
207 
 
208 
  def getComingSoonCount(self, ):
209 
    pass
210 
 
211 
  def getLatestArrivals(self, ):
212 
    """
213 
    Returns a list of items sorted in the descending order by start date.
214 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
215 
    """
216 
    pass
217 
 
218 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
219 
    """
220 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
221 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
222 
 
223 
    Parameters:
224 
     - beginIndex
225 
     - totalItems
226 
     - brand
227 
     - categories
228 
    """
229 
    pass
230 
 
231 
  def getLatestArrivalsCount(self, ):
232 
    """
233 
    Get the total number of latest arrivals we are willing to show.
234 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
235 
    """
236 
    pass
237 
 
238 
  def generateNewEntityID(self, ):
239 
    pass
240 
 
241 
  def addCategory(self, category):
242 
    """
243 
    All category related functions
244 
 
245 
    Parameters:
246 
     - category
247 
    """
248 
    pass
249 
 
250 
  def getCategory(self, id):
251 
    """
252 
    Parameters:
253 
     - id
254 
    """
255 
    pass
256 
 
257 
  def getAllCategories(self, ):
258 
    pass
259 
 
260 
  def getAllSimilarItems(self, itemId):
261 
    """
262 
    Returns the list of similar items.
263 
 
264 
    Parameters:
265 
     - itemId
266 
    """
267 
    pass
268 
 
269 
  def addSimilarItem(self, itemId, catalogItemId):
270 
    """
271 
    Adds similar item.
272 
 
273 
    Parameters:
274 
     - itemId
275 
     - catalogItemId
276 
    """
277 
    pass
278 
 
6512 kshitij.so 279 
  def addTag(self, displayName, itemId):
280 
    """
281 
    Tag Related
282 
 
283 
    Parameters:
284 
     - displayName
285 
     - itemId
286 
    """
287 
    pass
288 
 
289 
  def deleteEntityTag(self, displayName, itemId):
290 
    """
291 
    Parameters:
292 
     - displayName
293 
     - itemId
294 
    """
295 
    pass
296 
 
297 
  def deleteTag(self, displayName):
298 
    """
299 
    Parameters:
300 
     - displayName
301 
    """
302 
    pass
303 
 
304 
  def getAllTags(self, ):
305 
    pass
306 
 
307 
  def getAllEntitiesByTagName(self, displayName):
308 
    """
309 
    Parameters:
310 
     - displayName
311 
    """
312 
    pass
313 
 
6845 amit.gupta 314 
  def getAllEntityTags(self, ):
315 
    pass
316 
 
8590 kshitij.so 317 
  def addBanner(self, bannerCongregate):
6850 kshitij.so 318 
    """
8579 kshitij.so 319 
    Banner Related
320 
 
6850 kshitij.so 321 
    Parameters:
8590 kshitij.so 322 
     - bannerCongregate
6850 kshitij.so 323 
    """
324 
    pass
325 
 
8579 kshitij.so 326 
  def updateBanner(self, banner):
327 
    """
328 
    Parameters:
329 
     - banner
330 
    """
331 
    pass
332 
 
6850 kshitij.so 333 
  def getAllBanners(self, ):
334 
    pass
335 
 
9155 kshitij.so 336 
  def deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 337 
    """
338 
    Parameters:
339 
     - bannerName
9155 kshitij.so 340 
     - bannerType
6850 kshitij.so 341 
    """
342 
    pass
343 
 
9155 kshitij.so 344 
  def getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 345 
    """
346 
    Parameters:
347 
     - bannerName
9155 kshitij.so 348 
     - bannerType
6850 kshitij.so 349 
    """
350 
    pass
351 
 
352 
  def getActiveBanners(self, ):
353 
    pass
354 
 
8579 kshitij.so 355 
  def addBannerMap(self, bannerMaps):
6849 kshitij.so 356 
    """
357 
    Parameters:
8579 kshitij.so 358 
     - bannerMaps
6849 kshitij.so 359 
    """
360 
    pass
361 
 
8579 kshitij.so 362 
  def updateBannerMap(self, bannerMap):
363 
    """
364 
    Parameters:
365 
     - bannerMap
366 
    """
367 
    pass
368 
 
6849 kshitij.so 369 
  def deleteBannerMap(self, bannerName):
370 
    """
371 
    Parameters:
372 
     - bannerName
373 
    """
374 
    pass
375 
 
9155 kshitij.so 376 
  def getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 377 
    """
378 
    Parameters:
379 
     - bannerName
9155 kshitij.so 380 
     - bannerType
6849 kshitij.so 381 
    """
382 
    pass
383 
 
8579 kshitij.so 384 
  def addBannerUri(self, bannerUriMappings):
385 
    """
386 
    Parameters:
387 
     - bannerUriMappings
388 
    """
389 
    pass
390 
 
9155 kshitij.so 391 
  def getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 392 
    """
393 
    Parameters:
394 
     - bannerName
9155 kshitij.so 395 
     - bannerType
8579 kshitij.so 396 
    """
397 
    pass
398 
 
399 
  def addCampaign(self, campaign):
400 
    """
401 
    Parameters:
402 
     - campaign
403 
    """
404 
    pass
405 
 
406 
  def getCampaigns(self, campaignName):
407 
    """
408 
    Parameters:
409 
     - campaignName
410 
    """
411 
    pass
412 
 
413 
  def deleteCampaign(self, campaignId):
414 
    """
415 
    Parameters:
416 
     - campaignId
417 
    """
418 
    pass
419 
 
420 
  def getAllCampaigns(self, ):
421 
    pass
422 
 
9155 kshitij.so 423 
  def getActiveBannersForMobileSite(self, ):
424 
    pass
425 
 
5944 mandeep.dh 426 
  def deleteSimilarItem(self, itemId, catalogItemId):
427 
    """
428 
    Delete similar item.
429 
 
430 
    Parameters:
431 
     - itemId
432 
     - catalogItemId
433 
    """
434 
    pass
435 
 
436 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
437 
    """
438 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
439 
    If yes, returns the itemId else returns 0
440 
 
441 
    Parameters:
442 
     - brand
443 
     - modelNumber
444 
     - modelName
445 
     - color
446 
    """
447 
    pass
448 
 
449 
  def validateRiskyStatus(self, itemId):
450 
    """
451 
    Check wether item is risky and change status if inventory is not available for risky items
452 
 
453 
    Parameters:
454 
     - itemId
455 
    """
456 
    pass
457 
 
458 
  def changeItemRiskyFlag(self, itemId, risky):
459 
    """
460 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
461 
 
462 
    Parameters:
463 
     - itemId
464 
     - risky
465 
    """
466 
    pass
467 
 
468 
  def getItemsByRiskyFlag(self, ):
469 
    """
470 
    Returns list of items marked as risky.
471 
    """
472 
    pass
473 
 
474 
  def getItemsForMasterSheet(self, category, brand):
475 
    """
476 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
477 
 
478 
    Parameters:
479 
     - category
480 
     - brand
481 
    """
482 
    pass
483 
 
484 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
485 
    """
486 
    Returns list of catalog ids of items with same similarity index as of the given itemId
487 
 
488 
    Parameters:
489 
     - beginIndex
490 
     - totalItems
491 
     - itemId
492 
    """
493 
    pass
494 
 
495 
  def addProductNotification(self, itemId, email):
496 
    """
497 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
498 
 
499 
    Parameters:
500 
     - itemId
501 
     - email
502 
    """
503 
    pass
504 
 
505 
  def sendProductNotifications(self, ):
506 
    """
507 
    Send the product notifications to the users for items which has stock.
508 
    """
509 
    pass
510 
 
511 
  def getAllBrandsByCategory(self, categoryId):
512 
    """
513 
    Returns list of brand names for a given category Id
514 
 
515 
    Parameters:
516 
     - categoryId
517 
    """
518 
    pass
519 
 
520 
  def getAllBrands(self, ):
521 
    """
522 
    Returns list of brand names
523 
    """
524 
    pass
525 
 
526 
  def getAllSources(self, ):
527 
    """
528 
    Return list of all sources
529 
    """
530 
    pass
531 
 
532 
  def getItemPricingBySource(self, itemId, sourceId):
533 
    """
534 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
535 
 
536 
    Parameters:
537 
     - itemId
538 
     - sourceId
539 
    """
540 
    pass
541 
 
542 
  def addSourceItemPricing(self, sourceItemPricing):
543 
    """
544 
    Adds prices to be displayed corresponding to the item if user comes from a source.
545 
    If item is not found or source is not found, it will throw exception.
546 
 
547 
    Parameters:
548 
     - sourceItemPricing
549 
    """
550 
    pass
551 
 
552 
  def getAllSourcePricing(self, itemId):
553 
    """
554 
    Returns the list of source pricing information of an item.
555 
    Raises an exception if item not found corresponding to itemId
556 
 
557 
    Parameters:
558 
     - itemId
559 
    """
560 
    pass
561 
 
562 
  def getItemForSource(self, item_id, sourceId):
563 
    """
564 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
565 
 
566 
    Parameters:
567 
     - item_id
568 
     - sourceId
569 
    """
570 
    pass
571 
 
572 
  def searchItemsInRange(self, searchTerms, offset, limit):
573 
    """
574 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
575 
 
576 
    Parameters:
577 
     - searchTerms
578 
     - offset
579 
     - limit
580 
    """
581 
    pass
582 
 
583 
  def getSearchResultCount(self, searchTerms):
584 
    """
585 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
586 
 
587 
    Parameters:
588 
     - searchTerms
589 
    """
590 
    pass
591 
 
592 
  def getProductNotifications(self, startDateTime):
593 
    """
594 
    Returns a list of product notifications added after a supplied datetime
595 
 
596 
    Parameters:
597 
     - startDateTime
598 
    """
599 
    pass
600 
 
7897 amar.kumar 601 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 602 
    """
603 
    Returns a list of count of requests for product notification against each item
604 
 
605 
    Parameters:
606 
     - startDateTime
7897 amar.kumar 607 
     - categoryId
5944 mandeep.dh 608 
    """
609 
    pass
610 
 
611 
  def addAuthorizationLog(self, itemId, username, reason):
612 
    """
613 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
614 
 
615 
    Parameters:
616 
     - itemId
617 
     - username
618 
     - reason
619 
    """
620 
    pass
621 
 
622 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
623 
    """
624 
    Parameters:
625 
     - catalog_item_id
626 
     - voucherType
627 
     - voucherAmount
628 
    """
629 
    pass
630 
 
631 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
632 
    """
633 
    Parameters:
634 
     - catalog_item_id
635 
     - voucherType
636 
    """
637 
    pass
638 
 
639 
  def getVoucherAmount(self, itemId, voucherType):
640 
    """
641 
    Parameters:
642 
     - itemId
643 
     - voucherType
644 
    """
645 
    pass
646 
 
647 
  def getAllItemVouchers(self, itemId):
648 
    """
649 
    Parameters:
650 
     - itemId
651 
    """
652 
    pass
653 
 
654 
  def isValidCatalogItemId(self, catalog_item_id):
655 
    """
656 
    Parameters:
657 
     - catalog_item_id
658 
    """
659 
    pass
660 
 
7330 amit.gupta 661 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 662 
    """
663 
    Parameters:
664 
     - itemId
7330 amit.gupta 665 
     - stateId
6039 amit.gupta 666 
     - price
667 
    """
668 
    pass
5944 mandeep.dh 669 
 
6039 amit.gupta 670 
  def getVatAmountForItem(self, itemId, price):
671 
    """
672 
    Parameters:
673 
     - itemId
674 
     - price
675 
    """
676 
    pass
677 
 
6531 vikram.rag 678 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
679 
    """
680 
    Parameters:
681 
     - offset
682 
     - limit
683 
    """
684 
    pass
6039 amit.gupta 685 
 
6821 amar.kumar 686 
  def getAllAliveItems(self, ):
687 
    pass
688 
 
6921 anupam.sin 689 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 690 
    """
691 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 692 
 
6805 anupam.sin 693 
    Parameters:
694 
     - itemId
6921 anupam.sin 695 
     - price
6805 anupam.sin 696 
     - insurerId
697 
     - quantity
698 
    """
699 
    pass
700 
 
701 
  def getInsurer(self, insurerId):
702 
    """
703 
    Parameters:
704 
     - insurerId
705 
    """
706 
    pass
707 
 
6838 vikram.rag 708 
  def getAllInsurers(self, ):
709 
    pass
6805 anupam.sin 710 
 
6962 rajveer 711 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
712 
    """
713 
    Parameters:
714 
     - insurerId
715 
     - amount
716 
    """
717 
    pass
6838 vikram.rag 718 
 
7190 amar.kumar 719 
  def getFreebieForItem(self, itemId):
720 
    """
721 
    Parameters:
722 
     - itemId
723 
    """
724 
    pass
6962 rajveer 725 
 
7190 amar.kumar 726 
  def addOrUpdateFreebieForItem(self, freebieItem):
727 
    """
728 
    Parameters:
729 
     - freebieItem
730 
    """
731 
    pass
732 
 
7272 amit.gupta 733 
  def addOrUpdateBrandInfo(self, brandInfo):
734 
    """
735 
    Parameters:
736 
     - brandInfo
737 
    """
738 
    pass
739 
 
740 
  def getBrandInfo(self, ):
741 
    pass
742 
 
7256 rajveer 743 
  def getStorePricing(self, itemId):
744 
    """
745 
    Parameters:
746 
     - itemId
747 
    """
748 
    pass
7190 amar.kumar 749 
 
7306 rajveer 750 
  def getStorePricings(self, itemIds):
751 
    """
752 
    Parameters:
753 
     - itemIds
754 
    """
755 
    pass
756 
 
7382 rajveer 757 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 758 
    """
759 
    Parameters:
760 
     - sp
7382 rajveer 761 
     - allColors
7265 rajveer 762 
    """
763 
    pass
7256 rajveer 764 
 
7281 kshitij.so 765 
  def getAllAmazonListedItems(self, ):
766 
    pass
7265 rajveer 767 
 
8619 kshitij.so 768 
  def searchAmazonItems(self, searchTerm, offset, limit):
769 
    """
770 
    Parameters:
771 
     - searchTerm
772 
     - offset
773 
     - limit
774 
    """
775 
    pass
776 
 
777 
  def getAmazonSearchResultCount(self, searchTerm):
778 
    """
779 
    Parameters:
780 
     - searchTerm
781 
    """
782 
    pass
783 
 
784 
  def getCountForAmazonlistedItems(self, ):
785 
    pass
786 
 
7281 kshitij.so 787 
  def getAmazonItemDetails(self, itemId):
788 
    """
789 
    Parameters:
790 
     - itemId
791 
    """
792 
    pass
793 
 
8168 kshitij.so 794 
  def updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 795 
    """
796 
    Parameters:
8168 kshitij.so 797 
     - amazonlisted
7281 kshitij.so 798 
    """
799 
    pass
800 
 
801 
  def addAmazonItem(self, amazonlisted):
802 
    """
803 
    Parameters:
804 
     - amazonlisted
805 
    """
806 
    pass
807 
 
7291 vikram.rag 808 
  def getAsinItems(self, ):
809 
    pass
7281 kshitij.so 810 
 
7291 vikram.rag 811 
  def getAllFbaListedItems(self, ):
812 
    pass
813 
 
814 
  def getAllNonFbaListedItems(self, ):
815 
    pass
816 
 
7460 kshitij.so 817 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
818 
    """
819 
    Parameters:
820 
     - itemId
821 
     - holdInventory
822 
     - defaultInventory
823 
    """
824 
    pass
7291 vikram.rag 825 
 
7770 kshitij.so 826 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
827 
    """
828 
    Parameters:
829 
     - type
830 
     - sku
831 
     - timestamp
832 
    """
833 
    pass
7460 kshitij.so 834 
 
7897 amar.kumar 835 
  def getAllParentCategories(self, ):
836 
    pass
7770 kshitij.so 837 
 
7977 kshitij.so 838 
  def addPageViewEvent(self, pageViewEvents):
839 
    """
840 
    Parameters:
841 
     - pageViewEvents
842 
    """
843 
    pass
7897 amar.kumar 844 
 
7977 kshitij.so 845 
  def addCartEvent(self, cartEvents):
846 
    """
847 
    Parameters:
848 
     - cartEvents
849 
    """
850 
    pass
851 
 
8182 amar.kumar 852 
  def addEbayItem(self, ebayItem):
853 
    """
854 
    Parameters:
855 
     - ebayItem
856 
    """
857 
    pass
858 
 
859 
  def getEbayItem(self, listingId):
860 
    """
861 
    Parameters:
862 
     - listingId
863 
    """
864 
    pass
865 
 
866 
  def updateEbayItem(self, ebayItem):
867 
    """
868 
    Parameters:
869 
     - ebayItem
870 
    """
871 
    pass
872 
 
8139 kshitij.so 873 
  def getAmazonListedItems(self, offset, limit):
874 
    """
875 
    Parameters:
876 
     - offset
877 
     - limit
878 
    """
879 
    pass
7977 kshitij.so 880 
 
8168 kshitij.so 881 
  def updateAmazonAttributesInBulk(self, amazonlisted):
882 
    """
883 
    Parameters:
884 
     - amazonlisted
885 
    """
886 
    pass
8139 kshitij.so 887 
 
8379 vikram.rag 888 
  def getAllItemstoListOnFba(self, ):
889 
    pass
8168 kshitij.so 890 
 
8379 vikram.rag 891 
  def getAllItemstoListOnNonFba(self, ):
892 
    pass
893 
 
8619 kshitij.so 894 
  def updateAsin(self, item):
895 
    """
896 
    Parameters:
897 
     - item
898 
    """
899 
    pass
8616 vikram.rag 900 
 
8739 vikram.rag 901 
  def addOrUpdateSnapdealItem(self, snapdealitem):
902 
    """
903 
    Parameters:
904 
     - snapdealitem
905 
    """
906 
    pass
8619 kshitij.so 907 
 
8739 vikram.rag 908 
  def getSnapdealItem(self, item_id):
909 
    """
910 
    Parameters:
911 
     - item_id
912 
    """
913 
    pass
914 
 
9242 kshitij.so 915 
  def getSnapdealItemDetails(self, item_id):
916 
    """
917 
    Parameters:
918 
     - item_id
919 
    """
920 
    pass
921 
 
8739 vikram.rag 922 
  def getAllSnapdealItems(self, ):
923 
    pass
924 
 
9242 kshitij.so 925 
  def getSnapdealItems(self, offset, limit):
926 
    """
927 
    Parameters:
928 
     - offset
929 
     - limit
930 
    """
931 
    pass
8739 vikram.rag 932 
 
9242 kshitij.so 933 
  def searchSnapdealItems(self, searchTerm, offset, limit):
934 
    """
935 
    Parameters:
936 
     - searchTerm
937 
     - offset
938 
     - limit
939 
    """
940 
    pass
941 
 
942 
  def getCountForSnapdealItems(self, ):
943 
    pass
944 
 
945 
  def getSnapdealSearchResultCount(self, searchTerm):
946 
    """
947 
    Parameters:
948 
     - searchTerm
949 
    """
950 
    pass
951 
 
9299 kshitij.so 952 
  def getPrefferedInsurerForItem(self, itemId, insurerType):
953 
    """
954 
    Parameters:
955 
     - itemId
956 
     - insurerType
957 
    """
958 
    pass
9242 kshitij.so 959 
 
9456 vikram.rag 960 
  def getSnapdealItembySkuAtSnapdeal(self, skuAtSnapdeal):
961 
    """
962 
    Parameters:
963 
     - skuAtSnapdeal
964 
    """
965 
    pass
9299 kshitij.so 966 
 
9621 manish.sha 967 
  def getProductFeedSubmit(self, catalogItemId):
968 
    """
969 
    Parameters:
970 
     - catalogItemId
971 
    """
972 
    pass
9456 vikram.rag 973 
 
9621 manish.sha 974 
  def addProductFeedSubmit(self, productFeedSubmit):
975 
    """
976 
    Parameters:
977 
     - productFeedSubmit
978 
    """
979 
    pass
980 
 
981 
  def updateProductFeedSubmit(self, productFeedSubmit):
982 
    """
983 
    Parameters:
984 
     - productFeedSubmit
985 
    """
986 
    pass
987 
 
988 
  def deleteProductFeedSubmit(self, catalogItemId):
989 
    """
990 
    Parameters:
991 
     - catalogItemId
992 
    """
993 
    pass
994 
 
995 
  def getAllProductFeedSubmit(self, ):
996 
    pass
997 
 
9724 kshitij.so 998 
  def getMarketplacedetailsForItem(self, itemId, sourceId):
999 
    """
1000 
    Parameters:
1001 
     - itemId
1002 
     - sourceId
1003 
    """
1004 
    pass
9621 manish.sha 1005 
 
9724 kshitij.so 1006 
  def updateMarketplaceAttributesForItem(self, marketPlaceItem):
1007 
    """
1008 
    Parameters:
1009 
     - marketPlaceItem
1010 
    """
1011 
    pass
1012 
 
9779 kshitij.so 1013 
  def getCostingForMarketplace(self, source, item_id):
1014 
    """
1015 
    Parameters:
1016 
     - source
1017 
     - item_id
1018 
    """
1019 
    pass
1020 
 
9776 vikram.rag 1021 
  def getMarketPlaceItemsForPriceUpdate(self, source):
1022 
    """
1023 
    Parameters:
1024 
     - source
1025 
    """
1026 
    pass
9724 kshitij.so 1027 
 
9816 kshitij.so 1028 
  def updateMarketPlacePriceUpdateStatus(self, skulist, timestamp, source):
9776 vikram.rag 1029 
    """
1030 
    Parameters:
1031 
     - skulist
1032 
     - timestamp
9816 kshitij.so 1033 
     - source
9776 vikram.rag 1034 
    """
1035 
    pass
1036 
 
9861 rajveer 1037 
  def updateItemHoldInventory(self, itemHoldMap):
1038 
    """
1039 
    Parameters:
1040 
     - itemHoldMap
1041 
    """
1042 
    pass
9776 vikram.rag 1043 
 
9895 vikram.rag 1044 
  def updateNlcAtMarketplaces(self, item_id, vendor_id, nlc):
1045 
    """
1046 
    Parameters:
1047 
     - item_id
1048 
     - vendor_id
1049 
     - nlc
1050 
    """
1051 
    pass
9861 rajveer 1052 
 
9945 vikram.rag 1053 
  def getAllFlipkartItems(self, ):
1054 
    pass
9895 vikram.rag 1055 
 
10097 kshitij.so 1056 
  def addOrUpdateFlipkartItem(self, flipkartitem):
1057 
    """
1058 
    Parameters:
1059 
     - flipkartitem
1060 
    """
1061 
    pass
9945 vikram.rag 1062 
 
10097 kshitij.so 1063 
  def getFlipkartItem(self, item_id):
1064 
    """
1065 
    Parameters:
1066 
     - item_id
1067 
    """
1068 
    pass
1069 
 
1070 
  def getFlipkartItemDetails(self, item_id):
1071 
    """
1072 
    Parameters:
1073 
     - item_id
1074 
    """
1075 
    pass
1076 
 
1077 
  def getFlipkartItems(self, offset, limit):
1078 
    """
1079 
    Parameters:
1080 
     - offset
1081 
     - limit
1082 
    """
1083 
    pass
1084 
 
1085 
  def searchFlipkartItems(self, searchTerm, offset, limit):
1086 
    """
1087 
    Parameters:
1088 
     - searchTerm
1089 
     - offset
1090 
     - limit
1091 
    """
1092 
    pass
1093 
 
1094 
  def getCountForFlipkartItems(self, ):
1095 
    pass
1096 
 
1097 
  def getFlipkartSearchResultCount(self, searchTerm):
1098 
    """
1099 
    Parameters:
1100 
     - searchTerm
1101 
    """
1102 
    pass
1103 
 
1104 
  def getAllFkItems(self, ):
1105 
    pass
1106 
 
10140 vikram.rag 1107 
  def getFlipkartItemBySkyAtFlipkart(self, sku):
1108 
    """
1109 
    Parameters:
1110 
     - sku
1111 
    """
1112 
    pass
10097 kshitij.so 1113 
 
11015 kshitij.so 1114 
  def getMarketplaceHistory(self, source, offset, itemId):
1115 
    """
1116 
    Parameters:
1117 
     - source
1118 
     - offset
1119 
     - itemId
1120 
    """
1121 
    pass
1122 
 
10909 vikram.rag 1123 
  def getAllFbbListedItems(self, ):
1124 
    pass
10140 vikram.rag 1125 
 
10924 vikram.rag 1126 
  def getAllFbbPricingItems(self, ):
1127 
    pass
10909 vikram.rag 1128 
 
11015 kshitij.so 1129 
  def getCountForMarketplaceHistory(self, source, itemId):
1130 
    """
1131 
    Parameters:
1132 
     - source
1133 
     - itemId
1134 
    """
1135 
    pass
10924 vikram.rag 1136 
 
11015 kshitij.so 1137 
  def getMarketplaceHistoryByDate(self, source, startDate, endDate, offset, limit, itemId):
1138 
    """
1139 
    Parameters:
1140 
     - source
1141 
     - startDate
1142 
     - endDate
1143 
     - offset
1144 
     - limit
1145 
     - itemId
1146 
    """
1147 
    pass
1148 
 
1149 
 
5944 mandeep.dh 1150 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
1151 
  def __init__(self, iprot, oprot=None):
1152 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
1153 
 
1154 
  def addItem(self, item):
1155 
    """
1156 
    Availability and inventory attributes
1157 
 
1158 
    Parameters:
1159 
     - item
1160 
    """
1161 
    self.send_addItem(item)
1162 
    return self.recv_addItem()
1163 
 
1164 
  def send_addItem(self, item):
1165 
    self._oprot.writeMessageBegin('addItem', TMessageType.CALL, self._seqid)
1166 
    args = addItem_args()
1167 
    args.item = item
1168 
    args.write(self._oprot)
1169 
    self._oprot.writeMessageEnd()
1170 
    self._oprot.trans.flush()
1171 
 
1172 
  def recv_addItem(self, ):
1173 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1174 
    if mtype == TMessageType.EXCEPTION:
1175 
      x = TApplicationException()
1176 
      x.read(self._iprot)
1177 
      self._iprot.readMessageEnd()
1178 
      raise x
1179 
    result = addItem_result()
1180 
    result.read(self._iprot)
1181 
    self._iprot.readMessageEnd()
1182 
    if result.success is not None:
1183 
      return result.success
1184 
    if result.cex is not None:
1185 
      raise result.cex
1186 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItem failed: unknown result");
1187 
 
1188 
  def updateItem(self, item):
1189 
    """
1190 
    Parameters:
1191 
     - item
1192 
    """
1193 
    self.send_updateItem(item)
1194 
    return self.recv_updateItem()
1195 
 
1196 
  def send_updateItem(self, item):
1197 
    self._oprot.writeMessageBegin('updateItem', TMessageType.CALL, self._seqid)
1198 
    args = updateItem_args()
1199 
    args.item = item
1200 
    args.write(self._oprot)
1201 
    self._oprot.writeMessageEnd()
1202 
    self._oprot.trans.flush()
1203 
 
1204 
  def recv_updateItem(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 = updateItem_result()
1212 
    result.read(self._iprot)
1213 
    self._iprot.readMessageEnd()
1214 
    if result.success is not None:
1215 
      return result.success
1216 
    if result.cex is not None:
1217 
      raise result.cex
1218 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItem failed: unknown result");
1219 
 
1220 
  def isActive(self, itemId):
1221 
    """
1222 
    Checks if the item given to the corresponding itemId is active. If it's active,
1223 
    whether it's risky and if it's risky, its inventory position.
1224 
 
1225 
    Parameters:
1226 
     - itemId
1227 
    """
1228 
    self.send_isActive(itemId)
1229 
    return self.recv_isActive()
1230 
 
1231 
  def send_isActive(self, itemId):
1232 
    self._oprot.writeMessageBegin('isActive', TMessageType.CALL, self._seqid)
1233 
    args = isActive_args()
1234 
    args.itemId = itemId
1235 
    args.write(self._oprot)
1236 
    self._oprot.writeMessageEnd()
1237 
    self._oprot.trans.flush()
1238 
 
1239 
  def recv_isActive(self, ):
1240 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1241 
    if mtype == TMessageType.EXCEPTION:
1242 
      x = TApplicationException()
1243 
      x.read(self._iprot)
1244 
      self._iprot.readMessageEnd()
1245 
      raise x
1246 
    result = isActive_result()
1247 
    result.read(self._iprot)
1248 
    self._iprot.readMessageEnd()
1249 
    if result.success is not None:
1250 
      return result.success
1251 
    if result.isex is not None:
1252 
      raise result.isex
1253 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isActive failed: unknown result");
1254 
 
7438 amit.gupta 1255 
  def getItemsStatus(self, itemIds):
1256 
    """
1257 
    Parameters:
1258 
     - itemIds
1259 
    """
1260 
    self.send_getItemsStatus(itemIds)
1261 
    return self.recv_getItemsStatus()
1262 
 
1263 
  def send_getItemsStatus(self, itemIds):
1264 
    self._oprot.writeMessageBegin('getItemsStatus', TMessageType.CALL, self._seqid)
1265 
    args = getItemsStatus_args()
1266 
    args.itemIds = itemIds
1267 
    args.write(self._oprot)
1268 
    self._oprot.writeMessageEnd()
1269 
    self._oprot.trans.flush()
1270 
 
1271 
  def recv_getItemsStatus(self, ):
1272 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1273 
    if mtype == TMessageType.EXCEPTION:
1274 
      x = TApplicationException()
1275 
      x.read(self._iprot)
1276 
      self._iprot.readMessageEnd()
1277 
      raise x
1278 
    result = getItemsStatus_result()
1279 
    result.read(self._iprot)
1280 
    self._iprot.readMessageEnd()
1281 
    if result.success is not None:
1282 
      return result.success
1283 
    if result.isex is not None:
1284 
      raise result.isex
1285 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsStatus failed: unknown result");
1286 
 
5944 mandeep.dh 1287 
  def getItemStatusDescription(self, itemId):
1288 
    """
1289 
    Parameters:
1290 
     - itemId
1291 
    """
1292 
    self.send_getItemStatusDescription(itemId)
1293 
    return self.recv_getItemStatusDescription()
1294 
 
1295 
  def send_getItemStatusDescription(self, itemId):
1296 
    self._oprot.writeMessageBegin('getItemStatusDescription', TMessageType.CALL, self._seqid)
1297 
    args = getItemStatusDescription_args()
1298 
    args.itemId = itemId
1299 
    args.write(self._oprot)
1300 
    self._oprot.writeMessageEnd()
1301 
    self._oprot.trans.flush()
1302 
 
1303 
  def recv_getItemStatusDescription(self, ):
1304 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1305 
    if mtype == TMessageType.EXCEPTION:
1306 
      x = TApplicationException()
1307 
      x.read(self._iprot)
1308 
      self._iprot.readMessageEnd()
1309 
      raise x
1310 
    result = getItemStatusDescription_result()
1311 
    result.read(self._iprot)
1312 
    self._iprot.readMessageEnd()
1313 
    if result.success is not None:
1314 
      return result.success
1315 
    if result.isex is not None:
1316 
      raise result.isex
1317 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStatusDescription failed: unknown result");
1318 
 
1319 
  def startItemOn(self, item_id, timestamp):
1320 
    """
1321 
    Parameters:
1322 
     - item_id
1323 
     - timestamp
1324 
    """
1325 
    self.send_startItemOn(item_id, timestamp)
1326 
    self.recv_startItemOn()
1327 
 
1328 
  def send_startItemOn(self, item_id, timestamp):
1329 
    self._oprot.writeMessageBegin('startItemOn', TMessageType.CALL, self._seqid)
1330 
    args = startItemOn_args()
1331 
    args.item_id = item_id
1332 
    args.timestamp = timestamp
1333 
    args.write(self._oprot)
1334 
    self._oprot.writeMessageEnd()
1335 
    self._oprot.trans.flush()
1336 
 
1337 
  def recv_startItemOn(self, ):
1338 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1339 
    if mtype == TMessageType.EXCEPTION:
1340 
      x = TApplicationException()
1341 
      x.read(self._iprot)
1342 
      self._iprot.readMessageEnd()
1343 
      raise x
1344 
    result = startItemOn_result()
1345 
    result.read(self._iprot)
1346 
    self._iprot.readMessageEnd()
1347 
    if result.cex is not None:
1348 
      raise result.cex
1349 
    return
1350 
 
1351 
  def retireItemOn(self, item_id, timestamp):
1352 
    """
1353 
    Parameters:
1354 
     - item_id
1355 
     - timestamp
1356 
    """
1357 
    self.send_retireItemOn(item_id, timestamp)
1358 
    self.recv_retireItemOn()
1359 
 
1360 
  def send_retireItemOn(self, item_id, timestamp):
1361 
    self._oprot.writeMessageBegin('retireItemOn', TMessageType.CALL, self._seqid)
1362 
    args = retireItemOn_args()
1363 
    args.item_id = item_id
1364 
    args.timestamp = timestamp
1365 
    args.write(self._oprot)
1366 
    self._oprot.writeMessageEnd()
1367 
    self._oprot.trans.flush()
1368 
 
1369 
  def recv_retireItemOn(self, ):
1370 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1371 
    if mtype == TMessageType.EXCEPTION:
1372 
      x = TApplicationException()
1373 
      x.read(self._iprot)
1374 
      self._iprot.readMessageEnd()
1375 
      raise x
1376 
    result = retireItemOn_result()
1377 
    result.read(self._iprot)
1378 
    self._iprot.readMessageEnd()
1379 
    if result.cex is not None:
1380 
      raise result.cex
1381 
    return
1382 
 
1383 
  def changeItemStatus(self, item_id, timestamp, newstatus):
1384 
    """
1385 
    Parameters:
1386 
     - item_id
1387 
     - timestamp
1388 
     - newstatus
1389 
    """
1390 
    self.send_changeItemStatus(item_id, timestamp, newstatus)
1391 
    self.recv_changeItemStatus()
1392 
 
1393 
  def send_changeItemStatus(self, item_id, timestamp, newstatus):
1394 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
1395 
    args = changeItemStatus_args()
1396 
    args.item_id = item_id
1397 
    args.timestamp = timestamp
1398 
    args.newstatus = newstatus
1399 
    args.write(self._oprot)
1400 
    self._oprot.writeMessageEnd()
1401 
    self._oprot.trans.flush()
1402 
 
1403 
  def recv_changeItemStatus(self, ):
1404 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1405 
    if mtype == TMessageType.EXCEPTION:
1406 
      x = TApplicationException()
1407 
      x.read(self._iprot)
1408 
      self._iprot.readMessageEnd()
1409 
      raise x
1410 
    result = changeItemStatus_result()
1411 
    result.read(self._iprot)
1412 
    self._iprot.readMessageEnd()
1413 
    if result.cex is not None:
1414 
      raise result.cex
1415 
    return
1416 
 
1417 
  def getItem(self, item_id):
1418 
    """
1419 
    Parameters:
1420 
     - item_id
1421 
    """
1422 
    self.send_getItem(item_id)
1423 
    return self.recv_getItem()
1424 
 
1425 
  def send_getItem(self, item_id):
1426 
    self._oprot.writeMessageBegin('getItem', TMessageType.CALL, self._seqid)
1427 
    args = getItem_args()
1428 
    args.item_id = item_id
1429 
    args.write(self._oprot)
1430 
    self._oprot.writeMessageEnd()
1431 
    self._oprot.trans.flush()
1432 
 
1433 
  def recv_getItem(self, ):
1434 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1435 
    if mtype == TMessageType.EXCEPTION:
1436 
      x = TApplicationException()
1437 
      x.read(self._iprot)
1438 
      self._iprot.readMessageEnd()
1439 
      raise x
1440 
    result = getItem_result()
1441 
    result.read(self._iprot)
1442 
    self._iprot.readMessageEnd()
1443 
    if result.success is not None:
1444 
      return result.success
1445 
    if result.cex is not None:
1446 
      raise result.cex
1447 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItem failed: unknown result");
1448 
 
1449 
  def getItemsByCatalogId(self, catalog_item_id):
1450 
    """
1451 
    Parameters:
1452 
     - catalog_item_id
1453 
    """
1454 
    self.send_getItemsByCatalogId(catalog_item_id)
1455 
    return self.recv_getItemsByCatalogId()
1456 
 
1457 
  def send_getItemsByCatalogId(self, catalog_item_id):
1458 
    self._oprot.writeMessageBegin('getItemsByCatalogId', TMessageType.CALL, self._seqid)
1459 
    args = getItemsByCatalogId_args()
1460 
    args.catalog_item_id = catalog_item_id
1461 
    args.write(self._oprot)
1462 
    self._oprot.writeMessageEnd()
1463 
    self._oprot.trans.flush()
1464 
 
1465 
  def recv_getItemsByCatalogId(self, ):
1466 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1467 
    if mtype == TMessageType.EXCEPTION:
1468 
      x = TApplicationException()
1469 
      x.read(self._iprot)
1470 
      self._iprot.readMessageEnd()
1471 
      raise x
1472 
    result = getItemsByCatalogId_result()
1473 
    result.read(self._iprot)
1474 
    self._iprot.readMessageEnd()
1475 
    if result.success is not None:
1476 
      return result.success
1477 
    if result.cex is not None:
1478 
      raise result.cex
1479 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByCatalogId failed: unknown result");
1480 
 
1481 
  def getValidItemsByCatalogId(self, catalog_item_id):
1482 
    """
1483 
    Parameters:
1484 
     - catalog_item_id
1485 
    """
1486 
    self.send_getValidItemsByCatalogId(catalog_item_id)
1487 
    return self.recv_getValidItemsByCatalogId()
1488 
 
1489 
  def send_getValidItemsByCatalogId(self, catalog_item_id):
1490 
    self._oprot.writeMessageBegin('getValidItemsByCatalogId', TMessageType.CALL, self._seqid)
1491 
    args = getValidItemsByCatalogId_args()
1492 
    args.catalog_item_id = catalog_item_id
1493 
    args.write(self._oprot)
1494 
    self._oprot.writeMessageEnd()
1495 
    self._oprot.trans.flush()
1496 
 
1497 
  def recv_getValidItemsByCatalogId(self, ):
1498 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1499 
    if mtype == TMessageType.EXCEPTION:
1500 
      x = TApplicationException()
1501 
      x.read(self._iprot)
1502 
      self._iprot.readMessageEnd()
1503 
      raise x
1504 
    result = getValidItemsByCatalogId_result()
1505 
    result.read(self._iprot)
1506 
    self._iprot.readMessageEnd()
1507 
    if result.success is not None:
1508 
      return result.success
1509 
    if result.cex is not None:
1510 
      raise result.cex
1511 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidItemsByCatalogId failed: unknown result");
1512 
 
1513 
  def getAllItems(self, isActive):
1514 
    """
1515 
    Parameters:
1516 
     - isActive
1517 
    """
1518 
    self.send_getAllItems(isActive)
1519 
    return self.recv_getAllItems()
1520 
 
1521 
  def send_getAllItems(self, isActive):
1522 
    self._oprot.writeMessageBegin('getAllItems', TMessageType.CALL, self._seqid)
1523 
    args = getAllItems_args()
1524 
    args.isActive = isActive
1525 
    args.write(self._oprot)
1526 
    self._oprot.writeMessageEnd()
1527 
    self._oprot.trans.flush()
1528 
 
1529 
  def recv_getAllItems(self, ):
1530 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1531 
    if mtype == TMessageType.EXCEPTION:
1532 
      x = TApplicationException()
1533 
      x.read(self._iprot)
1534 
      self._iprot.readMessageEnd()
1535 
      raise x
1536 
    result = getAllItems_result()
1537 
    result.read(self._iprot)
1538 
    self._iprot.readMessageEnd()
1539 
    if result.success is not None:
1540 
      return result.success
1541 
    if result.cex is not None:
1542 
      raise result.cex
1543 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItems failed: unknown result");
1544 
 
1545 
  def getAllItemsByStatus(self, itemStatus):
1546 
    """
1547 
    Parameters:
1548 
     - itemStatus
1549 
    """
1550 
    self.send_getAllItemsByStatus(itemStatus)
1551 
    return self.recv_getAllItemsByStatus()
1552 
 
1553 
  def send_getAllItemsByStatus(self, itemStatus):
1554 
    self._oprot.writeMessageBegin('getAllItemsByStatus', TMessageType.CALL, self._seqid)
1555 
    args = getAllItemsByStatus_args()
1556 
    args.itemStatus = itemStatus
1557 
    args.write(self._oprot)
1558 
    self._oprot.writeMessageEnd()
1559 
    self._oprot.trans.flush()
1560 
 
1561 
  def recv_getAllItemsByStatus(self, ):
1562 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1563 
    if mtype == TMessageType.EXCEPTION:
1564 
      x = TApplicationException()
1565 
      x.read(self._iprot)
1566 
      self._iprot.readMessageEnd()
1567 
      raise x
1568 
    result = getAllItemsByStatus_result()
1569 
    result.read(self._iprot)
1570 
    self._iprot.readMessageEnd()
1571 
    if result.success is not None:
1572 
      return result.success
1573 
    if result.cex is not None:
1574 
      raise result.cex
1575 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatus failed: unknown result");
1576 
 
9253 rajveer 1577 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber, isAndroid):
5944 mandeep.dh 1578 
    """
1579 
    Parameters:
1580 
     - entityId
1581 
     - category
1582 
     - brand
1583 
     - modelName
1584 
     - modelNumber
9253 rajveer 1585 
     - isAndroid
5944 mandeep.dh 1586 
    """
9253 rajveer 1587 
    self.send_markItemAsContentComplete(entityId, category, brand, modelName, modelNumber, isAndroid)
5944 mandeep.dh 1588 
    return self.recv_markItemAsContentComplete()
1589 
 
9253 rajveer 1590 
  def send_markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber, isAndroid):
5944 mandeep.dh 1591 
    self._oprot.writeMessageBegin('markItemAsContentComplete', TMessageType.CALL, self._seqid)
1592 
    args = markItemAsContentComplete_args()
1593 
    args.entityId = entityId
1594 
    args.category = category
1595 
    args.brand = brand
1596 
    args.modelName = modelName
1597 
    args.modelNumber = modelNumber
9253 rajveer 1598 
    args.isAndroid = isAndroid
5944 mandeep.dh 1599 
    args.write(self._oprot)
1600 
    self._oprot.writeMessageEnd()
1601 
    self._oprot.trans.flush()
1602 
 
1603 
  def recv_markItemAsContentComplete(self, ):
1604 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1605 
    if mtype == TMessageType.EXCEPTION:
1606 
      x = TApplicationException()
1607 
      x.read(self._iprot)
1608 
      self._iprot.readMessageEnd()
1609 
      raise x
1610 
    result = markItemAsContentComplete_result()
1611 
    result.read(self._iprot)
1612 
    self._iprot.readMessageEnd()
1613 
    if result.success is not None:
1614 
      return result.success
1615 
    if result.cex is not None:
1616 
      raise result.cex
1617 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markItemAsContentComplete failed: unknown result");
1618 
 
1619 
  def getAllItemsInRange(self, offset, limit):
1620 
    """
1621 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
1622 
 
1623 
    Parameters:
1624 
     - offset
1625 
     - limit
1626 
    """
1627 
    self.send_getAllItemsInRange(offset, limit)
1628 
    return self.recv_getAllItemsInRange()
1629 
 
1630 
  def send_getAllItemsInRange(self, offset, limit):
1631 
    self._oprot.writeMessageBegin('getAllItemsInRange', TMessageType.CALL, self._seqid)
1632 
    args = getAllItemsInRange_args()
1633 
    args.offset = offset
1634 
    args.limit = limit
1635 
    args.write(self._oprot)
1636 
    self._oprot.writeMessageEnd()
1637 
    self._oprot.trans.flush()
1638 
 
1639 
  def recv_getAllItemsInRange(self, ):
1640 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1641 
    if mtype == TMessageType.EXCEPTION:
1642 
      x = TApplicationException()
1643 
      x.read(self._iprot)
1644 
      self._iprot.readMessageEnd()
1645 
      raise x
1646 
    result = getAllItemsInRange_result()
1647 
    result.read(self._iprot)
1648 
    self._iprot.readMessageEnd()
1649 
    if result.success is not None:
1650 
      return result.success
1651 
    if result.cex is not None:
1652 
      raise result.cex
1653 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsInRange failed: unknown result");
1654 
 
1655 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1656 
    """
1657 
    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.
1658 
 
1659 
    Parameters:
1660 
     - itemStatus
1661 
     - offset
1662 
     - limit
1663 
    """
1664 
    self.send_getAllItemsByStatusInRange(itemStatus, offset, limit)
1665 
    return self.recv_getAllItemsByStatusInRange()
1666 
 
1667 
  def send_getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1668 
    self._oprot.writeMessageBegin('getAllItemsByStatusInRange', TMessageType.CALL, self._seqid)
1669 
    args = getAllItemsByStatusInRange_args()
1670 
    args.itemStatus = itemStatus
1671 
    args.offset = offset
1672 
    args.limit = limit
1673 
    args.write(self._oprot)
1674 
    self._oprot.writeMessageEnd()
1675 
    self._oprot.trans.flush()
1676 
 
1677 
  def recv_getAllItemsByStatusInRange(self, ):
1678 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1679 
    if mtype == TMessageType.EXCEPTION:
1680 
      x = TApplicationException()
1681 
      x.read(self._iprot)
1682 
      self._iprot.readMessageEnd()
1683 
      raise x
1684 
    result = getAllItemsByStatusInRange_result()
1685 
    result.read(self._iprot)
1686 
    self._iprot.readMessageEnd()
1687 
    if result.success is not None:
1688 
      return result.success
1689 
    if result.cex is not None:
1690 
      raise result.cex
1691 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatusInRange failed: unknown result");
1692 
 
1693 
  def getItemCountByStatus(self, useStatus, itemStatus):
1694 
    """
1695 
    Gets a count of all items by status
1696 
 
1697 
    Parameters:
1698 
     - useStatus
1699 
     - itemStatus
1700 
    """
1701 
    self.send_getItemCountByStatus(useStatus, itemStatus)
1702 
    return self.recv_getItemCountByStatus()
1703 
 
1704 
  def send_getItemCountByStatus(self, useStatus, itemStatus):
1705 
    self._oprot.writeMessageBegin('getItemCountByStatus', TMessageType.CALL, self._seqid)
1706 
    args = getItemCountByStatus_args()
1707 
    args.useStatus = useStatus
1708 
    args.itemStatus = itemStatus
1709 
    args.write(self._oprot)
1710 
    self._oprot.writeMessageEnd()
1711 
    self._oprot.trans.flush()
1712 
 
1713 
  def recv_getItemCountByStatus(self, ):
1714 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1715 
    if mtype == TMessageType.EXCEPTION:
1716 
      x = TApplicationException()
1717 
      x.read(self._iprot)
1718 
      self._iprot.readMessageEnd()
1719 
      raise x
1720 
    result = getItemCountByStatus_result()
1721 
    result.read(self._iprot)
1722 
    self._iprot.readMessageEnd()
1723 
    if result.success is not None:
1724 
      return result.success
1725 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemCountByStatus failed: unknown result");
1726 
 
1727 
  def getBestSellers(self, ):
1728 
    self.send_getBestSellers()
1729 
    return self.recv_getBestSellers()
1730 
 
1731 
  def send_getBestSellers(self, ):
1732 
    self._oprot.writeMessageBegin('getBestSellers', TMessageType.CALL, self._seqid)
1733 
    args = getBestSellers_args()
1734 
    args.write(self._oprot)
1735 
    self._oprot.writeMessageEnd()
1736 
    self._oprot.trans.flush()
1737 
 
1738 
  def recv_getBestSellers(self, ):
1739 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1740 
    if mtype == TMessageType.EXCEPTION:
1741 
      x = TApplicationException()
1742 
      x.read(self._iprot)
1743 
      self._iprot.readMessageEnd()
1744 
      raise x
1745 
    result = getBestSellers_result()
1746 
    result.read(self._iprot)
1747 
    self._iprot.readMessageEnd()
1748 
    if result.success is not None:
1749 
      return result.success
1750 
    if result.isex is not None:
1751 
      raise result.isex
1752 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellers failed: unknown result");
1753 
 
1754 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1755 
    """
1756 
    Parameters:
1757 
     - beginIndex
1758 
     - totalItems
1759 
     - brand
1760 
     - category
1761 
    """
1762 
    self.send_getBestSellersCatalogIds(beginIndex, totalItems, brand, category)
1763 
    return self.recv_getBestSellersCatalogIds()
1764 
 
1765 
  def send_getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1766 
    self._oprot.writeMessageBegin('getBestSellersCatalogIds', TMessageType.CALL, self._seqid)
1767 
    args = getBestSellersCatalogIds_args()
1768 
    args.beginIndex = beginIndex
1769 
    args.totalItems = totalItems
1770 
    args.brand = brand
1771 
    args.category = category
1772 
    args.write(self._oprot)
1773 
    self._oprot.writeMessageEnd()
1774 
    self._oprot.trans.flush()
1775 
 
1776 
  def recv_getBestSellersCatalogIds(self, ):
1777 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1778 
    if mtype == TMessageType.EXCEPTION:
1779 
      x = TApplicationException()
1780 
      x.read(self._iprot)
1781 
      self._iprot.readMessageEnd()
1782 
      raise x
1783 
    result = getBestSellersCatalogIds_result()
1784 
    result.read(self._iprot)
1785 
    self._iprot.readMessageEnd()
1786 
    if result.success is not None:
1787 
      return result.success
1788 
    if result.cex is not None:
1789 
      raise result.cex
1790 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCatalogIds failed: unknown result");
1791 
 
1792 
  def getBestSellersCount(self, ):
1793 
    self.send_getBestSellersCount()
1794 
    return self.recv_getBestSellersCount()
1795 
 
1796 
  def send_getBestSellersCount(self, ):
1797 
    self._oprot.writeMessageBegin('getBestSellersCount', TMessageType.CALL, self._seqid)
1798 
    args = getBestSellersCount_args()
1799 
    args.write(self._oprot)
1800 
    self._oprot.writeMessageEnd()
1801 
    self._oprot.trans.flush()
1802 
 
1803 
  def recv_getBestSellersCount(self, ):
1804 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1805 
    if mtype == TMessageType.EXCEPTION:
1806 
      x = TApplicationException()
1807 
      x.read(self._iprot)
1808 
      self._iprot.readMessageEnd()
1809 
      raise x
1810 
    result = getBestSellersCount_result()
1811 
    result.read(self._iprot)
1812 
    self._iprot.readMessageEnd()
1813 
    if result.success is not None:
1814 
      return result.success
1815 
    if result.cex is not None:
1816 
      raise result.cex
1817 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCount failed: unknown result");
1818 
 
1819 
  def getBestDeals(self, ):
1820 
    self.send_getBestDeals()
1821 
    return self.recv_getBestDeals()
1822 
 
1823 
  def send_getBestDeals(self, ):
1824 
    self._oprot.writeMessageBegin('getBestDeals', TMessageType.CALL, self._seqid)
1825 
    args = getBestDeals_args()
1826 
    args.write(self._oprot)
1827 
    self._oprot.writeMessageEnd()
1828 
    self._oprot.trans.flush()
1829 
 
1830 
  def recv_getBestDeals(self, ):
1831 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1832 
    if mtype == TMessageType.EXCEPTION:
1833 
      x = TApplicationException()
1834 
      x.read(self._iprot)
1835 
      self._iprot.readMessageEnd()
1836 
      raise x
1837 
    result = getBestDeals_result()
1838 
    result.read(self._iprot)
1839 
    self._iprot.readMessageEnd()
1840 
    if result.success is not None:
1841 
      return result.success
1842 
    if result.isex is not None:
1843 
      raise result.isex
1844 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDeals failed: unknown result");
1845 
 
1846 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1847 
    """
1848 
    Parameters:
1849 
     - beginIndex
1850 
     - totalItems
1851 
     - brand
1852 
     - category
1853 
    """
1854 
    self.send_getBestDealsCatalogIds(beginIndex, totalItems, brand, category)
1855 
    return self.recv_getBestDealsCatalogIds()
1856 
 
1857 
  def send_getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1858 
    self._oprot.writeMessageBegin('getBestDealsCatalogIds', TMessageType.CALL, self._seqid)
1859 
    args = getBestDealsCatalogIds_args()
1860 
    args.beginIndex = beginIndex
1861 
    args.totalItems = totalItems
1862 
    args.brand = brand
1863 
    args.category = category
1864 
    args.write(self._oprot)
1865 
    self._oprot.writeMessageEnd()
1866 
    self._oprot.trans.flush()
1867 
 
1868 
  def recv_getBestDealsCatalogIds(self, ):
1869 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1870 
    if mtype == TMessageType.EXCEPTION:
1871 
      x = TApplicationException()
1872 
      x.read(self._iprot)
1873 
      self._iprot.readMessageEnd()
1874 
      raise x
1875 
    result = getBestDealsCatalogIds_result()
1876 
    result.read(self._iprot)
1877 
    self._iprot.readMessageEnd()
1878 
    if result.success is not None:
1879 
      return result.success
1880 
    if result.cex is not None:
1881 
      raise result.cex
1882 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCatalogIds failed: unknown result");
1883 
 
1884 
  def getBestDealsCount(self, ):
1885 
    self.send_getBestDealsCount()
1886 
    return self.recv_getBestDealsCount()
1887 
 
1888 
  def send_getBestDealsCount(self, ):
1889 
    self._oprot.writeMessageBegin('getBestDealsCount', TMessageType.CALL, self._seqid)
1890 
    args = getBestDealsCount_args()
1891 
    args.write(self._oprot)
1892 
    self._oprot.writeMessageEnd()
1893 
    self._oprot.trans.flush()
1894 
 
1895 
  def recv_getBestDealsCount(self, ):
1896 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1897 
    if mtype == TMessageType.EXCEPTION:
1898 
      x = TApplicationException()
1899 
      x.read(self._iprot)
1900 
      self._iprot.readMessageEnd()
1901 
      raise x
1902 
    result = getBestDealsCount_result()
1903 
    result.read(self._iprot)
1904 
    self._iprot.readMessageEnd()
1905 
    if result.success is not None:
1906 
      return result.success
1907 
    if result.cex is not None:
1908 
      raise result.cex
1909 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCount failed: unknown result");
1910 
 
1911 
  def getComingSoon(self, ):
1912 
    self.send_getComingSoon()
1913 
    return self.recv_getComingSoon()
1914 
 
1915 
  def send_getComingSoon(self, ):
1916 
    self._oprot.writeMessageBegin('getComingSoon', TMessageType.CALL, self._seqid)
1917 
    args = getComingSoon_args()
1918 
    args.write(self._oprot)
1919 
    self._oprot.writeMessageEnd()
1920 
    self._oprot.trans.flush()
1921 
 
1922 
  def recv_getComingSoon(self, ):
1923 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1924 
    if mtype == TMessageType.EXCEPTION:
1925 
      x = TApplicationException()
1926 
      x.read(self._iprot)
1927 
      self._iprot.readMessageEnd()
1928 
      raise x
1929 
    result = getComingSoon_result()
1930 
    result.read(self._iprot)
1931 
    self._iprot.readMessageEnd()
1932 
    if result.success is not None:
1933 
      return result.success
1934 
    if result.isex is not None:
1935 
      raise result.isex
1936 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoon failed: unknown result");
1937 
 
1938 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1939 
    """
1940 
    Parameters:
1941 
     - beginIndex
1942 
     - totalItems
1943 
     - brand
1944 
     - category
1945 
    """
1946 
    self.send_getComingSoonCatalogIds(beginIndex, totalItems, brand, category)
1947 
    return self.recv_getComingSoonCatalogIds()
1948 
 
1949 
  def send_getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1950 
    self._oprot.writeMessageBegin('getComingSoonCatalogIds', TMessageType.CALL, self._seqid)
1951 
    args = getComingSoonCatalogIds_args()
1952 
    args.beginIndex = beginIndex
1953 
    args.totalItems = totalItems
1954 
    args.brand = brand
1955 
    args.category = category
1956 
    args.write(self._oprot)
1957 
    self._oprot.writeMessageEnd()
1958 
    self._oprot.trans.flush()
1959 
 
1960 
  def recv_getComingSoonCatalogIds(self, ):
1961 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1962 
    if mtype == TMessageType.EXCEPTION:
1963 
      x = TApplicationException()
1964 
      x.read(self._iprot)
1965 
      self._iprot.readMessageEnd()
1966 
      raise x
1967 
    result = getComingSoonCatalogIds_result()
1968 
    result.read(self._iprot)
1969 
    self._iprot.readMessageEnd()
1970 
    if result.success is not None:
1971 
      return result.success
1972 
    if result.cex is not None:
1973 
      raise result.cex
1974 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCatalogIds failed: unknown result");
1975 
 
1976 
  def getComingSoonCount(self, ):
1977 
    self.send_getComingSoonCount()
1978 
    return self.recv_getComingSoonCount()
1979 
 
1980 
  def send_getComingSoonCount(self, ):
1981 
    self._oprot.writeMessageBegin('getComingSoonCount', TMessageType.CALL, self._seqid)
1982 
    args = getComingSoonCount_args()
1983 
    args.write(self._oprot)
1984 
    self._oprot.writeMessageEnd()
1985 
    self._oprot.trans.flush()
1986 
 
1987 
  def recv_getComingSoonCount(self, ):
1988 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1989 
    if mtype == TMessageType.EXCEPTION:
1990 
      x = TApplicationException()
1991 
      x.read(self._iprot)
1992 
      self._iprot.readMessageEnd()
1993 
      raise x
1994 
    result = getComingSoonCount_result()
1995 
    result.read(self._iprot)
1996 
    self._iprot.readMessageEnd()
1997 
    if result.success is not None:
1998 
      return result.success
1999 
    if result.cex is not None:
2000 
      raise result.cex
2001 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCount failed: unknown result");
2002 
 
2003 
  def getLatestArrivals(self, ):
2004 
    """
2005 
    Returns a list of items sorted in the descending order by start date.
2006 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
2007 
    """
2008 
    self.send_getLatestArrivals()
2009 
    return self.recv_getLatestArrivals()
2010 
 
2011 
  def send_getLatestArrivals(self, ):
2012 
    self._oprot.writeMessageBegin('getLatestArrivals', TMessageType.CALL, self._seqid)
2013 
    args = getLatestArrivals_args()
2014 
    args.write(self._oprot)
2015 
    self._oprot.writeMessageEnd()
2016 
    self._oprot.trans.flush()
2017 
 
2018 
  def recv_getLatestArrivals(self, ):
2019 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2020 
    if mtype == TMessageType.EXCEPTION:
2021 
      x = TApplicationException()
2022 
      x.read(self._iprot)
2023 
      self._iprot.readMessageEnd()
2024 
      raise x
2025 
    result = getLatestArrivals_result()
2026 
    result.read(self._iprot)
2027 
    self._iprot.readMessageEnd()
2028 
    if result.success is not None:
2029 
      return result.success
2030 
    if result.isex is not None:
2031 
      raise result.isex
2032 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivals failed: unknown result");
2033 
 
2034 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
2035 
    """
2036 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
2037 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
2038 
 
2039 
    Parameters:
2040 
     - beginIndex
2041 
     - totalItems
2042 
     - brand
2043 
     - categories
2044 
    """
2045 
    self.send_getLatestArrivalsCatalogIds(beginIndex, totalItems, brand, categories)
2046 
    return self.recv_getLatestArrivalsCatalogIds()
2047 
 
2048 
  def send_getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
2049 
    self._oprot.writeMessageBegin('getLatestArrivalsCatalogIds', TMessageType.CALL, self._seqid)
2050 
    args = getLatestArrivalsCatalogIds_args()
2051 
    args.beginIndex = beginIndex
2052 
    args.totalItems = totalItems
2053 
    args.brand = brand
2054 
    args.categories = categories
2055 
    args.write(self._oprot)
2056 
    self._oprot.writeMessageEnd()
2057 
    self._oprot.trans.flush()
2058 
 
2059 
  def recv_getLatestArrivalsCatalogIds(self, ):
2060 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2061 
    if mtype == TMessageType.EXCEPTION:
2062 
      x = TApplicationException()
2063 
      x.read(self._iprot)
2064 
      self._iprot.readMessageEnd()
2065 
      raise x
2066 
    result = getLatestArrivalsCatalogIds_result()
2067 
    result.read(self._iprot)
2068 
    self._iprot.readMessageEnd()
2069 
    if result.success is not None:
2070 
      return result.success
2071 
    if result.cex is not None:
2072 
      raise result.cex
2073 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCatalogIds failed: unknown result");
2074 
 
2075 
  def getLatestArrivalsCount(self, ):
2076 
    """
2077 
    Get the total number of latest arrivals we are willing to show.
2078 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
2079 
    """
2080 
    self.send_getLatestArrivalsCount()
2081 
    return self.recv_getLatestArrivalsCount()
2082 
 
2083 
  def send_getLatestArrivalsCount(self, ):
2084 
    self._oprot.writeMessageBegin('getLatestArrivalsCount', TMessageType.CALL, self._seqid)
2085 
    args = getLatestArrivalsCount_args()
2086 
    args.write(self._oprot)
2087 
    self._oprot.writeMessageEnd()
2088 
    self._oprot.trans.flush()
2089 
 
2090 
  def recv_getLatestArrivalsCount(self, ):
2091 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2092 
    if mtype == TMessageType.EXCEPTION:
2093 
      x = TApplicationException()
2094 
      x.read(self._iprot)
2095 
      self._iprot.readMessageEnd()
2096 
      raise x
2097 
    result = getLatestArrivalsCount_result()
2098 
    result.read(self._iprot)
2099 
    self._iprot.readMessageEnd()
2100 
    if result.success is not None:
2101 
      return result.success
2102 
    if result.cex is not None:
2103 
      raise result.cex
2104 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCount failed: unknown result");
2105 
 
2106 
  def generateNewEntityID(self, ):
2107 
    self.send_generateNewEntityID()
2108 
    return self.recv_generateNewEntityID()
2109 
 
2110 
  def send_generateNewEntityID(self, ):
2111 
    self._oprot.writeMessageBegin('generateNewEntityID', TMessageType.CALL, self._seqid)
2112 
    args = generateNewEntityID_args()
2113 
    args.write(self._oprot)
2114 
    self._oprot.writeMessageEnd()
2115 
    self._oprot.trans.flush()
2116 
 
2117 
  def recv_generateNewEntityID(self, ):
2118 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2119 
    if mtype == TMessageType.EXCEPTION:
2120 
      x = TApplicationException()
2121 
      x.read(self._iprot)
2122 
      self._iprot.readMessageEnd()
2123 
      raise x
2124 
    result = generateNewEntityID_result()
2125 
    result.read(self._iprot)
2126 
    self._iprot.readMessageEnd()
2127 
    if result.success is not None:
2128 
      return result.success
2129 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateNewEntityID failed: unknown result");
2130 
 
2131 
  def addCategory(self, category):
2132 
    """
2133 
    All category related functions
2134 
 
2135 
    Parameters:
2136 
     - category
2137 
    """
2138 
    self.send_addCategory(category)
2139 
    return self.recv_addCategory()
2140 
 
2141 
  def send_addCategory(self, category):
2142 
    self._oprot.writeMessageBegin('addCategory', TMessageType.CALL, self._seqid)
2143 
    args = addCategory_args()
2144 
    args.category = category
2145 
    args.write(self._oprot)
2146 
    self._oprot.writeMessageEnd()
2147 
    self._oprot.trans.flush()
2148 
 
2149 
  def recv_addCategory(self, ):
2150 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2151 
    if mtype == TMessageType.EXCEPTION:
2152 
      x = TApplicationException()
2153 
      x.read(self._iprot)
2154 
      self._iprot.readMessageEnd()
2155 
      raise x
2156 
    result = addCategory_result()
2157 
    result.read(self._iprot)
2158 
    self._iprot.readMessageEnd()
2159 
    if result.success is not None:
2160 
      return result.success
2161 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addCategory failed: unknown result");
2162 
 
2163 
  def getCategory(self, id):
2164 
    """
2165 
    Parameters:
2166 
     - id
2167 
    """
2168 
    self.send_getCategory(id)
2169 
    return self.recv_getCategory()
2170 
 
2171 
  def send_getCategory(self, id):
2172 
    self._oprot.writeMessageBegin('getCategory', TMessageType.CALL, self._seqid)
2173 
    args = getCategory_args()
2174 
    args.id = id
2175 
    args.write(self._oprot)
2176 
    self._oprot.writeMessageEnd()
2177 
    self._oprot.trans.flush()
2178 
 
2179 
  def recv_getCategory(self, ):
2180 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2181 
    if mtype == TMessageType.EXCEPTION:
2182 
      x = TApplicationException()
2183 
      x.read(self._iprot)
2184 
      self._iprot.readMessageEnd()
2185 
      raise x
2186 
    result = getCategory_result()
2187 
    result.read(self._iprot)
2188 
    self._iprot.readMessageEnd()
2189 
    if result.success is not None:
2190 
      return result.success
2191 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCategory failed: unknown result");
2192 
 
2193 
  def getAllCategories(self, ):
2194 
    self.send_getAllCategories()
2195 
    return self.recv_getAllCategories()
2196 
 
2197 
  def send_getAllCategories(self, ):
2198 
    self._oprot.writeMessageBegin('getAllCategories', TMessageType.CALL, self._seqid)
2199 
    args = getAllCategories_args()
2200 
    args.write(self._oprot)
2201 
    self._oprot.writeMessageEnd()
2202 
    self._oprot.trans.flush()
2203 
 
2204 
  def recv_getAllCategories(self, ):
2205 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2206 
    if mtype == TMessageType.EXCEPTION:
2207 
      x = TApplicationException()
2208 
      x.read(self._iprot)
2209 
      self._iprot.readMessageEnd()
2210 
      raise x
2211 
    result = getAllCategories_result()
2212 
    result.read(self._iprot)
2213 
    self._iprot.readMessageEnd()
2214 
    if result.success is not None:
2215 
      return result.success
2216 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCategories failed: unknown result");
2217 
 
2218 
  def getAllSimilarItems(self, itemId):
2219 
    """
2220 
    Returns the list of similar items.
2221 
 
2222 
    Parameters:
2223 
     - itemId
2224 
    """
2225 
    self.send_getAllSimilarItems(itemId)
2226 
    return self.recv_getAllSimilarItems()
2227 
 
2228 
  def send_getAllSimilarItems(self, itemId):
2229 
    self._oprot.writeMessageBegin('getAllSimilarItems', TMessageType.CALL, self._seqid)
2230 
    args = getAllSimilarItems_args()
2231 
    args.itemId = itemId
2232 
    args.write(self._oprot)
2233 
    self._oprot.writeMessageEnd()
2234 
    self._oprot.trans.flush()
2235 
 
2236 
  def recv_getAllSimilarItems(self, ):
2237 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2238 
    if mtype == TMessageType.EXCEPTION:
2239 
      x = TApplicationException()
2240 
      x.read(self._iprot)
2241 
      self._iprot.readMessageEnd()
2242 
      raise x
2243 
    result = getAllSimilarItems_result()
2244 
    result.read(self._iprot)
2245 
    self._iprot.readMessageEnd()
2246 
    if result.success is not None:
2247 
      return result.success
2248 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSimilarItems failed: unknown result");
2249 
 
2250 
  def addSimilarItem(self, itemId, catalogItemId):
2251 
    """
2252 
    Adds similar item.
2253 
 
2254 
    Parameters:
2255 
     - itemId
2256 
     - catalogItemId
2257 
    """
2258 
    self.send_addSimilarItem(itemId, catalogItemId)
2259 
    return self.recv_addSimilarItem()
2260 
 
2261 
  def send_addSimilarItem(self, itemId, catalogItemId):
2262 
    self._oprot.writeMessageBegin('addSimilarItem', TMessageType.CALL, self._seqid)
2263 
    args = addSimilarItem_args()
2264 
    args.itemId = itemId
2265 
    args.catalogItemId = catalogItemId
2266 
    args.write(self._oprot)
2267 
    self._oprot.writeMessageEnd()
2268 
    self._oprot.trans.flush()
2269 
 
2270 
  def recv_addSimilarItem(self, ):
2271 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2272 
    if mtype == TMessageType.EXCEPTION:
2273 
      x = TApplicationException()
2274 
      x.read(self._iprot)
2275 
      self._iprot.readMessageEnd()
2276 
      raise x
2277 
    result = addSimilarItem_result()
2278 
    result.read(self._iprot)
2279 
    self._iprot.readMessageEnd()
2280 
    if result.success is not None:
2281 
      return result.success
2282 
    if result.cex is not None:
2283 
      raise result.cex
2284 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSimilarItem failed: unknown result");
2285 
 
6512 kshitij.so 2286 
  def addTag(self, displayName, itemId):
2287 
    """
2288 
    Tag Related
2289 
 
2290 
    Parameters:
2291 
     - displayName
2292 
     - itemId
2293 
    """
2294 
    self.send_addTag(displayName, itemId)
2295 
    return self.recv_addTag()
2296 
 
2297 
  def send_addTag(self, displayName, itemId):
2298 
    self._oprot.writeMessageBegin('addTag', TMessageType.CALL, self._seqid)
2299 
    args = addTag_args()
2300 
    args.displayName = displayName
2301 
    args.itemId = itemId
2302 
    args.write(self._oprot)
2303 
    self._oprot.writeMessageEnd()
2304 
    self._oprot.trans.flush()
2305 
 
2306 
  def recv_addTag(self, ):
2307 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2308 
    if mtype == TMessageType.EXCEPTION:
2309 
      x = TApplicationException()
2310 
      x.read(self._iprot)
2311 
      self._iprot.readMessageEnd()
2312 
      raise x
2313 
    result = addTag_result()
2314 
    result.read(self._iprot)
2315 
    self._iprot.readMessageEnd()
2316 
    if result.success is not None:
2317 
      return result.success
2318 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTag failed: unknown result");
2319 
 
2320 
  def deleteEntityTag(self, displayName, itemId):
2321 
    """
2322 
    Parameters:
2323 
     - displayName
2324 
     - itemId
2325 
    """
2326 
    self.send_deleteEntityTag(displayName, itemId)
2327 
    return self.recv_deleteEntityTag()
2328 
 
2329 
  def send_deleteEntityTag(self, displayName, itemId):
2330 
    self._oprot.writeMessageBegin('deleteEntityTag', TMessageType.CALL, self._seqid)
2331 
    args = deleteEntityTag_args()
2332 
    args.displayName = displayName
2333 
    args.itemId = itemId
2334 
    args.write(self._oprot)
2335 
    self._oprot.writeMessageEnd()
2336 
    self._oprot.trans.flush()
2337 
 
2338 
  def recv_deleteEntityTag(self, ):
2339 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2340 
    if mtype == TMessageType.EXCEPTION:
2341 
      x = TApplicationException()
2342 
      x.read(self._iprot)
2343 
      self._iprot.readMessageEnd()
2344 
      raise x
2345 
    result = deleteEntityTag_result()
2346 
    result.read(self._iprot)
2347 
    self._iprot.readMessageEnd()
2348 
    if result.success is not None:
2349 
      return result.success
2350 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteEntityTag failed: unknown result");
2351 
 
2352 
  def deleteTag(self, displayName):
2353 
    """
2354 
    Parameters:
2355 
     - displayName
2356 
    """
2357 
    self.send_deleteTag(displayName)
2358 
    return self.recv_deleteTag()
2359 
 
2360 
  def send_deleteTag(self, displayName):
2361 
    self._oprot.writeMessageBegin('deleteTag', TMessageType.CALL, self._seqid)
2362 
    args = deleteTag_args()
2363 
    args.displayName = displayName
2364 
    args.write(self._oprot)
2365 
    self._oprot.writeMessageEnd()
2366 
    self._oprot.trans.flush()
2367 
 
2368 
  def recv_deleteTag(self, ):
2369 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2370 
    if mtype == TMessageType.EXCEPTION:
2371 
      x = TApplicationException()
2372 
      x.read(self._iprot)
2373 
      self._iprot.readMessageEnd()
2374 
      raise x
2375 
    result = deleteTag_result()
2376 
    result.read(self._iprot)
2377 
    self._iprot.readMessageEnd()
2378 
    if result.success is not None:
2379 
      return result.success
2380 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteTag failed: unknown result");
2381 
 
2382 
  def getAllTags(self, ):
2383 
    self.send_getAllTags()
2384 
    return self.recv_getAllTags()
2385 
 
2386 
  def send_getAllTags(self, ):
2387 
    self._oprot.writeMessageBegin('getAllTags', TMessageType.CALL, self._seqid)
2388 
    args = getAllTags_args()
2389 
    args.write(self._oprot)
2390 
    self._oprot.writeMessageEnd()
2391 
    self._oprot.trans.flush()
2392 
 
2393 
  def recv_getAllTags(self, ):
2394 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2395 
    if mtype == TMessageType.EXCEPTION:
2396 
      x = TApplicationException()
2397 
      x.read(self._iprot)
2398 
      self._iprot.readMessageEnd()
2399 
      raise x
2400 
    result = getAllTags_result()
2401 
    result.read(self._iprot)
2402 
    self._iprot.readMessageEnd()
2403 
    if result.success is not None:
2404 
      return result.success
2405 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllTags failed: unknown result");
2406 
 
2407 
  def getAllEntitiesByTagName(self, displayName):
2408 
    """
2409 
    Parameters:
2410 
     - displayName
2411 
    """
2412 
    self.send_getAllEntitiesByTagName(displayName)
2413 
    return self.recv_getAllEntitiesByTagName()
2414 
 
2415 
  def send_getAllEntitiesByTagName(self, displayName):
2416 
    self._oprot.writeMessageBegin('getAllEntitiesByTagName', TMessageType.CALL, self._seqid)
2417 
    args = getAllEntitiesByTagName_args()
2418 
    args.displayName = displayName
2419 
    args.write(self._oprot)
2420 
    self._oprot.writeMessageEnd()
2421 
    self._oprot.trans.flush()
2422 
 
2423 
  def recv_getAllEntitiesByTagName(self, ):
2424 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2425 
    if mtype == TMessageType.EXCEPTION:
2426 
      x = TApplicationException()
2427 
      x.read(self._iprot)
2428 
      self._iprot.readMessageEnd()
2429 
      raise x
2430 
    result = getAllEntitiesByTagName_result()
2431 
    result.read(self._iprot)
2432 
    self._iprot.readMessageEnd()
2433 
    if result.success is not None:
2434 
      return result.success
2435 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntitiesByTagName failed: unknown result");
2436 
 
6845 amit.gupta 2437 
  def getAllEntityTags(self, ):
2438 
    self.send_getAllEntityTags()
2439 
    return self.recv_getAllEntityTags()
2440 
 
2441 
  def send_getAllEntityTags(self, ):
2442 
    self._oprot.writeMessageBegin('getAllEntityTags', TMessageType.CALL, self._seqid)
2443 
    args = getAllEntityTags_args()
2444 
    args.write(self._oprot)
2445 
    self._oprot.writeMessageEnd()
2446 
    self._oprot.trans.flush()
2447 
 
2448 
  def recv_getAllEntityTags(self, ):
2449 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2450 
    if mtype == TMessageType.EXCEPTION:
2451 
      x = TApplicationException()
2452 
      x.read(self._iprot)
2453 
      self._iprot.readMessageEnd()
2454 
      raise x
2455 
    result = getAllEntityTags_result()
2456 
    result.read(self._iprot)
2457 
    self._iprot.readMessageEnd()
2458 
    if result.success is not None:
2459 
      return result.success
2460 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntityTags failed: unknown result");
2461 
 
8590 kshitij.so 2462 
  def addBanner(self, bannerCongregate):
6850 kshitij.so 2463 
    """
8579 kshitij.so 2464 
    Banner Related
2465 
 
6850 kshitij.so 2466 
    Parameters:
8590 kshitij.so 2467 
     - bannerCongregate
6850 kshitij.so 2468 
    """
8590 kshitij.so 2469 
    self.send_addBanner(bannerCongregate)
10097 kshitij.so 2470 
    return self.recv_addBanner()
6850 kshitij.so 2471 
 
8590 kshitij.so 2472 
  def send_addBanner(self, bannerCongregate):
6850 kshitij.so 2473 
    self._oprot.writeMessageBegin('addBanner', TMessageType.CALL, self._seqid)
2474 
    args = addBanner_args()
8590 kshitij.so 2475 
    args.bannerCongregate = bannerCongregate
6850 kshitij.so 2476 
    args.write(self._oprot)
2477 
    self._oprot.writeMessageEnd()
2478 
    self._oprot.trans.flush()
2479 
 
2480 
  def recv_addBanner(self, ):
2481 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2482 
    if mtype == TMessageType.EXCEPTION:
2483 
      x = TApplicationException()
2484 
      x.read(self._iprot)
2485 
      self._iprot.readMessageEnd()
2486 
      raise x
2487 
    result = addBanner_result()
2488 
    result.read(self._iprot)
2489 
    self._iprot.readMessageEnd()
10097 kshitij.so 2490 
    if result.success is not None:
2491 
      return result.success
2492 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBanner failed: unknown result");
6850 kshitij.so 2493 
 
8579 kshitij.so 2494 
  def updateBanner(self, banner):
2495 
    """
2496 
    Parameters:
2497 
     - banner
2498 
    """
2499 
    self.send_updateBanner(banner)
2500 
    return self.recv_updateBanner()
2501 
 
2502 
  def send_updateBanner(self, banner):
2503 
    self._oprot.writeMessageBegin('updateBanner', TMessageType.CALL, self._seqid)
2504 
    args = updateBanner_args()
2505 
    args.banner = banner
2506 
    args.write(self._oprot)
2507 
    self._oprot.writeMessageEnd()
2508 
    self._oprot.trans.flush()
2509 
 
2510 
  def recv_updateBanner(self, ):
2511 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2512 
    if mtype == TMessageType.EXCEPTION:
2513 
      x = TApplicationException()
2514 
      x.read(self._iprot)
2515 
      self._iprot.readMessageEnd()
2516 
      raise x
2517 
    result = updateBanner_result()
2518 
    result.read(self._iprot)
2519 
    self._iprot.readMessageEnd()
2520 
    if result.success is not None:
2521 
      return result.success
2522 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBanner failed: unknown result");
2523 
 
6850 kshitij.so 2524 
  def getAllBanners(self, ):
2525 
    self.send_getAllBanners()
2526 
    return self.recv_getAllBanners()
2527 
 
2528 
  def send_getAllBanners(self, ):
2529 
    self._oprot.writeMessageBegin('getAllBanners', TMessageType.CALL, self._seqid)
2530 
    args = getAllBanners_args()
2531 
    args.write(self._oprot)
2532 
    self._oprot.writeMessageEnd()
2533 
    self._oprot.trans.flush()
2534 
 
2535 
  def recv_getAllBanners(self, ):
2536 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2537 
    if mtype == TMessageType.EXCEPTION:
2538 
      x = TApplicationException()
2539 
      x.read(self._iprot)
2540 
      self._iprot.readMessageEnd()
2541 
      raise x
2542 
    result = getAllBanners_result()
2543 
    result.read(self._iprot)
2544 
    self._iprot.readMessageEnd()
2545 
    if result.success is not None:
2546 
      return result.success
2547 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBanners failed: unknown result");
2548 
 
9155 kshitij.so 2549 
  def deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 2550 
    """
2551 
    Parameters:
2552 
     - bannerName
9155 kshitij.so 2553 
     - bannerType
6850 kshitij.so 2554 
    """
9155 kshitij.so 2555 
    self.send_deleteBanner(bannerName, bannerType)
6850 kshitij.so 2556 
    return self.recv_deleteBanner()
2557 
 
9155 kshitij.so 2558 
  def send_deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 2559 
    self._oprot.writeMessageBegin('deleteBanner', TMessageType.CALL, self._seqid)
2560 
    args = deleteBanner_args()
2561 
    args.bannerName = bannerName
9155 kshitij.so 2562 
    args.bannerType = bannerType
6850 kshitij.so 2563 
    args.write(self._oprot)
2564 
    self._oprot.writeMessageEnd()
2565 
    self._oprot.trans.flush()
2566 
 
2567 
  def recv_deleteBanner(self, ):
2568 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2569 
    if mtype == TMessageType.EXCEPTION:
2570 
      x = TApplicationException()
2571 
      x.read(self._iprot)
2572 
      self._iprot.readMessageEnd()
2573 
      raise x
2574 
    result = deleteBanner_result()
2575 
    result.read(self._iprot)
2576 
    self._iprot.readMessageEnd()
2577 
    if result.success is not None:
2578 
      return result.success
2579 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBanner failed: unknown result");
2580 
 
9155 kshitij.so 2581 
  def getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 2582 
    """
2583 
    Parameters:
2584 
     - bannerName
9155 kshitij.so 2585 
     - bannerType
6850 kshitij.so 2586 
    """
9155 kshitij.so 2587 
    self.send_getBannerDetails(bannerName, bannerType)
6850 kshitij.so 2588 
    return self.recv_getBannerDetails()
2589 
 
9155 kshitij.so 2590 
  def send_getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 2591 
    self._oprot.writeMessageBegin('getBannerDetails', TMessageType.CALL, self._seqid)
2592 
    args = getBannerDetails_args()
2593 
    args.bannerName = bannerName
9155 kshitij.so 2594 
    args.bannerType = bannerType
6850 kshitij.so 2595 
    args.write(self._oprot)
2596 
    self._oprot.writeMessageEnd()
2597 
    self._oprot.trans.flush()
2598 
 
2599 
  def recv_getBannerDetails(self, ):
2600 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2601 
    if mtype == TMessageType.EXCEPTION:
2602 
      x = TApplicationException()
2603 
      x.read(self._iprot)
2604 
      self._iprot.readMessageEnd()
2605 
      raise x
2606 
    result = getBannerDetails_result()
2607 
    result.read(self._iprot)
2608 
    self._iprot.readMessageEnd()
2609 
    if result.success is not None:
2610 
      return result.success
2611 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerDetails failed: unknown result");
2612 
 
2613 
  def getActiveBanners(self, ):
2614 
    self.send_getActiveBanners()
2615 
    return self.recv_getActiveBanners()
2616 
 
2617 
  def send_getActiveBanners(self, ):
2618 
    self._oprot.writeMessageBegin('getActiveBanners', TMessageType.CALL, self._seqid)
2619 
    args = getActiveBanners_args()
2620 
    args.write(self._oprot)
2621 
    self._oprot.writeMessageEnd()
2622 
    self._oprot.trans.flush()
2623 
 
2624 
  def recv_getActiveBanners(self, ):
2625 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2626 
    if mtype == TMessageType.EXCEPTION:
2627 
      x = TApplicationException()
2628 
      x.read(self._iprot)
2629 
      self._iprot.readMessageEnd()
2630 
      raise x
2631 
    result = getActiveBanners_result()
2632 
    result.read(self._iprot)
2633 
    self._iprot.readMessageEnd()
2634 
    if result.success is not None:
2635 
      return result.success
2636 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBanners failed: unknown result");
2637 
 
8579 kshitij.so 2638 
  def addBannerMap(self, bannerMaps):
6849 kshitij.so 2639 
    """
2640 
    Parameters:
8579 kshitij.so 2641 
     - bannerMaps
6849 kshitij.so 2642 
    """
8579 kshitij.so 2643 
    self.send_addBannerMap(bannerMaps)
6849 kshitij.so 2644 
    return self.recv_addBannerMap()
2645 
 
8579 kshitij.so 2646 
  def send_addBannerMap(self, bannerMaps):
6849 kshitij.so 2647 
    self._oprot.writeMessageBegin('addBannerMap', TMessageType.CALL, self._seqid)
2648 
    args = addBannerMap_args()
8579 kshitij.so 2649 
    args.bannerMaps = bannerMaps
6849 kshitij.so 2650 
    args.write(self._oprot)
2651 
    self._oprot.writeMessageEnd()
2652 
    self._oprot.trans.flush()
2653 
 
2654 
  def recv_addBannerMap(self, ):
2655 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2656 
    if mtype == TMessageType.EXCEPTION:
2657 
      x = TApplicationException()
2658 
      x.read(self._iprot)
2659 
      self._iprot.readMessageEnd()
2660 
      raise x
2661 
    result = addBannerMap_result()
2662 
    result.read(self._iprot)
2663 
    self._iprot.readMessageEnd()
2664 
    if result.success is not None:
2665 
      return result.success
2666 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBannerMap failed: unknown result");
2667 
 
8579 kshitij.so 2668 
  def updateBannerMap(self, bannerMap):
2669 
    """
2670 
    Parameters:
2671 
     - bannerMap
2672 
    """
2673 
    self.send_updateBannerMap(bannerMap)
2674 
    return self.recv_updateBannerMap()
2675 
 
2676 
  def send_updateBannerMap(self, bannerMap):
2677 
    self._oprot.writeMessageBegin('updateBannerMap', TMessageType.CALL, self._seqid)
2678 
    args = updateBannerMap_args()
2679 
    args.bannerMap = bannerMap
2680 
    args.write(self._oprot)
2681 
    self._oprot.writeMessageEnd()
2682 
    self._oprot.trans.flush()
2683 
 
2684 
  def recv_updateBannerMap(self, ):
2685 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2686 
    if mtype == TMessageType.EXCEPTION:
2687 
      x = TApplicationException()
2688 
      x.read(self._iprot)
2689 
      self._iprot.readMessageEnd()
2690 
      raise x
2691 
    result = updateBannerMap_result()
2692 
    result.read(self._iprot)
2693 
    self._iprot.readMessageEnd()
2694 
    if result.success is not None:
2695 
      return result.success
2696 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBannerMap failed: unknown result");
2697 
 
6849 kshitij.so 2698 
  def deleteBannerMap(self, bannerName):
2699 
    """
2700 
    Parameters:
2701 
     - bannerName
2702 
    """
2703 
    self.send_deleteBannerMap(bannerName)
2704 
    return self.recv_deleteBannerMap()
2705 
 
2706 
  def send_deleteBannerMap(self, bannerName):
2707 
    self._oprot.writeMessageBegin('deleteBannerMap', TMessageType.CALL, self._seqid)
2708 
    args = deleteBannerMap_args()
2709 
    args.bannerName = bannerName
2710 
    args.write(self._oprot)
2711 
    self._oprot.writeMessageEnd()
2712 
    self._oprot.trans.flush()
2713 
 
2714 
  def recv_deleteBannerMap(self, ):
2715 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2716 
    if mtype == TMessageType.EXCEPTION:
2717 
      x = TApplicationException()
2718 
      x.read(self._iprot)
2719 
      self._iprot.readMessageEnd()
2720 
      raise x
2721 
    result = deleteBannerMap_result()
2722 
    result.read(self._iprot)
2723 
    self._iprot.readMessageEnd()
2724 
    if result.success is not None:
2725 
      return result.success
2726 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBannerMap failed: unknown result");
2727 
 
9155 kshitij.so 2728 
  def getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 2729 
    """
2730 
    Parameters:
2731 
     - bannerName
9155 kshitij.so 2732 
     - bannerType
6849 kshitij.so 2733 
    """
9155 kshitij.so 2734 
    self.send_getBannerMapDetails(bannerName, bannerType)
6849 kshitij.so 2735 
    return self.recv_getBannerMapDetails()
2736 
 
9155 kshitij.so 2737 
  def send_getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 2738 
    self._oprot.writeMessageBegin('getBannerMapDetails', TMessageType.CALL, self._seqid)
2739 
    args = getBannerMapDetails_args()
2740 
    args.bannerName = bannerName
9155 kshitij.so 2741 
    args.bannerType = bannerType
6849 kshitij.so 2742 
    args.write(self._oprot)
2743 
    self._oprot.writeMessageEnd()
2744 
    self._oprot.trans.flush()
2745 
 
2746 
  def recv_getBannerMapDetails(self, ):
2747 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2748 
    if mtype == TMessageType.EXCEPTION:
2749 
      x = TApplicationException()
2750 
      x.read(self._iprot)
2751 
      self._iprot.readMessageEnd()
2752 
      raise x
2753 
    result = getBannerMapDetails_result()
2754 
    result.read(self._iprot)
2755 
    self._iprot.readMessageEnd()
2756 
    if result.success is not None:
2757 
      return result.success
2758 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerMapDetails failed: unknown result");
2759 
 
8579 kshitij.so 2760 
  def addBannerUri(self, bannerUriMappings):
2761 
    """
2762 
    Parameters:
2763 
     - bannerUriMappings
2764 
    """
2765 
    self.send_addBannerUri(bannerUriMappings)
2766 
    self.recv_addBannerUri()
2767 
 
2768 
  def send_addBannerUri(self, bannerUriMappings):
2769 
    self._oprot.writeMessageBegin('addBannerUri', TMessageType.CALL, self._seqid)
2770 
    args = addBannerUri_args()
2771 
    args.bannerUriMappings = bannerUriMappings
2772 
    args.write(self._oprot)
2773 
    self._oprot.writeMessageEnd()
2774 
    self._oprot.trans.flush()
2775 
 
2776 
  def recv_addBannerUri(self, ):
2777 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2778 
    if mtype == TMessageType.EXCEPTION:
2779 
      x = TApplicationException()
2780 
      x.read(self._iprot)
2781 
      self._iprot.readMessageEnd()
2782 
      raise x
2783 
    result = addBannerUri_result()
2784 
    result.read(self._iprot)
2785 
    self._iprot.readMessageEnd()
2786 
    return
2787 
 
9155 kshitij.so 2788 
  def getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 2789 
    """
2790 
    Parameters:
2791 
     - bannerName
9155 kshitij.so 2792 
     - bannerType
8579 kshitij.so 2793 
    """
9155 kshitij.so 2794 
    self.send_getUriMapping(bannerName, bannerType)
8579 kshitij.so 2795 
    return self.recv_getUriMapping()
2796 
 
9155 kshitij.so 2797 
  def send_getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 2798 
    self._oprot.writeMessageBegin('getUriMapping', TMessageType.CALL, self._seqid)
2799 
    args = getUriMapping_args()
2800 
    args.bannerName = bannerName
9155 kshitij.so 2801 
    args.bannerType = bannerType
8579 kshitij.so 2802 
    args.write(self._oprot)
2803 
    self._oprot.writeMessageEnd()
2804 
    self._oprot.trans.flush()
2805 
 
2806 
  def recv_getUriMapping(self, ):
2807 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2808 
    if mtype == TMessageType.EXCEPTION:
2809 
      x = TApplicationException()
2810 
      x.read(self._iprot)
2811 
      self._iprot.readMessageEnd()
2812 
      raise x
2813 
    result = getUriMapping_result()
2814 
    result.read(self._iprot)
2815 
    self._iprot.readMessageEnd()
2816 
    if result.success is not None:
2817 
      return result.success
2818 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUriMapping failed: unknown result");
2819 
 
2820 
  def addCampaign(self, campaign):
2821 
    """
2822 
    Parameters:
2823 
     - campaign
2824 
    """
2825 
    self.send_addCampaign(campaign)
2826 
    self.recv_addCampaign()
2827 
 
2828 
  def send_addCampaign(self, campaign):
2829 
    self._oprot.writeMessageBegin('addCampaign', TMessageType.CALL, self._seqid)
2830 
    args = addCampaign_args()
2831 
    args.campaign = campaign
2832 
    args.write(self._oprot)
2833 
    self._oprot.writeMessageEnd()
2834 
    self._oprot.trans.flush()
2835 
 
2836 
  def recv_addCampaign(self, ):
2837 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2838 
    if mtype == TMessageType.EXCEPTION:
2839 
      x = TApplicationException()
2840 
      x.read(self._iprot)
2841 
      self._iprot.readMessageEnd()
2842 
      raise x
2843 
    result = addCampaign_result()
2844 
    result.read(self._iprot)
2845 
    self._iprot.readMessageEnd()
2846 
    return
2847 
 
2848 
  def getCampaigns(self, campaignName):
2849 
    """
2850 
    Parameters:
2851 
     - campaignName
2852 
    """
2853 
    self.send_getCampaigns(campaignName)
2854 
    return self.recv_getCampaigns()
2855 
 
2856 
  def send_getCampaigns(self, campaignName):
2857 
    self._oprot.writeMessageBegin('getCampaigns', TMessageType.CALL, self._seqid)
2858 
    args = getCampaigns_args()
2859 
    args.campaignName = campaignName
2860 
    args.write(self._oprot)
2861 
    self._oprot.writeMessageEnd()
2862 
    self._oprot.trans.flush()
2863 
 
2864 
  def recv_getCampaigns(self, ):
2865 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2866 
    if mtype == TMessageType.EXCEPTION:
2867 
      x = TApplicationException()
2868 
      x.read(self._iprot)
2869 
      self._iprot.readMessageEnd()
2870 
      raise x
2871 
    result = getCampaigns_result()
2872 
    result.read(self._iprot)
2873 
    self._iprot.readMessageEnd()
2874 
    if result.success is not None:
2875 
      return result.success
2876 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCampaigns failed: unknown result");
2877 
 
2878 
  def deleteCampaign(self, campaignId):
2879 
    """
2880 
    Parameters:
2881 
     - campaignId
2882 
    """
2883 
    self.send_deleteCampaign(campaignId)
2884 
    self.recv_deleteCampaign()
2885 
 
2886 
  def send_deleteCampaign(self, campaignId):
2887 
    self._oprot.writeMessageBegin('deleteCampaign', TMessageType.CALL, self._seqid)
2888 
    args = deleteCampaign_args()
2889 
    args.campaignId = campaignId
2890 
    args.write(self._oprot)
2891 
    self._oprot.writeMessageEnd()
2892 
    self._oprot.trans.flush()
2893 
 
2894 
  def recv_deleteCampaign(self, ):
2895 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2896 
    if mtype == TMessageType.EXCEPTION:
2897 
      x = TApplicationException()
2898 
      x.read(self._iprot)
2899 
      self._iprot.readMessageEnd()
2900 
      raise x
2901 
    result = deleteCampaign_result()
2902 
    result.read(self._iprot)
2903 
    self._iprot.readMessageEnd()
2904 
    return
2905 
 
2906 
  def getAllCampaigns(self, ):
2907 
    self.send_getAllCampaigns()
2908 
    return self.recv_getAllCampaigns()
2909 
 
2910 
  def send_getAllCampaigns(self, ):
2911 
    self._oprot.writeMessageBegin('getAllCampaigns', TMessageType.CALL, self._seqid)
2912 
    args = getAllCampaigns_args()
2913 
    args.write(self._oprot)
2914 
    self._oprot.writeMessageEnd()
2915 
    self._oprot.trans.flush()
2916 
 
2917 
  def recv_getAllCampaigns(self, ):
2918 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2919 
    if mtype == TMessageType.EXCEPTION:
2920 
      x = TApplicationException()
2921 
      x.read(self._iprot)
2922 
      self._iprot.readMessageEnd()
2923 
      raise x
2924 
    result = getAllCampaigns_result()
2925 
    result.read(self._iprot)
2926 
    self._iprot.readMessageEnd()
2927 
    if result.success is not None:
2928 
      return result.success
2929 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCampaigns failed: unknown result");
2930 
 
9155 kshitij.so 2931 
  def getActiveBannersForMobileSite(self, ):
2932 
    self.send_getActiveBannersForMobileSite()
2933 
    return self.recv_getActiveBannersForMobileSite()
2934 
 
2935 
  def send_getActiveBannersForMobileSite(self, ):
2936 
    self._oprot.writeMessageBegin('getActiveBannersForMobileSite', TMessageType.CALL, self._seqid)
2937 
    args = getActiveBannersForMobileSite_args()
2938 
    args.write(self._oprot)
2939 
    self._oprot.writeMessageEnd()
2940 
    self._oprot.trans.flush()
2941 
 
2942 
  def recv_getActiveBannersForMobileSite(self, ):
2943 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2944 
    if mtype == TMessageType.EXCEPTION:
2945 
      x = TApplicationException()
2946 
      x.read(self._iprot)
2947 
      self._iprot.readMessageEnd()
2948 
      raise x
2949 
    result = getActiveBannersForMobileSite_result()
2950 
    result.read(self._iprot)
2951 
    self._iprot.readMessageEnd()
2952 
    if result.success is not None:
2953 
      return result.success
2954 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBannersForMobileSite failed: unknown result");
2955 
 
5944 mandeep.dh 2956 
  def deleteSimilarItem(self, itemId, catalogItemId):
2957 
    """
2958 
    Delete similar item.
2959 
 
2960 
    Parameters:
2961 
     - itemId
2962 
     - catalogItemId
2963 
    """
2964 
    self.send_deleteSimilarItem(itemId, catalogItemId)
2965 
    return self.recv_deleteSimilarItem()
2966 
 
2967 
  def send_deleteSimilarItem(self, itemId, catalogItemId):
2968 
    self._oprot.writeMessageBegin('deleteSimilarItem', TMessageType.CALL, self._seqid)
2969 
    args = deleteSimilarItem_args()
2970 
    args.itemId = itemId
2971 
    args.catalogItemId = catalogItemId
2972 
    args.write(self._oprot)
2973 
    self._oprot.writeMessageEnd()
2974 
    self._oprot.trans.flush()
2975 
 
2976 
  def recv_deleteSimilarItem(self, ):
2977 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2978 
    if mtype == TMessageType.EXCEPTION:
2979 
      x = TApplicationException()
2980 
      x.read(self._iprot)
2981 
      self._iprot.readMessageEnd()
2982 
      raise x
2983 
    result = deleteSimilarItem_result()
2984 
    result.read(self._iprot)
2985 
    self._iprot.readMessageEnd()
2986 
    if result.success is not None:
2987 
      return result.success
2988 
    if result.cex is not None:
2989 
      raise result.cex
2990 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteSimilarItem failed: unknown result");
2991 
 
2992 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
2993 
    """
2994 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
2995 
    If yes, returns the itemId else returns 0
2996 
 
2997 
    Parameters:
2998 
     - brand
2999 
     - modelNumber
3000 
     - modelName
3001 
     - color
3002 
    """
3003 
    self.send_checkSimilarItem(brand, modelNumber, modelName, color)
3004 
    return self.recv_checkSimilarItem()
3005 
 
3006 
  def send_checkSimilarItem(self, brand, modelNumber, modelName, color):
3007 
    self._oprot.writeMessageBegin('checkSimilarItem', TMessageType.CALL, self._seqid)
3008 
    args = checkSimilarItem_args()
3009 
    args.brand = brand
3010 
    args.modelNumber = modelNumber
3011 
    args.modelName = modelName
3012 
    args.color = color
3013 
    args.write(self._oprot)
3014 
    self._oprot.writeMessageEnd()
3015 
    self._oprot.trans.flush()
3016 
 
3017 
  def recv_checkSimilarItem(self, ):
3018 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3019 
    if mtype == TMessageType.EXCEPTION:
3020 
      x = TApplicationException()
3021 
      x.read(self._iprot)
3022 
      self._iprot.readMessageEnd()
3023 
      raise x
3024 
    result = checkSimilarItem_result()
3025 
    result.read(self._iprot)
3026 
    self._iprot.readMessageEnd()
3027 
    if result.success is not None:
3028 
      return result.success
3029 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkSimilarItem failed: unknown result");
3030 
 
3031 
  def validateRiskyStatus(self, itemId):
3032 
    """
3033 
    Check wether item is risky and change status if inventory is not available for risky items
3034 
 
3035 
    Parameters:
3036 
     - itemId
3037 
    """
3038 
    self.send_validateRiskyStatus(itemId)
3039 
    self.recv_validateRiskyStatus()
3040 
 
3041 
  def send_validateRiskyStatus(self, itemId):
3042 
    self._oprot.writeMessageBegin('validateRiskyStatus', TMessageType.CALL, self._seqid)
3043 
    args = validateRiskyStatus_args()
3044 
    args.itemId = itemId
3045 
    args.write(self._oprot)
3046 
    self._oprot.writeMessageEnd()
3047 
    self._oprot.trans.flush()
3048 
 
3049 
  def recv_validateRiskyStatus(self, ):
3050 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3051 
    if mtype == TMessageType.EXCEPTION:
3052 
      x = TApplicationException()
3053 
      x.read(self._iprot)
3054 
      self._iprot.readMessageEnd()
3055 
      raise x
3056 
    result = validateRiskyStatus_result()
3057 
    result.read(self._iprot)
3058 
    self._iprot.readMessageEnd()
3059 
    return
3060 
 
3061 
  def changeItemRiskyFlag(self, itemId, risky):
3062 
    """
3063 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
3064 
 
3065 
    Parameters:
3066 
     - itemId
3067 
     - risky
3068 
    """
3069 
    self.send_changeItemRiskyFlag(itemId, risky)
3070 
    self.recv_changeItemRiskyFlag()
3071 
 
3072 
  def send_changeItemRiskyFlag(self, itemId, risky):
3073 
    self._oprot.writeMessageBegin('changeItemRiskyFlag', TMessageType.CALL, self._seqid)
3074 
    args = changeItemRiskyFlag_args()
3075 
    args.itemId = itemId
3076 
    args.risky = risky
3077 
    args.write(self._oprot)
3078 
    self._oprot.writeMessageEnd()
3079 
    self._oprot.trans.flush()
3080 
 
3081 
  def recv_changeItemRiskyFlag(self, ):
3082 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3083 
    if mtype == TMessageType.EXCEPTION:
3084 
      x = TApplicationException()
3085 
      x.read(self._iprot)
3086 
      self._iprot.readMessageEnd()
3087 
      raise x
3088 
    result = changeItemRiskyFlag_result()
3089 
    result.read(self._iprot)
3090 
    self._iprot.readMessageEnd()
3091 
    return
3092 
 
3093 
  def getItemsByRiskyFlag(self, ):
3094 
    """
3095 
    Returns list of items marked as risky.
3096 
    """
3097 
    self.send_getItemsByRiskyFlag()
3098 
    return self.recv_getItemsByRiskyFlag()
3099 
 
3100 
  def send_getItemsByRiskyFlag(self, ):
3101 
    self._oprot.writeMessageBegin('getItemsByRiskyFlag', TMessageType.CALL, self._seqid)
3102 
    args = getItemsByRiskyFlag_args()
3103 
    args.write(self._oprot)
3104 
    self._oprot.writeMessageEnd()
3105 
    self._oprot.trans.flush()
3106 
 
3107 
  def recv_getItemsByRiskyFlag(self, ):
3108 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3109 
    if mtype == TMessageType.EXCEPTION:
3110 
      x = TApplicationException()
3111 
      x.read(self._iprot)
3112 
      self._iprot.readMessageEnd()
3113 
      raise x
3114 
    result = getItemsByRiskyFlag_result()
3115 
    result.read(self._iprot)
3116 
    self._iprot.readMessageEnd()
3117 
    if result.success is not None:
3118 
      return result.success
3119 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByRiskyFlag failed: unknown result");
3120 
 
3121 
  def getItemsForMasterSheet(self, category, brand):
3122 
    """
3123 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
3124 
 
3125 
    Parameters:
3126 
     - category
3127 
     - brand
3128 
    """
3129 
    self.send_getItemsForMasterSheet(category, brand)
3130 
    return self.recv_getItemsForMasterSheet()
3131 
 
3132 
  def send_getItemsForMasterSheet(self, category, brand):
3133 
    self._oprot.writeMessageBegin('getItemsForMasterSheet', TMessageType.CALL, self._seqid)
3134 
    args = getItemsForMasterSheet_args()
3135 
    args.category = category
3136 
    args.brand = brand
3137 
    args.write(self._oprot)
3138 
    self._oprot.writeMessageEnd()
3139 
    self._oprot.trans.flush()
3140 
 
3141 
  def recv_getItemsForMasterSheet(self, ):
3142 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3143 
    if mtype == TMessageType.EXCEPTION:
3144 
      x = TApplicationException()
3145 
      x.read(self._iprot)
3146 
      self._iprot.readMessageEnd()
3147 
      raise x
3148 
    result = getItemsForMasterSheet_result()
3149 
    result.read(self._iprot)
3150 
    self._iprot.readMessageEnd()
3151 
    if result.success is not None:
3152 
      return result.success
3153 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsForMasterSheet failed: unknown result");
3154 
 
3155 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
3156 
    """
3157 
    Returns list of catalog ids of items with same similarity index as of the given itemId
3158 
 
3159 
    Parameters:
3160 
     - beginIndex
3161 
     - totalItems
3162 
     - itemId
3163 
    """
3164 
    self.send_getSimilarItemsCatalogIds(beginIndex, totalItems, itemId)
3165 
    return self.recv_getSimilarItemsCatalogIds()
3166 
 
3167 
  def send_getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
3168 
    self._oprot.writeMessageBegin('getSimilarItemsCatalogIds', TMessageType.CALL, self._seqid)
3169 
    args = getSimilarItemsCatalogIds_args()
3170 
    args.beginIndex = beginIndex
3171 
    args.totalItems = totalItems
3172 
    args.itemId = itemId
3173 
    args.write(self._oprot)
3174 
    self._oprot.writeMessageEnd()
3175 
    self._oprot.trans.flush()
3176 
 
3177 
  def recv_getSimilarItemsCatalogIds(self, ):
3178 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3179 
    if mtype == TMessageType.EXCEPTION:
3180 
      x = TApplicationException()
3181 
      x.read(self._iprot)
3182 
      self._iprot.readMessageEnd()
3183 
      raise x
3184 
    result = getSimilarItemsCatalogIds_result()
3185 
    result.read(self._iprot)
3186 
    self._iprot.readMessageEnd()
3187 
    if result.success is not None:
3188 
      return result.success
3189 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSimilarItemsCatalogIds failed: unknown result");
3190 
 
3191 
  def addProductNotification(self, itemId, email):
3192 
    """
3193 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
3194 
 
3195 
    Parameters:
3196 
     - itemId
3197 
     - email
3198 
    """
3199 
    self.send_addProductNotification(itemId, email)
3200 
    return self.recv_addProductNotification()
3201 
 
3202 
  def send_addProductNotification(self, itemId, email):
3203 
    self._oprot.writeMessageBegin('addProductNotification', TMessageType.CALL, self._seqid)
3204 
    args = addProductNotification_args()
3205 
    args.itemId = itemId
3206 
    args.email = email
3207 
    args.write(self._oprot)
3208 
    self._oprot.writeMessageEnd()
3209 
    self._oprot.trans.flush()
3210 
 
3211 
  def recv_addProductNotification(self, ):
3212 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3213 
    if mtype == TMessageType.EXCEPTION:
3214 
      x = TApplicationException()
3215 
      x.read(self._iprot)
3216 
      self._iprot.readMessageEnd()
3217 
      raise x
3218 
    result = addProductNotification_result()
3219 
    result.read(self._iprot)
3220 
    self._iprot.readMessageEnd()
3221 
    if result.success is not None:
3222 
      return result.success
3223 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductNotification failed: unknown result");
3224 
 
3225 
  def sendProductNotifications(self, ):
3226 
    """
3227 
    Send the product notifications to the users for items which has stock.
3228 
    """
3229 
    self.send_sendProductNotifications()
3230 
    return self.recv_sendProductNotifications()
3231 
 
3232 
  def send_sendProductNotifications(self, ):
3233 
    self._oprot.writeMessageBegin('sendProductNotifications', TMessageType.CALL, self._seqid)
3234 
    args = sendProductNotifications_args()
3235 
    args.write(self._oprot)
3236 
    self._oprot.writeMessageEnd()
3237 
    self._oprot.trans.flush()
3238 
 
3239 
  def recv_sendProductNotifications(self, ):
3240 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3241 
    if mtype == TMessageType.EXCEPTION:
3242 
      x = TApplicationException()
3243 
      x.read(self._iprot)
3244 
      self._iprot.readMessageEnd()
3245 
      raise x
3246 
    result = sendProductNotifications_result()
3247 
    result.read(self._iprot)
3248 
    self._iprot.readMessageEnd()
3249 
    if result.success is not None:
3250 
      return result.success
3251 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendProductNotifications failed: unknown result");
3252 
 
3253 
  def getAllBrandsByCategory(self, categoryId):
3254 
    """
3255 
    Returns list of brand names for a given category Id
3256 
 
3257 
    Parameters:
3258 
     - categoryId
3259 
    """
3260 
    self.send_getAllBrandsByCategory(categoryId)
3261 
    return self.recv_getAllBrandsByCategory()
3262 
 
3263 
  def send_getAllBrandsByCategory(self, categoryId):
3264 
    self._oprot.writeMessageBegin('getAllBrandsByCategory', TMessageType.CALL, self._seqid)
3265 
    args = getAllBrandsByCategory_args()
3266 
    args.categoryId = categoryId
3267 
    args.write(self._oprot)
3268 
    self._oprot.writeMessageEnd()
3269 
    self._oprot.trans.flush()
3270 
 
3271 
  def recv_getAllBrandsByCategory(self, ):
3272 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3273 
    if mtype == TMessageType.EXCEPTION:
3274 
      x = TApplicationException()
3275 
      x.read(self._iprot)
3276 
      self._iprot.readMessageEnd()
3277 
      raise x
3278 
    result = getAllBrandsByCategory_result()
3279 
    result.read(self._iprot)
3280 
    self._iprot.readMessageEnd()
3281 
    if result.success is not None:
3282 
      return result.success
3283 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrandsByCategory failed: unknown result");
3284 
 
3285 
  def getAllBrands(self, ):
3286 
    """
3287 
    Returns list of brand names
3288 
    """
3289 
    self.send_getAllBrands()
3290 
    return self.recv_getAllBrands()
3291 
 
3292 
  def send_getAllBrands(self, ):
3293 
    self._oprot.writeMessageBegin('getAllBrands', TMessageType.CALL, self._seqid)
3294 
    args = getAllBrands_args()
3295 
    args.write(self._oprot)
3296 
    self._oprot.writeMessageEnd()
3297 
    self._oprot.trans.flush()
3298 
 
3299 
  def recv_getAllBrands(self, ):
3300 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3301 
    if mtype == TMessageType.EXCEPTION:
3302 
      x = TApplicationException()
3303 
      x.read(self._iprot)
3304 
      self._iprot.readMessageEnd()
3305 
      raise x
3306 
    result = getAllBrands_result()
3307 
    result.read(self._iprot)
3308 
    self._iprot.readMessageEnd()
3309 
    if result.success is not None:
3310 
      return result.success
3311 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrands failed: unknown result");
3312 
 
3313 
  def getAllSources(self, ):
3314 
    """
3315 
    Return list of all sources
3316 
    """
3317 
    self.send_getAllSources()
3318 
    return self.recv_getAllSources()
3319 
 
3320 
  def send_getAllSources(self, ):
3321 
    self._oprot.writeMessageBegin('getAllSources', TMessageType.CALL, self._seqid)
3322 
    args = getAllSources_args()
3323 
    args.write(self._oprot)
3324 
    self._oprot.writeMessageEnd()
3325 
    self._oprot.trans.flush()
3326 
 
3327 
  def recv_getAllSources(self, ):
3328 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3329 
    if mtype == TMessageType.EXCEPTION:
3330 
      x = TApplicationException()
3331 
      x.read(self._iprot)
3332 
      self._iprot.readMessageEnd()
3333 
      raise x
3334 
    result = getAllSources_result()
3335 
    result.read(self._iprot)
3336 
    self._iprot.readMessageEnd()
3337 
    if result.success is not None:
3338 
      return result.success
3339 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSources failed: unknown result");
3340 
 
3341 
  def getItemPricingBySource(self, itemId, sourceId):
3342 
    """
3343 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
3344 
 
3345 
    Parameters:
3346 
     - itemId
3347 
     - sourceId
3348 
    """
3349 
    self.send_getItemPricingBySource(itemId, sourceId)
3350 
    return self.recv_getItemPricingBySource()
3351 
 
3352 
  def send_getItemPricingBySource(self, itemId, sourceId):
3353 
    self._oprot.writeMessageBegin('getItemPricingBySource', TMessageType.CALL, self._seqid)
3354 
    args = getItemPricingBySource_args()
3355 
    args.itemId = itemId
3356 
    args.sourceId = sourceId
3357 
    args.write(self._oprot)
3358 
    self._oprot.writeMessageEnd()
3359 
    self._oprot.trans.flush()
3360 
 
3361 
  def recv_getItemPricingBySource(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 = getItemPricingBySource_result()
3369 
    result.read(self._iprot)
3370 
    self._iprot.readMessageEnd()
3371 
    if result.success is not None:
3372 
      return result.success
3373 
    if result.cex is not None:
3374 
      raise result.cex
3375 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricingBySource failed: unknown result");
3376 
 
3377 
  def addSourceItemPricing(self, sourceItemPricing):
3378 
    """
3379 
    Adds prices to be displayed corresponding to the item if user comes from a source.
3380 
    If item is not found or source is not found, it will throw exception.
3381 
 
3382 
    Parameters:
3383 
     - sourceItemPricing
3384 
    """
3385 
    self.send_addSourceItemPricing(sourceItemPricing)
3386 
    self.recv_addSourceItemPricing()
3387 
 
3388 
  def send_addSourceItemPricing(self, sourceItemPricing):
3389 
    self._oprot.writeMessageBegin('addSourceItemPricing', TMessageType.CALL, self._seqid)
3390 
    args = addSourceItemPricing_args()
3391 
    args.sourceItemPricing = sourceItemPricing
3392 
    args.write(self._oprot)
3393 
    self._oprot.writeMessageEnd()
3394 
    self._oprot.trans.flush()
3395 
 
3396 
  def recv_addSourceItemPricing(self, ):
3397 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3398 
    if mtype == TMessageType.EXCEPTION:
3399 
      x = TApplicationException()
3400 
      x.read(self._iprot)
3401 
      self._iprot.readMessageEnd()
3402 
      raise x
3403 
    result = addSourceItemPricing_result()
3404 
    result.read(self._iprot)
3405 
    self._iprot.readMessageEnd()
3406 
    if result.cex is not None:
3407 
      raise result.cex
3408 
    return
3409 
 
3410 
  def getAllSourcePricing(self, itemId):
3411 
    """
3412 
    Returns the list of source pricing information of an item.
3413 
    Raises an exception if item not found corresponding to itemId
3414 
 
3415 
    Parameters:
3416 
     - itemId
3417 
    """
3418 
    self.send_getAllSourcePricing(itemId)
3419 
    return self.recv_getAllSourcePricing()
3420 
 
3421 
  def send_getAllSourcePricing(self, itemId):
3422 
    self._oprot.writeMessageBegin('getAllSourcePricing', TMessageType.CALL, self._seqid)
3423 
    args = getAllSourcePricing_args()
3424 
    args.itemId = itemId
3425 
    args.write(self._oprot)
3426 
    self._oprot.writeMessageEnd()
3427 
    self._oprot.trans.flush()
3428 
 
3429 
  def recv_getAllSourcePricing(self, ):
3430 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3431 
    if mtype == TMessageType.EXCEPTION:
3432 
      x = TApplicationException()
3433 
      x.read(self._iprot)
3434 
      self._iprot.readMessageEnd()
3435 
      raise x
3436 
    result = getAllSourcePricing_result()
3437 
    result.read(self._iprot)
3438 
    self._iprot.readMessageEnd()
3439 
    if result.success is not None:
3440 
      return result.success
3441 
    if result.cex is not None:
3442 
      raise result.cex
3443 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSourcePricing failed: unknown result");
3444 
 
3445 
  def getItemForSource(self, item_id, sourceId):
3446 
    """
3447 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
3448 
 
3449 
    Parameters:
3450 
     - item_id
3451 
     - sourceId
3452 
    """
3453 
    self.send_getItemForSource(item_id, sourceId)
3454 
    return self.recv_getItemForSource()
3455 
 
3456 
  def send_getItemForSource(self, item_id, sourceId):
3457 
    self._oprot.writeMessageBegin('getItemForSource', TMessageType.CALL, self._seqid)
3458 
    args = getItemForSource_args()
3459 
    args.item_id = item_id
3460 
    args.sourceId = sourceId
3461 
    args.write(self._oprot)
3462 
    self._oprot.writeMessageEnd()
3463 
    self._oprot.trans.flush()
3464 
 
3465 
  def recv_getItemForSource(self, ):
3466 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3467 
    if mtype == TMessageType.EXCEPTION:
3468 
      x = TApplicationException()
3469 
      x.read(self._iprot)
3470 
      self._iprot.readMessageEnd()
3471 
      raise x
3472 
    result = getItemForSource_result()
3473 
    result.read(self._iprot)
3474 
    self._iprot.readMessageEnd()
3475 
    if result.success is not None:
3476 
      return result.success
3477 
    if result.cex is not None:
3478 
      raise result.cex
3479 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemForSource failed: unknown result");
3480 
 
3481 
  def searchItemsInRange(self, searchTerms, offset, limit):
3482 
    """
3483 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
3484 
 
3485 
    Parameters:
3486 
     - searchTerms
3487 
     - offset
3488 
     - limit
3489 
    """
3490 
    self.send_searchItemsInRange(searchTerms, offset, limit)
3491 
    return self.recv_searchItemsInRange()
3492 
 
3493 
  def send_searchItemsInRange(self, searchTerms, offset, limit):
3494 
    self._oprot.writeMessageBegin('searchItemsInRange', TMessageType.CALL, self._seqid)
3495 
    args = searchItemsInRange_args()
3496 
    args.searchTerms = searchTerms
3497 
    args.offset = offset
3498 
    args.limit = limit
3499 
    args.write(self._oprot)
3500 
    self._oprot.writeMessageEnd()
3501 
    self._oprot.trans.flush()
3502 
 
3503 
  def recv_searchItemsInRange(self, ):
3504 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3505 
    if mtype == TMessageType.EXCEPTION:
3506 
      x = TApplicationException()
3507 
      x.read(self._iprot)
3508 
      self._iprot.readMessageEnd()
3509 
      raise x
3510 
    result = searchItemsInRange_result()
3511 
    result.read(self._iprot)
3512 
    self._iprot.readMessageEnd()
3513 
    if result.success is not None:
3514 
      return result.success
3515 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchItemsInRange failed: unknown result");
3516 
 
3517 
  def getSearchResultCount(self, searchTerms):
3518 
    """
3519 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
3520 
 
3521 
    Parameters:
3522 
     - searchTerms
3523 
    """
3524 
    self.send_getSearchResultCount(searchTerms)
3525 
    return self.recv_getSearchResultCount()
3526 
 
3527 
  def send_getSearchResultCount(self, searchTerms):
3528 
    self._oprot.writeMessageBegin('getSearchResultCount', TMessageType.CALL, self._seqid)
3529 
    args = getSearchResultCount_args()
3530 
    args.searchTerms = searchTerms
3531 
    args.write(self._oprot)
3532 
    self._oprot.writeMessageEnd()
3533 
    self._oprot.trans.flush()
3534 
 
3535 
  def recv_getSearchResultCount(self, ):
3536 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3537 
    if mtype == TMessageType.EXCEPTION:
3538 
      x = TApplicationException()
3539 
      x.read(self._iprot)
3540 
      self._iprot.readMessageEnd()
3541 
      raise x
3542 
    result = getSearchResultCount_result()
3543 
    result.read(self._iprot)
3544 
    self._iprot.readMessageEnd()
3545 
    if result.success is not None:
3546 
      return result.success
3547 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSearchResultCount failed: unknown result");
3548 
 
3549 
  def getProductNotifications(self, startDateTime):
3550 
    """
3551 
    Returns a list of product notifications added after a supplied datetime
3552 
 
3553 
    Parameters:
3554 
     - startDateTime
3555 
    """
3556 
    self.send_getProductNotifications(startDateTime)
3557 
    return self.recv_getProductNotifications()
3558 
 
3559 
  def send_getProductNotifications(self, startDateTime):
3560 
    self._oprot.writeMessageBegin('getProductNotifications', TMessageType.CALL, self._seqid)
3561 
    args = getProductNotifications_args()
3562 
    args.startDateTime = startDateTime
3563 
    args.write(self._oprot)
3564 
    self._oprot.writeMessageEnd()
3565 
    self._oprot.trans.flush()
3566 
 
3567 
  def recv_getProductNotifications(self, ):
3568 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3569 
    if mtype == TMessageType.EXCEPTION:
3570 
      x = TApplicationException()
3571 
      x.read(self._iprot)
3572 
      self._iprot.readMessageEnd()
3573 
      raise x
3574 
    result = getProductNotifications_result()
3575 
    result.read(self._iprot)
3576 
    self._iprot.readMessageEnd()
3577 
    if result.success is not None:
3578 
      return result.success
3579 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotifications failed: unknown result");
3580 
 
7897 amar.kumar 3581 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3582 
    """
3583 
    Returns a list of count of requests for product notification against each item
3584 
 
3585 
    Parameters:
3586 
     - startDateTime
7897 amar.kumar 3587 
     - categoryId
5944 mandeep.dh 3588 
    """
7897 amar.kumar 3589 
    self.send_getProductNotificationRequestCount(startDateTime, categoryId)
5944 mandeep.dh 3590 
    return self.recv_getProductNotificationRequestCount()
3591 
 
7897 amar.kumar 3592 
  def send_getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3593 
    self._oprot.writeMessageBegin('getProductNotificationRequestCount', TMessageType.CALL, self._seqid)
3594 
    args = getProductNotificationRequestCount_args()
3595 
    args.startDateTime = startDateTime
7897 amar.kumar 3596 
    args.categoryId = categoryId
5944 mandeep.dh 3597 
    args.write(self._oprot)
3598 
    self._oprot.writeMessageEnd()
3599 
    self._oprot.trans.flush()
3600 
 
3601 
  def recv_getProductNotificationRequestCount(self, ):
3602 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3603 
    if mtype == TMessageType.EXCEPTION:
3604 
      x = TApplicationException()
3605 
      x.read(self._iprot)
3606 
      self._iprot.readMessageEnd()
3607 
      raise x
3608 
    result = getProductNotificationRequestCount_result()
3609 
    result.read(self._iprot)
3610 
    self._iprot.readMessageEnd()
3611 
    if result.success is not None:
3612 
      return result.success
3613 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotificationRequestCount failed: unknown result");
3614 
 
3615 
  def addAuthorizationLog(self, itemId, username, reason):
3616 
    """
3617 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
3618 
 
3619 
    Parameters:
3620 
     - itemId
3621 
     - username
3622 
     - reason
3623 
    """
3624 
    self.send_addAuthorizationLog(itemId, username, reason)
3625 
    return self.recv_addAuthorizationLog()
3626 
 
3627 
  def send_addAuthorizationLog(self, itemId, username, reason):
3628 
    self._oprot.writeMessageBegin('addAuthorizationLog', TMessageType.CALL, self._seqid)
3629 
    args = addAuthorizationLog_args()
3630 
    args.itemId = itemId
3631 
    args.username = username
3632 
    args.reason = reason
3633 
    args.write(self._oprot)
3634 
    self._oprot.writeMessageEnd()
3635 
    self._oprot.trans.flush()
3636 
 
3637 
  def recv_addAuthorizationLog(self, ):
3638 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3639 
    if mtype == TMessageType.EXCEPTION:
3640 
      x = TApplicationException()
3641 
      x.read(self._iprot)
3642 
      self._iprot.readMessageEnd()
3643 
      raise x
3644 
    result = addAuthorizationLog_result()
3645 
    result.read(self._iprot)
3646 
    self._iprot.readMessageEnd()
3647 
    if result.success is not None:
3648 
      return result.success
3649 
    if result.cex is not None:
3650 
      raise result.cex
3651 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAuthorizationLog failed: unknown result");
3652 
 
3653 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3654 
    """
3655 
    Parameters:
3656 
     - catalog_item_id
3657 
     - voucherType
3658 
     - voucherAmount
3659 
    """
3660 
    self.send_addupdateVoucherForItem(catalog_item_id, voucherType, voucherAmount)
3661 
    return self.recv_addupdateVoucherForItem()
3662 
 
3663 
  def send_addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3664 
    self._oprot.writeMessageBegin('addupdateVoucherForItem', TMessageType.CALL, self._seqid)
3665 
    args = addupdateVoucherForItem_args()
3666 
    args.catalog_item_id = catalog_item_id
3667 
    args.voucherType = voucherType
3668 
    args.voucherAmount = voucherAmount
3669 
    args.write(self._oprot)
3670 
    self._oprot.writeMessageEnd()
3671 
    self._oprot.trans.flush()
3672 
 
3673 
  def recv_addupdateVoucherForItem(self, ):
3674 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3675 
    if mtype == TMessageType.EXCEPTION:
3676 
      x = TApplicationException()
3677 
      x.read(self._iprot)
3678 
      self._iprot.readMessageEnd()
3679 
      raise x
3680 
    result = addupdateVoucherForItem_result()
3681 
    result.read(self._iprot)
3682 
    self._iprot.readMessageEnd()
3683 
    if result.success is not None:
3684 
      return result.success
3685 
    if result.cex is not None:
3686 
      raise result.cex
3687 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addupdateVoucherForItem failed: unknown result");
3688 
 
3689 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
3690 
    """
3691 
    Parameters:
3692 
     - catalog_item_id
3693 
     - voucherType
3694 
    """
3695 
    self.send_deleteVoucherForItem(catalog_item_id, voucherType)
3696 
    return self.recv_deleteVoucherForItem()
3697 
 
3698 
  def send_deleteVoucherForItem(self, catalog_item_id, voucherType):
3699 
    self._oprot.writeMessageBegin('deleteVoucherForItem', TMessageType.CALL, self._seqid)
3700 
    args = deleteVoucherForItem_args()
3701 
    args.catalog_item_id = catalog_item_id
3702 
    args.voucherType = voucherType
3703 
    args.write(self._oprot)
3704 
    self._oprot.writeMessageEnd()
3705 
    self._oprot.trans.flush()
3706 
 
3707 
  def recv_deleteVoucherForItem(self, ):
3708 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3709 
    if mtype == TMessageType.EXCEPTION:
3710 
      x = TApplicationException()
3711 
      x.read(self._iprot)
3712 
      self._iprot.readMessageEnd()
3713 
      raise x
3714 
    result = deleteVoucherForItem_result()
3715 
    result.read(self._iprot)
3716 
    self._iprot.readMessageEnd()
3717 
    if result.success is not None:
3718 
      return result.success
3719 
    if result.cex is not None:
3720 
      raise result.cex
3721 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteVoucherForItem failed: unknown result");
3722 
 
3723 
  def getVoucherAmount(self, itemId, voucherType):
3724 
    """
3725 
    Parameters:
3726 
     - itemId
3727 
     - voucherType
3728 
    """
3729 
    self.send_getVoucherAmount(itemId, voucherType)
3730 
    return self.recv_getVoucherAmount()
3731 
 
3732 
  def send_getVoucherAmount(self, itemId, voucherType):
3733 
    self._oprot.writeMessageBegin('getVoucherAmount', TMessageType.CALL, self._seqid)
3734 
    args = getVoucherAmount_args()
3735 
    args.itemId = itemId
3736 
    args.voucherType = voucherType
3737 
    args.write(self._oprot)
3738 
    self._oprot.writeMessageEnd()
3739 
    self._oprot.trans.flush()
3740 
 
3741 
  def recv_getVoucherAmount(self, ):
3742 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3743 
    if mtype == TMessageType.EXCEPTION:
3744 
      x = TApplicationException()
3745 
      x.read(self._iprot)
3746 
      self._iprot.readMessageEnd()
3747 
      raise x
3748 
    result = getVoucherAmount_result()
3749 
    result.read(self._iprot)
3750 
    self._iprot.readMessageEnd()
3751 
    if result.success is not None:
3752 
      return result.success
3753 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVoucherAmount failed: unknown result");
3754 
 
3755 
  def getAllItemVouchers(self, itemId):
3756 
    """
3757 
    Parameters:
3758 
     - itemId
3759 
    """
3760 
    self.send_getAllItemVouchers(itemId)
3761 
    return self.recv_getAllItemVouchers()
3762 
 
3763 
  def send_getAllItemVouchers(self, itemId):
3764 
    self._oprot.writeMessageBegin('getAllItemVouchers', TMessageType.CALL, self._seqid)
3765 
    args = getAllItemVouchers_args()
3766 
    args.itemId = itemId
3767 
    args.write(self._oprot)
3768 
    self._oprot.writeMessageEnd()
3769 
    self._oprot.trans.flush()
3770 
 
3771 
  def recv_getAllItemVouchers(self, ):
3772 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3773 
    if mtype == TMessageType.EXCEPTION:
3774 
      x = TApplicationException()
3775 
      x.read(self._iprot)
3776 
      self._iprot.readMessageEnd()
3777 
      raise x
3778 
    result = getAllItemVouchers_result()
3779 
    result.read(self._iprot)
3780 
    self._iprot.readMessageEnd()
3781 
    if result.success is not None:
3782 
      return result.success
3783 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemVouchers failed: unknown result");
3784 
 
3785 
  def isValidCatalogItemId(self, catalog_item_id):
3786 
    """
3787 
    Parameters:
3788 
     - catalog_item_id
3789 
    """
3790 
    self.send_isValidCatalogItemId(catalog_item_id)
3791 
    return self.recv_isValidCatalogItemId()
3792 
 
3793 
  def send_isValidCatalogItemId(self, catalog_item_id):
3794 
    self._oprot.writeMessageBegin('isValidCatalogItemId', TMessageType.CALL, self._seqid)
3795 
    args = isValidCatalogItemId_args()
3796 
    args.catalog_item_id = catalog_item_id
3797 
    args.write(self._oprot)
3798 
    self._oprot.writeMessageEnd()
3799 
    self._oprot.trans.flush()
3800 
 
3801 
  def recv_isValidCatalogItemId(self, ):
3802 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3803 
    if mtype == TMessageType.EXCEPTION:
3804 
      x = TApplicationException()
3805 
      x.read(self._iprot)
3806 
      self._iprot.readMessageEnd()
3807 
      raise x
3808 
    result = isValidCatalogItemId_result()
3809 
    result.read(self._iprot)
3810 
    self._iprot.readMessageEnd()
3811 
    if result.success is not None:
3812 
      return result.success
3813 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isValidCatalogItemId failed: unknown result");
3814 
 
7330 amit.gupta 3815 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3816 
    """
3817 
    Parameters:
3818 
     - itemId
7330 amit.gupta 3819 
     - stateId
6039 amit.gupta 3820 
     - price
3821 
    """
7330 amit.gupta 3822 
    self.send_getVatPercentageForItem(itemId, stateId, price)
6039 amit.gupta 3823 
    return self.recv_getVatPercentageForItem()
5944 mandeep.dh 3824 
 
7330 amit.gupta 3825 
  def send_getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3826 
    self._oprot.writeMessageBegin('getVatPercentageForItem', TMessageType.CALL, self._seqid)
3827 
    args = getVatPercentageForItem_args()
3828 
    args.itemId = itemId
7330 amit.gupta 3829 
    args.stateId = stateId
6039 amit.gupta 3830 
    args.price = price
3831 
    args.write(self._oprot)
3832 
    self._oprot.writeMessageEnd()
3833 
    self._oprot.trans.flush()
3834 
 
3835 
  def recv_getVatPercentageForItem(self, ):
3836 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3837 
    if mtype == TMessageType.EXCEPTION:
3838 
      x = TApplicationException()
3839 
      x.read(self._iprot)
3840 
      self._iprot.readMessageEnd()
3841 
      raise x
3842 
    result = getVatPercentageForItem_result()
3843 
    result.read(self._iprot)
3844 
    self._iprot.readMessageEnd()
3845 
    if result.success is not None:
3846 
      return result.success
7340 amit.gupta 3847 
    if result.cex is not None:
3848 
      raise result.cex
6039 amit.gupta 3849 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatPercentageForItem failed: unknown result");
3850 
 
3851 
  def getVatAmountForItem(self, itemId, price):
3852 
    """
3853 
    Parameters:
3854 
     - itemId
3855 
     - price
3856 
    """
3857 
    self.send_getVatAmountForItem(itemId, price)
3858 
    return self.recv_getVatAmountForItem()
3859 
 
3860 
  def send_getVatAmountForItem(self, itemId, price):
3861 
    self._oprot.writeMessageBegin('getVatAmountForItem', TMessageType.CALL, self._seqid)
3862 
    args = getVatAmountForItem_args()
3863 
    args.itemId = itemId
3864 
    args.price = price
3865 
    args.write(self._oprot)
3866 
    self._oprot.writeMessageEnd()
3867 
    self._oprot.trans.flush()
3868 
 
3869 
  def recv_getVatAmountForItem(self, ):
3870 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3871 
    if mtype == TMessageType.EXCEPTION:
3872 
      x = TApplicationException()
3873 
      x.read(self._iprot)
3874 
      self._iprot.readMessageEnd()
3875 
      raise x
3876 
    result = getVatAmountForItem_result()
3877 
    result.read(self._iprot)
3878 
    self._iprot.readMessageEnd()
3879 
    if result.success is not None:
3880 
      return result.success
3881 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatAmountForItem failed: unknown result");
3882 
 
6531 vikram.rag 3883 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3884 
    """
3885 
    Parameters:
3886 
     - offset
3887 
     - limit
3888 
    """
3889 
    self.send_getAllIgnoredInventoryUpdateItemsList(offset, limit)
3890 
    return self.recv_getAllIgnoredInventoryUpdateItemsList()
6039 amit.gupta 3891 
 
6531 vikram.rag 3892 
  def send_getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3893 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryUpdateItemsList', TMessageType.CALL, self._seqid)
3894 
    args = getAllIgnoredInventoryUpdateItemsList_args()
3895 
    args.offset = offset
3896 
    args.limit = limit
3897 
    args.write(self._oprot)
3898 
    self._oprot.writeMessageEnd()
3899 
    self._oprot.trans.flush()
3900 
 
3901 
  def recv_getAllIgnoredInventoryUpdateItemsList(self, ):
3902 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3903 
    if mtype == TMessageType.EXCEPTION:
3904 
      x = TApplicationException()
3905 
      x.read(self._iprot)
3906 
      self._iprot.readMessageEnd()
3907 
      raise x
3908 
    result = getAllIgnoredInventoryUpdateItemsList_result()
3909 
    result.read(self._iprot)
3910 
    self._iprot.readMessageEnd()
3911 
    if result.success is not None:
3912 
      return result.success
3913 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryUpdateItemsList failed: unknown result");
3914 
 
6821 amar.kumar 3915 
  def getAllAliveItems(self, ):
3916 
    self.send_getAllAliveItems()
3917 
    return self.recv_getAllAliveItems()
3918 
 
3919 
  def send_getAllAliveItems(self, ):
3920 
    self._oprot.writeMessageBegin('getAllAliveItems', TMessageType.CALL, self._seqid)
3921 
    args = getAllAliveItems_args()
3922 
    args.write(self._oprot)
3923 
    self._oprot.writeMessageEnd()
3924 
    self._oprot.trans.flush()
3925 
 
3926 
  def recv_getAllAliveItems(self, ):
3927 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3928 
    if mtype == TMessageType.EXCEPTION:
3929 
      x = TApplicationException()
3930 
      x.read(self._iprot)
3931 
      self._iprot.readMessageEnd()
3932 
      raise x
3933 
    result = getAllAliveItems_result()
3934 
    result.read(self._iprot)
3935 
    self._iprot.readMessageEnd()
3936 
    if result.success is not None:
3937 
      return result.success
3938 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAliveItems failed: unknown result");
3939 
 
6921 anupam.sin 3940 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3941 
    """
3942 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 3943 
 
6805 anupam.sin 3944 
    Parameters:
3945 
     - itemId
6921 anupam.sin 3946 
     - price
6805 anupam.sin 3947 
     - insurerId
3948 
     - quantity
3949 
    """
6921 anupam.sin 3950 
    self.send_getInsuranceAmount(itemId, price, insurerId, quantity)
6805 anupam.sin 3951 
    return self.recv_getInsuranceAmount()
3952 
 
6921 anupam.sin 3953 
  def send_getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3954 
    self._oprot.writeMessageBegin('getInsuranceAmount', TMessageType.CALL, self._seqid)
3955 
    args = getInsuranceAmount_args()
3956 
    args.itemId = itemId
6921 anupam.sin 3957 
    args.price = price
6805 anupam.sin 3958 
    args.insurerId = insurerId
3959 
    args.quantity = quantity
3960 
    args.write(self._oprot)
3961 
    self._oprot.writeMessageEnd()
3962 
    self._oprot.trans.flush()
3963 
 
3964 
  def recv_getInsuranceAmount(self, ):
3965 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3966 
    if mtype == TMessageType.EXCEPTION:
3967 
      x = TApplicationException()
3968 
      x.read(self._iprot)
3969 
      self._iprot.readMessageEnd()
3970 
      raise x
3971 
    result = getInsuranceAmount_result()
3972 
    result.read(self._iprot)
3973 
    self._iprot.readMessageEnd()
3974 
    if result.success is not None:
3975 
      return result.success
3976 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsuranceAmount failed: unknown result");
3977 
 
3978 
  def getInsurer(self, insurerId):
3979 
    """
3980 
    Parameters:
3981 
     - insurerId
3982 
    """
3983 
    self.send_getInsurer(insurerId)
3984 
    return self.recv_getInsurer()
3985 
 
3986 
  def send_getInsurer(self, insurerId):
3987 
    self._oprot.writeMessageBegin('getInsurer', TMessageType.CALL, self._seqid)
3988 
    args = getInsurer_args()
3989 
    args.insurerId = insurerId
3990 
    args.write(self._oprot)
3991 
    self._oprot.writeMessageEnd()
3992 
    self._oprot.trans.flush()
3993 
 
3994 
  def recv_getInsurer(self, ):
3995 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3996 
    if mtype == TMessageType.EXCEPTION:
3997 
      x = TApplicationException()
3998 
      x.read(self._iprot)
3999 
      self._iprot.readMessageEnd()
4000 
      raise x
4001 
    result = getInsurer_result()
4002 
    result.read(self._iprot)
4003 
    self._iprot.readMessageEnd()
4004 
    if result.success is not None:
4005 
      return result.success
4006 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsurer failed: unknown result");
4007 
 
6838 vikram.rag 4008 
  def getAllInsurers(self, ):
4009 
    self.send_getAllInsurers()
4010 
    return self.recv_getAllInsurers()
6805 anupam.sin 4011 
 
6838 vikram.rag 4012 
  def send_getAllInsurers(self, ):
4013 
    self._oprot.writeMessageBegin('getAllInsurers', TMessageType.CALL, self._seqid)
4014 
    args = getAllInsurers_args()
4015 
    args.write(self._oprot)
4016 
    self._oprot.writeMessageEnd()
4017 
    self._oprot.trans.flush()
4018 
 
4019 
  def recv_getAllInsurers(self, ):
4020 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4021 
    if mtype == TMessageType.EXCEPTION:
4022 
      x = TApplicationException()
4023 
      x.read(self._iprot)
4024 
      self._iprot.readMessageEnd()
4025 
      raise x
4026 
    result = getAllInsurers_result()
4027 
    result.read(self._iprot)
4028 
    self._iprot.readMessageEnd()
4029 
    if result.success is not None:
4030 
      return result.success
4031 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllInsurers failed: unknown result");
4032 
 
6962 rajveer 4033 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
4034 
    """
4035 
    Parameters:
4036 
     - insurerId
4037 
     - amount
4038 
    """
4039 
    self.send_updateInsuranceDeclaredAmount(insurerId, amount)
4040 
    self.recv_updateInsuranceDeclaredAmount()
6838 vikram.rag 4041 
 
6962 rajveer 4042 
  def send_updateInsuranceDeclaredAmount(self, insurerId, amount):
4043 
    self._oprot.writeMessageBegin('updateInsuranceDeclaredAmount', TMessageType.CALL, self._seqid)
4044 
    args = updateInsuranceDeclaredAmount_args()
4045 
    args.insurerId = insurerId
4046 
    args.amount = amount
4047 
    args.write(self._oprot)
4048 
    self._oprot.writeMessageEnd()
4049 
    self._oprot.trans.flush()
4050 
 
4051 
  def recv_updateInsuranceDeclaredAmount(self, ):
4052 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4053 
    if mtype == TMessageType.EXCEPTION:
4054 
      x = TApplicationException()
4055 
      x.read(self._iprot)
4056 
      self._iprot.readMessageEnd()
4057 
      raise x
4058 
    result = updateInsuranceDeclaredAmount_result()
4059 
    result.read(self._iprot)
4060 
    self._iprot.readMessageEnd()
4061 
    return
4062 
 
7190 amar.kumar 4063 
  def getFreebieForItem(self, itemId):
4064 
    """
4065 
    Parameters:
4066 
     - itemId
4067 
    """
4068 
    self.send_getFreebieForItem(itemId)
4069 
    return self.recv_getFreebieForItem()
6962 rajveer 4070 
 
7190 amar.kumar 4071 
  def send_getFreebieForItem(self, itemId):
4072 
    self._oprot.writeMessageBegin('getFreebieForItem', TMessageType.CALL, self._seqid)
4073 
    args = getFreebieForItem_args()
4074 
    args.itemId = itemId
4075 
    args.write(self._oprot)
4076 
    self._oprot.writeMessageEnd()
4077 
    self._oprot.trans.flush()
4078 
 
4079 
  def recv_getFreebieForItem(self, ):
4080 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4081 
    if mtype == TMessageType.EXCEPTION:
4082 
      x = TApplicationException()
4083 
      x.read(self._iprot)
4084 
      self._iprot.readMessageEnd()
4085 
      raise x
4086 
    result = getFreebieForItem_result()
4087 
    result.read(self._iprot)
4088 
    self._iprot.readMessageEnd()
4089 
    if result.success is not None:
4090 
      return result.success
4091 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFreebieForItem failed: unknown result");
4092 
 
4093 
  def addOrUpdateFreebieForItem(self, freebieItem):
4094 
    """
4095 
    Parameters:
4096 
     - freebieItem
4097 
    """
4098 
    self.send_addOrUpdateFreebieForItem(freebieItem)
4099 
    self.recv_addOrUpdateFreebieForItem()
4100 
 
4101 
  def send_addOrUpdateFreebieForItem(self, freebieItem):
4102 
    self._oprot.writeMessageBegin('addOrUpdateFreebieForItem', TMessageType.CALL, self._seqid)
4103 
    args = addOrUpdateFreebieForItem_args()
4104 
    args.freebieItem = freebieItem
4105 
    args.write(self._oprot)
4106 
    self._oprot.writeMessageEnd()
4107 
    self._oprot.trans.flush()
4108 
 
4109 
  def recv_addOrUpdateFreebieForItem(self, ):
4110 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4111 
    if mtype == TMessageType.EXCEPTION:
4112 
      x = TApplicationException()
4113 
      x.read(self._iprot)
4114 
      self._iprot.readMessageEnd()
4115 
      raise x
4116 
    result = addOrUpdateFreebieForItem_result()
4117 
    result.read(self._iprot)
4118 
    self._iprot.readMessageEnd()
4119 
    return
4120 
 
7272 amit.gupta 4121 
  def addOrUpdateBrandInfo(self, brandInfo):
4122 
    """
4123 
    Parameters:
4124 
     - brandInfo
4125 
    """
4126 
    self.send_addOrUpdateBrandInfo(brandInfo)
4127 
    self.recv_addOrUpdateBrandInfo()
4128 
 
4129 
  def send_addOrUpdateBrandInfo(self, brandInfo):
4130 
    self._oprot.writeMessageBegin('addOrUpdateBrandInfo', TMessageType.CALL, self._seqid)
4131 
    args = addOrUpdateBrandInfo_args()
4132 
    args.brandInfo = brandInfo
4133 
    args.write(self._oprot)
4134 
    self._oprot.writeMessageEnd()
4135 
    self._oprot.trans.flush()
4136 
 
4137 
  def recv_addOrUpdateBrandInfo(self, ):
4138 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4139 
    if mtype == TMessageType.EXCEPTION:
4140 
      x = TApplicationException()
4141 
      x.read(self._iprot)
4142 
      self._iprot.readMessageEnd()
4143 
      raise x
4144 
    result = addOrUpdateBrandInfo_result()
4145 
    result.read(self._iprot)
4146 
    self._iprot.readMessageEnd()
4147 
    return
4148 
 
4149 
  def getBrandInfo(self, ):
4150 
    self.send_getBrandInfo()
4151 
    return self.recv_getBrandInfo()
4152 
 
4153 
  def send_getBrandInfo(self, ):
4154 
    self._oprot.writeMessageBegin('getBrandInfo', TMessageType.CALL, self._seqid)
4155 
    args = getBrandInfo_args()
4156 
    args.write(self._oprot)
4157 
    self._oprot.writeMessageEnd()
4158 
    self._oprot.trans.flush()
4159 
 
4160 
  def recv_getBrandInfo(self, ):
4161 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4162 
    if mtype == TMessageType.EXCEPTION:
4163 
      x = TApplicationException()
4164 
      x.read(self._iprot)
4165 
      self._iprot.readMessageEnd()
4166 
      raise x
4167 
    result = getBrandInfo_result()
4168 
    result.read(self._iprot)
4169 
    self._iprot.readMessageEnd()
4170 
    if result.success is not None:
4171 
      return result.success
4172 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrandInfo failed: unknown result");
4173 
 
7256 rajveer 4174 
  def getStorePricing(self, itemId):
4175 
    """
4176 
    Parameters:
4177 
     - itemId
4178 
    """
4179 
    self.send_getStorePricing(itemId)
4180 
    return self.recv_getStorePricing()
7190 amar.kumar 4181 
 
7256 rajveer 4182 
  def send_getStorePricing(self, itemId):
4183 
    self._oprot.writeMessageBegin('getStorePricing', TMessageType.CALL, self._seqid)
4184 
    args = getStorePricing_args()
4185 
    args.itemId = itemId
4186 
    args.write(self._oprot)
4187 
    self._oprot.writeMessageEnd()
4188 
    self._oprot.trans.flush()
4189 
 
4190 
  def recv_getStorePricing(self, ):
4191 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4192 
    if mtype == TMessageType.EXCEPTION:
4193 
      x = TApplicationException()
4194 
      x.read(self._iprot)
4195 
      self._iprot.readMessageEnd()
4196 
      raise x
4197 
    result = getStorePricing_result()
4198 
    result.read(self._iprot)
4199 
    self._iprot.readMessageEnd()
4200 
    if result.success is not None:
4201 
      return result.success
4202 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricing failed: unknown result");
4203 
 
7306 rajveer 4204 
  def getStorePricings(self, itemIds):
4205 
    """
4206 
    Parameters:
4207 
     - itemIds
4208 
    """
4209 
    self.send_getStorePricings(itemIds)
4210 
    return self.recv_getStorePricings()
4211 
 
4212 
  def send_getStorePricings(self, itemIds):
4213 
    self._oprot.writeMessageBegin('getStorePricings', TMessageType.CALL, self._seqid)
4214 
    args = getStorePricings_args()
4215 
    args.itemIds = itemIds
4216 
    args.write(self._oprot)
4217 
    self._oprot.writeMessageEnd()
4218 
    self._oprot.trans.flush()
4219 
 
4220 
  def recv_getStorePricings(self, ):
4221 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4222 
    if mtype == TMessageType.EXCEPTION:
4223 
      x = TApplicationException()
4224 
      x.read(self._iprot)
4225 
      self._iprot.readMessageEnd()
4226 
      raise x
4227 
    result = getStorePricings_result()
4228 
    result.read(self._iprot)
4229 
    self._iprot.readMessageEnd()
4230 
    if result.success is not None:
4231 
      return result.success
4232 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricings failed: unknown result");
4233 
 
7382 rajveer 4234 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 4235 
    """
4236 
    Parameters:
4237 
     - sp
7382 rajveer 4238 
     - allColors
7265 rajveer 4239 
    """
7382 rajveer 4240 
    self.send_updateStorePricing(sp, allColors)
7265 rajveer 4241 
    self.recv_updateStorePricing()
7256 rajveer 4242 
 
7382 rajveer 4243 
  def send_updateStorePricing(self, sp, allColors):
7265 rajveer 4244 
    self._oprot.writeMessageBegin('updateStorePricing', TMessageType.CALL, self._seqid)
4245 
    args = updateStorePricing_args()
4246 
    args.sp = sp
7382 rajveer 4247 
    args.allColors = allColors
7265 rajveer 4248 
    args.write(self._oprot)
4249 
    self._oprot.writeMessageEnd()
4250 
    self._oprot.trans.flush()
4251 
 
4252 
  def recv_updateStorePricing(self, ):
4253 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4254 
    if mtype == TMessageType.EXCEPTION:
4255 
      x = TApplicationException()
4256 
      x.read(self._iprot)
4257 
      self._iprot.readMessageEnd()
4258 
      raise x
4259 
    result = updateStorePricing_result()
4260 
    result.read(self._iprot)
4261 
    self._iprot.readMessageEnd()
4262 
    return
4263 
 
7281 kshitij.so 4264 
  def getAllAmazonListedItems(self, ):
4265 
    self.send_getAllAmazonListedItems()
4266 
    return self.recv_getAllAmazonListedItems()
7265 rajveer 4267 
 
7281 kshitij.so 4268 
  def send_getAllAmazonListedItems(self, ):
4269 
    self._oprot.writeMessageBegin('getAllAmazonListedItems', TMessageType.CALL, self._seqid)
4270 
    args = getAllAmazonListedItems_args()
4271 
    args.write(self._oprot)
4272 
    self._oprot.writeMessageEnd()
4273 
    self._oprot.trans.flush()
4274 
 
4275 
  def recv_getAllAmazonListedItems(self, ):
4276 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4277 
    if mtype == TMessageType.EXCEPTION:
4278 
      x = TApplicationException()
4279 
      x.read(self._iprot)
4280 
      self._iprot.readMessageEnd()
4281 
      raise x
4282 
    result = getAllAmazonListedItems_result()
4283 
    result.read(self._iprot)
4284 
    self._iprot.readMessageEnd()
4285 
    if result.success is not None:
4286 
      return result.success
4287 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonListedItems failed: unknown result");
4288 
 
8619 kshitij.so 4289 
  def searchAmazonItems(self, searchTerm, offset, limit):
4290 
    """
4291 
    Parameters:
4292 
     - searchTerm
4293 
     - offset
4294 
     - limit
4295 
    """
4296 
    self.send_searchAmazonItems(searchTerm, offset, limit)
4297 
    return self.recv_searchAmazonItems()
4298 
 
4299 
  def send_searchAmazonItems(self, searchTerm, offset, limit):
4300 
    self._oprot.writeMessageBegin('searchAmazonItems', TMessageType.CALL, self._seqid)
4301 
    args = searchAmazonItems_args()
4302 
    args.searchTerm = searchTerm
4303 
    args.offset = offset
4304 
    args.limit = limit
4305 
    args.write(self._oprot)
4306 
    self._oprot.writeMessageEnd()
4307 
    self._oprot.trans.flush()
4308 
 
4309 
  def recv_searchAmazonItems(self, ):
4310 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4311 
    if mtype == TMessageType.EXCEPTION:
4312 
      x = TApplicationException()
4313 
      x.read(self._iprot)
4314 
      self._iprot.readMessageEnd()
4315 
      raise x
4316 
    result = searchAmazonItems_result()
4317 
    result.read(self._iprot)
4318 
    self._iprot.readMessageEnd()
4319 
    if result.success is not None:
4320 
      return result.success
4321 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchAmazonItems failed: unknown result");
4322 
 
4323 
  def getAmazonSearchResultCount(self, searchTerm):
4324 
    """
4325 
    Parameters:
4326 
     - searchTerm
4327 
    """
4328 
    self.send_getAmazonSearchResultCount(searchTerm)
4329 
    return self.recv_getAmazonSearchResultCount()
4330 
 
4331 
  def send_getAmazonSearchResultCount(self, searchTerm):
4332 
    self._oprot.writeMessageBegin('getAmazonSearchResultCount', TMessageType.CALL, self._seqid)
4333 
    args = getAmazonSearchResultCount_args()
4334 
    args.searchTerm = searchTerm
4335 
    args.write(self._oprot)
4336 
    self._oprot.writeMessageEnd()
4337 
    self._oprot.trans.flush()
4338 
 
4339 
  def recv_getAmazonSearchResultCount(self, ):
4340 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4341 
    if mtype == TMessageType.EXCEPTION:
4342 
      x = TApplicationException()
4343 
      x.read(self._iprot)
4344 
      self._iprot.readMessageEnd()
4345 
      raise x
4346 
    result = getAmazonSearchResultCount_result()
4347 
    result.read(self._iprot)
4348 
    self._iprot.readMessageEnd()
4349 
    if result.success is not None:
4350 
      return result.success
4351 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonSearchResultCount failed: unknown result");
4352 
 
4353 
  def getCountForAmazonlistedItems(self, ):
4354 
    self.send_getCountForAmazonlistedItems()
4355 
    return self.recv_getCountForAmazonlistedItems()
4356 
 
4357 
  def send_getCountForAmazonlistedItems(self, ):
4358 
    self._oprot.writeMessageBegin('getCountForAmazonlistedItems', TMessageType.CALL, self._seqid)
4359 
    args = getCountForAmazonlistedItems_args()
4360 
    args.write(self._oprot)
4361 
    self._oprot.writeMessageEnd()
4362 
    self._oprot.trans.flush()
4363 
 
4364 
  def recv_getCountForAmazonlistedItems(self, ):
4365 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4366 
    if mtype == TMessageType.EXCEPTION:
4367 
      x = TApplicationException()
4368 
      x.read(self._iprot)
4369 
      self._iprot.readMessageEnd()
4370 
      raise x
4371 
    result = getCountForAmazonlistedItems_result()
4372 
    result.read(self._iprot)
4373 
    self._iprot.readMessageEnd()
4374 
    if result.success is not None:
4375 
      return result.success
4376 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForAmazonlistedItems failed: unknown result");
4377 
 
7281 kshitij.so 4378 
  def getAmazonItemDetails(self, itemId):
4379 
    """
4380 
    Parameters:
4381 
     - itemId
4382 
    """
4383 
    self.send_getAmazonItemDetails(itemId)
4384 
    return self.recv_getAmazonItemDetails()
4385 
 
4386 
  def send_getAmazonItemDetails(self, itemId):
4387 
    self._oprot.writeMessageBegin('getAmazonItemDetails', TMessageType.CALL, self._seqid)
4388 
    args = getAmazonItemDetails_args()
4389 
    args.itemId = itemId
4390 
    args.write(self._oprot)
4391 
    self._oprot.writeMessageEnd()
4392 
    self._oprot.trans.flush()
4393 
 
4394 
  def recv_getAmazonItemDetails(self, ):
4395 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4396 
    if mtype == TMessageType.EXCEPTION:
4397 
      x = TApplicationException()
4398 
      x.read(self._iprot)
4399 
      self._iprot.readMessageEnd()
4400 
      raise x
4401 
    result = getAmazonItemDetails_result()
4402 
    result.read(self._iprot)
4403 
    self._iprot.readMessageEnd()
4404 
    if result.success is not None:
4405 
      return result.success
4406 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonItemDetails failed: unknown result");
4407 
 
8168 kshitij.so 4408 
  def updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4409 
    """
4410 
    Parameters:
8168 kshitij.so 4411 
     - amazonlisted
7281 kshitij.so 4412 
    """
8168 kshitij.so 4413 
    self.send_updateAmazonItemDetails(amazonlisted)
7281 kshitij.so 4414 
    self.recv_updateAmazonItemDetails()
4415 
 
8168 kshitij.so 4416 
  def send_updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4417 
    self._oprot.writeMessageBegin('updateAmazonItemDetails', TMessageType.CALL, self._seqid)
4418 
    args = updateAmazonItemDetails_args()
8168 kshitij.so 4419 
    args.amazonlisted = amazonlisted
7281 kshitij.so 4420 
    args.write(self._oprot)
4421 
    self._oprot.writeMessageEnd()
4422 
    self._oprot.trans.flush()
4423 
 
4424 
  def recv_updateAmazonItemDetails(self, ):
4425 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4426 
    if mtype == TMessageType.EXCEPTION:
4427 
      x = TApplicationException()
4428 
      x.read(self._iprot)
4429 
      self._iprot.readMessageEnd()
4430 
      raise x
4431 
    result = updateAmazonItemDetails_result()
4432 
    result.read(self._iprot)
4433 
    self._iprot.readMessageEnd()
4434 
    return
4435 
 
4436 
  def addAmazonItem(self, amazonlisted):
4437 
    """
4438 
    Parameters:
4439 
     - amazonlisted
4440 
    """
4441 
    self.send_addAmazonItem(amazonlisted)
4442 
    self.recv_addAmazonItem()
4443 
 
4444 
  def send_addAmazonItem(self, amazonlisted):
4445 
    self._oprot.writeMessageBegin('addAmazonItem', TMessageType.CALL, self._seqid)
4446 
    args = addAmazonItem_args()
4447 
    args.amazonlisted = amazonlisted
4448 
    args.write(self._oprot)
4449 
    self._oprot.writeMessageEnd()
4450 
    self._oprot.trans.flush()
4451 
 
4452 
  def recv_addAmazonItem(self, ):
4453 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4454 
    if mtype == TMessageType.EXCEPTION:
4455 
      x = TApplicationException()
4456 
      x.read(self._iprot)
4457 
      self._iprot.readMessageEnd()
4458 
      raise x
4459 
    result = addAmazonItem_result()
4460 
    result.read(self._iprot)
4461 
    self._iprot.readMessageEnd()
4462 
    return
4463 
 
7291 vikram.rag 4464 
  def getAsinItems(self, ):
4465 
    self.send_getAsinItems()
4466 
    return self.recv_getAsinItems()
7281 kshitij.so 4467 
 
7291 vikram.rag 4468 
  def send_getAsinItems(self, ):
4469 
    self._oprot.writeMessageBegin('getAsinItems', TMessageType.CALL, self._seqid)
4470 
    args = getAsinItems_args()
4471 
    args.write(self._oprot)
4472 
    self._oprot.writeMessageEnd()
4473 
    self._oprot.trans.flush()
4474 
 
4475 
  def recv_getAsinItems(self, ):
4476 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4477 
    if mtype == TMessageType.EXCEPTION:
4478 
      x = TApplicationException()
4479 
      x.read(self._iprot)
4480 
      self._iprot.readMessageEnd()
4481 
      raise x
4482 
    result = getAsinItems_result()
4483 
    result.read(self._iprot)
4484 
    self._iprot.readMessageEnd()
4485 
    if result.success is not None:
4486 
      return result.success
4487 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAsinItems failed: unknown result");
4488 
 
4489 
  def getAllFbaListedItems(self, ):
4490 
    self.send_getAllFbaListedItems()
4491 
    return self.recv_getAllFbaListedItems()
4492 
 
4493 
  def send_getAllFbaListedItems(self, ):
4494 
    self._oprot.writeMessageBegin('getAllFbaListedItems', TMessageType.CALL, self._seqid)
4495 
    args = getAllFbaListedItems_args()
4496 
    args.write(self._oprot)
4497 
    self._oprot.writeMessageEnd()
4498 
    self._oprot.trans.flush()
4499 
 
4500 
  def recv_getAllFbaListedItems(self, ):
4501 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4502 
    if mtype == TMessageType.EXCEPTION:
4503 
      x = TApplicationException()
4504 
      x.read(self._iprot)
4505 
      self._iprot.readMessageEnd()
4506 
      raise x
4507 
    result = getAllFbaListedItems_result()
4508 
    result.read(self._iprot)
4509 
    self._iprot.readMessageEnd()
4510 
    if result.success is not None:
4511 
      return result.success
4512 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbaListedItems failed: unknown result");
4513 
 
4514 
  def getAllNonFbaListedItems(self, ):
4515 
    self.send_getAllNonFbaListedItems()
4516 
    return self.recv_getAllNonFbaListedItems()
4517 
 
4518 
  def send_getAllNonFbaListedItems(self, ):
4519 
    self._oprot.writeMessageBegin('getAllNonFbaListedItems', TMessageType.CALL, self._seqid)
4520 
    args = getAllNonFbaListedItems_args()
4521 
    args.write(self._oprot)
4522 
    self._oprot.writeMessageEnd()
4523 
    self._oprot.trans.flush()
4524 
 
4525 
  def recv_getAllNonFbaListedItems(self, ):
4526 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4527 
    if mtype == TMessageType.EXCEPTION:
4528 
      x = TApplicationException()
4529 
      x.read(self._iprot)
4530 
      self._iprot.readMessageEnd()
4531 
      raise x
4532 
    result = getAllNonFbaListedItems_result()
4533 
    result.read(self._iprot)
4534 
    self._iprot.readMessageEnd()
4535 
    if result.success is not None:
4536 
      return result.success
4537 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllNonFbaListedItems failed: unknown result");
4538 
 
7460 kshitij.so 4539 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
4540 
    """
4541 
    Parameters:
4542 
     - itemId
4543 
     - holdInventory
4544 
     - defaultInventory
4545 
    """
4546 
    self.send_updateItemInventory(itemId, holdInventory, defaultInventory)
4547 
    return self.recv_updateItemInventory()
7291 vikram.rag 4548 
 
7460 kshitij.so 4549 
  def send_updateItemInventory(self, itemId, holdInventory, defaultInventory):
4550 
    self._oprot.writeMessageBegin('updateItemInventory', TMessageType.CALL, self._seqid)
4551 
    args = updateItemInventory_args()
4552 
    args.itemId = itemId
4553 
    args.holdInventory = holdInventory
4554 
    args.defaultInventory = defaultInventory
4555 
    args.write(self._oprot)
4556 
    self._oprot.writeMessageEnd()
4557 
    self._oprot.trans.flush()
4558 
 
4559 
  def recv_updateItemInventory(self, ):
4560 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4561 
    if mtype == TMessageType.EXCEPTION:
4562 
      x = TApplicationException()
4563 
      x.read(self._iprot)
4564 
      self._iprot.readMessageEnd()
4565 
      raise x
4566 
    result = updateItemInventory_result()
4567 
    result.read(self._iprot)
4568 
    self._iprot.readMessageEnd()
4569 
    if result.success is not None:
4570 
      return result.success
4571 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItemInventory failed: unknown result");
4572 
 
7770 kshitij.so 4573 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4574 
    """
4575 
    Parameters:
4576 
     - type
4577 
     - sku
4578 
     - timestamp
4579 
    """
4580 
    self.send_updateTimestampForAmazonFeeds(type, sku, timestamp)
4581 
    return self.recv_updateTimestampForAmazonFeeds()
7460 kshitij.so 4582 
 
7770 kshitij.so 4583 
  def send_updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4584 
    self._oprot.writeMessageBegin('updateTimestampForAmazonFeeds', TMessageType.CALL, self._seqid)
4585 
    args = updateTimestampForAmazonFeeds_args()
4586 
    args.type = type
4587 
    args.sku = sku
4588 
    args.timestamp = timestamp
4589 
    args.write(self._oprot)
4590 
    self._oprot.writeMessageEnd()
4591 
    self._oprot.trans.flush()
4592 
 
4593 
  def recv_updateTimestampForAmazonFeeds(self, ):
4594 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4595 
    if mtype == TMessageType.EXCEPTION:
4596 
      x = TApplicationException()
4597 
      x.read(self._iprot)
4598 
      self._iprot.readMessageEnd()
4599 
      raise x
4600 
    result = updateTimestampForAmazonFeeds_result()
4601 
    result.read(self._iprot)
4602 
    self._iprot.readMessageEnd()
4603 
    if result.success is not None:
4604 
      return result.success
4605 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateTimestampForAmazonFeeds failed: unknown result");
4606 
 
7897 amar.kumar 4607 
  def getAllParentCategories(self, ):
4608 
    self.send_getAllParentCategories()
4609 
    return self.recv_getAllParentCategories()
7770 kshitij.so 4610 
 
7897 amar.kumar 4611 
  def send_getAllParentCategories(self, ):
4612 
    self._oprot.writeMessageBegin('getAllParentCategories', TMessageType.CALL, self._seqid)
4613 
    args = getAllParentCategories_args()
4614 
    args.write(self._oprot)
4615 
    self._oprot.writeMessageEnd()
4616 
    self._oprot.trans.flush()
4617 
 
4618 
  def recv_getAllParentCategories(self, ):
4619 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4620 
    if mtype == TMessageType.EXCEPTION:
4621 
      x = TApplicationException()
4622 
      x.read(self._iprot)
4623 
      self._iprot.readMessageEnd()
4624 
      raise x
4625 
    result = getAllParentCategories_result()
4626 
    result.read(self._iprot)
4627 
    self._iprot.readMessageEnd()
4628 
    if result.success is not None:
4629 
      return result.success
4630 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllParentCategories failed: unknown result");
4631 
 
7977 kshitij.so 4632 
  def addPageViewEvent(self, pageViewEvents):
4633 
    """
4634 
    Parameters:
4635 
     - pageViewEvents
4636 
    """
4637 
    self.send_addPageViewEvent(pageViewEvents)
4638 
    self.recv_addPageViewEvent()
7897 amar.kumar 4639 
 
7977 kshitij.so 4640 
  def send_addPageViewEvent(self, pageViewEvents):
4641 
    self._oprot.writeMessageBegin('addPageViewEvent', TMessageType.CALL, self._seqid)
4642 
    args = addPageViewEvent_args()
4643 
    args.pageViewEvents = pageViewEvents
4644 
    args.write(self._oprot)
4645 
    self._oprot.writeMessageEnd()
4646 
    self._oprot.trans.flush()
4647 
 
4648 
  def recv_addPageViewEvent(self, ):
4649 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4650 
    if mtype == TMessageType.EXCEPTION:
4651 
      x = TApplicationException()
4652 
      x.read(self._iprot)
4653 
      self._iprot.readMessageEnd()
4654 
      raise x
4655 
    result = addPageViewEvent_result()
4656 
    result.read(self._iprot)
4657 
    self._iprot.readMessageEnd()
4658 
    return
4659 
 
4660 
  def addCartEvent(self, cartEvents):
4661 
    """
4662 
    Parameters:
4663 
     - cartEvents
4664 
    """
4665 
    self.send_addCartEvent(cartEvents)
4666 
    self.recv_addCartEvent()
4667 
 
4668 
  def send_addCartEvent(self, cartEvents):
4669 
    self._oprot.writeMessageBegin('addCartEvent', TMessageType.CALL, self._seqid)
4670 
    args = addCartEvent_args()
4671 
    args.cartEvents = cartEvents
4672 
    args.write(self._oprot)
4673 
    self._oprot.writeMessageEnd()
4674 
    self._oprot.trans.flush()
4675 
 
4676 
  def recv_addCartEvent(self, ):
4677 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4678 
    if mtype == TMessageType.EXCEPTION:
4679 
      x = TApplicationException()
4680 
      x.read(self._iprot)
4681 
      self._iprot.readMessageEnd()
4682 
      raise x
4683 
    result = addCartEvent_result()
4684 
    result.read(self._iprot)
4685 
    self._iprot.readMessageEnd()
4686 
    return
4687 
 
8182 amar.kumar 4688 
  def addEbayItem(self, ebayItem):
4689 
    """
4690 
    Parameters:
4691 
     - ebayItem
4692 
    """
4693 
    self.send_addEbayItem(ebayItem)
4694 
    self.recv_addEbayItem()
4695 
 
4696 
  def send_addEbayItem(self, ebayItem):
4697 
    self._oprot.writeMessageBegin('addEbayItem', TMessageType.CALL, self._seqid)
4698 
    args = addEbayItem_args()
4699 
    args.ebayItem = ebayItem
4700 
    args.write(self._oprot)
4701 
    self._oprot.writeMessageEnd()
4702 
    self._oprot.trans.flush()
4703 
 
4704 
  def recv_addEbayItem(self, ):
4705 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4706 
    if mtype == TMessageType.EXCEPTION:
4707 
      x = TApplicationException()
4708 
      x.read(self._iprot)
4709 
      self._iprot.readMessageEnd()
4710 
      raise x
4711 
    result = addEbayItem_result()
4712 
    result.read(self._iprot)
4713 
    self._iprot.readMessageEnd()
4714 
    return
4715 
 
4716 
  def getEbayItem(self, listingId):
4717 
    """
4718 
    Parameters:
4719 
     - listingId
4720 
    """
4721 
    self.send_getEbayItem(listingId)
4722 
    return self.recv_getEbayItem()
4723 
 
4724 
  def send_getEbayItem(self, listingId):
4725 
    self._oprot.writeMessageBegin('getEbayItem', TMessageType.CALL, self._seqid)
4726 
    args = getEbayItem_args()
4727 
    args.listingId = listingId
4728 
    args.write(self._oprot)
4729 
    self._oprot.writeMessageEnd()
4730 
    self._oprot.trans.flush()
4731 
 
4732 
  def recv_getEbayItem(self, ):
4733 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4734 
    if mtype == TMessageType.EXCEPTION:
4735 
      x = TApplicationException()
4736 
      x.read(self._iprot)
4737 
      self._iprot.readMessageEnd()
4738 
      raise x
4739 
    result = getEbayItem_result()
4740 
    result.read(self._iprot)
4741 
    self._iprot.readMessageEnd()
4742 
    if result.success is not None:
4743 
      return result.success
4744 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEbayItem failed: unknown result");
4745 
 
4746 
  def updateEbayItem(self, ebayItem):
4747 
    """
4748 
    Parameters:
4749 
     - ebayItem
4750 
    """
4751 
    self.send_updateEbayItem(ebayItem)
4752 
    self.recv_updateEbayItem()
4753 
 
4754 
  def send_updateEbayItem(self, ebayItem):
4755 
    self._oprot.writeMessageBegin('updateEbayItem', TMessageType.CALL, self._seqid)
4756 
    args = updateEbayItem_args()
4757 
    args.ebayItem = ebayItem
4758 
    args.write(self._oprot)
4759 
    self._oprot.writeMessageEnd()
4760 
    self._oprot.trans.flush()
4761 
 
4762 
  def recv_updateEbayItem(self, ):
4763 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4764 
    if mtype == TMessageType.EXCEPTION:
4765 
      x = TApplicationException()
4766 
      x.read(self._iprot)
4767 
      self._iprot.readMessageEnd()
4768 
      raise x
4769 
    result = updateEbayItem_result()
4770 
    result.read(self._iprot)
4771 
    self._iprot.readMessageEnd()
4772 
    return
4773 
 
8139 kshitij.so 4774 
  def getAmazonListedItems(self, offset, limit):
4775 
    """
4776 
    Parameters:
4777 
     - offset
4778 
     - limit
4779 
    """
4780 
    self.send_getAmazonListedItems(offset, limit)
4781 
    return self.recv_getAmazonListedItems()
7977 kshitij.so 4782 
 
8139 kshitij.so 4783 
  def send_getAmazonListedItems(self, offset, limit):
4784 
    self._oprot.writeMessageBegin('getAmazonListedItems', TMessageType.CALL, self._seqid)
4785 
    args = getAmazonListedItems_args()
4786 
    args.offset = offset
4787 
    args.limit = limit
4788 
    args.write(self._oprot)
4789 
    self._oprot.writeMessageEnd()
4790 
    self._oprot.trans.flush()
4791 
 
4792 
  def recv_getAmazonListedItems(self, ):
4793 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4794 
    if mtype == TMessageType.EXCEPTION:
4795 
      x = TApplicationException()
4796 
      x.read(self._iprot)
4797 
      self._iprot.readMessageEnd()
4798 
      raise x
4799 
    result = getAmazonListedItems_result()
4800 
    result.read(self._iprot)
4801 
    self._iprot.readMessageEnd()
4802 
    if result.success is not None:
4803 
      return result.success
4804 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonListedItems failed: unknown result");
4805 
 
8168 kshitij.so 4806 
  def updateAmazonAttributesInBulk(self, amazonlisted):
4807 
    """
4808 
    Parameters:
4809 
     - amazonlisted
4810 
    """
4811 
    self.send_updateAmazonAttributesInBulk(amazonlisted)
4812 
    return self.recv_updateAmazonAttributesInBulk()
8139 kshitij.so 4813 
 
8168 kshitij.so 4814 
  def send_updateAmazonAttributesInBulk(self, amazonlisted):
4815 
    self._oprot.writeMessageBegin('updateAmazonAttributesInBulk', TMessageType.CALL, self._seqid)
4816 
    args = updateAmazonAttributesInBulk_args()
4817 
    args.amazonlisted = amazonlisted
4818 
    args.write(self._oprot)
4819 
    self._oprot.writeMessageEnd()
4820 
    self._oprot.trans.flush()
4821 
 
4822 
  def recv_updateAmazonAttributesInBulk(self, ):
4823 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4824 
    if mtype == TMessageType.EXCEPTION:
4825 
      x = TApplicationException()
4826 
      x.read(self._iprot)
4827 
      self._iprot.readMessageEnd()
4828 
      raise x
4829 
    result = updateAmazonAttributesInBulk_result()
4830 
    result.read(self._iprot)
4831 
    self._iprot.readMessageEnd()
4832 
    if result.success is not None:
4833 
      return result.success
4834 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateAmazonAttributesInBulk failed: unknown result");
4835 
 
8379 vikram.rag 4836 
  def getAllItemstoListOnFba(self, ):
4837 
    self.send_getAllItemstoListOnFba()
4838 
    return self.recv_getAllItemstoListOnFba()
8168 kshitij.so 4839 
 
8379 vikram.rag 4840 
  def send_getAllItemstoListOnFba(self, ):
4841 
    self._oprot.writeMessageBegin('getAllItemstoListOnFba', TMessageType.CALL, self._seqid)
4842 
    args = getAllItemstoListOnFba_args()
4843 
    args.write(self._oprot)
4844 
    self._oprot.writeMessageEnd()
4845 
    self._oprot.trans.flush()
4846 
 
4847 
  def recv_getAllItemstoListOnFba(self, ):
4848 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4849 
    if mtype == TMessageType.EXCEPTION:
4850 
      x = TApplicationException()
4851 
      x.read(self._iprot)
4852 
      self._iprot.readMessageEnd()
4853 
      raise x
4854 
    result = getAllItemstoListOnFba_result()
4855 
    result.read(self._iprot)
4856 
    self._iprot.readMessageEnd()
4857 
    if result.success is not None:
4858 
      return result.success
4859 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnFba failed: unknown result");
4860 
 
4861 
  def getAllItemstoListOnNonFba(self, ):
4862 
    self.send_getAllItemstoListOnNonFba()
4863 
    return self.recv_getAllItemstoListOnNonFba()
4864 
 
4865 
  def send_getAllItemstoListOnNonFba(self, ):
4866 
    self._oprot.writeMessageBegin('getAllItemstoListOnNonFba', TMessageType.CALL, self._seqid)
4867 
    args = getAllItemstoListOnNonFba_args()
4868 
    args.write(self._oprot)
4869 
    self._oprot.writeMessageEnd()
4870 
    self._oprot.trans.flush()
4871 
 
4872 
  def recv_getAllItemstoListOnNonFba(self, ):
4873 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4874 
    if mtype == TMessageType.EXCEPTION:
4875 
      x = TApplicationException()
4876 
      x.read(self._iprot)
4877 
      self._iprot.readMessageEnd()
4878 
      raise x
4879 
    result = getAllItemstoListOnNonFba_result()
4880 
    result.read(self._iprot)
4881 
    self._iprot.readMessageEnd()
4882 
    if result.success is not None:
4883 
      return result.success
4884 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnNonFba failed: unknown result");
4885 
 
8619 kshitij.so 4886 
  def updateAsin(self, item):
4887 
    """
4888 
    Parameters:
4889 
     - item
4890 
    """
4891 
    self.send_updateAsin(item)
4892 
    self.recv_updateAsin()
8616 vikram.rag 4893 
 
8619 kshitij.so 4894 
  def send_updateAsin(self, item):
4895 
    self._oprot.writeMessageBegin('updateAsin', TMessageType.CALL, self._seqid)
4896 
    args = updateAsin_args()
4897 
    args.item = item
4898 
    args.write(self._oprot)
4899 
    self._oprot.writeMessageEnd()
4900 
    self._oprot.trans.flush()
4901 
 
4902 
  def recv_updateAsin(self, ):
4903 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4904 
    if mtype == TMessageType.EXCEPTION:
4905 
      x = TApplicationException()
4906 
      x.read(self._iprot)
4907 
      self._iprot.readMessageEnd()
4908 
      raise x
4909 
    result = updateAsin_result()
4910 
    result.read(self._iprot)
4911 
    self._iprot.readMessageEnd()
4912 
    return
4913 
 
8739 vikram.rag 4914 
  def addOrUpdateSnapdealItem(self, snapdealitem):
4915 
    """
4916 
    Parameters:
4917 
     - snapdealitem
4918 
    """
4919 
    self.send_addOrUpdateSnapdealItem(snapdealitem)
4920 
    return self.recv_addOrUpdateSnapdealItem()
8619 kshitij.so 4921 
 
8739 vikram.rag 4922 
  def send_addOrUpdateSnapdealItem(self, snapdealitem):
4923 
    self._oprot.writeMessageBegin('addOrUpdateSnapdealItem', TMessageType.CALL, self._seqid)
4924 
    args = addOrUpdateSnapdealItem_args()
4925 
    args.snapdealitem = snapdealitem
4926 
    args.write(self._oprot)
4927 
    self._oprot.writeMessageEnd()
4928 
    self._oprot.trans.flush()
4929 
 
4930 
  def recv_addOrUpdateSnapdealItem(self, ):
4931 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4932 
    if mtype == TMessageType.EXCEPTION:
4933 
      x = TApplicationException()
4934 
      x.read(self._iprot)
4935 
      self._iprot.readMessageEnd()
4936 
      raise x
4937 
    result = addOrUpdateSnapdealItem_result()
4938 
    result.read(self._iprot)
4939 
    self._iprot.readMessageEnd()
4940 
    if result.success is not None:
4941 
      return result.success
4942 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addOrUpdateSnapdealItem failed: unknown result");
4943 
 
4944 
  def getSnapdealItem(self, item_id):
4945 
    """
4946 
    Parameters:
4947 
     - item_id
4948 
    """
4949 
    self.send_getSnapdealItem(item_id)
4950 
    return self.recv_getSnapdealItem()
4951 
 
4952 
  def send_getSnapdealItem(self, item_id):
4953 
    self._oprot.writeMessageBegin('getSnapdealItem', TMessageType.CALL, self._seqid)
4954 
    args = getSnapdealItem_args()
4955 
    args.item_id = item_id
4956 
    args.write(self._oprot)
4957 
    self._oprot.writeMessageEnd()
4958 
    self._oprot.trans.flush()
4959 
 
4960 
  def recv_getSnapdealItem(self, ):
4961 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4962 
    if mtype == TMessageType.EXCEPTION:
4963 
      x = TApplicationException()
4964 
      x.read(self._iprot)
4965 
      self._iprot.readMessageEnd()
4966 
      raise x
4967 
    result = getSnapdealItem_result()
4968 
    result.read(self._iprot)
4969 
    self._iprot.readMessageEnd()
4970 
    if result.success is not None:
4971 
      return result.success
4972 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItem failed: unknown result");
4973 
 
9242 kshitij.so 4974 
  def getSnapdealItemDetails(self, item_id):
4975 
    """
4976 
    Parameters:
4977 
     - item_id
4978 
    """
4979 
    self.send_getSnapdealItemDetails(item_id)
4980 
    return self.recv_getSnapdealItemDetails()
4981 
 
4982 
  def send_getSnapdealItemDetails(self, item_id):
4983 
    self._oprot.writeMessageBegin('getSnapdealItemDetails', TMessageType.CALL, self._seqid)
4984 
    args = getSnapdealItemDetails_args()
4985 
    args.item_id = item_id
4986 
    args.write(self._oprot)
4987 
    self._oprot.writeMessageEnd()
4988 
    self._oprot.trans.flush()
4989 
 
4990 
  def recv_getSnapdealItemDetails(self, ):
4991 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4992 
    if mtype == TMessageType.EXCEPTION:
4993 
      x = TApplicationException()
4994 
      x.read(self._iprot)
4995 
      self._iprot.readMessageEnd()
4996 
      raise x
4997 
    result = getSnapdealItemDetails_result()
4998 
    result.read(self._iprot)
4999 
    self._iprot.readMessageEnd()
5000 
    if result.success is not None:
5001 
      return result.success
5002 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItemDetails failed: unknown result");
5003 
 
8739 vikram.rag 5004 
  def getAllSnapdealItems(self, ):
5005 
    self.send_getAllSnapdealItems()
5006 
    return self.recv_getAllSnapdealItems()
5007 
 
5008 
  def send_getAllSnapdealItems(self, ):
5009 
    self._oprot.writeMessageBegin('getAllSnapdealItems', TMessageType.CALL, self._seqid)
5010 
    args = getAllSnapdealItems_args()
5011 
    args.write(self._oprot)
5012 
    self._oprot.writeMessageEnd()
5013 
    self._oprot.trans.flush()
5014 
 
5015 
  def recv_getAllSnapdealItems(self, ):
5016 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5017 
    if mtype == TMessageType.EXCEPTION:
5018 
      x = TApplicationException()
5019 
      x.read(self._iprot)
5020 
      self._iprot.readMessageEnd()
5021 
      raise x
5022 
    result = getAllSnapdealItems_result()
5023 
    result.read(self._iprot)
5024 
    self._iprot.readMessageEnd()
5025 
    if result.success is not None:
5026 
      return result.success
5027 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSnapdealItems failed: unknown result");
5028 
 
9242 kshitij.so 5029 
  def getSnapdealItems(self, offset, limit):
5030 
    """
5031 
    Parameters:
5032 
     - offset
5033 
     - limit
5034 
    """
5035 
    self.send_getSnapdealItems(offset, limit)
5036 
    return self.recv_getSnapdealItems()
8739 vikram.rag 5037 
 
9242 kshitij.so 5038 
  def send_getSnapdealItems(self, offset, limit):
5039 
    self._oprot.writeMessageBegin('getSnapdealItems', TMessageType.CALL, self._seqid)
5040 
    args = getSnapdealItems_args()
5041 
    args.offset = offset
5042 
    args.limit = limit
5043 
    args.write(self._oprot)
5044 
    self._oprot.writeMessageEnd()
5045 
    self._oprot.trans.flush()
5046 
 
5047 
  def recv_getSnapdealItems(self, ):
5048 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5049 
    if mtype == TMessageType.EXCEPTION:
5050 
      x = TApplicationException()
5051 
      x.read(self._iprot)
5052 
      self._iprot.readMessageEnd()
5053 
      raise x
5054 
    result = getSnapdealItems_result()
5055 
    result.read(self._iprot)
5056 
    self._iprot.readMessageEnd()
5057 
    if result.success is not None:
5058 
      return result.success
5059 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItems failed: unknown result");
5060 
 
5061 
  def searchSnapdealItems(self, searchTerm, offset, limit):
5062 
    """
5063 
    Parameters:
5064 
     - searchTerm
5065 
     - offset
5066 
     - limit
5067 
    """
5068 
    self.send_searchSnapdealItems(searchTerm, offset, limit)
5069 
    return self.recv_searchSnapdealItems()
5070 
 
5071 
  def send_searchSnapdealItems(self, searchTerm, offset, limit):
5072 
    self._oprot.writeMessageBegin('searchSnapdealItems', TMessageType.CALL, self._seqid)
5073 
    args = searchSnapdealItems_args()
5074 
    args.searchTerm = searchTerm
5075 
    args.offset = offset
5076 
    args.limit = limit
5077 
    args.write(self._oprot)
5078 
    self._oprot.writeMessageEnd()
5079 
    self._oprot.trans.flush()
5080 
 
5081 
  def recv_searchSnapdealItems(self, ):
5082 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5083 
    if mtype == TMessageType.EXCEPTION:
5084 
      x = TApplicationException()
5085 
      x.read(self._iprot)
5086 
      self._iprot.readMessageEnd()
5087 
      raise x
5088 
    result = searchSnapdealItems_result()
5089 
    result.read(self._iprot)
5090 
    self._iprot.readMessageEnd()
5091 
    if result.success is not None:
5092 
      return result.success
5093 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchSnapdealItems failed: unknown result");
5094 
 
5095 
  def getCountForSnapdealItems(self, ):
5096 
    self.send_getCountForSnapdealItems()
5097 
    return self.recv_getCountForSnapdealItems()
5098 
 
5099 
  def send_getCountForSnapdealItems(self, ):
5100 
    self._oprot.writeMessageBegin('getCountForSnapdealItems', TMessageType.CALL, self._seqid)
5101 
    args = getCountForSnapdealItems_args()
5102 
    args.write(self._oprot)
5103 
    self._oprot.writeMessageEnd()
5104 
    self._oprot.trans.flush()
5105 
 
5106 
  def recv_getCountForSnapdealItems(self, ):
5107 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5108 
    if mtype == TMessageType.EXCEPTION:
5109 
      x = TApplicationException()
5110 
      x.read(self._iprot)
5111 
      self._iprot.readMessageEnd()
5112 
      raise x
5113 
    result = getCountForSnapdealItems_result()
5114 
    result.read(self._iprot)
5115 
    self._iprot.readMessageEnd()
5116 
    if result.success is not None:
5117 
      return result.success
5118 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForSnapdealItems failed: unknown result");
5119 
 
5120 
  def getSnapdealSearchResultCount(self, searchTerm):
5121 
    """
5122 
    Parameters:
5123 
     - searchTerm
5124 
    """
5125 
    self.send_getSnapdealSearchResultCount(searchTerm)
5126 
    return self.recv_getSnapdealSearchResultCount()
5127 
 
5128 
  def send_getSnapdealSearchResultCount(self, searchTerm):
5129 
    self._oprot.writeMessageBegin('getSnapdealSearchResultCount', TMessageType.CALL, self._seqid)
5130 
    args = getSnapdealSearchResultCount_args()
5131 
    args.searchTerm = searchTerm
5132 
    args.write(self._oprot)
5133 
    self._oprot.writeMessageEnd()
5134 
    self._oprot.trans.flush()
5135 
 
5136 
  def recv_getSnapdealSearchResultCount(self, ):
5137 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5138 
    if mtype == TMessageType.EXCEPTION:
5139 
      x = TApplicationException()
5140 
      x.read(self._iprot)
5141 
      self._iprot.readMessageEnd()
5142 
      raise x
5143 
    result = getSnapdealSearchResultCount_result()
5144 
    result.read(self._iprot)
5145 
    self._iprot.readMessageEnd()
5146 
    if result.success is not None:
5147 
      return result.success
5148 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealSearchResultCount failed: unknown result");
5149 
 
9299 kshitij.so 5150 
  def getPrefferedInsurerForItem(self, itemId, insurerType):
5151 
    """
5152 
    Parameters:
5153 
     - itemId
5154 
     - insurerType
5155 
    """
5156 
    self.send_getPrefferedInsurerForItem(itemId, insurerType)
5157 
    return self.recv_getPrefferedInsurerForItem()
9242 kshitij.so 5158 
 
9299 kshitij.so 5159 
  def send_getPrefferedInsurerForItem(self, itemId, insurerType):
5160 
    self._oprot.writeMessageBegin('getPrefferedInsurerForItem', TMessageType.CALL, self._seqid)
5161 
    args = getPrefferedInsurerForItem_args()
5162 
    args.itemId = itemId
5163 
    args.insurerType = insurerType
5164 
    args.write(self._oprot)
5165 
    self._oprot.writeMessageEnd()
5166 
    self._oprot.trans.flush()
5167 
 
5168 
  def recv_getPrefferedInsurerForItem(self, ):
5169 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5170 
    if mtype == TMessageType.EXCEPTION:
5171 
      x = TApplicationException()
5172 
      x.read(self._iprot)
5173 
      self._iprot.readMessageEnd()
5174 
      raise x
5175 
    result = getPrefferedInsurerForItem_result()
5176 
    result.read(self._iprot)
5177 
    self._iprot.readMessageEnd()
5178 
    if result.success is not None:
5179 
      return result.success
5180 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrefferedInsurerForItem failed: unknown result");
5181 
 
9456 vikram.rag 5182 
  def getSnapdealItembySkuAtSnapdeal(self, skuAtSnapdeal):
5183 
    """
5184 
    Parameters:
5185 
     - skuAtSnapdeal
5186 
    """
5187 
    self.send_getSnapdealItembySkuAtSnapdeal(skuAtSnapdeal)
5188 
    return self.recv_getSnapdealItembySkuAtSnapdeal()
9299 kshitij.so 5189 
 
9456 vikram.rag 5190 
  def send_getSnapdealItembySkuAtSnapdeal(self, skuAtSnapdeal):
5191 
    self._oprot.writeMessageBegin('getSnapdealItembySkuAtSnapdeal', TMessageType.CALL, self._seqid)
5192 
    args = getSnapdealItembySkuAtSnapdeal_args()
5193 
    args.skuAtSnapdeal = skuAtSnapdeal
5194 
    args.write(self._oprot)
5195 
    self._oprot.writeMessageEnd()
5196 
    self._oprot.trans.flush()
5197 
 
5198 
  def recv_getSnapdealItembySkuAtSnapdeal(self, ):
5199 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5200 
    if mtype == TMessageType.EXCEPTION:
5201 
      x = TApplicationException()
5202 
      x.read(self._iprot)
5203 
      self._iprot.readMessageEnd()
5204 
      raise x
5205 
    result = getSnapdealItembySkuAtSnapdeal_result()
5206 
    result.read(self._iprot)
5207 
    self._iprot.readMessageEnd()
5208 
    if result.success is not None:
5209 
      return result.success
5210 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItembySkuAtSnapdeal failed: unknown result");
5211 
 
9621 manish.sha 5212 
  def getProductFeedSubmit(self, catalogItemId):
5213 
    """
5214 
    Parameters:
5215 
     - catalogItemId
5216 
    """
5217 
    self.send_getProductFeedSubmit(catalogItemId)
5218 
    return self.recv_getProductFeedSubmit()
9456 vikram.rag 5219 
 
9621 manish.sha 5220 
  def send_getProductFeedSubmit(self, catalogItemId):
5221 
    self._oprot.writeMessageBegin('getProductFeedSubmit', TMessageType.CALL, self._seqid)
5222 
    args = getProductFeedSubmit_args()
5223 
    args.catalogItemId = catalogItemId
5224 
    args.write(self._oprot)
5225 
    self._oprot.writeMessageEnd()
5226 
    self._oprot.trans.flush()
5227 
 
5228 
  def recv_getProductFeedSubmit(self, ):
5229 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5230 
    if mtype == TMessageType.EXCEPTION:
5231 
      x = TApplicationException()
5232 
      x.read(self._iprot)
5233 
      self._iprot.readMessageEnd()
5234 
      raise x
5235 
    result = getProductFeedSubmit_result()
5236 
    result.read(self._iprot)
5237 
    self._iprot.readMessageEnd()
5238 
    if result.success is not None:
5239 
      return result.success
5240 
    if result.cex is not None:
5241 
      raise result.cex
5242 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductFeedSubmit failed: unknown result");
5243 
 
5244 
  def addProductFeedSubmit(self, productFeedSubmit):
5245 
    """
5246 
    Parameters:
5247 
     - productFeedSubmit
5248 
    """
5249 
    self.send_addProductFeedSubmit(productFeedSubmit)
5250 
    return self.recv_addProductFeedSubmit()
5251 
 
5252 
  def send_addProductFeedSubmit(self, productFeedSubmit):
5253 
    self._oprot.writeMessageBegin('addProductFeedSubmit', TMessageType.CALL, self._seqid)
5254 
    args = addProductFeedSubmit_args()
5255 
    args.productFeedSubmit = productFeedSubmit
5256 
    args.write(self._oprot)
5257 
    self._oprot.writeMessageEnd()
5258 
    self._oprot.trans.flush()
5259 
 
5260 
  def recv_addProductFeedSubmit(self, ):
5261 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5262 
    if mtype == TMessageType.EXCEPTION:
5263 
      x = TApplicationException()
5264 
      x.read(self._iprot)
5265 
      self._iprot.readMessageEnd()
5266 
      raise x
5267 
    result = addProductFeedSubmit_result()
5268 
    result.read(self._iprot)
5269 
    self._iprot.readMessageEnd()
5270 
    if result.success is not None:
5271 
      return result.success
5272 
    if result.cex is not None:
5273 
      raise result.cex
5274 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductFeedSubmit failed: unknown result");
5275 
 
5276 
  def updateProductFeedSubmit(self, productFeedSubmit):
5277 
    """
5278 
    Parameters:
5279 
     - productFeedSubmit
5280 
    """
5281 
    self.send_updateProductFeedSubmit(productFeedSubmit)
5282 
    return self.recv_updateProductFeedSubmit()
5283 
 
5284 
  def send_updateProductFeedSubmit(self, productFeedSubmit):
5285 
    self._oprot.writeMessageBegin('updateProductFeedSubmit', TMessageType.CALL, self._seqid)
5286 
    args = updateProductFeedSubmit_args()
5287 
    args.productFeedSubmit = productFeedSubmit
5288 
    args.write(self._oprot)
5289 
    self._oprot.writeMessageEnd()
5290 
    self._oprot.trans.flush()
5291 
 
5292 
  def recv_updateProductFeedSubmit(self, ):
5293 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5294 
    if mtype == TMessageType.EXCEPTION:
5295 
      x = TApplicationException()
5296 
      x.read(self._iprot)
5297 
      self._iprot.readMessageEnd()
5298 
      raise x
5299 
    result = updateProductFeedSubmit_result()
5300 
    result.read(self._iprot)
5301 
    self._iprot.readMessageEnd()
5302 
    if result.success is not None:
5303 
      return result.success
5304 
    if result.cex is not None:
5305 
      raise result.cex
5306 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateProductFeedSubmit failed: unknown result");
5307 
 
5308 
  def deleteProductFeedSubmit(self, catalogItemId):
5309 
    """
5310 
    Parameters:
5311 
     - catalogItemId
5312 
    """
5313 
    self.send_deleteProductFeedSubmit(catalogItemId)
5314 
    return self.recv_deleteProductFeedSubmit()
5315 
 
5316 
  def send_deleteProductFeedSubmit(self, catalogItemId):
5317 
    self._oprot.writeMessageBegin('deleteProductFeedSubmit', TMessageType.CALL, self._seqid)
5318 
    args = deleteProductFeedSubmit_args()
5319 
    args.catalogItemId = catalogItemId
5320 
    args.write(self._oprot)
5321 
    self._oprot.writeMessageEnd()
5322 
    self._oprot.trans.flush()
5323 
 
5324 
  def recv_deleteProductFeedSubmit(self, ):
5325 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5326 
    if mtype == TMessageType.EXCEPTION:
5327 
      x = TApplicationException()
5328 
      x.read(self._iprot)
5329 
      self._iprot.readMessageEnd()
5330 
      raise x
5331 
    result = deleteProductFeedSubmit_result()
5332 
    result.read(self._iprot)
5333 
    self._iprot.readMessageEnd()
5334 
    if result.success is not None:
5335 
      return result.success
5336 
    if result.cex is not None:
5337 
      raise result.cex
5338 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteProductFeedSubmit failed: unknown result");
5339 
 
5340 
  def getAllProductFeedSubmit(self, ):
5341 
    self.send_getAllProductFeedSubmit()
5342 
    return self.recv_getAllProductFeedSubmit()
5343 
 
5344 
  def send_getAllProductFeedSubmit(self, ):
5345 
    self._oprot.writeMessageBegin('getAllProductFeedSubmit', TMessageType.CALL, self._seqid)
5346 
    args = getAllProductFeedSubmit_args()
5347 
    args.write(self._oprot)
5348 
    self._oprot.writeMessageEnd()
5349 
    self._oprot.trans.flush()
5350 
 
5351 
  def recv_getAllProductFeedSubmit(self, ):
5352 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5353 
    if mtype == TMessageType.EXCEPTION:
5354 
      x = TApplicationException()
5355 
      x.read(self._iprot)
5356 
      self._iprot.readMessageEnd()
5357 
      raise x
5358 
    result = getAllProductFeedSubmit_result()
5359 
    result.read(self._iprot)
5360 
    self._iprot.readMessageEnd()
5361 
    if result.success is not None:
5362 
      return result.success
5363 
    if result.cex is not None:
5364 
      raise result.cex
5365 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllProductFeedSubmit failed: unknown result");
5366 
 
9724 kshitij.so 5367 
  def getMarketplacedetailsForItem(self, itemId, sourceId):
5368 
    """
5369 
    Parameters:
5370 
     - itemId
5371 
     - sourceId
5372 
    """
5373 
    self.send_getMarketplacedetailsForItem(itemId, sourceId)
5374 
    return self.recv_getMarketplacedetailsForItem()
9621 manish.sha 5375 
 
9724 kshitij.so 5376 
  def send_getMarketplacedetailsForItem(self, itemId, sourceId):
5377 
    self._oprot.writeMessageBegin('getMarketplacedetailsForItem', TMessageType.CALL, self._seqid)
5378 
    args = getMarketplacedetailsForItem_args()
5379 
    args.itemId = itemId
5380 
    args.sourceId = sourceId
5381 
    args.write(self._oprot)
5382 
    self._oprot.writeMessageEnd()
5383 
    self._oprot.trans.flush()
5384 
 
5385 
  def recv_getMarketplacedetailsForItem(self, ):
5386 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5387 
    if mtype == TMessageType.EXCEPTION:
5388 
      x = TApplicationException()
5389 
      x.read(self._iprot)
5390 
      self._iprot.readMessageEnd()
5391 
      raise x
5392 
    result = getMarketplacedetailsForItem_result()
5393 
    result.read(self._iprot)
5394 
    self._iprot.readMessageEnd()
5395 
    if result.success is not None:
5396 
      return result.success
5397 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMarketplacedetailsForItem failed: unknown result");
5398 
 
5399 
  def updateMarketplaceAttributesForItem(self, marketPlaceItem):
5400 
    """
5401 
    Parameters:
5402 
     - marketPlaceItem
5403 
    """
5404 
    self.send_updateMarketplaceAttributesForItem(marketPlaceItem)
5405 
    return self.recv_updateMarketplaceAttributesForItem()
5406 
 
5407 
  def send_updateMarketplaceAttributesForItem(self, marketPlaceItem):
5408 
    self._oprot.writeMessageBegin('updateMarketplaceAttributesForItem', TMessageType.CALL, self._seqid)
5409 
    args = updateMarketplaceAttributesForItem_args()
5410 
    args.marketPlaceItem = marketPlaceItem
5411 
    args.write(self._oprot)
5412 
    self._oprot.writeMessageEnd()
5413 
    self._oprot.trans.flush()
5414 
 
5415 
  def recv_updateMarketplaceAttributesForItem(self, ):
5416 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5417 
    if mtype == TMessageType.EXCEPTION:
5418 
      x = TApplicationException()
5419 
      x.read(self._iprot)
5420 
      self._iprot.readMessageEnd()
5421 
      raise x
5422 
    result = updateMarketplaceAttributesForItem_result()
5423 
    result.read(self._iprot)
5424 
    self._iprot.readMessageEnd()
5425 
    if result.success is not None:
5426 
      return result.success
5427 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMarketplaceAttributesForItem failed: unknown result");
5428 
 
9779 kshitij.so 5429 
  def getCostingForMarketplace(self, source, item_id):
5430 
    """
5431 
    Parameters:
5432 
     - source
5433 
     - item_id
5434 
    """
5435 
    self.send_getCostingForMarketplace(source, item_id)
5436 
    return self.recv_getCostingForMarketplace()
5437 
 
5438 
  def send_getCostingForMarketplace(self, source, item_id):
5439 
    self._oprot.writeMessageBegin('getCostingForMarketplace', TMessageType.CALL, self._seqid)
5440 
    args = getCostingForMarketplace_args()
5441 
    args.source = source
5442 
    args.item_id = item_id
5443 
    args.write(self._oprot)
5444 
    self._oprot.writeMessageEnd()
5445 
    self._oprot.trans.flush()
5446 
 
5447 
  def recv_getCostingForMarketplace(self, ):
5448 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5449 
    if mtype == TMessageType.EXCEPTION:
5450 
      x = TApplicationException()
5451 
      x.read(self._iprot)
5452 
      self._iprot.readMessageEnd()
5453 
      raise x
5454 
    result = getCostingForMarketplace_result()
5455 
    result.read(self._iprot)
5456 
    self._iprot.readMessageEnd()
5457 
    if result.success is not None:
5458 
      return result.success
5459 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCostingForMarketplace failed: unknown result");
5460 
 
9776 vikram.rag 5461 
  def getMarketPlaceItemsForPriceUpdate(self, source):
5462 
    """
5463 
    Parameters:
5464 
     - source
5465 
    """
5466 
    self.send_getMarketPlaceItemsForPriceUpdate(source)
5467 
    return self.recv_getMarketPlaceItemsForPriceUpdate()
9724 kshitij.so 5468 
 
9776 vikram.rag 5469 
  def send_getMarketPlaceItemsForPriceUpdate(self, source):
5470 
    self._oprot.writeMessageBegin('getMarketPlaceItemsForPriceUpdate', TMessageType.CALL, self._seqid)
5471 
    args = getMarketPlaceItemsForPriceUpdate_args()
5472 
    args.source = source
5473 
    args.write(self._oprot)
5474 
    self._oprot.writeMessageEnd()
5475 
    self._oprot.trans.flush()
5476 
 
5477 
  def recv_getMarketPlaceItemsForPriceUpdate(self, ):
5478 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5479 
    if mtype == TMessageType.EXCEPTION:
5480 
      x = TApplicationException()
5481 
      x.read(self._iprot)
5482 
      self._iprot.readMessageEnd()
5483 
      raise x
5484 
    result = getMarketPlaceItemsForPriceUpdate_result()
5485 
    result.read(self._iprot)
5486 
    self._iprot.readMessageEnd()
5487 
    if result.success is not None:
5488 
      return result.success
5489 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMarketPlaceItemsForPriceUpdate failed: unknown result");
5490 
 
9816 kshitij.so 5491 
  def updateMarketPlacePriceUpdateStatus(self, skulist, timestamp, source):
9776 vikram.rag 5492 
    """
5493 
    Parameters:
5494 
     - skulist
5495 
     - timestamp
9816 kshitij.so 5496 
     - source
9776 vikram.rag 5497 
    """
9816 kshitij.so 5498 
    self.send_updateMarketPlacePriceUpdateStatus(skulist, timestamp, source)
9776 vikram.rag 5499 
    self.recv_updateMarketPlacePriceUpdateStatus()
5500 
 
9816 kshitij.so 5501 
  def send_updateMarketPlacePriceUpdateStatus(self, skulist, timestamp, source):
9776 vikram.rag 5502 
    self._oprot.writeMessageBegin('updateMarketPlacePriceUpdateStatus', TMessageType.CALL, self._seqid)
5503 
    args = updateMarketPlacePriceUpdateStatus_args()
5504 
    args.skulist = skulist
5505 
    args.timestamp = timestamp
9816 kshitij.so 5506 
    args.source = source
9776 vikram.rag 5507 
    args.write(self._oprot)
5508 
    self._oprot.writeMessageEnd()
5509 
    self._oprot.trans.flush()
5510 
 
5511 
  def recv_updateMarketPlacePriceUpdateStatus(self, ):
5512 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5513 
    if mtype == TMessageType.EXCEPTION:
5514 
      x = TApplicationException()
5515 
      x.read(self._iprot)
5516 
      self._iprot.readMessageEnd()
5517 
      raise x
5518 
    result = updateMarketPlacePriceUpdateStatus_result()
5519 
    result.read(self._iprot)
5520 
    self._iprot.readMessageEnd()
5521 
    return
5522 
 
9861 rajveer 5523 
  def updateItemHoldInventory(self, itemHoldMap):
5524 
    """
5525 
    Parameters:
5526 
     - itemHoldMap
5527 
    """
5528 
    self.send_updateItemHoldInventory(itemHoldMap)
5529 
    self.recv_updateItemHoldInventory()
9776 vikram.rag 5530 
 
9861 rajveer 5531 
  def send_updateItemHoldInventory(self, itemHoldMap):
5532 
    self._oprot.writeMessageBegin('updateItemHoldInventory', TMessageType.CALL, self._seqid)
5533 
    args = updateItemHoldInventory_args()
5534 
    args.itemHoldMap = itemHoldMap
5535 
    args.write(self._oprot)
5536 
    self._oprot.writeMessageEnd()
5537 
    self._oprot.trans.flush()
5538 
 
5539 
  def recv_updateItemHoldInventory(self, ):
5540 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5541 
    if mtype == TMessageType.EXCEPTION:
5542 
      x = TApplicationException()
5543 
      x.read(self._iprot)
5544 
      self._iprot.readMessageEnd()
5545 
      raise x
5546 
    result = updateItemHoldInventory_result()
5547 
    result.read(self._iprot)
5548 
    self._iprot.readMessageEnd()
5549 
    return
5550 
 
9895 vikram.rag 5551 
  def updateNlcAtMarketplaces(self, item_id, vendor_id, nlc):
5552 
    """
5553 
    Parameters:
5554 
     - item_id
5555 
     - vendor_id
5556 
     - nlc
5557 
    """
5558 
    self.send_updateNlcAtMarketplaces(item_id, vendor_id, nlc)
5559 
    self.recv_updateNlcAtMarketplaces()
9861 rajveer 5560 
 
9895 vikram.rag 5561 
  def send_updateNlcAtMarketplaces(self, item_id, vendor_id, nlc):
5562 
    self._oprot.writeMessageBegin('updateNlcAtMarketplaces', TMessageType.CALL, self._seqid)
5563 
    args = updateNlcAtMarketplaces_args()
5564 
    args.item_id = item_id
5565 
    args.vendor_id = vendor_id
5566 
    args.nlc = nlc
5567 
    args.write(self._oprot)
5568 
    self._oprot.writeMessageEnd()
5569 
    self._oprot.trans.flush()
5570 
 
5571 
  def recv_updateNlcAtMarketplaces(self, ):
5572 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5573 
    if mtype == TMessageType.EXCEPTION:
5574 
      x = TApplicationException()
5575 
      x.read(self._iprot)
5576 
      self._iprot.readMessageEnd()
5577 
      raise x
5578 
    result = updateNlcAtMarketplaces_result()
5579 
    result.read(self._iprot)
5580 
    self._iprot.readMessageEnd()
5581 
    return
5582 
 
9945 vikram.rag 5583 
  def getAllFlipkartItems(self, ):
5584 
    self.send_getAllFlipkartItems()
5585 
    return self.recv_getAllFlipkartItems()
9895 vikram.rag 5586 
 
9945 vikram.rag 5587 
  def send_getAllFlipkartItems(self, ):
5588 
    self._oprot.writeMessageBegin('getAllFlipkartItems', TMessageType.CALL, self._seqid)
5589 
    args = getAllFlipkartItems_args()
5590 
    args.write(self._oprot)
5591 
    self._oprot.writeMessageEnd()
5592 
    self._oprot.trans.flush()
5593 
 
5594 
  def recv_getAllFlipkartItems(self, ):
5595 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5596 
    if mtype == TMessageType.EXCEPTION:
5597 
      x = TApplicationException()
5598 
      x.read(self._iprot)
5599 
      self._iprot.readMessageEnd()
5600 
      raise x
5601 
    result = getAllFlipkartItems_result()
5602 
    result.read(self._iprot)
5603 
    self._iprot.readMessageEnd()
5604 
    if result.success is not None:
5605 
      return result.success
5606 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFlipkartItems failed: unknown result");
5607 
 
10097 kshitij.so 5608 
  def addOrUpdateFlipkartItem(self, flipkartitem):
5609 
    """
5610 
    Parameters:
5611 
     - flipkartitem
5612 
    """
5613 
    self.send_addOrUpdateFlipkartItem(flipkartitem)
5614 
    return self.recv_addOrUpdateFlipkartItem()
9945 vikram.rag 5615 
 
10097 kshitij.so 5616 
  def send_addOrUpdateFlipkartItem(self, flipkartitem):
5617 
    self._oprot.writeMessageBegin('addOrUpdateFlipkartItem', TMessageType.CALL, self._seqid)
5618 
    args = addOrUpdateFlipkartItem_args()
5619 
    args.flipkartitem = flipkartitem
5620 
    args.write(self._oprot)
5621 
    self._oprot.writeMessageEnd()
5622 
    self._oprot.trans.flush()
5623 
 
5624 
  def recv_addOrUpdateFlipkartItem(self, ):
5625 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5626 
    if mtype == TMessageType.EXCEPTION:
5627 
      x = TApplicationException()
5628 
      x.read(self._iprot)
5629 
      self._iprot.readMessageEnd()
5630 
      raise x
5631 
    result = addOrUpdateFlipkartItem_result()
5632 
    result.read(self._iprot)
5633 
    self._iprot.readMessageEnd()
5634 
    if result.success is not None:
5635 
      return result.success
5636 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addOrUpdateFlipkartItem failed: unknown result");
5637 
 
5638 
  def getFlipkartItem(self, item_id):
5639 
    """
5640 
    Parameters:
5641 
     - item_id
5642 
    """
5643 
    self.send_getFlipkartItem(item_id)
5644 
    return self.recv_getFlipkartItem()
5645 
 
5646 
  def send_getFlipkartItem(self, item_id):
5647 
    self._oprot.writeMessageBegin('getFlipkartItem', TMessageType.CALL, self._seqid)
5648 
    args = getFlipkartItem_args()
5649 
    args.item_id = item_id
5650 
    args.write(self._oprot)
5651 
    self._oprot.writeMessageEnd()
5652 
    self._oprot.trans.flush()
5653 
 
5654 
  def recv_getFlipkartItem(self, ):
5655 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5656 
    if mtype == TMessageType.EXCEPTION:
5657 
      x = TApplicationException()
5658 
      x.read(self._iprot)
5659 
      self._iprot.readMessageEnd()
5660 
      raise x
5661 
    result = getFlipkartItem_result()
5662 
    result.read(self._iprot)
5663 
    self._iprot.readMessageEnd()
5664 
    if result.success is not None:
5665 
      return result.success
5666 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartItem failed: unknown result");
5667 
 
5668 
  def getFlipkartItemDetails(self, item_id):
5669 
    """
5670 
    Parameters:
5671 
     - item_id
5672 
    """
5673 
    self.send_getFlipkartItemDetails(item_id)
5674 
    return self.recv_getFlipkartItemDetails()
5675 
 
5676 
  def send_getFlipkartItemDetails(self, item_id):
5677 
    self._oprot.writeMessageBegin('getFlipkartItemDetails', TMessageType.CALL, self._seqid)
5678 
    args = getFlipkartItemDetails_args()
5679 
    args.item_id = item_id
5680 
    args.write(self._oprot)
5681 
    self._oprot.writeMessageEnd()
5682 
    self._oprot.trans.flush()
5683 
 
5684 
  def recv_getFlipkartItemDetails(self, ):
5685 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5686 
    if mtype == TMessageType.EXCEPTION:
5687 
      x = TApplicationException()
5688 
      x.read(self._iprot)
5689 
      self._iprot.readMessageEnd()
5690 
      raise x
5691 
    result = getFlipkartItemDetails_result()
5692 
    result.read(self._iprot)
5693 
    self._iprot.readMessageEnd()
5694 
    if result.success is not None:
5695 
      return result.success
5696 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartItemDetails failed: unknown result");
5697 
 
5698 
  def getFlipkartItems(self, offset, limit):
5699 
    """
5700 
    Parameters:
5701 
     - offset
5702 
     - limit
5703 
    """
5704 
    self.send_getFlipkartItems(offset, limit)
5705 
    return self.recv_getFlipkartItems()
5706 
 
5707 
  def send_getFlipkartItems(self, offset, limit):
5708 
    self._oprot.writeMessageBegin('getFlipkartItems', TMessageType.CALL, self._seqid)
5709 
    args = getFlipkartItems_args()
5710 
    args.offset = offset
5711 
    args.limit = limit
5712 
    args.write(self._oprot)
5713 
    self._oprot.writeMessageEnd()
5714 
    self._oprot.trans.flush()
5715 
 
5716 
  def recv_getFlipkartItems(self, ):
5717 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5718 
    if mtype == TMessageType.EXCEPTION:
5719 
      x = TApplicationException()
5720 
      x.read(self._iprot)
5721 
      self._iprot.readMessageEnd()
5722 
      raise x
5723 
    result = getFlipkartItems_result()
5724 
    result.read(self._iprot)
5725 
    self._iprot.readMessageEnd()
5726 
    if result.success is not None:
5727 
      return result.success
5728 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartItems failed: unknown result");
5729 
 
5730 
  def searchFlipkartItems(self, searchTerm, offset, limit):
5731 
    """
5732 
    Parameters:
5733 
     - searchTerm
5734 
     - offset
5735 
     - limit
5736 
    """
5737 
    self.send_searchFlipkartItems(searchTerm, offset, limit)
5738 
    return self.recv_searchFlipkartItems()
5739 
 
5740 
  def send_searchFlipkartItems(self, searchTerm, offset, limit):
5741 
    self._oprot.writeMessageBegin('searchFlipkartItems', TMessageType.CALL, self._seqid)
5742 
    args = searchFlipkartItems_args()
5743 
    args.searchTerm = searchTerm
5744 
    args.offset = offset
5745 
    args.limit = limit
5746 
    args.write(self._oprot)
5747 
    self._oprot.writeMessageEnd()
5748 
    self._oprot.trans.flush()
5749 
 
5750 
  def recv_searchFlipkartItems(self, ):
5751 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5752 
    if mtype == TMessageType.EXCEPTION:
5753 
      x = TApplicationException()
5754 
      x.read(self._iprot)
5755 
      self._iprot.readMessageEnd()
5756 
      raise x
5757 
    result = searchFlipkartItems_result()
5758 
    result.read(self._iprot)
5759 
    self._iprot.readMessageEnd()
5760 
    if result.success is not None:
5761 
      return result.success
5762 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchFlipkartItems failed: unknown result");
5763 
 
5764 
  def getCountForFlipkartItems(self, ):
5765 
    self.send_getCountForFlipkartItems()
5766 
    return self.recv_getCountForFlipkartItems()
5767 
 
5768 
  def send_getCountForFlipkartItems(self, ):
5769 
    self._oprot.writeMessageBegin('getCountForFlipkartItems', TMessageType.CALL, self._seqid)
5770 
    args = getCountForFlipkartItems_args()
5771 
    args.write(self._oprot)
5772 
    self._oprot.writeMessageEnd()
5773 
    self._oprot.trans.flush()
5774 
 
5775 
  def recv_getCountForFlipkartItems(self, ):
5776 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5777 
    if mtype == TMessageType.EXCEPTION:
5778 
      x = TApplicationException()
5779 
      x.read(self._iprot)
5780 
      self._iprot.readMessageEnd()
5781 
      raise x
5782 
    result = getCountForFlipkartItems_result()
5783 
    result.read(self._iprot)
5784 
    self._iprot.readMessageEnd()
5785 
    if result.success is not None:
5786 
      return result.success
5787 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForFlipkartItems failed: unknown result");
5788 
 
5789 
  def getFlipkartSearchResultCount(self, searchTerm):
5790 
    """
5791 
    Parameters:
5792 
     - searchTerm
5793 
    """
5794 
    self.send_getFlipkartSearchResultCount(searchTerm)
5795 
    return self.recv_getFlipkartSearchResultCount()
5796 
 
5797 
  def send_getFlipkartSearchResultCount(self, searchTerm):
5798 
    self._oprot.writeMessageBegin('getFlipkartSearchResultCount', TMessageType.CALL, self._seqid)
5799 
    args = getFlipkartSearchResultCount_args()
5800 
    args.searchTerm = searchTerm
5801 
    args.write(self._oprot)
5802 
    self._oprot.writeMessageEnd()
5803 
    self._oprot.trans.flush()
5804 
 
5805 
  def recv_getFlipkartSearchResultCount(self, ):
5806 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5807 
    if mtype == TMessageType.EXCEPTION:
5808 
      x = TApplicationException()
5809 
      x.read(self._iprot)
5810 
      self._iprot.readMessageEnd()
5811 
      raise x
5812 
    result = getFlipkartSearchResultCount_result()
5813 
    result.read(self._iprot)
5814 
    self._iprot.readMessageEnd()
5815 
    if result.success is not None:
5816 
      return result.success
5817 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartSearchResultCount failed: unknown result");
5818 
 
5819 
  def getAllFkItems(self, ):
5820 
    self.send_getAllFkItems()
5821 
    return self.recv_getAllFkItems()
5822 
 
5823 
  def send_getAllFkItems(self, ):
5824 
    self._oprot.writeMessageBegin('getAllFkItems', TMessageType.CALL, self._seqid)
5825 
    args = getAllFkItems_args()
5826 
    args.write(self._oprot)
5827 
    self._oprot.writeMessageEnd()
5828 
    self._oprot.trans.flush()
5829 
 
5830 
  def recv_getAllFkItems(self, ):
5831 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5832 
    if mtype == TMessageType.EXCEPTION:
5833 
      x = TApplicationException()
5834 
      x.read(self._iprot)
5835 
      self._iprot.readMessageEnd()
5836 
      raise x
5837 
    result = getAllFkItems_result()
5838 
    result.read(self._iprot)
5839 
    self._iprot.readMessageEnd()
5840 
    if result.success is not None:
5841 
      return result.success
5842 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFkItems failed: unknown result");
5843 
 
10140 vikram.rag 5844 
  def getFlipkartItemBySkyAtFlipkart(self, sku):
5845 
    """
5846 
    Parameters:
5847 
     - sku
5848 
    """
5849 
    self.send_getFlipkartItemBySkyAtFlipkart(sku)
5850 
    return self.recv_getFlipkartItemBySkyAtFlipkart()
10097 kshitij.so 5851 
 
10140 vikram.rag 5852 
  def send_getFlipkartItemBySkyAtFlipkart(self, sku):
5853 
    self._oprot.writeMessageBegin('getFlipkartItemBySkyAtFlipkart', TMessageType.CALL, self._seqid)
5854 
    args = getFlipkartItemBySkyAtFlipkart_args()
5855 
    args.sku = sku
5856 
    args.write(self._oprot)
5857 
    self._oprot.writeMessageEnd()
5858 
    self._oprot.trans.flush()
5859 
 
5860 
  def recv_getFlipkartItemBySkyAtFlipkart(self, ):
5861 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5862 
    if mtype == TMessageType.EXCEPTION:
5863 
      x = TApplicationException()
5864 
      x.read(self._iprot)
5865 
      self._iprot.readMessageEnd()
5866 
      raise x
5867 
    result = getFlipkartItemBySkyAtFlipkart_result()
5868 
    result.read(self._iprot)
5869 
    self._iprot.readMessageEnd()
5870 
    if result.success is not None:
5871 
      return result.success
5872 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartItemBySkyAtFlipkart failed: unknown result");
5873 
 
11015 kshitij.so 5874 
  def getMarketplaceHistory(self, source, offset, itemId):
5875 
    """
5876 
    Parameters:
5877 
     - source
5878 
     - offset
5879 
     - itemId
5880 
    """
5881 
    self.send_getMarketplaceHistory(source, offset, itemId)
5882 
    return self.recv_getMarketplaceHistory()
5883 
 
5884 
  def send_getMarketplaceHistory(self, source, offset, itemId):
5885 
    self._oprot.writeMessageBegin('getMarketplaceHistory', TMessageType.CALL, self._seqid)
5886 
    args = getMarketplaceHistory_args()
5887 
    args.source = source
5888 
    args.offset = offset
5889 
    args.itemId = itemId
5890 
    args.write(self._oprot)
5891 
    self._oprot.writeMessageEnd()
5892 
    self._oprot.trans.flush()
5893 
 
5894 
  def recv_getMarketplaceHistory(self, ):
5895 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5896 
    if mtype == TMessageType.EXCEPTION:
5897 
      x = TApplicationException()
5898 
      x.read(self._iprot)
5899 
      self._iprot.readMessageEnd()
5900 
      raise x
5901 
    result = getMarketplaceHistory_result()
5902 
    result.read(self._iprot)
5903 
    self._iprot.readMessageEnd()
5904 
    if result.success is not None:
5905 
      return result.success
5906 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMarketplaceHistory failed: unknown result");
5907 
 
10909 vikram.rag 5908 
  def getAllFbbListedItems(self, ):
5909 
    self.send_getAllFbbListedItems()
5910 
    return self.recv_getAllFbbListedItems()
10140 vikram.rag 5911 
 
10909 vikram.rag 5912 
  def send_getAllFbbListedItems(self, ):
5913 
    self._oprot.writeMessageBegin('getAllFbbListedItems', TMessageType.CALL, self._seqid)
5914 
    args = getAllFbbListedItems_args()
5915 
    args.write(self._oprot)
5916 
    self._oprot.writeMessageEnd()
5917 
    self._oprot.trans.flush()
5918 
 
5919 
  def recv_getAllFbbListedItems(self, ):
5920 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5921 
    if mtype == TMessageType.EXCEPTION:
5922 
      x = TApplicationException()
5923 
      x.read(self._iprot)
5924 
      self._iprot.readMessageEnd()
5925 
      raise x
5926 
    result = getAllFbbListedItems_result()
5927 
    result.read(self._iprot)
5928 
    self._iprot.readMessageEnd()
5929 
    if result.success is not None:
5930 
      return result.success
5931 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbbListedItems failed: unknown result");
5932 
 
10924 vikram.rag 5933 
  def getAllFbbPricingItems(self, ):
5934 
    self.send_getAllFbbPricingItems()
5935 
    return self.recv_getAllFbbPricingItems()
10909 vikram.rag 5936 
 
10924 vikram.rag 5937 
  def send_getAllFbbPricingItems(self, ):
5938 
    self._oprot.writeMessageBegin('getAllFbbPricingItems', TMessageType.CALL, self._seqid)
5939 
    args = getAllFbbPricingItems_args()
5940 
    args.write(self._oprot)
5941 
    self._oprot.writeMessageEnd()
5942 
    self._oprot.trans.flush()
5943 
 
5944 
  def recv_getAllFbbPricingItems(self, ):
5945 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5946 
    if mtype == TMessageType.EXCEPTION:
5947 
      x = TApplicationException()
5948 
      x.read(self._iprot)
5949 
      self._iprot.readMessageEnd()
5950 
      raise x
5951 
    result = getAllFbbPricingItems_result()
5952 
    result.read(self._iprot)
5953 
    self._iprot.readMessageEnd()
5954 
    if result.success is not None:
5955 
      return result.success
5956 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbbPricingItems failed: unknown result");
5957 
 
11015 kshitij.so 5958 
  def getCountForMarketplaceHistory(self, source, itemId):
5959 
    """
5960 
    Parameters:
5961 
     - source
5962 
     - itemId
5963 
    """
5964 
    self.send_getCountForMarketplaceHistory(source, itemId)
5965 
    return self.recv_getCountForMarketplaceHistory()
10924 vikram.rag 5966 
 
11015 kshitij.so 5967 
  def send_getCountForMarketplaceHistory(self, source, itemId):
5968 
    self._oprot.writeMessageBegin('getCountForMarketplaceHistory', TMessageType.CALL, self._seqid)
5969 
    args = getCountForMarketplaceHistory_args()
5970 
    args.source = source
5971 
    args.itemId = itemId
5972 
    args.write(self._oprot)
5973 
    self._oprot.writeMessageEnd()
5974 
    self._oprot.trans.flush()
5975 
 
5976 
  def recv_getCountForMarketplaceHistory(self, ):
5977 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5978 
    if mtype == TMessageType.EXCEPTION:
5979 
      x = TApplicationException()
5980 
      x.read(self._iprot)
5981 
      self._iprot.readMessageEnd()
5982 
      raise x
5983 
    result = getCountForMarketplaceHistory_result()
5984 
    result.read(self._iprot)
5985 
    self._iprot.readMessageEnd()
5986 
    if result.success is not None:
5987 
      return result.success
5988 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForMarketplaceHistory failed: unknown result");
5989 
 
5990 
  def getMarketplaceHistoryByDate(self, source, startDate, endDate, offset, limit, itemId):
5991 
    """
5992 
    Parameters:
5993 
     - source
5994 
     - startDate
5995 
     - endDate
5996 
     - offset
5997 
     - limit
5998 
     - itemId
5999 
    """
6000 
    self.send_getMarketplaceHistoryByDate(source, startDate, endDate, offset, limit, itemId)
6001 
    return self.recv_getMarketplaceHistoryByDate()
6002 
 
6003 
  def send_getMarketplaceHistoryByDate(self, source, startDate, endDate, offset, limit, itemId):
6004 
    self._oprot.writeMessageBegin('getMarketplaceHistoryByDate', TMessageType.CALL, self._seqid)
6005 
    args = getMarketplaceHistoryByDate_args()
6006 
    args.source = source
6007 
    args.startDate = startDate
6008 
    args.endDate = endDate
6009 
    args.offset = offset
6010 
    args.limit = limit
6011 
    args.itemId = itemId
6012 
    args.write(self._oprot)
6013 
    self._oprot.writeMessageEnd()
6014 
    self._oprot.trans.flush()
6015 
 
6016 
  def recv_getMarketplaceHistoryByDate(self, ):
6017 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6018 
    if mtype == TMessageType.EXCEPTION:
6019 
      x = TApplicationException()
6020 
      x.read(self._iprot)
6021 
      self._iprot.readMessageEnd()
6022 
      raise x
6023 
    result = getMarketplaceHistoryByDate_result()
6024 
    result.read(self._iprot)
6025 
    self._iprot.readMessageEnd()
6026 
    if result.success is not None:
6027 
      return result.success
6028 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMarketplaceHistoryByDate failed: unknown result");
6029 
 
6030 
 
5944 mandeep.dh 6031 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
6032 
  def __init__(self, handler):
6033 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
6034 
    self._processMap["addItem"] = Processor.process_addItem
6035 
    self._processMap["updateItem"] = Processor.process_updateItem
6036 
    self._processMap["isActive"] = Processor.process_isActive
7438 amit.gupta 6037 
    self._processMap["getItemsStatus"] = Processor.process_getItemsStatus
5944 mandeep.dh 6038 
    self._processMap["getItemStatusDescription"] = Processor.process_getItemStatusDescription
6039 
    self._processMap["startItemOn"] = Processor.process_startItemOn
6040 
    self._processMap["retireItemOn"] = Processor.process_retireItemOn
6041 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
6042 
    self._processMap["getItem"] = Processor.process_getItem
6043 
    self._processMap["getItemsByCatalogId"] = Processor.process_getItemsByCatalogId
6044 
    self._processMap["getValidItemsByCatalogId"] = Processor.process_getValidItemsByCatalogId
6045 
    self._processMap["getAllItems"] = Processor.process_getAllItems
6046 
    self._processMap["getAllItemsByStatus"] = Processor.process_getAllItemsByStatus
6047 
    self._processMap["markItemAsContentComplete"] = Processor.process_markItemAsContentComplete
6048 
    self._processMap["getAllItemsInRange"] = Processor.process_getAllItemsInRange
6049 
    self._processMap["getAllItemsByStatusInRange"] = Processor.process_getAllItemsByStatusInRange
6050 
    self._processMap["getItemCountByStatus"] = Processor.process_getItemCountByStatus
6051 
    self._processMap["getBestSellers"] = Processor.process_getBestSellers
6052 
    self._processMap["getBestSellersCatalogIds"] = Processor.process_getBestSellersCatalogIds
6053 
    self._processMap["getBestSellersCount"] = Processor.process_getBestSellersCount
6054 
    self._processMap["getBestDeals"] = Processor.process_getBestDeals
6055 
    self._processMap["getBestDealsCatalogIds"] = Processor.process_getBestDealsCatalogIds
6056 
    self._processMap["getBestDealsCount"] = Processor.process_getBestDealsCount
6057 
    self._processMap["getComingSoon"] = Processor.process_getComingSoon
6058 
    self._processMap["getComingSoonCatalogIds"] = Processor.process_getComingSoonCatalogIds
6059 
    self._processMap["getComingSoonCount"] = Processor.process_getComingSoonCount
6060 
    self._processMap["getLatestArrivals"] = Processor.process_getLatestArrivals
6061 
    self._processMap["getLatestArrivalsCatalogIds"] = Processor.process_getLatestArrivalsCatalogIds
6062 
    self._processMap["getLatestArrivalsCount"] = Processor.process_getLatestArrivalsCount
6063 
    self._processMap["generateNewEntityID"] = Processor.process_generateNewEntityID
6064 
    self._processMap["addCategory"] = Processor.process_addCategory
6065 
    self._processMap["getCategory"] = Processor.process_getCategory
6066 
    self._processMap["getAllCategories"] = Processor.process_getAllCategories
6067 
    self._processMap["getAllSimilarItems"] = Processor.process_getAllSimilarItems
6068 
    self._processMap["addSimilarItem"] = Processor.process_addSimilarItem
6512 kshitij.so 6069 
    self._processMap["addTag"] = Processor.process_addTag
6070 
    self._processMap["deleteEntityTag"] = Processor.process_deleteEntityTag
6071 
    self._processMap["deleteTag"] = Processor.process_deleteTag
6072 
    self._processMap["getAllTags"] = Processor.process_getAllTags
6073 
    self._processMap["getAllEntitiesByTagName"] = Processor.process_getAllEntitiesByTagName
6845 amit.gupta 6074 
    self._processMap["getAllEntityTags"] = Processor.process_getAllEntityTags
6850 kshitij.so 6075 
    self._processMap["addBanner"] = Processor.process_addBanner
8579 kshitij.so 6076 
    self._processMap["updateBanner"] = Processor.process_updateBanner
6850 kshitij.so 6077 
    self._processMap["getAllBanners"] = Processor.process_getAllBanners
6078 
    self._processMap["deleteBanner"] = Processor.process_deleteBanner
6079 
    self._processMap["getBannerDetails"] = Processor.process_getBannerDetails
6080 
    self._processMap["getActiveBanners"] = Processor.process_getActiveBanners
6849 kshitij.so 6081 
    self._processMap["addBannerMap"] = Processor.process_addBannerMap
8579 kshitij.so 6082 
    self._processMap["updateBannerMap"] = Processor.process_updateBannerMap
6849 kshitij.so 6083 
    self._processMap["deleteBannerMap"] = Processor.process_deleteBannerMap
6084 
    self._processMap["getBannerMapDetails"] = Processor.process_getBannerMapDetails
8579 kshitij.so 6085 
    self._processMap["addBannerUri"] = Processor.process_addBannerUri
6086 
    self._processMap["getUriMapping"] = Processor.process_getUriMapping
6087 
    self._processMap["addCampaign"] = Processor.process_addCampaign
6088 
    self._processMap["getCampaigns"] = Processor.process_getCampaigns
6089 
    self._processMap["deleteCampaign"] = Processor.process_deleteCampaign
6090 
    self._processMap["getAllCampaigns"] = Processor.process_getAllCampaigns
9155 kshitij.so 6091 
    self._processMap["getActiveBannersForMobileSite"] = Processor.process_getActiveBannersForMobileSite
5944 mandeep.dh 6092 
    self._processMap["deleteSimilarItem"] = Processor.process_deleteSimilarItem
6093 
    self._processMap["checkSimilarItem"] = Processor.process_checkSimilarItem
6094 
    self._processMap["validateRiskyStatus"] = Processor.process_validateRiskyStatus
6095 
    self._processMap["changeItemRiskyFlag"] = Processor.process_changeItemRiskyFlag
6096 
    self._processMap["getItemsByRiskyFlag"] = Processor.process_getItemsByRiskyFlag
6097 
    self._processMap["getItemsForMasterSheet"] = Processor.process_getItemsForMasterSheet
6098 
    self._processMap["getSimilarItemsCatalogIds"] = Processor.process_getSimilarItemsCatalogIds
6099 
    self._processMap["addProductNotification"] = Processor.process_addProductNotification
6100 
    self._processMap["sendProductNotifications"] = Processor.process_sendProductNotifications
6101 
    self._processMap["getAllBrandsByCategory"] = Processor.process_getAllBrandsByCategory
6102 
    self._processMap["getAllBrands"] = Processor.process_getAllBrands
6103 
    self._processMap["getAllSources"] = Processor.process_getAllSources
6104 
    self._processMap["getItemPricingBySource"] = Processor.process_getItemPricingBySource
6105 
    self._processMap["addSourceItemPricing"] = Processor.process_addSourceItemPricing
6106 
    self._processMap["getAllSourcePricing"] = Processor.process_getAllSourcePricing
6107 
    self._processMap["getItemForSource"] = Processor.process_getItemForSource
6108 
    self._processMap["searchItemsInRange"] = Processor.process_searchItemsInRange
6109 
    self._processMap["getSearchResultCount"] = Processor.process_getSearchResultCount
6110 
    self._processMap["getProductNotifications"] = Processor.process_getProductNotifications
6111 
    self._processMap["getProductNotificationRequestCount"] = Processor.process_getProductNotificationRequestCount
6112 
    self._processMap["addAuthorizationLog"] = Processor.process_addAuthorizationLog
6113 
    self._processMap["addupdateVoucherForItem"] = Processor.process_addupdateVoucherForItem
6114 
    self._processMap["deleteVoucherForItem"] = Processor.process_deleteVoucherForItem
6115 
    self._processMap["getVoucherAmount"] = Processor.process_getVoucherAmount
6116 
    self._processMap["getAllItemVouchers"] = Processor.process_getAllItemVouchers
6117 
    self._processMap["isValidCatalogItemId"] = Processor.process_isValidCatalogItemId
6039 amit.gupta 6118 
    self._processMap["getVatPercentageForItem"] = Processor.process_getVatPercentageForItem
6119 
    self._processMap["getVatAmountForItem"] = Processor.process_getVatAmountForItem
6531 vikram.rag 6120 
    self._processMap["getAllIgnoredInventoryUpdateItemsList"] = Processor.process_getAllIgnoredInventoryUpdateItemsList
6821 amar.kumar 6121 
    self._processMap["getAllAliveItems"] = Processor.process_getAllAliveItems
6805 anupam.sin 6122 
    self._processMap["getInsuranceAmount"] = Processor.process_getInsuranceAmount
6123 
    self._processMap["getInsurer"] = Processor.process_getInsurer
6838 vikram.rag 6124 
    self._processMap["getAllInsurers"] = Processor.process_getAllInsurers
6962 rajveer 6125 
    self._processMap["updateInsuranceDeclaredAmount"] = Processor.process_updateInsuranceDeclaredAmount
7190 amar.kumar 6126 
    self._processMap["getFreebieForItem"] = Processor.process_getFreebieForItem
6127 
    self._processMap["addOrUpdateFreebieForItem"] = Processor.process_addOrUpdateFreebieForItem
7272 amit.gupta 6128 
    self._processMap["addOrUpdateBrandInfo"] = Processor.process_addOrUpdateBrandInfo
6129 
    self._processMap["getBrandInfo"] = Processor.process_getBrandInfo
7256 rajveer 6130 
    self._processMap["getStorePricing"] = Processor.process_getStorePricing
7306 rajveer 6131 
    self._processMap["getStorePricings"] = Processor.process_getStorePricings
7265 rajveer 6132 
    self._processMap["updateStorePricing"] = Processor.process_updateStorePricing
7281 kshitij.so 6133 
    self._processMap["getAllAmazonListedItems"] = Processor.process_getAllAmazonListedItems
8619 kshitij.so 6134 
    self._processMap["searchAmazonItems"] = Processor.process_searchAmazonItems
6135 
    self._processMap["getAmazonSearchResultCount"] = Processor.process_getAmazonSearchResultCount
6136 
    self._processMap["getCountForAmazonlistedItems"] = Processor.process_getCountForAmazonlistedItems
7281 kshitij.so 6137 
    self._processMap["getAmazonItemDetails"] = Processor.process_getAmazonItemDetails
6138 
    self._processMap["updateAmazonItemDetails"] = Processor.process_updateAmazonItemDetails
6139 
    self._processMap["addAmazonItem"] = Processor.process_addAmazonItem
7291 vikram.rag 6140 
    self._processMap["getAsinItems"] = Processor.process_getAsinItems
6141 
    self._processMap["getAllFbaListedItems"] = Processor.process_getAllFbaListedItems
6142 
    self._processMap["getAllNonFbaListedItems"] = Processor.process_getAllNonFbaListedItems
7460 kshitij.so 6143 
    self._processMap["updateItemInventory"] = Processor.process_updateItemInventory
7770 kshitij.so 6144 
    self._processMap["updateTimestampForAmazonFeeds"] = Processor.process_updateTimestampForAmazonFeeds
7897 amar.kumar 6145 
    self._processMap["getAllParentCategories"] = Processor.process_getAllParentCategories
7977 kshitij.so 6146 
    self._processMap["addPageViewEvent"] = Processor.process_addPageViewEvent
6147 
    self._processMap["addCartEvent"] = Processor.process_addCartEvent
8182 amar.kumar 6148 
    self._processMap["addEbayItem"] = Processor.process_addEbayItem
6149 
    self._processMap["getEbayItem"] = Processor.process_getEbayItem
6150 
    self._processMap["updateEbayItem"] = Processor.process_updateEbayItem
8139 kshitij.so 6151 
    self._processMap["getAmazonListedItems"] = Processor.process_getAmazonListedItems
8168 kshitij.so 6152 
    self._processMap["updateAmazonAttributesInBulk"] = Processor.process_updateAmazonAttributesInBulk
8379 vikram.rag 6153 
    self._processMap["getAllItemstoListOnFba"] = Processor.process_getAllItemstoListOnFba
6154 
    self._processMap["getAllItemstoListOnNonFba"] = Processor.process_getAllItemstoListOnNonFba
8619 kshitij.so 6155 
    self._processMap["updateAsin"] = Processor.process_updateAsin
8739 vikram.rag 6156 
    self._processMap["addOrUpdateSnapdealItem"] = Processor.process_addOrUpdateSnapdealItem
6157 
    self._processMap["getSnapdealItem"] = Processor.process_getSnapdealItem
9242 kshitij.so 6158 
    self._processMap["getSnapdealItemDetails"] = Processor.process_getSnapdealItemDetails
8739 vikram.rag 6159 
    self._processMap["getAllSnapdealItems"] = Processor.process_getAllSnapdealItems
9242 kshitij.so 6160 
    self._processMap["getSnapdealItems"] = Processor.process_getSnapdealItems
6161 
    self._processMap["searchSnapdealItems"] = Processor.process_searchSnapdealItems
6162 
    self._processMap["getCountForSnapdealItems"] = Processor.process_getCountForSnapdealItems
6163 
    self._processMap["getSnapdealSearchResultCount"] = Processor.process_getSnapdealSearchResultCount
9299 kshitij.so 6164 
    self._processMap["getPrefferedInsurerForItem"] = Processor.process_getPrefferedInsurerForItem
9456 vikram.rag 6165 
    self._processMap["getSnapdealItembySkuAtSnapdeal"] = Processor.process_getSnapdealItembySkuAtSnapdeal
9621 manish.sha 6166 
    self._processMap["getProductFeedSubmit"] = Processor.process_getProductFeedSubmit
6167 
    self._processMap["addProductFeedSubmit"] = Processor.process_addProductFeedSubmit
6168 
    self._processMap["updateProductFeedSubmit"] = Processor.process_updateProductFeedSubmit
6169 
    self._processMap["deleteProductFeedSubmit"] = Processor.process_deleteProductFeedSubmit
6170 
    self._processMap["getAllProductFeedSubmit"] = Processor.process_getAllProductFeedSubmit
9724 kshitij.so 6171 
    self._processMap["getMarketplacedetailsForItem"] = Processor.process_getMarketplacedetailsForItem
6172 
    self._processMap["updateMarketplaceAttributesForItem"] = Processor.process_updateMarketplaceAttributesForItem
9779 kshitij.so 6173 
    self._processMap["getCostingForMarketplace"] = Processor.process_getCostingForMarketplace
9776 vikram.rag 6174 
    self._processMap["getMarketPlaceItemsForPriceUpdate"] = Processor.process_getMarketPlaceItemsForPriceUpdate
6175 
    self._processMap["updateMarketPlacePriceUpdateStatus"] = Processor.process_updateMarketPlacePriceUpdateStatus
9861 rajveer 6176 
    self._processMap["updateItemHoldInventory"] = Processor.process_updateItemHoldInventory
9895 vikram.rag 6177 
    self._processMap["updateNlcAtMarketplaces"] = Processor.process_updateNlcAtMarketplaces
9945 vikram.rag 6178 
    self._processMap["getAllFlipkartItems"] = Processor.process_getAllFlipkartItems
10097 kshitij.so 6179 
    self._processMap["addOrUpdateFlipkartItem"] = Processor.process_addOrUpdateFlipkartItem
6180 
    self._processMap["getFlipkartItem"] = Processor.process_getFlipkartItem
6181 
    self._processMap["getFlipkartItemDetails"] = Processor.process_getFlipkartItemDetails
6182 
    self._processMap["getFlipkartItems"] = Processor.process_getFlipkartItems
6183 
    self._processMap["searchFlipkartItems"] = Processor.process_searchFlipkartItems
6184 
    self._processMap["getCountForFlipkartItems"] = Processor.process_getCountForFlipkartItems
6185 
    self._processMap["getFlipkartSearchResultCount"] = Processor.process_getFlipkartSearchResultCount
6186 
    self._processMap["getAllFkItems"] = Processor.process_getAllFkItems
10140 vikram.rag 6187 
    self._processMap["getFlipkartItemBySkyAtFlipkart"] = Processor.process_getFlipkartItemBySkyAtFlipkart
11015 kshitij.so 6188 
    self._processMap["getMarketplaceHistory"] = Processor.process_getMarketplaceHistory
10909 vikram.rag 6189 
    self._processMap["getAllFbbListedItems"] = Processor.process_getAllFbbListedItems
10924 vikram.rag 6190 
    self._processMap["getAllFbbPricingItems"] = Processor.process_getAllFbbPricingItems
11015 kshitij.so 6191 
    self._processMap["getCountForMarketplaceHistory"] = Processor.process_getCountForMarketplaceHistory
6192 
    self._processMap["getMarketplaceHistoryByDate"] = Processor.process_getMarketplaceHistoryByDate
5944 mandeep.dh 6193 
 
6194 
  def process(self, iprot, oprot):
6195 
    (name, type, seqid) = iprot.readMessageBegin()
6196 
    if name not in self._processMap:
6197 
      iprot.skip(TType.STRUCT)
6198 
      iprot.readMessageEnd()
6199 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
6200 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
6201 
      x.write(oprot)
6202 
      oprot.writeMessageEnd()
6203 
      oprot.trans.flush()
6204 
      return
6205 
    else:
6206 
      self._processMap[name](self, seqid, iprot, oprot)
6207 
    return True
6208 
 
6209 
  def process_addItem(self, seqid, iprot, oprot):
6210 
    args = addItem_args()
6211 
    args.read(iprot)
6212 
    iprot.readMessageEnd()
6213 
    result = addItem_result()
6214 
    try:
6215 
      result.success = self._handler.addItem(args.item)
6216 
    except CatalogServiceException, cex:
6217 
      result.cex = cex
6218 
    oprot.writeMessageBegin("addItem", TMessageType.REPLY, seqid)
6219 
    result.write(oprot)
6220 
    oprot.writeMessageEnd()
6221 
    oprot.trans.flush()
6222 
 
6223 
  def process_updateItem(self, seqid, iprot, oprot):
6224 
    args = updateItem_args()
6225 
    args.read(iprot)
6226 
    iprot.readMessageEnd()
6227 
    result = updateItem_result()
6228 
    try:
6229 
      result.success = self._handler.updateItem(args.item)
6230 
    except CatalogServiceException, cex:
6231 
      result.cex = cex
6232 
    oprot.writeMessageBegin("updateItem", TMessageType.REPLY, seqid)
6233 
    result.write(oprot)
6234 
    oprot.writeMessageEnd()
6235 
    oprot.trans.flush()
6236 
 
6237 
  def process_isActive(self, seqid, iprot, oprot):
6238 
    args = isActive_args()
6239 
    args.read(iprot)
6240 
    iprot.readMessageEnd()
6241 
    result = isActive_result()
6242 
    try:
6243 
      result.success = self._handler.isActive(args.itemId)
6244 
    except CatalogServiceException, isex:
6245 
      result.isex = isex
6246 
    oprot.writeMessageBegin("isActive", TMessageType.REPLY, seqid)
6247 
    result.write(oprot)
6248 
    oprot.writeMessageEnd()
6249 
    oprot.trans.flush()
6250 
 
7438 amit.gupta 6251 
  def process_getItemsStatus(self, seqid, iprot, oprot):
6252 
    args = getItemsStatus_args()
6253 
    args.read(iprot)
6254 
    iprot.readMessageEnd()
6255 
    result = getItemsStatus_result()
6256 
    try:
6257 
      result.success = self._handler.getItemsStatus(args.itemIds)
6258 
    except CatalogServiceException, isex:
6259 
      result.isex = isex
6260 
    oprot.writeMessageBegin("getItemsStatus", TMessageType.REPLY, seqid)
6261 
    result.write(oprot)
6262 
    oprot.writeMessageEnd()
6263 
    oprot.trans.flush()
6264 
 
5944 mandeep.dh 6265 
  def process_getItemStatusDescription(self, seqid, iprot, oprot):
6266 
    args = getItemStatusDescription_args()
6267 
    args.read(iprot)
6268 
    iprot.readMessageEnd()
6269 
    result = getItemStatusDescription_result()
6270 
    try:
6271 
      result.success = self._handler.getItemStatusDescription(args.itemId)
6272 
    except CatalogServiceException, isex:
6273 
      result.isex = isex
6274 
    oprot.writeMessageBegin("getItemStatusDescription", TMessageType.REPLY, seqid)
6275 
    result.write(oprot)
6276 
    oprot.writeMessageEnd()
6277 
    oprot.trans.flush()
6278 
 
6279 
  def process_startItemOn(self, seqid, iprot, oprot):
6280 
    args = startItemOn_args()
6281 
    args.read(iprot)
6282 
    iprot.readMessageEnd()
6283 
    result = startItemOn_result()
6284 
    try:
6285 
      self._handler.startItemOn(args.item_id, args.timestamp)
6286 
    except CatalogServiceException, cex:
6287 
      result.cex = cex
6288 
    oprot.writeMessageBegin("startItemOn", TMessageType.REPLY, seqid)
6289 
    result.write(oprot)
6290 
    oprot.writeMessageEnd()
6291 
    oprot.trans.flush()
6292 
 
6293 
  def process_retireItemOn(self, seqid, iprot, oprot):
6294 
    args = retireItemOn_args()
6295 
    args.read(iprot)
6296 
    iprot.readMessageEnd()
6297 
    result = retireItemOn_result()
6298 
    try:
6299 
      self._handler.retireItemOn(args.item_id, args.timestamp)
6300 
    except CatalogServiceException, cex:
6301 
      result.cex = cex
6302 
    oprot.writeMessageBegin("retireItemOn", TMessageType.REPLY, seqid)
6303 
    result.write(oprot)
6304 
    oprot.writeMessageEnd()
6305 
    oprot.trans.flush()
6306 
 
6307 
  def process_changeItemStatus(self, seqid, iprot, oprot):
6308 
    args = changeItemStatus_args()
6309 
    args.read(iprot)
6310 
    iprot.readMessageEnd()
6311 
    result = changeItemStatus_result()
6312 
    try:
6313 
      self._handler.changeItemStatus(args.item_id, args.timestamp, args.newstatus)
6314 
    except CatalogServiceException, cex:
6315 
      result.cex = cex
6316 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
6317 
    result.write(oprot)
6318 
    oprot.writeMessageEnd()
6319 
    oprot.trans.flush()
6320 
 
6321 
  def process_getItem(self, seqid, iprot, oprot):
6322 
    args = getItem_args()
6323 
    args.read(iprot)
6324 
    iprot.readMessageEnd()
6325 
    result = getItem_result()
6326 
    try:
6327 
      result.success = self._handler.getItem(args.item_id)
6328 
    except CatalogServiceException, cex:
6329 
      result.cex = cex
6330 
    oprot.writeMessageBegin("getItem", TMessageType.REPLY, seqid)
6331 
    result.write(oprot)
6332 
    oprot.writeMessageEnd()
6333 
    oprot.trans.flush()
6334 
 
6335 
  def process_getItemsByCatalogId(self, seqid, iprot, oprot):
6336 
    args = getItemsByCatalogId_args()
6337 
    args.read(iprot)
6338 
    iprot.readMessageEnd()
6339 
    result = getItemsByCatalogId_result()
6340 
    try:
6341 
      result.success = self._handler.getItemsByCatalogId(args.catalog_item_id)
6342 
    except CatalogServiceException, cex:
6343 
      result.cex = cex
6344 
    oprot.writeMessageBegin("getItemsByCatalogId", TMessageType.REPLY, seqid)
6345 
    result.write(oprot)
6346 
    oprot.writeMessageEnd()
6347 
    oprot.trans.flush()
6348 
 
6349 
  def process_getValidItemsByCatalogId(self, seqid, iprot, oprot):
6350 
    args = getValidItemsByCatalogId_args()
6351 
    args.read(iprot)
6352 
    iprot.readMessageEnd()
6353 
    result = getValidItemsByCatalogId_result()
6354 
    try:
6355 
      result.success = self._handler.getValidItemsByCatalogId(args.catalog_item_id)
6356 
    except CatalogServiceException, cex:
6357 
      result.cex = cex
6358 
    oprot.writeMessageBegin("getValidItemsByCatalogId", TMessageType.REPLY, seqid)
6359 
    result.write(oprot)
6360 
    oprot.writeMessageEnd()
6361 
    oprot.trans.flush()
6362 
 
6363 
  def process_getAllItems(self, seqid, iprot, oprot):
6364 
    args = getAllItems_args()
6365 
    args.read(iprot)
6366 
    iprot.readMessageEnd()
6367 
    result = getAllItems_result()
6368 
    try:
6369 
      result.success = self._handler.getAllItems(args.isActive)
6370 
    except CatalogServiceException, cex:
6371 
      result.cex = cex
6372 
    oprot.writeMessageBegin("getAllItems", TMessageType.REPLY, seqid)
6373 
    result.write(oprot)
6374 
    oprot.writeMessageEnd()
6375 
    oprot.trans.flush()
6376 
 
6377 
  def process_getAllItemsByStatus(self, seqid, iprot, oprot):
6378 
    args = getAllItemsByStatus_args()
6379 
    args.read(iprot)
6380 
    iprot.readMessageEnd()
6381 
    result = getAllItemsByStatus_result()
6382 
    try:
6383 
      result.success = self._handler.getAllItemsByStatus(args.itemStatus)
6384 
    except CatalogServiceException, cex:
6385 
      result.cex = cex
6386 
    oprot.writeMessageBegin("getAllItemsByStatus", TMessageType.REPLY, seqid)
6387 
    result.write(oprot)
6388 
    oprot.writeMessageEnd()
6389 
    oprot.trans.flush()
6390 
 
6391 
  def process_markItemAsContentComplete(self, seqid, iprot, oprot):
6392 
    args = markItemAsContentComplete_args()
6393 
    args.read(iprot)
6394 
    iprot.readMessageEnd()
6395 
    result = markItemAsContentComplete_result()
6396 
    try:
9253 rajveer 6397 
      result.success = self._handler.markItemAsContentComplete(args.entityId, args.category, args.brand, args.modelName, args.modelNumber, args.isAndroid)
5944 mandeep.dh 6398 
    except CatalogServiceException, cex:
6399 
      result.cex = cex
6400 
    oprot.writeMessageBegin("markItemAsContentComplete", TMessageType.REPLY, seqid)
6401 
    result.write(oprot)
6402 
    oprot.writeMessageEnd()
6403 
    oprot.trans.flush()
6404 
 
6405 
  def process_getAllItemsInRange(self, seqid, iprot, oprot):
6406 
    args = getAllItemsInRange_args()
6407 
    args.read(iprot)
6408 
    iprot.readMessageEnd()
6409 
    result = getAllItemsInRange_result()
6410 
    try:
6411 
      result.success = self._handler.getAllItemsInRange(args.offset, args.limit)
6412 
    except CatalogServiceException, cex:
6413 
      result.cex = cex
6414 
    oprot.writeMessageBegin("getAllItemsInRange", TMessageType.REPLY, seqid)
6415 
    result.write(oprot)
6416 
    oprot.writeMessageEnd()
6417 
    oprot.trans.flush()
6418 
 
6419 
  def process_getAllItemsByStatusInRange(self, seqid, iprot, oprot):
6420 
    args = getAllItemsByStatusInRange_args()
6421 
    args.read(iprot)
6422 
    iprot.readMessageEnd()
6423 
    result = getAllItemsByStatusInRange_result()
6424 
    try:
6425 
      result.success = self._handler.getAllItemsByStatusInRange(args.itemStatus, args.offset, args.limit)
6426 
    except CatalogServiceException, cex:
6427 
      result.cex = cex
6428 
    oprot.writeMessageBegin("getAllItemsByStatusInRange", TMessageType.REPLY, seqid)
6429 
    result.write(oprot)
6430 
    oprot.writeMessageEnd()
6431 
    oprot.trans.flush()
6432 
 
6433 
  def process_getItemCountByStatus(self, seqid, iprot, oprot):
6434 
    args = getItemCountByStatus_args()
6435 
    args.read(iprot)
6436 
    iprot.readMessageEnd()
6437 
    result = getItemCountByStatus_result()
6438 
    result.success = self._handler.getItemCountByStatus(args.useStatus, args.itemStatus)
6439 
    oprot.writeMessageBegin("getItemCountByStatus", TMessageType.REPLY, seqid)
6440 
    result.write(oprot)
6441 
    oprot.writeMessageEnd()
6442 
    oprot.trans.flush()
6443 
 
6444 
  def process_getBestSellers(self, seqid, iprot, oprot):
6445 
    args = getBestSellers_args()
6446 
    args.read(iprot)
6447 
    iprot.readMessageEnd()
6448 
    result = getBestSellers_result()
6449 
    try:
6450 
      result.success = self._handler.getBestSellers()
6451 
    except CatalogServiceException, isex:
6452 
      result.isex = isex
6453 
    oprot.writeMessageBegin("getBestSellers", TMessageType.REPLY, seqid)
6454 
    result.write(oprot)
6455 
    oprot.writeMessageEnd()
6456 
    oprot.trans.flush()
6457 
 
6458 
  def process_getBestSellersCatalogIds(self, seqid, iprot, oprot):
6459 
    args = getBestSellersCatalogIds_args()
6460 
    args.read(iprot)
6461 
    iprot.readMessageEnd()
6462 
    result = getBestSellersCatalogIds_result()
6463 
    try:
6464 
      result.success = self._handler.getBestSellersCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
6465 
    except CatalogServiceException, cex:
6466 
      result.cex = cex
6467 
    oprot.writeMessageBegin("getBestSellersCatalogIds", TMessageType.REPLY, seqid)
6468 
    result.write(oprot)
6469 
    oprot.writeMessageEnd()
6470 
    oprot.trans.flush()
6471 
 
6472 
  def process_getBestSellersCount(self, seqid, iprot, oprot):
6473 
    args = getBestSellersCount_args()
6474 
    args.read(iprot)
6475 
    iprot.readMessageEnd()
6476 
    result = getBestSellersCount_result()
6477 
    try:
6478 
      result.success = self._handler.getBestSellersCount()
6479 
    except CatalogServiceException, cex:
6480 
      result.cex = cex
6481 
    oprot.writeMessageBegin("getBestSellersCount", TMessageType.REPLY, seqid)
6482 
    result.write(oprot)
6483 
    oprot.writeMessageEnd()
6484 
    oprot.trans.flush()
6485 
 
6486 
  def process_getBestDeals(self, seqid, iprot, oprot):
6487 
    args = getBestDeals_args()
6488 
    args.read(iprot)
6489 
    iprot.readMessageEnd()
6490 
    result = getBestDeals_result()
6491 
    try:
6492 
      result.success = self._handler.getBestDeals()
6493 
    except CatalogServiceException, isex:
6494 
      result.isex = isex
6495 
    oprot.writeMessageBegin("getBestDeals", TMessageType.REPLY, seqid)
6496 
    result.write(oprot)
6497 
    oprot.writeMessageEnd()
6498 
    oprot.trans.flush()
6499 
 
6500 
  def process_getBestDealsCatalogIds(self, seqid, iprot, oprot):
6501 
    args = getBestDealsCatalogIds_args()
6502 
    args.read(iprot)
6503 
    iprot.readMessageEnd()
6504 
    result = getBestDealsCatalogIds_result()
6505 
    try:
6506 
      result.success = self._handler.getBestDealsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
6507 
    except CatalogServiceException, cex:
6508 
      result.cex = cex
6509 
    oprot.writeMessageBegin("getBestDealsCatalogIds", TMessageType.REPLY, seqid)
6510 
    result.write(oprot)
6511 
    oprot.writeMessageEnd()
6512 
    oprot.trans.flush()
6513 
 
6514 
  def process_getBestDealsCount(self, seqid, iprot, oprot):
6515 
    args = getBestDealsCount_args()
6516 
    args.read(iprot)
6517 
    iprot.readMessageEnd()
6518 
    result = getBestDealsCount_result()
6519 
    try:
6520 
      result.success = self._handler.getBestDealsCount()
6521 
    except CatalogServiceException, cex:
6522 
      result.cex = cex
6523 
    oprot.writeMessageBegin("getBestDealsCount", TMessageType.REPLY, seqid)
6524 
    result.write(oprot)
6525 
    oprot.writeMessageEnd()
6526 
    oprot.trans.flush()
6527 
 
6528 
  def process_getComingSoon(self, seqid, iprot, oprot):
6529 
    args = getComingSoon_args()
6530 
    args.read(iprot)
6531 
    iprot.readMessageEnd()
6532 
    result = getComingSoon_result()
6533 
    try:
6534 
      result.success = self._handler.getComingSoon()
6535 
    except CatalogServiceException, isex:
6536 
      result.isex = isex
6537 
    oprot.writeMessageBegin("getComingSoon", TMessageType.REPLY, seqid)
6538 
    result.write(oprot)
6539 
    oprot.writeMessageEnd()
6540 
    oprot.trans.flush()
6541 
 
6542 
  def process_getComingSoonCatalogIds(self, seqid, iprot, oprot):
6543 
    args = getComingSoonCatalogIds_args()
6544 
    args.read(iprot)
6545 
    iprot.readMessageEnd()
6546 
    result = getComingSoonCatalogIds_result()
6547 
    try:
6548 
      result.success = self._handler.getComingSoonCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
6549 
    except CatalogServiceException, cex:
6550 
      result.cex = cex
6551 
    oprot.writeMessageBegin("getComingSoonCatalogIds", TMessageType.REPLY, seqid)
6552 
    result.write(oprot)
6553 
    oprot.writeMessageEnd()
6554 
    oprot.trans.flush()
6555 
 
6556 
  def process_getComingSoonCount(self, seqid, iprot, oprot):
6557 
    args = getComingSoonCount_args()
6558 
    args.read(iprot)
6559 
    iprot.readMessageEnd()
6560 
    result = getComingSoonCount_result()
6561 
    try:
6562 
      result.success = self._handler.getComingSoonCount()
6563 
    except CatalogServiceException, cex:
6564 
      result.cex = cex
6565 
    oprot.writeMessageBegin("getComingSoonCount", TMessageType.REPLY, seqid)
6566 
    result.write(oprot)
6567 
    oprot.writeMessageEnd()
6568 
    oprot.trans.flush()
6569 
 
6570 
  def process_getLatestArrivals(self, seqid, iprot, oprot):
6571 
    args = getLatestArrivals_args()
6572 
    args.read(iprot)
6573 
    iprot.readMessageEnd()
6574 
    result = getLatestArrivals_result()
6575 
    try:
6576 
      result.success = self._handler.getLatestArrivals()
6577 
    except CatalogServiceException, isex:
6578 
      result.isex = isex
6579 
    oprot.writeMessageBegin("getLatestArrivals", TMessageType.REPLY, seqid)
6580 
    result.write(oprot)
6581 
    oprot.writeMessageEnd()
6582 
    oprot.trans.flush()
6583 
 
6584 
  def process_getLatestArrivalsCatalogIds(self, seqid, iprot, oprot):
6585 
    args = getLatestArrivalsCatalogIds_args()
6586 
    args.read(iprot)
6587 
    iprot.readMessageEnd()
6588 
    result = getLatestArrivalsCatalogIds_result()
6589 
    try:
6590 
      result.success = self._handler.getLatestArrivalsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.categories)
6591 
    except CatalogServiceException, cex:
6592 
      result.cex = cex
6593 
    oprot.writeMessageBegin("getLatestArrivalsCatalogIds", TMessageType.REPLY, seqid)
6594 
    result.write(oprot)
6595 
    oprot.writeMessageEnd()
6596 
    oprot.trans.flush()
6597 
 
6598 
  def process_getLatestArrivalsCount(self, seqid, iprot, oprot):
6599 
    args = getLatestArrivalsCount_args()
6600 
    args.read(iprot)
6601 
    iprot.readMessageEnd()
6602 
    result = getLatestArrivalsCount_result()
6603 
    try:
6604 
      result.success = self._handler.getLatestArrivalsCount()
6605 
    except CatalogServiceException, cex:
6606 
      result.cex = cex
6607 
    oprot.writeMessageBegin("getLatestArrivalsCount", TMessageType.REPLY, seqid)
6608 
    result.write(oprot)
6609 
    oprot.writeMessageEnd()
6610 
    oprot.trans.flush()
6611 
 
6612 
  def process_generateNewEntityID(self, seqid, iprot, oprot):
6613 
    args = generateNewEntityID_args()
6614 
    args.read(iprot)
6615 
    iprot.readMessageEnd()
6616 
    result = generateNewEntityID_result()
6617 
    result.success = self._handler.generateNewEntityID()
6618 
    oprot.writeMessageBegin("generateNewEntityID", TMessageType.REPLY, seqid)
6619 
    result.write(oprot)
6620 
    oprot.writeMessageEnd()
6621 
    oprot.trans.flush()
6622 
 
6623 
  def process_addCategory(self, seqid, iprot, oprot):
6624 
    args = addCategory_args()
6625 
    args.read(iprot)
6626 
    iprot.readMessageEnd()
6627 
    result = addCategory_result()
6628 
    result.success = self._handler.addCategory(args.category)
6629 
    oprot.writeMessageBegin("addCategory", TMessageType.REPLY, seqid)
6630 
    result.write(oprot)
6631 
    oprot.writeMessageEnd()
6632 
    oprot.trans.flush()
6633 
 
6634 
  def process_getCategory(self, seqid, iprot, oprot):
6635 
    args = getCategory_args()
6636 
    args.read(iprot)
6637 
    iprot.readMessageEnd()
6638 
    result = getCategory_result()
6639 
    result.success = self._handler.getCategory(args.id)
6640 
    oprot.writeMessageBegin("getCategory", TMessageType.REPLY, seqid)
6641 
    result.write(oprot)
6642 
    oprot.writeMessageEnd()
6643 
    oprot.trans.flush()
6644 
 
6645 
  def process_getAllCategories(self, seqid, iprot, oprot):
6646 
    args = getAllCategories_args()
6647 
    args.read(iprot)
6648 
    iprot.readMessageEnd()
6649 
    result = getAllCategories_result()
6650 
    result.success = self._handler.getAllCategories()
6651 
    oprot.writeMessageBegin("getAllCategories", TMessageType.REPLY, seqid)
6652 
    result.write(oprot)
6653 
    oprot.writeMessageEnd()
6654 
    oprot.trans.flush()
6655 
 
6656 
  def process_getAllSimilarItems(self, seqid, iprot, oprot):
6657 
    args = getAllSimilarItems_args()
6658 
    args.read(iprot)
6659 
    iprot.readMessageEnd()
6660 
    result = getAllSimilarItems_result()
6661 
    result.success = self._handler.getAllSimilarItems(args.itemId)
6662 
    oprot.writeMessageBegin("getAllSimilarItems", TMessageType.REPLY, seqid)
6663 
    result.write(oprot)
6664 
    oprot.writeMessageEnd()
6665 
    oprot.trans.flush()
6666 
 
6667 
  def process_addSimilarItem(self, seqid, iprot, oprot):
6668 
    args = addSimilarItem_args()
6669 
    args.read(iprot)
6670 
    iprot.readMessageEnd()
6671 
    result = addSimilarItem_result()
6672 
    try:
6673 
      result.success = self._handler.addSimilarItem(args.itemId, args.catalogItemId)
6674 
    except CatalogServiceException, cex:
6675 
      result.cex = cex
6676 
    oprot.writeMessageBegin("addSimilarItem", TMessageType.REPLY, seqid)
6677 
    result.write(oprot)
6678 
    oprot.writeMessageEnd()
6679 
    oprot.trans.flush()
6680 
 
6512 kshitij.so 6681 
  def process_addTag(self, seqid, iprot, oprot):
6682 
    args = addTag_args()
6683 
    args.read(iprot)
6684 
    iprot.readMessageEnd()
6685 
    result = addTag_result()
6686 
    result.success = self._handler.addTag(args.displayName, args.itemId)
6687 
    oprot.writeMessageBegin("addTag", TMessageType.REPLY, seqid)
6688 
    result.write(oprot)
6689 
    oprot.writeMessageEnd()
6690 
    oprot.trans.flush()
6691 
 
6692 
  def process_deleteEntityTag(self, seqid, iprot, oprot):
6693 
    args = deleteEntityTag_args()
6694 
    args.read(iprot)
6695 
    iprot.readMessageEnd()
6696 
    result = deleteEntityTag_result()
6697 
    result.success = self._handler.deleteEntityTag(args.displayName, args.itemId)
6698 
    oprot.writeMessageBegin("deleteEntityTag", TMessageType.REPLY, seqid)
6699 
    result.write(oprot)
6700 
    oprot.writeMessageEnd()
6701 
    oprot.trans.flush()
6702 
 
6703 
  def process_deleteTag(self, seqid, iprot, oprot):
6704 
    args = deleteTag_args()
6705 
    args.read(iprot)
6706 
    iprot.readMessageEnd()
6707 
    result = deleteTag_result()
6708 
    result.success = self._handler.deleteTag(args.displayName)
6709 
    oprot.writeMessageBegin("deleteTag", TMessageType.REPLY, seqid)
6710 
    result.write(oprot)
6711 
    oprot.writeMessageEnd()
6712 
    oprot.trans.flush()
6713 
 
6714 
  def process_getAllTags(self, seqid, iprot, oprot):
6715 
    args = getAllTags_args()
6716 
    args.read(iprot)
6717 
    iprot.readMessageEnd()
6718 
    result = getAllTags_result()
6719 
    result.success = self._handler.getAllTags()
6720 
    oprot.writeMessageBegin("getAllTags", TMessageType.REPLY, seqid)
6721 
    result.write(oprot)
6722 
    oprot.writeMessageEnd()
6723 
    oprot.trans.flush()
6724 
 
6725 
  def process_getAllEntitiesByTagName(self, seqid, iprot, oprot):
6726 
    args = getAllEntitiesByTagName_args()
6727 
    args.read(iprot)
6728 
    iprot.readMessageEnd()
6729 
    result = getAllEntitiesByTagName_result()
6730 
    result.success = self._handler.getAllEntitiesByTagName(args.displayName)
6731 
    oprot.writeMessageBegin("getAllEntitiesByTagName", TMessageType.REPLY, seqid)
6732 
    result.write(oprot)
6733 
    oprot.writeMessageEnd()
6734 
    oprot.trans.flush()
6735 
 
6845 amit.gupta 6736 
  def process_getAllEntityTags(self, seqid, iprot, oprot):
6737 
    args = getAllEntityTags_args()
6738 
    args.read(iprot)
6739 
    iprot.readMessageEnd()
6740 
    result = getAllEntityTags_result()
6741 
    result.success = self._handler.getAllEntityTags()
6742 
    oprot.writeMessageBegin("getAllEntityTags", TMessageType.REPLY, seqid)
6743 
    result.write(oprot)
6744 
    oprot.writeMessageEnd()
6745 
    oprot.trans.flush()
6746 
 
6850 kshitij.so 6747 
  def process_addBanner(self, seqid, iprot, oprot):
6748 
    args = addBanner_args()
6749 
    args.read(iprot)
6750 
    iprot.readMessageEnd()
6751 
    result = addBanner_result()
10097 kshitij.so 6752 
    result.success = self._handler.addBanner(args.bannerCongregate)
6850 kshitij.so 6753 
    oprot.writeMessageBegin("addBanner", TMessageType.REPLY, seqid)
6754 
    result.write(oprot)
6755 
    oprot.writeMessageEnd()
6756 
    oprot.trans.flush()
6757 
 
8579 kshitij.so 6758 
  def process_updateBanner(self, seqid, iprot, oprot):
6759 
    args = updateBanner_args()
6760 
    args.read(iprot)
6761 
    iprot.readMessageEnd()
6762 
    result = updateBanner_result()
6763 
    result.success = self._handler.updateBanner(args.banner)
6764 
    oprot.writeMessageBegin("updateBanner", TMessageType.REPLY, seqid)
6765 
    result.write(oprot)
6766 
    oprot.writeMessageEnd()
6767 
    oprot.trans.flush()
6768 
 
6850 kshitij.so 6769 
  def process_getAllBanners(self, seqid, iprot, oprot):
6770 
    args = getAllBanners_args()
6771 
    args.read(iprot)
6772 
    iprot.readMessageEnd()
6773 
    result = getAllBanners_result()
6774 
    result.success = self._handler.getAllBanners()
6775 
    oprot.writeMessageBegin("getAllBanners", TMessageType.REPLY, seqid)
6776 
    result.write(oprot)
6777 
    oprot.writeMessageEnd()
6778 
    oprot.trans.flush()
6779 
 
6780 
  def process_deleteBanner(self, seqid, iprot, oprot):
6781 
    args = deleteBanner_args()
6782 
    args.read(iprot)
6783 
    iprot.readMessageEnd()
6784 
    result = deleteBanner_result()
9155 kshitij.so 6785 
    result.success = self._handler.deleteBanner(args.bannerName, args.bannerType)
6850 kshitij.so 6786 
    oprot.writeMessageBegin("deleteBanner", TMessageType.REPLY, seqid)
6787 
    result.write(oprot)
6788 
    oprot.writeMessageEnd()
6789 
    oprot.trans.flush()
6790 
 
6791 
  def process_getBannerDetails(self, seqid, iprot, oprot):
6792 
    args = getBannerDetails_args()
6793 
    args.read(iprot)
6794 
    iprot.readMessageEnd()
6795 
    result = getBannerDetails_result()
9155 kshitij.so 6796 
    result.success = self._handler.getBannerDetails(args.bannerName, args.bannerType)
6850 kshitij.so 6797 
    oprot.writeMessageBegin("getBannerDetails", TMessageType.REPLY, seqid)
6798 
    result.write(oprot)
6799 
    oprot.writeMessageEnd()
6800 
    oprot.trans.flush()
6801 
 
6802 
  def process_getActiveBanners(self, seqid, iprot, oprot):
6803 
    args = getActiveBanners_args()
6804 
    args.read(iprot)
6805 
    iprot.readMessageEnd()
6806 
    result = getActiveBanners_result()
6807 
    result.success = self._handler.getActiveBanners()
6808 
    oprot.writeMessageBegin("getActiveBanners", TMessageType.REPLY, seqid)
6809 
    result.write(oprot)
6810 
    oprot.writeMessageEnd()
6811 
    oprot.trans.flush()
6812 
 
6849 kshitij.so 6813 
  def process_addBannerMap(self, seqid, iprot, oprot):
6814 
    args = addBannerMap_args()
6815 
    args.read(iprot)
6816 
    iprot.readMessageEnd()
6817 
    result = addBannerMap_result()
8579 kshitij.so 6818 
    result.success = self._handler.addBannerMap(args.bannerMaps)
6849 kshitij.so 6819 
    oprot.writeMessageBegin("addBannerMap", TMessageType.REPLY, seqid)
6820 
    result.write(oprot)
6821 
    oprot.writeMessageEnd()
6822 
    oprot.trans.flush()
6823 
 
8579 kshitij.so 6824 
  def process_updateBannerMap(self, seqid, iprot, oprot):
6825 
    args = updateBannerMap_args()
6826 
    args.read(iprot)
6827 
    iprot.readMessageEnd()
6828 
    result = updateBannerMap_result()
6829 
    result.success = self._handler.updateBannerMap(args.bannerMap)
6830 
    oprot.writeMessageBegin("updateBannerMap", TMessageType.REPLY, seqid)
6831 
    result.write(oprot)
6832 
    oprot.writeMessageEnd()
6833 
    oprot.trans.flush()
6834 
 
6849 kshitij.so 6835 
  def process_deleteBannerMap(self, seqid, iprot, oprot):
6836 
    args = deleteBannerMap_args()
6837 
    args.read(iprot)
6838 
    iprot.readMessageEnd()
6839 
    result = deleteBannerMap_result()
6840 
    result.success = self._handler.deleteBannerMap(args.bannerName)
6841 
    oprot.writeMessageBegin("deleteBannerMap", TMessageType.REPLY, seqid)
6842 
    result.write(oprot)
6843 
    oprot.writeMessageEnd()
6844 
    oprot.trans.flush()
6845 
 
6846 
  def process_getBannerMapDetails(self, seqid, iprot, oprot):
6847 
    args = getBannerMapDetails_args()
6848 
    args.read(iprot)
6849 
    iprot.readMessageEnd()
6850 
    result = getBannerMapDetails_result()
9155 kshitij.so 6851 
    result.success = self._handler.getBannerMapDetails(args.bannerName, args.bannerType)
6849 kshitij.so 6852 
    oprot.writeMessageBegin("getBannerMapDetails", TMessageType.REPLY, seqid)
6853 
    result.write(oprot)
6854 
    oprot.writeMessageEnd()
6855 
    oprot.trans.flush()
6856 
 
8579 kshitij.so 6857 
  def process_addBannerUri(self, seqid, iprot, oprot):
6858 
    args = addBannerUri_args()
6859 
    args.read(iprot)
6860 
    iprot.readMessageEnd()
6861 
    result = addBannerUri_result()
6862 
    self._handler.addBannerUri(args.bannerUriMappings)
6863 
    oprot.writeMessageBegin("addBannerUri", TMessageType.REPLY, seqid)
6864 
    result.write(oprot)
6865 
    oprot.writeMessageEnd()
6866 
    oprot.trans.flush()
6867 
 
6868 
  def process_getUriMapping(self, seqid, iprot, oprot):
6869 
    args = getUriMapping_args()
6870 
    args.read(iprot)
6871 
    iprot.readMessageEnd()
6872 
    result = getUriMapping_result()
9155 kshitij.so 6873 
    result.success = self._handler.getUriMapping(args.bannerName, args.bannerType)
8579 kshitij.so 6874 
    oprot.writeMessageBegin("getUriMapping", TMessageType.REPLY, seqid)
6875 
    result.write(oprot)
6876 
    oprot.writeMessageEnd()
6877 
    oprot.trans.flush()
6878 
 
6879 
  def process_addCampaign(self, seqid, iprot, oprot):
6880 
    args = addCampaign_args()
6881 
    args.read(iprot)
6882 
    iprot.readMessageEnd()
6883 
    result = addCampaign_result()
6884 
    self._handler.addCampaign(args.campaign)
6885 
    oprot.writeMessageBegin("addCampaign", TMessageType.REPLY, seqid)
6886 
    result.write(oprot)
6887 
    oprot.writeMessageEnd()
6888 
    oprot.trans.flush()
6889 
 
6890 
  def process_getCampaigns(self, seqid, iprot, oprot):
6891 
    args = getCampaigns_args()
6892 
    args.read(iprot)
6893 
    iprot.readMessageEnd()
6894 
    result = getCampaigns_result()
6895 
    result.success = self._handler.getCampaigns(args.campaignName)
6896 
    oprot.writeMessageBegin("getCampaigns", TMessageType.REPLY, seqid)
6897 
    result.write(oprot)
6898 
    oprot.writeMessageEnd()
6899 
    oprot.trans.flush()
6900 
 
6901 
  def process_deleteCampaign(self, seqid, iprot, oprot):
6902 
    args = deleteCampaign_args()
6903 
    args.read(iprot)
6904 
    iprot.readMessageEnd()
6905 
    result = deleteCampaign_result()
6906 
    self._handler.deleteCampaign(args.campaignId)
6907 
    oprot.writeMessageBegin("deleteCampaign", TMessageType.REPLY, seqid)
6908 
    result.write(oprot)
6909 
    oprot.writeMessageEnd()
6910 
    oprot.trans.flush()
6911 
 
6912 
  def process_getAllCampaigns(self, seqid, iprot, oprot):
6913 
    args = getAllCampaigns_args()
6914 
    args.read(iprot)
6915 
    iprot.readMessageEnd()
6916 
    result = getAllCampaigns_result()
6917 
    result.success = self._handler.getAllCampaigns()
6918 
    oprot.writeMessageBegin("getAllCampaigns", TMessageType.REPLY, seqid)
6919 
    result.write(oprot)
6920 
    oprot.writeMessageEnd()
6921 
    oprot.trans.flush()
6922 
 
9155 kshitij.so 6923 
  def process_getActiveBannersForMobileSite(self, seqid, iprot, oprot):
6924 
    args = getActiveBannersForMobileSite_args()
6925 
    args.read(iprot)
6926 
    iprot.readMessageEnd()
6927 
    result = getActiveBannersForMobileSite_result()
6928 
    result.success = self._handler.getActiveBannersForMobileSite()
6929 
    oprot.writeMessageBegin("getActiveBannersForMobileSite", TMessageType.REPLY, seqid)
6930 
    result.write(oprot)
6931 
    oprot.writeMessageEnd()
6932 
    oprot.trans.flush()
6933 
 
5944 mandeep.dh 6934 
  def process_deleteSimilarItem(self, seqid, iprot, oprot):
6935 
    args = deleteSimilarItem_args()
6936 
    args.read(iprot)
6937 
    iprot.readMessageEnd()
6938 
    result = deleteSimilarItem_result()
6939 
    try:
6940 
      result.success = self._handler.deleteSimilarItem(args.itemId, args.catalogItemId)
6941 
    except CatalogServiceException, cex:
6942 
      result.cex = cex
6943 
    oprot.writeMessageBegin("deleteSimilarItem", TMessageType.REPLY, seqid)
6944 
    result.write(oprot)
6945 
    oprot.writeMessageEnd()
6946 
    oprot.trans.flush()
6947 
 
6948 
  def process_checkSimilarItem(self, seqid, iprot, oprot):
6949 
    args = checkSimilarItem_args()
6950 
    args.read(iprot)
6951 
    iprot.readMessageEnd()
6952 
    result = checkSimilarItem_result()
6953 
    result.success = self._handler.checkSimilarItem(args.brand, args.modelNumber, args.modelName, args.color)
6954 
    oprot.writeMessageBegin("checkSimilarItem", TMessageType.REPLY, seqid)
6955 
    result.write(oprot)
6956 
    oprot.writeMessageEnd()
6957 
    oprot.trans.flush()
6958 
 
6959 
  def process_validateRiskyStatus(self, seqid, iprot, oprot):
6960 
    args = validateRiskyStatus_args()
6961 
    args.read(iprot)
6962 
    iprot.readMessageEnd()
6963 
    result = validateRiskyStatus_result()
6964 
    self._handler.validateRiskyStatus(args.itemId)
6965 
    oprot.writeMessageBegin("validateRiskyStatus", TMessageType.REPLY, seqid)
6966 
    result.write(oprot)
6967 
    oprot.writeMessageEnd()
6968 
    oprot.trans.flush()
6969 
 
6970 
  def process_changeItemRiskyFlag(self, seqid, iprot, oprot):
6971 
    args = changeItemRiskyFlag_args()
6972 
    args.read(iprot)
6973 
    iprot.readMessageEnd()
6974 
    result = changeItemRiskyFlag_result()
6975 
    self._handler.changeItemRiskyFlag(args.itemId, args.risky)
6976 
    oprot.writeMessageBegin("changeItemRiskyFlag", TMessageType.REPLY, seqid)
6977 
    result.write(oprot)
6978 
    oprot.writeMessageEnd()
6979 
    oprot.trans.flush()
6980 
 
6981 
  def process_getItemsByRiskyFlag(self, seqid, iprot, oprot):
6982 
    args = getItemsByRiskyFlag_args()
6983 
    args.read(iprot)
6984 
    iprot.readMessageEnd()
6985 
    result = getItemsByRiskyFlag_result()
6986 
    result.success = self._handler.getItemsByRiskyFlag()
6987 
    oprot.writeMessageBegin("getItemsByRiskyFlag", TMessageType.REPLY, seqid)
6988 
    result.write(oprot)
6989 
    oprot.writeMessageEnd()
6990 
    oprot.trans.flush()
6991 
 
6992 
  def process_getItemsForMasterSheet(self, seqid, iprot, oprot):
6993 
    args = getItemsForMasterSheet_args()
6994 
    args.read(iprot)
6995 
    iprot.readMessageEnd()
6996 
    result = getItemsForMasterSheet_result()
6997 
    result.success = self._handler.getItemsForMasterSheet(args.category, args.brand)
6998 
    oprot.writeMessageBegin("getItemsForMasterSheet", TMessageType.REPLY, seqid)
6999 
    result.write(oprot)
7000 
    oprot.writeMessageEnd()
7001 
    oprot.trans.flush()
7002 
 
7003 
  def process_getSimilarItemsCatalogIds(self, seqid, iprot, oprot):
7004 
    args = getSimilarItemsCatalogIds_args()
7005 
    args.read(iprot)
7006 
    iprot.readMessageEnd()
7007 
    result = getSimilarItemsCatalogIds_result()
7008 
    result.success = self._handler.getSimilarItemsCatalogIds(args.beginIndex, args.totalItems, args.itemId)
7009 
    oprot.writeMessageBegin("getSimilarItemsCatalogIds", TMessageType.REPLY, seqid)
7010 
    result.write(oprot)
7011 
    oprot.writeMessageEnd()
7012 
    oprot.trans.flush()
7013 
 
7014 
  def process_addProductNotification(self, seqid, iprot, oprot):
7015 
    args = addProductNotification_args()
7016 
    args.read(iprot)
7017 
    iprot.readMessageEnd()
7018 
    result = addProductNotification_result()
7019 
    result.success = self._handler.addProductNotification(args.itemId, args.email)
7020 
    oprot.writeMessageBegin("addProductNotification", TMessageType.REPLY, seqid)
7021 
    result.write(oprot)
7022 
    oprot.writeMessageEnd()
7023 
    oprot.trans.flush()
7024 
 
7025 
  def process_sendProductNotifications(self, seqid, iprot, oprot):
7026 
    args = sendProductNotifications_args()
7027 
    args.read(iprot)
7028 
    iprot.readMessageEnd()
7029 
    result = sendProductNotifications_result()
7030 
    result.success = self._handler.sendProductNotifications()
7031 
    oprot.writeMessageBegin("sendProductNotifications", TMessageType.REPLY, seqid)
7032 
    result.write(oprot)
7033 
    oprot.writeMessageEnd()
7034 
    oprot.trans.flush()
7035 
 
7036 
  def process_getAllBrandsByCategory(self, seqid, iprot, oprot):
7037 
    args = getAllBrandsByCategory_args()
7038 
    args.read(iprot)
7039 
    iprot.readMessageEnd()
7040 
    result = getAllBrandsByCategory_result()
7041 
    result.success = self._handler.getAllBrandsByCategory(args.categoryId)
7042 
    oprot.writeMessageBegin("getAllBrandsByCategory", TMessageType.REPLY, seqid)
7043 
    result.write(oprot)
7044 
    oprot.writeMessageEnd()
7045 
    oprot.trans.flush()
7046 
 
7047 
  def process_getAllBrands(self, seqid, iprot, oprot):
7048 
    args = getAllBrands_args()
7049 
    args.read(iprot)
7050 
    iprot.readMessageEnd()
7051 
    result = getAllBrands_result()
7052 
    result.success = self._handler.getAllBrands()
7053 
    oprot.writeMessageBegin("getAllBrands", TMessageType.REPLY, seqid)
7054 
    result.write(oprot)
7055 
    oprot.writeMessageEnd()
7056 
    oprot.trans.flush()
7057 
 
7058 
  def process_getAllSources(self, seqid, iprot, oprot):
7059 
    args = getAllSources_args()
7060 
    args.read(iprot)
7061 
    iprot.readMessageEnd()
7062 
    result = getAllSources_result()
7063 
    result.success = self._handler.getAllSources()
7064 
    oprot.writeMessageBegin("getAllSources", TMessageType.REPLY, seqid)
7065 
    result.write(oprot)
7066 
    oprot.writeMessageEnd()
7067 
    oprot.trans.flush()
7068 
 
7069 
  def process_getItemPricingBySource(self, seqid, iprot, oprot):
7070 
    args = getItemPricingBySource_args()
7071 
    args.read(iprot)
7072 
    iprot.readMessageEnd()
7073 
    result = getItemPricingBySource_result()
7074 
    try:
7075 
      result.success = self._handler.getItemPricingBySource(args.itemId, args.sourceId)
7076 
    except CatalogServiceException, cex:
7077 
      result.cex = cex
7078 
    oprot.writeMessageBegin("getItemPricingBySource", TMessageType.REPLY, seqid)
7079 
    result.write(oprot)
7080 
    oprot.writeMessageEnd()
7081 
    oprot.trans.flush()
7082 
 
7083 
  def process_addSourceItemPricing(self, seqid, iprot, oprot):
7084 
    args = addSourceItemPricing_args()
7085 
    args.read(iprot)
7086 
    iprot.readMessageEnd()
7087 
    result = addSourceItemPricing_result()
7088 
    try:
7089 
      self._handler.addSourceItemPricing(args.sourceItemPricing)
7090 
    except CatalogServiceException, cex:
7091 
      result.cex = cex
7092 
    oprot.writeMessageBegin("addSourceItemPricing", TMessageType.REPLY, seqid)
7093 
    result.write(oprot)
7094 
    oprot.writeMessageEnd()
7095 
    oprot.trans.flush()
7096 
 
7097 
  def process_getAllSourcePricing(self, seqid, iprot, oprot):
7098 
    args = getAllSourcePricing_args()
7099 
    args.read(iprot)
7100 
    iprot.readMessageEnd()
7101 
    result = getAllSourcePricing_result()
7102 
    try:
7103 
      result.success = self._handler.getAllSourcePricing(args.itemId)
7104 
    except CatalogServiceException, cex:
7105 
      result.cex = cex
7106 
    oprot.writeMessageBegin("getAllSourcePricing", TMessageType.REPLY, seqid)
7107 
    result.write(oprot)
7108 
    oprot.writeMessageEnd()
7109 
    oprot.trans.flush()
7110 
 
7111 
  def process_getItemForSource(self, seqid, iprot, oprot):
7112 
    args = getItemForSource_args()
7113 
    args.read(iprot)
7114 
    iprot.readMessageEnd()
7115 
    result = getItemForSource_result()
7116 
    try:
7117 
      result.success = self._handler.getItemForSource(args.item_id, args.sourceId)
7118 
    except CatalogServiceException, cex:
7119 
      result.cex = cex
7120 
    oprot.writeMessageBegin("getItemForSource", TMessageType.REPLY, seqid)
7121 
    result.write(oprot)
7122 
    oprot.writeMessageEnd()
7123 
    oprot.trans.flush()
7124 
 
7125 
  def process_searchItemsInRange(self, seqid, iprot, oprot):
7126 
    args = searchItemsInRange_args()
7127 
    args.read(iprot)
7128 
    iprot.readMessageEnd()
7129 
    result = searchItemsInRange_result()
7130 
    result.success = self._handler.searchItemsInRange(args.searchTerms, args.offset, args.limit)
7131 
    oprot.writeMessageBegin("searchItemsInRange", TMessageType.REPLY, seqid)
7132 
    result.write(oprot)
7133 
    oprot.writeMessageEnd()
7134 
    oprot.trans.flush()
7135 
 
7136 
  def process_getSearchResultCount(self, seqid, iprot, oprot):
7137 
    args = getSearchResultCount_args()
7138 
    args.read(iprot)
7139 
    iprot.readMessageEnd()
7140 
    result = getSearchResultCount_result()
7141 
    result.success = self._handler.getSearchResultCount(args.searchTerms)
7142 
    oprot.writeMessageBegin("getSearchResultCount", TMessageType.REPLY, seqid)
7143 
    result.write(oprot)
7144 
    oprot.writeMessageEnd()
7145 
    oprot.trans.flush()
7146 
 
7147 
  def process_getProductNotifications(self, seqid, iprot, oprot):
7148 
    args = getProductNotifications_args()
7149 
    args.read(iprot)
7150 
    iprot.readMessageEnd()
7151 
    result = getProductNotifications_result()
7152 
    result.success = self._handler.getProductNotifications(args.startDateTime)
7153 
    oprot.writeMessageBegin("getProductNotifications", TMessageType.REPLY, seqid)
7154 
    result.write(oprot)
7155 
    oprot.writeMessageEnd()
7156 
    oprot.trans.flush()
7157 
 
7158 
  def process_getProductNotificationRequestCount(self, seqid, iprot, oprot):
7159 
    args = getProductNotificationRequestCount_args()
7160 
    args.read(iprot)
7161 
    iprot.readMessageEnd()
7162 
    result = getProductNotificationRequestCount_result()
7897 amar.kumar 7163 
    result.success = self._handler.getProductNotificationRequestCount(args.startDateTime, args.categoryId)
5944 mandeep.dh 7164 
    oprot.writeMessageBegin("getProductNotificationRequestCount", TMessageType.REPLY, seqid)
7165 
    result.write(oprot)
7166 
    oprot.writeMessageEnd()
7167 
    oprot.trans.flush()
7168 
 
7169 
  def process_addAuthorizationLog(self, seqid, iprot, oprot):
7170 
    args = addAuthorizationLog_args()
7171 
    args.read(iprot)
7172 
    iprot.readMessageEnd()
7173 
    result = addAuthorizationLog_result()
7174 
    try:
7175 
      result.success = self._handler.addAuthorizationLog(args.itemId, args.username, args.reason)
7176 
    except CatalogServiceException, cex:
7177 
      result.cex = cex
7178 
    oprot.writeMessageBegin("addAuthorizationLog", TMessageType.REPLY, seqid)
7179 
    result.write(oprot)
7180 
    oprot.writeMessageEnd()
7181 
    oprot.trans.flush()
7182 
 
7183 
  def process_addupdateVoucherForItem(self, seqid, iprot, oprot):
7184 
    args = addupdateVoucherForItem_args()
7185 
    args.read(iprot)
7186 
    iprot.readMessageEnd()
7187 
    result = addupdateVoucherForItem_result()
7188 
    try:
7189 
      result.success = self._handler.addupdateVoucherForItem(args.catalog_item_id, args.voucherType, args.voucherAmount)
7190 
    except CatalogServiceException, cex:
7191 
      result.cex = cex
7192 
    oprot.writeMessageBegin("addupdateVoucherForItem", TMessageType.REPLY, seqid)
7193 
    result.write(oprot)
7194 
    oprot.writeMessageEnd()
7195 
    oprot.trans.flush()
7196 
 
7197 
  def process_deleteVoucherForItem(self, seqid, iprot, oprot):
7198 
    args = deleteVoucherForItem_args()
7199 
    args.read(iprot)
7200 
    iprot.readMessageEnd()
7201 
    result = deleteVoucherForItem_result()
7202 
    try:
7203 
      result.success = self._handler.deleteVoucherForItem(args.catalog_item_id, args.voucherType)
7204 
    except CatalogServiceException, cex:
7205 
      result.cex = cex
7206 
    oprot.writeMessageBegin("deleteVoucherForItem", TMessageType.REPLY, seqid)
7207 
    result.write(oprot)
7208 
    oprot.writeMessageEnd()
7209 
    oprot.trans.flush()
7210 
 
7211 
  def process_getVoucherAmount(self, seqid, iprot, oprot):
7212 
    args = getVoucherAmount_args()
7213 
    args.read(iprot)
7214 
    iprot.readMessageEnd()
7215 
    result = getVoucherAmount_result()
7216 
    result.success = self._handler.getVoucherAmount(args.itemId, args.voucherType)
7217 
    oprot.writeMessageBegin("getVoucherAmount", TMessageType.REPLY, seqid)
7218 
    result.write(oprot)
7219 
    oprot.writeMessageEnd()
7220 
    oprot.trans.flush()
7221 
 
7222 
  def process_getAllItemVouchers(self, seqid, iprot, oprot):
7223 
    args = getAllItemVouchers_args()
7224 
    args.read(iprot)
7225 
    iprot.readMessageEnd()
7226 
    result = getAllItemVouchers_result()
7227 
    result.success = self._handler.getAllItemVouchers(args.itemId)
7228 
    oprot.writeMessageBegin("getAllItemVouchers", TMessageType.REPLY, seqid)
7229 
    result.write(oprot)
7230 
    oprot.writeMessageEnd()
7231 
    oprot.trans.flush()
7232 
 
7233 
  def process_isValidCatalogItemId(self, seqid, iprot, oprot):
7234 
    args = isValidCatalogItemId_args()
7235 
    args.read(iprot)
7236 
    iprot.readMessageEnd()
7237 
    result = isValidCatalogItemId_result()
7238 
    result.success = self._handler.isValidCatalogItemId(args.catalog_item_id)
7239 
    oprot.writeMessageBegin("isValidCatalogItemId", TMessageType.REPLY, seqid)
7240 
    result.write(oprot)
7241 
    oprot.writeMessageEnd()
7242 
    oprot.trans.flush()
7243 
 
6039 amit.gupta 7244 
  def process_getVatPercentageForItem(self, seqid, iprot, oprot):
7245 
    args = getVatPercentageForItem_args()
7246 
    args.read(iprot)
7247 
    iprot.readMessageEnd()
7248 
    result = getVatPercentageForItem_result()
7340 amit.gupta 7249 
    try:
7250 
      result.success = self._handler.getVatPercentageForItem(args.itemId, args.stateId, args.price)
7251 
    except CatalogServiceException, cex:
7252 
      result.cex = cex
6039 amit.gupta 7253 
    oprot.writeMessageBegin("getVatPercentageForItem", TMessageType.REPLY, seqid)
7254 
    result.write(oprot)
7255 
    oprot.writeMessageEnd()
7256 
    oprot.trans.flush()
5944 mandeep.dh 7257 
 
6039 amit.gupta 7258 
  def process_getVatAmountForItem(self, seqid, iprot, oprot):
7259 
    args = getVatAmountForItem_args()
7260 
    args.read(iprot)
7261 
    iprot.readMessageEnd()
7262 
    result = getVatAmountForItem_result()
7263 
    result.success = self._handler.getVatAmountForItem(args.itemId, args.price)
7264 
    oprot.writeMessageBegin("getVatAmountForItem", TMessageType.REPLY, seqid)
7265 
    result.write(oprot)
7266 
    oprot.writeMessageEnd()
7267 
    oprot.trans.flush()
7268 
 
6531 vikram.rag 7269 
  def process_getAllIgnoredInventoryUpdateItemsList(self, seqid, iprot, oprot):
7270 
    args = getAllIgnoredInventoryUpdateItemsList_args()
7271 
    args.read(iprot)
7272 
    iprot.readMessageEnd()
7273 
    result = getAllIgnoredInventoryUpdateItemsList_result()
7274 
    result.success = self._handler.getAllIgnoredInventoryUpdateItemsList(args.offset, args.limit)
7275 
    oprot.writeMessageBegin("getAllIgnoredInventoryUpdateItemsList", TMessageType.REPLY, seqid)
7276 
    result.write(oprot)
7277 
    oprot.writeMessageEnd()
7278 
    oprot.trans.flush()
6039 amit.gupta 7279 
 
6821 amar.kumar 7280 
  def process_getAllAliveItems(self, seqid, iprot, oprot):
7281 
    args = getAllAliveItems_args()
7282 
    args.read(iprot)
7283 
    iprot.readMessageEnd()
7284 
    result = getAllAliveItems_result()
7285 
    result.success = self._handler.getAllAliveItems()
7286 
    oprot.writeMessageBegin("getAllAliveItems", TMessageType.REPLY, seqid)
7287 
    result.write(oprot)
7288 
    oprot.writeMessageEnd()
7289 
    oprot.trans.flush()
7290 
 
6805 anupam.sin 7291 
  def process_getInsuranceAmount(self, seqid, iprot, oprot):
7292 
    args = getInsuranceAmount_args()
7293 
    args.read(iprot)
7294 
    iprot.readMessageEnd()
7295 
    result = getInsuranceAmount_result()
6921 anupam.sin 7296 
    result.success = self._handler.getInsuranceAmount(args.itemId, args.price, args.insurerId, args.quantity)
6805 anupam.sin 7297 
    oprot.writeMessageBegin("getInsuranceAmount", TMessageType.REPLY, seqid)
7298 
    result.write(oprot)
7299 
    oprot.writeMessageEnd()
7300 
    oprot.trans.flush()
6531 vikram.rag 7301 
 
6805 anupam.sin 7302 
  def process_getInsurer(self, seqid, iprot, oprot):
7303 
    args = getInsurer_args()
7304 
    args.read(iprot)
7305 
    iprot.readMessageEnd()
7306 
    result = getInsurer_result()
7307 
    result.success = self._handler.getInsurer(args.insurerId)
7308 
    oprot.writeMessageBegin("getInsurer", TMessageType.REPLY, seqid)
7309 
    result.write(oprot)
7310 
    oprot.writeMessageEnd()
7311 
    oprot.trans.flush()
7312 
 
6838 vikram.rag 7313 
  def process_getAllInsurers(self, seqid, iprot, oprot):
7314 
    args = getAllInsurers_args()
7315 
    args.read(iprot)
7316 
    iprot.readMessageEnd()
7317 
    result = getAllInsurers_result()
7318 
    result.success = self._handler.getAllInsurers()
7319 
    oprot.writeMessageBegin("getAllInsurers", TMessageType.REPLY, seqid)
7320 
    result.write(oprot)
7321 
    oprot.writeMessageEnd()
7322 
    oprot.trans.flush()
6805 anupam.sin 7323 
 
6962 rajveer 7324 
  def process_updateInsuranceDeclaredAmount(self, seqid, iprot, oprot):
7325 
    args = updateInsuranceDeclaredAmount_args()
7326 
    args.read(iprot)
7327 
    iprot.readMessageEnd()
7328 
    result = updateInsuranceDeclaredAmount_result()
7329 
    self._handler.updateInsuranceDeclaredAmount(args.insurerId, args.amount)
7330 
    oprot.writeMessageBegin("updateInsuranceDeclaredAmount", TMessageType.REPLY, seqid)
7331 
    result.write(oprot)
7332 
    oprot.writeMessageEnd()
7333 
    oprot.trans.flush()
6838 vikram.rag 7334 
 
7190 amar.kumar 7335 
  def process_getFreebieForItem(self, seqid, iprot, oprot):
7336 
    args = getFreebieForItem_args()
7337 
    args.read(iprot)
7338 
    iprot.readMessageEnd()
7339 
    result = getFreebieForItem_result()
7340 
    result.success = self._handler.getFreebieForItem(args.itemId)
7341 
    oprot.writeMessageBegin("getFreebieForItem", TMessageType.REPLY, seqid)
7342 
    result.write(oprot)
7343 
    oprot.writeMessageEnd()
7344 
    oprot.trans.flush()
6962 rajveer 7345 
 
7190 amar.kumar 7346 
  def process_addOrUpdateFreebieForItem(self, seqid, iprot, oprot):
7347 
    args = addOrUpdateFreebieForItem_args()
7348 
    args.read(iprot)
7349 
    iprot.readMessageEnd()
7350 
    result = addOrUpdateFreebieForItem_result()
7351 
    self._handler.addOrUpdateFreebieForItem(args.freebieItem)
7352 
    oprot.writeMessageBegin("addOrUpdateFreebieForItem", TMessageType.REPLY, seqid)
7353 
    result.write(oprot)
7354 
    oprot.writeMessageEnd()
7355 
    oprot.trans.flush()
7356 
 
7272 amit.gupta 7357 
  def process_addOrUpdateBrandInfo(self, seqid, iprot, oprot):
7358 
    args = addOrUpdateBrandInfo_args()
7359 
    args.read(iprot)
7360 
    iprot.readMessageEnd()
7361 
    result = addOrUpdateBrandInfo_result()
7362 
    self._handler.addOrUpdateBrandInfo(args.brandInfo)
7363 
    oprot.writeMessageBegin("addOrUpdateBrandInfo", TMessageType.REPLY, seqid)
7364 
    result.write(oprot)
7365 
    oprot.writeMessageEnd()
7366 
    oprot.trans.flush()
7367 
 
7368 
  def process_getBrandInfo(self, seqid, iprot, oprot):
7369 
    args = getBrandInfo_args()
7370 
    args.read(iprot)
7371 
    iprot.readMessageEnd()
7372 
    result = getBrandInfo_result()
7373 
    result.success = self._handler.getBrandInfo()
7374 
    oprot.writeMessageBegin("getBrandInfo", TMessageType.REPLY, seqid)
7375 
    result.write(oprot)
7376 
    oprot.writeMessageEnd()
7377 
    oprot.trans.flush()
7378 
 
7256 rajveer 7379 
  def process_getStorePricing(self, seqid, iprot, oprot):
7380 
    args = getStorePricing_args()
7381 
    args.read(iprot)
7382 
    iprot.readMessageEnd()
7383 
    result = getStorePricing_result()
7384 
    result.success = self._handler.getStorePricing(args.itemId)
7385 
    oprot.writeMessageBegin("getStorePricing", TMessageType.REPLY, seqid)
7386 
    result.write(oprot)
7387 
    oprot.writeMessageEnd()
7388 
    oprot.trans.flush()
7190 amar.kumar 7389 
 
7306 rajveer 7390 
  def process_getStorePricings(self, seqid, iprot, oprot):
7391 
    args = getStorePricings_args()
7392 
    args.read(iprot)
7393 
    iprot.readMessageEnd()
7394 
    result = getStorePricings_result()
7395 
    result.success = self._handler.getStorePricings(args.itemIds)
7396 
    oprot.writeMessageBegin("getStorePricings", TMessageType.REPLY, seqid)
7397 
    result.write(oprot)
7398 
    oprot.writeMessageEnd()
7399 
    oprot.trans.flush()
7400 
 
7265 rajveer 7401 
  def process_updateStorePricing(self, seqid, iprot, oprot):
7402 
    args = updateStorePricing_args()
7403 
    args.read(iprot)
7404 
    iprot.readMessageEnd()
7405 
    result = updateStorePricing_result()
7382 rajveer 7406 
    self._handler.updateStorePricing(args.sp, args.allColors)
7265 rajveer 7407 
    oprot.writeMessageBegin("updateStorePricing", TMessageType.REPLY, seqid)
7408 
    result.write(oprot)
7409 
    oprot.writeMessageEnd()
7410 
    oprot.trans.flush()
7256 rajveer 7411 
 
7281 kshitij.so 7412 
  def process_getAllAmazonListedItems(self, seqid, iprot, oprot):
7413 
    args = getAllAmazonListedItems_args()
7414 
    args.read(iprot)
7415 
    iprot.readMessageEnd()
7416 
    result = getAllAmazonListedItems_result()
7417 
    result.success = self._handler.getAllAmazonListedItems()
7418 
    oprot.writeMessageBegin("getAllAmazonListedItems", TMessageType.REPLY, seqid)
7419 
    result.write(oprot)
7420 
    oprot.writeMessageEnd()
7421 
    oprot.trans.flush()
7265 rajveer 7422 
 
8619 kshitij.so 7423 
  def process_searchAmazonItems(self, seqid, iprot, oprot):
7424 
    args = searchAmazonItems_args()
7425 
    args.read(iprot)
7426 
    iprot.readMessageEnd()
7427 
    result = searchAmazonItems_result()
7428 
    result.success = self._handler.searchAmazonItems(args.searchTerm, args.offset, args.limit)
7429 
    oprot.writeMessageBegin("searchAmazonItems", TMessageType.REPLY, seqid)
7430 
    result.write(oprot)
7431 
    oprot.writeMessageEnd()
7432 
    oprot.trans.flush()
7433 
 
7434 
  def process_getAmazonSearchResultCount(self, seqid, iprot, oprot):
7435 
    args = getAmazonSearchResultCount_args()
7436 
    args.read(iprot)
7437 
    iprot.readMessageEnd()
7438 
    result = getAmazonSearchResultCount_result()
7439 
    result.success = self._handler.getAmazonSearchResultCount(args.searchTerm)
7440 
    oprot.writeMessageBegin("getAmazonSearchResultCount", TMessageType.REPLY, seqid)
7441 
    result.write(oprot)
7442 
    oprot.writeMessageEnd()
7443 
    oprot.trans.flush()
7444 
 
7445 
  def process_getCountForAmazonlistedItems(self, seqid, iprot, oprot):
7446 
    args = getCountForAmazonlistedItems_args()
7447 
    args.read(iprot)
7448 
    iprot.readMessageEnd()
7449 
    result = getCountForAmazonlistedItems_result()
7450 
    result.success = self._handler.getCountForAmazonlistedItems()
7451 
    oprot.writeMessageBegin("getCountForAmazonlistedItems", TMessageType.REPLY, seqid)
7452 
    result.write(oprot)
7453 
    oprot.writeMessageEnd()
7454 
    oprot.trans.flush()
7455 
 
7281 kshitij.so 7456 
  def process_getAmazonItemDetails(self, seqid, iprot, oprot):
7457 
    args = getAmazonItemDetails_args()
7458 
    args.read(iprot)
7459 
    iprot.readMessageEnd()
7460 
    result = getAmazonItemDetails_result()
7461 
    result.success = self._handler.getAmazonItemDetails(args.itemId)
7462 
    oprot.writeMessageBegin("getAmazonItemDetails", TMessageType.REPLY, seqid)
7463 
    result.write(oprot)
7464 
    oprot.writeMessageEnd()
7465 
    oprot.trans.flush()
7466 
 
7467 
  def process_updateAmazonItemDetails(self, seqid, iprot, oprot):
7468 
    args = updateAmazonItemDetails_args()
7469 
    args.read(iprot)
7470 
    iprot.readMessageEnd()
7471 
    result = updateAmazonItemDetails_result()
8168 kshitij.so 7472 
    self._handler.updateAmazonItemDetails(args.amazonlisted)
7281 kshitij.so 7473 
    oprot.writeMessageBegin("updateAmazonItemDetails", TMessageType.REPLY, seqid)
7474 
    result.write(oprot)
7475 
    oprot.writeMessageEnd()
7476 
    oprot.trans.flush()
7477 
 
7478 
  def process_addAmazonItem(self, seqid, iprot, oprot):
7479 
    args = addAmazonItem_args()
7480 
    args.read(iprot)
7481 
    iprot.readMessageEnd()
7482 
    result = addAmazonItem_result()
7483 
    self._handler.addAmazonItem(args.amazonlisted)
7484 
    oprot.writeMessageBegin("addAmazonItem", TMessageType.REPLY, seqid)
7485 
    result.write(oprot)
7486 
    oprot.writeMessageEnd()
7487 
    oprot.trans.flush()
7488 
 
7291 vikram.rag 7489 
  def process_getAsinItems(self, seqid, iprot, oprot):
7490 
    args = getAsinItems_args()
7491 
    args.read(iprot)
7492 
    iprot.readMessageEnd()
7493 
    result = getAsinItems_result()
7494 
    result.success = self._handler.getAsinItems()
7495 
    oprot.writeMessageBegin("getAsinItems", TMessageType.REPLY, seqid)
7496 
    result.write(oprot)
7497 
    oprot.writeMessageEnd()
7498 
    oprot.trans.flush()
7281 kshitij.so 7499 
 
7291 vikram.rag 7500 
  def process_getAllFbaListedItems(self, seqid, iprot, oprot):
7501 
    args = getAllFbaListedItems_args()
7502 
    args.read(iprot)
7503 
    iprot.readMessageEnd()
7504 
    result = getAllFbaListedItems_result()
7505 
    result.success = self._handler.getAllFbaListedItems()
7506 
    oprot.writeMessageBegin("getAllFbaListedItems", TMessageType.REPLY, seqid)
7507 
    result.write(oprot)
7508 
    oprot.writeMessageEnd()
7509 
    oprot.trans.flush()
7510 
 
7511 
  def process_getAllNonFbaListedItems(self, seqid, iprot, oprot):
7512 
    args = getAllNonFbaListedItems_args()
7513 
    args.read(iprot)
7514 
    iprot.readMessageEnd()
7515 
    result = getAllNonFbaListedItems_result()
7516 
    result.success = self._handler.getAllNonFbaListedItems()
7517 
    oprot.writeMessageBegin("getAllNonFbaListedItems", TMessageType.REPLY, seqid)
7518 
    result.write(oprot)
7519 
    oprot.writeMessageEnd()
7520 
    oprot.trans.flush()
7521 
 
7460 kshitij.so 7522 
  def process_updateItemInventory(self, seqid, iprot, oprot):
7523 
    args = updateItemInventory_args()
7524 
    args.read(iprot)
7525 
    iprot.readMessageEnd()
7526 
    result = updateItemInventory_result()
7527 
    result.success = self._handler.updateItemInventory(args.itemId, args.holdInventory, args.defaultInventory)
7528 
    oprot.writeMessageBegin("updateItemInventory", TMessageType.REPLY, seqid)
7529 
    result.write(oprot)
7530 
    oprot.writeMessageEnd()
7531 
    oprot.trans.flush()
7291 vikram.rag 7532 
 
7770 kshitij.so 7533 
  def process_updateTimestampForAmazonFeeds(self, seqid, iprot, oprot):
7534 
    args = updateTimestampForAmazonFeeds_args()
7535 
    args.read(iprot)
7536 
    iprot.readMessageEnd()
7537 
    result = updateTimestampForAmazonFeeds_result()
7538 
    result.success = self._handler.updateTimestampForAmazonFeeds(args.type, args.sku, args.timestamp)
7539 
    oprot.writeMessageBegin("updateTimestampForAmazonFeeds", TMessageType.REPLY, seqid)
7540 
    result.write(oprot)
7541 
    oprot.writeMessageEnd()
7542 
    oprot.trans.flush()
7460 kshitij.so 7543 
 
7897 amar.kumar 7544 
  def process_getAllParentCategories(self, seqid, iprot, oprot):
7545 
    args = getAllParentCategories_args()
7546 
    args.read(iprot)
7547 
    iprot.readMessageEnd()
7548 
    result = getAllParentCategories_result()
7549 
    result.success = self._handler.getAllParentCategories()
7550 
    oprot.writeMessageBegin("getAllParentCategories", TMessageType.REPLY, seqid)
7551 
    result.write(oprot)
7552 
    oprot.writeMessageEnd()
7553 
    oprot.trans.flush()
7770 kshitij.so 7554 
 
7977 kshitij.so 7555 
  def process_addPageViewEvent(self, seqid, iprot, oprot):
7556 
    args = addPageViewEvent_args()
7557 
    args.read(iprot)
7558 
    iprot.readMessageEnd()
7559 
    result = addPageViewEvent_result()
7560 
    self._handler.addPageViewEvent(args.pageViewEvents)
7561 
    oprot.writeMessageBegin("addPageViewEvent", TMessageType.REPLY, seqid)
7562 
    result.write(oprot)
7563 
    oprot.writeMessageEnd()
7564 
    oprot.trans.flush()
7897 amar.kumar 7565 
 
7977 kshitij.so 7566 
  def process_addCartEvent(self, seqid, iprot, oprot):
7567 
    args = addCartEvent_args()
7568 
    args.read(iprot)
7569 
    iprot.readMessageEnd()
7570 
    result = addCartEvent_result()
7571 
    self._handler.addCartEvent(args.cartEvents)
7572 
    oprot.writeMessageBegin("addCartEvent", TMessageType.REPLY, seqid)
7573 
    result.write(oprot)
7574 
    oprot.writeMessageEnd()
7575 
    oprot.trans.flush()
7576 
 
8182 amar.kumar 7577 
  def process_addEbayItem(self, seqid, iprot, oprot):
7578 
    args = addEbayItem_args()
7579 
    args.read(iprot)
7580 
    iprot.readMessageEnd()
7581 
    result = addEbayItem_result()
7582 
    self._handler.addEbayItem(args.ebayItem)
7583 
    oprot.writeMessageBegin("addEbayItem", TMessageType.REPLY, seqid)
7584 
    result.write(oprot)
7585 
    oprot.writeMessageEnd()
7586 
    oprot.trans.flush()
7587 
 
7588 
  def process_getEbayItem(self, seqid, iprot, oprot):
7589 
    args = getEbayItem_args()
7590 
    args.read(iprot)
7591 
    iprot.readMessageEnd()
7592 
    result = getEbayItem_result()
7593 
    result.success = self._handler.getEbayItem(args.listingId)
7594 
    oprot.writeMessageBegin("getEbayItem", TMessageType.REPLY, seqid)
7595 
    result.write(oprot)
7596 
    oprot.writeMessageEnd()
7597 
    oprot.trans.flush()
7598 
 
7599 
  def process_updateEbayItem(self, seqid, iprot, oprot):
7600 
    args = updateEbayItem_args()
7601 
    args.read(iprot)
7602 
    iprot.readMessageEnd()
7603 
    result = updateEbayItem_result()
7604 
    self._handler.updateEbayItem(args.ebayItem)
7605 
    oprot.writeMessageBegin("updateEbayItem", TMessageType.REPLY, seqid)
7606 
    result.write(oprot)
7607 
    oprot.writeMessageEnd()
7608 
    oprot.trans.flush()
7609 
 
8139 kshitij.so 7610 
  def process_getAmazonListedItems(self, seqid, iprot, oprot):
7611 
    args = getAmazonListedItems_args()
7612 
    args.read(iprot)
7613 
    iprot.readMessageEnd()
7614 
    result = getAmazonListedItems_result()
7615 
    result.success = self._handler.getAmazonListedItems(args.offset, args.limit)
7616 
    oprot.writeMessageBegin("getAmazonListedItems", TMessageType.REPLY, seqid)
7617 
    result.write(oprot)
7618 
    oprot.writeMessageEnd()
7619 
    oprot.trans.flush()
7977 kshitij.so 7620 
 
8168 kshitij.so 7621 
  def process_updateAmazonAttributesInBulk(self, seqid, iprot, oprot):
7622 
    args = updateAmazonAttributesInBulk_args()
7623 
    args.read(iprot)
7624 
    iprot.readMessageEnd()
7625 
    result = updateAmazonAttributesInBulk_result()
7626 
    result.success = self._handler.updateAmazonAttributesInBulk(args.amazonlisted)
7627 
    oprot.writeMessageBegin("updateAmazonAttributesInBulk", TMessageType.REPLY, seqid)
7628 
    result.write(oprot)
7629 
    oprot.writeMessageEnd()
7630 
    oprot.trans.flush()
8139 kshitij.so 7631 
 
8379 vikram.rag 7632 
  def process_getAllItemstoListOnFba(self, seqid, iprot, oprot):
7633 
    args = getAllItemstoListOnFba_args()
7634 
    args.read(iprot)
7635 
    iprot.readMessageEnd()
7636 
    result = getAllItemstoListOnFba_result()
7637 
    result.success = self._handler.getAllItemstoListOnFba()
7638 
    oprot.writeMessageBegin("getAllItemstoListOnFba", TMessageType.REPLY, seqid)
7639 
    result.write(oprot)
7640 
    oprot.writeMessageEnd()
7641 
    oprot.trans.flush()
8168 kshitij.so 7642 
 
8379 vikram.rag 7643 
  def process_getAllItemstoListOnNonFba(self, seqid, iprot, oprot):
7644 
    args = getAllItemstoListOnNonFba_args()
7645 
    args.read(iprot)
7646 
    iprot.readMessageEnd()
7647 
    result = getAllItemstoListOnNonFba_result()
7648 
    result.success = self._handler.getAllItemstoListOnNonFba()
7649 
    oprot.writeMessageBegin("getAllItemstoListOnNonFba", TMessageType.REPLY, seqid)
7650 
    result.write(oprot)
7651 
    oprot.writeMessageEnd()
7652 
    oprot.trans.flush()
7653 
 
8619 kshitij.so 7654 
  def process_updateAsin(self, seqid, iprot, oprot):
7655 
    args = updateAsin_args()
7656 
    args.read(iprot)
7657 
    iprot.readMessageEnd()
7658 
    result = updateAsin_result()
7659 
    self._handler.updateAsin(args.item)
7660 
    oprot.writeMessageBegin("updateAsin", TMessageType.REPLY, seqid)
7661 
    result.write(oprot)
7662 
    oprot.writeMessageEnd()
7663 
    oprot.trans.flush()
8616 vikram.rag 7664 
 
8739 vikram.rag 7665 
  def process_addOrUpdateSnapdealItem(self, seqid, iprot, oprot):
7666 
    args = addOrUpdateSnapdealItem_args()
7667 
    args.read(iprot)
7668 
    iprot.readMessageEnd()
7669 
    result = addOrUpdateSnapdealItem_result()
7670 
    result.success = self._handler.addOrUpdateSnapdealItem(args.snapdealitem)
7671 
    oprot.writeMessageBegin("addOrUpdateSnapdealItem", TMessageType.REPLY, seqid)
7672 
    result.write(oprot)
7673 
    oprot.writeMessageEnd()
7674 
    oprot.trans.flush()
8619 kshitij.so 7675 
 
8739 vikram.rag 7676 
  def process_getSnapdealItem(self, seqid, iprot, oprot):
7677 
    args = getSnapdealItem_args()
7678 
    args.read(iprot)
7679 
    iprot.readMessageEnd()
7680 
    result = getSnapdealItem_result()
7681 
    result.success = self._handler.getSnapdealItem(args.item_id)
7682 
    oprot.writeMessageBegin("getSnapdealItem", TMessageType.REPLY, seqid)
7683 
    result.write(oprot)
7684 
    oprot.writeMessageEnd()
7685 
    oprot.trans.flush()
7686 
 
9242 kshitij.so 7687 
  def process_getSnapdealItemDetails(self, seqid, iprot, oprot):
7688 
    args = getSnapdealItemDetails_args()
7689 
    args.read(iprot)
7690 
    iprot.readMessageEnd()
7691 
    result = getSnapdealItemDetails_result()
7692 
    result.success = self._handler.getSnapdealItemDetails(args.item_id)
7693 
    oprot.writeMessageBegin("getSnapdealItemDetails", TMessageType.REPLY, seqid)
7694 
    result.write(oprot)
7695 
    oprot.writeMessageEnd()
7696 
    oprot.trans.flush()
7697 
 
8739 vikram.rag 7698 
  def process_getAllSnapdealItems(self, seqid, iprot, oprot):
7699 
    args = getAllSnapdealItems_args()
7700 
    args.read(iprot)
7701 
    iprot.readMessageEnd()
7702 
    result = getAllSnapdealItems_result()
7703 
    result.success = self._handler.getAllSnapdealItems()
7704 
    oprot.writeMessageBegin("getAllSnapdealItems", TMessageType.REPLY, seqid)
7705 
    result.write(oprot)
7706 
    oprot.writeMessageEnd()
7707 
    oprot.trans.flush()
7708 
 
9242 kshitij.so 7709 
  def process_getSnapdealItems(self, seqid, iprot, oprot):
7710 
    args = getSnapdealItems_args()
7711 
    args.read(iprot)
7712 
    iprot.readMessageEnd()
7713 
    result = getSnapdealItems_result()
7714 
    result.success = self._handler.getSnapdealItems(args.offset, args.limit)
7715 
    oprot.writeMessageBegin("getSnapdealItems", TMessageType.REPLY, seqid)
7716 
    result.write(oprot)
7717 
    oprot.writeMessageEnd()
7718 
    oprot.trans.flush()
8739 vikram.rag 7719 
 
9242 kshitij.so 7720 
  def process_searchSnapdealItems(self, seqid, iprot, oprot):
7721 
    args = searchSnapdealItems_args()
7722 
    args.read(iprot)
7723 
    iprot.readMessageEnd()
7724 
    result = searchSnapdealItems_result()
7725 
    result.success = self._handler.searchSnapdealItems(args.searchTerm, args.offset, args.limit)
7726 
    oprot.writeMessageBegin("searchSnapdealItems", TMessageType.REPLY, seqid)
7727 
    result.write(oprot)
7728 
    oprot.writeMessageEnd()
7729 
    oprot.trans.flush()
7730 
 
7731 
  def process_getCountForSnapdealItems(self, seqid, iprot, oprot):
7732 
    args = getCountForSnapdealItems_args()
7733 
    args.read(iprot)
7734 
    iprot.readMessageEnd()
7735 
    result = getCountForSnapdealItems_result()
7736 
    result.success = self._handler.getCountForSnapdealItems()
7737 
    oprot.writeMessageBegin("getCountForSnapdealItems", TMessageType.REPLY, seqid)
7738 
    result.write(oprot)
7739 
    oprot.writeMessageEnd()
7740 
    oprot.trans.flush()
7741 
 
7742 
  def process_getSnapdealSearchResultCount(self, seqid, iprot, oprot):
7743 
    args = getSnapdealSearchResultCount_args()
7744 
    args.read(iprot)
7745 
    iprot.readMessageEnd()
7746 
    result = getSnapdealSearchResultCount_result()
7747 
    result.success = self._handler.getSnapdealSearchResultCount(args.searchTerm)
7748 
    oprot.writeMessageBegin("getSnapdealSearchResultCount", TMessageType.REPLY, seqid)
7749 
    result.write(oprot)
7750 
    oprot.writeMessageEnd()
7751 
    oprot.trans.flush()
7752 
 
9299 kshitij.so 7753 
  def process_getPrefferedInsurerForItem(self, seqid, iprot, oprot):
7754 
    args = getPrefferedInsurerForItem_args()
7755 
    args.read(iprot)
7756 
    iprot.readMessageEnd()
7757 
    result = getPrefferedInsurerForItem_result()
7758 
    result.success = self._handler.getPrefferedInsurerForItem(args.itemId, args.insurerType)
7759 
    oprot.writeMessageBegin("getPrefferedInsurerForItem", TMessageType.REPLY, seqid)
7760 
    result.write(oprot)
7761 
    oprot.writeMessageEnd()
7762 
    oprot.trans.flush()
9242 kshitij.so 7763 
 
9456 vikram.rag 7764 
  def process_getSnapdealItembySkuAtSnapdeal(self, seqid, iprot, oprot):
7765 
    args = getSnapdealItembySkuAtSnapdeal_args()
7766 
    args.read(iprot)
7767 
    iprot.readMessageEnd()
7768 
    result = getSnapdealItembySkuAtSnapdeal_result()
7769 
    result.success = self._handler.getSnapdealItembySkuAtSnapdeal(args.skuAtSnapdeal)
7770 
    oprot.writeMessageBegin("getSnapdealItembySkuAtSnapdeal", TMessageType.REPLY, seqid)
7771 
    result.write(oprot)
7772 
    oprot.writeMessageEnd()
7773 
    oprot.trans.flush()
9299 kshitij.so 7774 
 
9621 manish.sha 7775 
  def process_getProductFeedSubmit(self, seqid, iprot, oprot):
7776 
    args = getProductFeedSubmit_args()
7777 
    args.read(iprot)
7778 
    iprot.readMessageEnd()
7779 
    result = getProductFeedSubmit_result()
7780 
    try:
7781 
      result.success = self._handler.getProductFeedSubmit(args.catalogItemId)
7782 
    except CatalogServiceException, cex:
7783 
      result.cex = cex
7784 
    oprot.writeMessageBegin("getProductFeedSubmit", TMessageType.REPLY, seqid)
7785 
    result.write(oprot)
7786 
    oprot.writeMessageEnd()
7787 
    oprot.trans.flush()
9456 vikram.rag 7788 
 
9621 manish.sha 7789 
  def process_addProductFeedSubmit(self, seqid, iprot, oprot):
7790 
    args = addProductFeedSubmit_args()
7791 
    args.read(iprot)
7792 
    iprot.readMessageEnd()
7793 
    result = addProductFeedSubmit_result()
7794 
    try:
7795 
      result.success = self._handler.addProductFeedSubmit(args.productFeedSubmit)
7796 
    except CatalogServiceException, cex:
7797 
      result.cex = cex
7798 
    oprot.writeMessageBegin("addProductFeedSubmit", TMessageType.REPLY, seqid)
7799 
    result.write(oprot)
7800 
    oprot.writeMessageEnd()
7801 
    oprot.trans.flush()
7802 
 
7803 
  def process_updateProductFeedSubmit(self, seqid, iprot, oprot):
7804 
    args = updateProductFeedSubmit_args()
7805 
    args.read(iprot)
7806 
    iprot.readMessageEnd()
7807 
    result = updateProductFeedSubmit_result()
7808 
    try:
7809 
      result.success = self._handler.updateProductFeedSubmit(args.productFeedSubmit)
7810 
    except CatalogServiceException, cex:
7811 
      result.cex = cex
7812 
    oprot.writeMessageBegin("updateProductFeedSubmit", TMessageType.REPLY, seqid)
7813 
    result.write(oprot)
7814 
    oprot.writeMessageEnd()
7815 
    oprot.trans.flush()
7816 
 
7817 
  def process_deleteProductFeedSubmit(self, seqid, iprot, oprot):
7818 
    args = deleteProductFeedSubmit_args()
7819 
    args.read(iprot)
7820 
    iprot.readMessageEnd()
7821 
    result = deleteProductFeedSubmit_result()
7822 
    try:
7823 
      result.success = self._handler.deleteProductFeedSubmit(args.catalogItemId)
7824 
    except CatalogServiceException, cex:
7825 
      result.cex = cex
7826 
    oprot.writeMessageBegin("deleteProductFeedSubmit", TMessageType.REPLY, seqid)
7827 
    result.write(oprot)
7828 
    oprot.writeMessageEnd()
7829 
    oprot.trans.flush()
7830 
 
7831 
  def process_getAllProductFeedSubmit(self, seqid, iprot, oprot):
7832 
    args = getAllProductFeedSubmit_args()
7833 
    args.read(iprot)
7834 
    iprot.readMessageEnd()
7835 
    result = getAllProductFeedSubmit_result()
7836 
    try:
7837 
      result.success = self._handler.getAllProductFeedSubmit()
7838 
    except CatalogServiceException, cex:
7839 
      result.cex = cex
7840 
    oprot.writeMessageBegin("getAllProductFeedSubmit", TMessageType.REPLY, seqid)
7841 
    result.write(oprot)
7842 
    oprot.writeMessageEnd()
7843 
    oprot.trans.flush()
7844 
 
9724 kshitij.so 7845 
  def process_getMarketplacedetailsForItem(self, seqid, iprot, oprot):
7846 
    args = getMarketplacedetailsForItem_args()
7847 
    args.read(iprot)
7848 
    iprot.readMessageEnd()
7849 
    result = getMarketplacedetailsForItem_result()
7850 
    result.success = self._handler.getMarketplacedetailsForItem(args.itemId, args.sourceId)
7851 
    oprot.writeMessageBegin("getMarketplacedetailsForItem", TMessageType.REPLY, seqid)
7852 
    result.write(oprot)
7853 
    oprot.writeMessageEnd()
7854 
    oprot.trans.flush()
9621 manish.sha 7855 
 
9724 kshitij.so 7856 
  def process_updateMarketplaceAttributesForItem(self, seqid, iprot, oprot):
7857 
    args = updateMarketplaceAttributesForItem_args()
7858 
    args.read(iprot)
7859 
    iprot.readMessageEnd()
7860 
    result = updateMarketplaceAttributesForItem_result()
7861 
    result.success = self._handler.updateMarketplaceAttributesForItem(args.marketPlaceItem)
7862 
    oprot.writeMessageBegin("updateMarketplaceAttributesForItem", TMessageType.REPLY, seqid)
7863 
    result.write(oprot)
7864 
    oprot.writeMessageEnd()
7865 
    oprot.trans.flush()
7866 
 
9779 kshitij.so 7867 
  def process_getCostingForMarketplace(self, seqid, iprot, oprot):
7868 
    args = getCostingForMarketplace_args()
7869 
    args.read(iprot)
7870 
    iprot.readMessageEnd()
7871 
    result = getCostingForMarketplace_result()
7872 
    result.success = self._handler.getCostingForMarketplace(args.source, args.item_id)
7873 
    oprot.writeMessageBegin("getCostingForMarketplace", TMessageType.REPLY, seqid)
7874 
    result.write(oprot)
7875 
    oprot.writeMessageEnd()
7876 
    oprot.trans.flush()
7877 
 
9776 vikram.rag 7878 
  def process_getMarketPlaceItemsForPriceUpdate(self, seqid, iprot, oprot):
7879 
    args = getMarketPlaceItemsForPriceUpdate_args()
7880 
    args.read(iprot)
7881 
    iprot.readMessageEnd()
7882 
    result = getMarketPlaceItemsForPriceUpdate_result()
7883 
    result.success = self._handler.getMarketPlaceItemsForPriceUpdate(args.source)
7884 
    oprot.writeMessageBegin("getMarketPlaceItemsForPriceUpdate", TMessageType.REPLY, seqid)
7885 
    result.write(oprot)
7886 
    oprot.writeMessageEnd()
7887 
    oprot.trans.flush()
9724 kshitij.so 7888 
 
9776 vikram.rag 7889 
  def process_updateMarketPlacePriceUpdateStatus(self, seqid, iprot, oprot):
7890 
    args = updateMarketPlacePriceUpdateStatus_args()
7891 
    args.read(iprot)
7892 
    iprot.readMessageEnd()
7893 
    result = updateMarketPlacePriceUpdateStatus_result()
9816 kshitij.so 7894 
    self._handler.updateMarketPlacePriceUpdateStatus(args.skulist, args.timestamp, args.source)
9776 vikram.rag 7895 
    oprot.writeMessageBegin("updateMarketPlacePriceUpdateStatus", TMessageType.REPLY, seqid)
7896 
    result.write(oprot)
7897 
    oprot.writeMessageEnd()
7898 
    oprot.trans.flush()
7899 
 
9861 rajveer 7900 
  def process_updateItemHoldInventory(self, seqid, iprot, oprot):
7901 
    args = updateItemHoldInventory_args()
7902 
    args.read(iprot)
7903 
    iprot.readMessageEnd()
7904 
    result = updateItemHoldInventory_result()
7905 
    self._handler.updateItemHoldInventory(args.itemHoldMap)
7906 
    oprot.writeMessageBegin("updateItemHoldInventory", TMessageType.REPLY, seqid)
7907 
    result.write(oprot)
7908 
    oprot.writeMessageEnd()
7909 
    oprot.trans.flush()
9776 vikram.rag 7910 
 
9895 vikram.rag 7911 
  def process_updateNlcAtMarketplaces(self, seqid, iprot, oprot):
7912 
    args = updateNlcAtMarketplaces_args()
7913 
    args.read(iprot)
7914 
    iprot.readMessageEnd()
7915 
    result = updateNlcAtMarketplaces_result()
7916 
    self._handler.updateNlcAtMarketplaces(args.item_id, args.vendor_id, args.nlc)
7917 
    oprot.writeMessageBegin("updateNlcAtMarketplaces", TMessageType.REPLY, seqid)
7918 
    result.write(oprot)
7919 
    oprot.writeMessageEnd()
7920 
    oprot.trans.flush()
9861 rajveer 7921 
 
9945 vikram.rag 7922 
  def process_getAllFlipkartItems(self, seqid, iprot, oprot):
7923 
    args = getAllFlipkartItems_args()
7924 
    args.read(iprot)
7925 
    iprot.readMessageEnd()
7926 
    result = getAllFlipkartItems_result()
7927 
    result.success = self._handler.getAllFlipkartItems()
7928 
    oprot.writeMessageBegin("getAllFlipkartItems", TMessageType.REPLY, seqid)
7929 
    result.write(oprot)
7930 
    oprot.writeMessageEnd()
7931 
    oprot.trans.flush()
9895 vikram.rag 7932 
 
10097 kshitij.so 7933 
  def process_addOrUpdateFlipkartItem(self, seqid, iprot, oprot):
7934 
    args = addOrUpdateFlipkartItem_args()
7935 
    args.read(iprot)
7936 
    iprot.readMessageEnd()
7937 
    result = addOrUpdateFlipkartItem_result()
7938 
    result.success = self._handler.addOrUpdateFlipkartItem(args.flipkartitem)
7939 
    oprot.writeMessageBegin("addOrUpdateFlipkartItem", TMessageType.REPLY, seqid)
7940 
    result.write(oprot)
7941 
    oprot.writeMessageEnd()
7942 
    oprot.trans.flush()
9945 vikram.rag 7943 
 
10097 kshitij.so 7944 
  def process_getFlipkartItem(self, seqid, iprot, oprot):
7945 
    args = getFlipkartItem_args()
7946 
    args.read(iprot)
7947 
    iprot.readMessageEnd()
7948 
    result = getFlipkartItem_result()
7949 
    result.success = self._handler.getFlipkartItem(args.item_id)
7950 
    oprot.writeMessageBegin("getFlipkartItem", TMessageType.REPLY, seqid)
7951 
    result.write(oprot)
7952 
    oprot.writeMessageEnd()
7953 
    oprot.trans.flush()
7954 
 
7955 
  def process_getFlipkartItemDetails(self, seqid, iprot, oprot):
7956 
    args = getFlipkartItemDetails_args()
7957 
    args.read(iprot)
7958 
    iprot.readMessageEnd()
7959 
    result = getFlipkartItemDetails_result()
7960 
    result.success = self._handler.getFlipkartItemDetails(args.item_id)
7961 
    oprot.writeMessageBegin("getFlipkartItemDetails", TMessageType.REPLY, seqid)
7962 
    result.write(oprot)
7963 
    oprot.writeMessageEnd()
7964 
    oprot.trans.flush()
7965 
 
7966 
  def process_getFlipkartItems(self, seqid, iprot, oprot):
7967 
    args = getFlipkartItems_args()
7968 
    args.read(iprot)
7969 
    iprot.readMessageEnd()
7970 
    result = getFlipkartItems_result()
7971 
    result.success = self._handler.getFlipkartItems(args.offset, args.limit)
7972 
    oprot.writeMessageBegin("getFlipkartItems", TMessageType.REPLY, seqid)
7973 
    result.write(oprot)
7974 
    oprot.writeMessageEnd()
7975 
    oprot.trans.flush()
7976 
 
7977 
  def process_searchFlipkartItems(self, seqid, iprot, oprot):
7978 
    args = searchFlipkartItems_args()
7979 
    args.read(iprot)
7980 
    iprot.readMessageEnd()
7981 
    result = searchFlipkartItems_result()
7982 
    result.success = self._handler.searchFlipkartItems(args.searchTerm, args.offset, args.limit)
7983 
    oprot.writeMessageBegin("searchFlipkartItems", TMessageType.REPLY, seqid)
7984 
    result.write(oprot)
7985 
    oprot.writeMessageEnd()
7986 
    oprot.trans.flush()
7987 
 
7988 
  def process_getCountForFlipkartItems(self, seqid, iprot, oprot):
7989 
    args = getCountForFlipkartItems_args()
7990 
    args.read(iprot)
7991 
    iprot.readMessageEnd()
7992 
    result = getCountForFlipkartItems_result()
7993 
    result.success = self._handler.getCountForFlipkartItems()
7994 
    oprot.writeMessageBegin("getCountForFlipkartItems", TMessageType.REPLY, seqid)
7995 
    result.write(oprot)
7996 
    oprot.writeMessageEnd()
7997 
    oprot.trans.flush()
7998 
 
7999 
  def process_getFlipkartSearchResultCount(self, seqid, iprot, oprot):
8000 
    args = getFlipkartSearchResultCount_args()
8001 
    args.read(iprot)
8002 
    iprot.readMessageEnd()
8003 
    result = getFlipkartSearchResultCount_result()
8004 
    result.success = self._handler.getFlipkartSearchResultCount(args.searchTerm)
8005 
    oprot.writeMessageBegin("getFlipkartSearchResultCount", TMessageType.REPLY, seqid)
8006 
    result.write(oprot)
8007 
    oprot.writeMessageEnd()
8008 
    oprot.trans.flush()
8009 
 
8010 
  def process_getAllFkItems(self, seqid, iprot, oprot):
8011 
    args = getAllFkItems_args()
8012 
    args.read(iprot)
8013 
    iprot.readMessageEnd()
8014 
    result = getAllFkItems_result()
8015 
    result.success = self._handler.getAllFkItems()
8016 
    oprot.writeMessageBegin("getAllFkItems", TMessageType.REPLY, seqid)
8017 
    result.write(oprot)
8018 
    oprot.writeMessageEnd()
8019 
    oprot.trans.flush()
8020 
 
10140 vikram.rag 8021 
  def process_getFlipkartItemBySkyAtFlipkart(self, seqid, iprot, oprot):
8022 
    args = getFlipkartItemBySkyAtFlipkart_args()
8023 
    args.read(iprot)
8024 
    iprot.readMessageEnd()
8025 
    result = getFlipkartItemBySkyAtFlipkart_result()
8026 
    result.success = self._handler.getFlipkartItemBySkyAtFlipkart(args.sku)
8027 
    oprot.writeMessageBegin("getFlipkartItemBySkyAtFlipkart", TMessageType.REPLY, seqid)
8028 
    result.write(oprot)
8029 
    oprot.writeMessageEnd()
8030 
    oprot.trans.flush()
10097 kshitij.so 8031 
 
11015 kshitij.so 8032 
  def process_getMarketplaceHistory(self, seqid, iprot, oprot):
8033 
    args = getMarketplaceHistory_args()
8034 
    args.read(iprot)
8035 
    iprot.readMessageEnd()
8036 
    result = getMarketplaceHistory_result()
8037 
    result.success = self._handler.getMarketplaceHistory(args.source, args.offset, args.itemId)
8038 
    oprot.writeMessageBegin("getMarketplaceHistory", TMessageType.REPLY, seqid)
8039 
    result.write(oprot)
8040 
    oprot.writeMessageEnd()
8041 
    oprot.trans.flush()
8042 
 
10909 vikram.rag 8043 
  def process_getAllFbbListedItems(self, seqid, iprot, oprot):
8044 
    args = getAllFbbListedItems_args()
8045 
    args.read(iprot)
8046 
    iprot.readMessageEnd()
8047 
    result = getAllFbbListedItems_result()
8048 
    result.success = self._handler.getAllFbbListedItems()
8049 
    oprot.writeMessageBegin("getAllFbbListedItems", TMessageType.REPLY, seqid)
8050 
    result.write(oprot)
8051 
    oprot.writeMessageEnd()
8052 
    oprot.trans.flush()
10140 vikram.rag 8053 
 
10924 vikram.rag 8054 
  def process_getAllFbbPricingItems(self, seqid, iprot, oprot):
8055 
    args = getAllFbbPricingItems_args()
8056 
    args.read(iprot)
8057 
    iprot.readMessageEnd()
8058 
    result = getAllFbbPricingItems_result()
8059 
    result.success = self._handler.getAllFbbPricingItems()
8060 
    oprot.writeMessageBegin("getAllFbbPricingItems", TMessageType.REPLY, seqid)
8061 
    result.write(oprot)
8062 
    oprot.writeMessageEnd()
8063 
    oprot.trans.flush()
10909 vikram.rag 8064 
 
11015 kshitij.so 8065 
  def process_getCountForMarketplaceHistory(self, seqid, iprot, oprot):
8066 
    args = getCountForMarketplaceHistory_args()
8067 
    args.read(iprot)
8068 
    iprot.readMessageEnd()
8069 
    result = getCountForMarketplaceHistory_result()
8070 
    result.success = self._handler.getCountForMarketplaceHistory(args.source, args.itemId)
8071 
    oprot.writeMessageBegin("getCountForMarketplaceHistory", TMessageType.REPLY, seqid)
8072 
    result.write(oprot)
8073 
    oprot.writeMessageEnd()
8074 
    oprot.trans.flush()
10924 vikram.rag 8075 
 
11015 kshitij.so 8076 
  def process_getMarketplaceHistoryByDate(self, seqid, iprot, oprot):
8077 
    args = getMarketplaceHistoryByDate_args()
8078 
    args.read(iprot)
8079 
    iprot.readMessageEnd()
8080 
    result = getMarketplaceHistoryByDate_result()
8081 
    result.success = self._handler.getMarketplaceHistoryByDate(args.source, args.startDate, args.endDate, args.offset, args.limit, args.itemId)
8082 
    oprot.writeMessageBegin("getMarketplaceHistoryByDate", TMessageType.REPLY, seqid)
8083 
    result.write(oprot)
8084 
    oprot.writeMessageEnd()
8085 
    oprot.trans.flush()
8086 
 
8087 
 
5944 mandeep.dh 8088 
# HELPER FUNCTIONS AND STRUCTURES
8089 
 
8090 
class addItem_args:
8091 
  """
8092 
  Attributes:
8093 
   - item
8094 
  """
8095 
 
8096 
  thrift_spec = (
8097 
    None, # 0
8098 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
8099 
  )
8100 
 
8101 
  def __init__(self, item=None,):
8102 
    self.item = item
8103 
 
8104 
  def read(self, iprot):
8105 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8106 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8107 
      return
8108 
    iprot.readStructBegin()
8109 
    while True:
8110 
      (fname, ftype, fid) = iprot.readFieldBegin()
8111 
      if ftype == TType.STOP:
8112 
        break
8113 
      if fid == 1:
8114 
        if ftype == TType.STRUCT:
8115 
          self.item = Item()
8116 
          self.item.read(iprot)
8117 
        else:
8118 
          iprot.skip(ftype)
8119 
      else:
8120 
        iprot.skip(ftype)
8121 
      iprot.readFieldEnd()
8122 
    iprot.readStructEnd()
8123 
 
8124 
  def write(self, oprot):
8125 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8126 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8127 
      return
8128 
    oprot.writeStructBegin('addItem_args')
8129 
    if self.item is not None:
8130 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
8131 
      self.item.write(oprot)
8132 
      oprot.writeFieldEnd()
8133 
    oprot.writeFieldStop()
8134 
    oprot.writeStructEnd()
8135 
 
8136 
  def validate(self):
8137 
    return
8138 
 
8139 
 
8140 
  def __repr__(self):
8141 
    L = ['%s=%r' % (key, value)
8142 
      for key, value in self.__dict__.iteritems()]
8143 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8144 
 
8145 
  def __eq__(self, other):
8146 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8147 
 
8148 
  def __ne__(self, other):
8149 
    return not (self == other)
8150 
 
8151 
class addItem_result:
8152 
  """
8153 
  Attributes:
8154 
   - success
8155 
   - cex
8156 
  """
8157 
 
8158 
  thrift_spec = (
8159 
    (0, TType.I64, 'success', None, None, ), # 0
8160 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8161 
  )
8162 
 
8163 
  def __init__(self, success=None, cex=None,):
8164 
    self.success = success
8165 
    self.cex = cex
8166 
 
8167 
  def read(self, iprot):
8168 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8169 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8170 
      return
8171 
    iprot.readStructBegin()
8172 
    while True:
8173 
      (fname, ftype, fid) = iprot.readFieldBegin()
8174 
      if ftype == TType.STOP:
8175 
        break
8176 
      if fid == 0:
8177 
        if ftype == TType.I64:
8178 
          self.success = iprot.readI64();
8179 
        else:
8180 
          iprot.skip(ftype)
8181 
      elif fid == 1:
8182 
        if ftype == TType.STRUCT:
8183 
          self.cex = CatalogServiceException()
8184 
          self.cex.read(iprot)
8185 
        else:
8186 
          iprot.skip(ftype)
8187 
      else:
8188 
        iprot.skip(ftype)
8189 
      iprot.readFieldEnd()
8190 
    iprot.readStructEnd()
8191 
 
8192 
  def write(self, oprot):
8193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8195 
      return
8196 
    oprot.writeStructBegin('addItem_result')
8197 
    if self.success is not None:
8198 
      oprot.writeFieldBegin('success', TType.I64, 0)
8199 
      oprot.writeI64(self.success)
8200 
      oprot.writeFieldEnd()
8201 
    if self.cex is not None:
8202 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8203 
      self.cex.write(oprot)
8204 
      oprot.writeFieldEnd()
8205 
    oprot.writeFieldStop()
8206 
    oprot.writeStructEnd()
8207 
 
8208 
  def validate(self):
8209 
    return
8210 
 
8211 
 
8212 
  def __repr__(self):
8213 
    L = ['%s=%r' % (key, value)
8214 
      for key, value in self.__dict__.iteritems()]
8215 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8216 
 
8217 
  def __eq__(self, other):
8218 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8219 
 
8220 
  def __ne__(self, other):
8221 
    return not (self == other)
8222 
 
8223 
class updateItem_args:
8224 
  """
8225 
  Attributes:
8226 
   - item
8227 
  """
8228 
 
8229 
  thrift_spec = (
8230 
    None, # 0
8231 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
8232 
  )
8233 
 
8234 
  def __init__(self, item=None,):
8235 
    self.item = item
8236 
 
8237 
  def read(self, iprot):
8238 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8239 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8240 
      return
8241 
    iprot.readStructBegin()
8242 
    while True:
8243 
      (fname, ftype, fid) = iprot.readFieldBegin()
8244 
      if ftype == TType.STOP:
8245 
        break
8246 
      if fid == 1:
8247 
        if ftype == TType.STRUCT:
8248 
          self.item = Item()
8249 
          self.item.read(iprot)
8250 
        else:
8251 
          iprot.skip(ftype)
8252 
      else:
8253 
        iprot.skip(ftype)
8254 
      iprot.readFieldEnd()
8255 
    iprot.readStructEnd()
8256 
 
8257 
  def write(self, oprot):
8258 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8259 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8260 
      return
8261 
    oprot.writeStructBegin('updateItem_args')
8262 
    if self.item is not None:
8263 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
8264 
      self.item.write(oprot)
8265 
      oprot.writeFieldEnd()
8266 
    oprot.writeFieldStop()
8267 
    oprot.writeStructEnd()
8268 
 
8269 
  def validate(self):
8270 
    return
8271 
 
8272 
 
8273 
  def __repr__(self):
8274 
    L = ['%s=%r' % (key, value)
8275 
      for key, value in self.__dict__.iteritems()]
8276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8277 
 
8278 
  def __eq__(self, other):
8279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8280 
 
8281 
  def __ne__(self, other):
8282 
    return not (self == other)
8283 
 
8284 
class updateItem_result:
8285 
  """
8286 
  Attributes:
8287 
   - success
8288 
   - cex
8289 
  """
8290 
 
8291 
  thrift_spec = (
8292 
    (0, TType.I64, 'success', None, None, ), # 0
8293 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8294 
  )
8295 
 
8296 
  def __init__(self, success=None, cex=None,):
8297 
    self.success = success
8298 
    self.cex = cex
8299 
 
8300 
  def read(self, iprot):
8301 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8302 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8303 
      return
8304 
    iprot.readStructBegin()
8305 
    while True:
8306 
      (fname, ftype, fid) = iprot.readFieldBegin()
8307 
      if ftype == TType.STOP:
8308 
        break
8309 
      if fid == 0:
8310 
        if ftype == TType.I64:
8311 
          self.success = iprot.readI64();
8312 
        else:
8313 
          iprot.skip(ftype)
8314 
      elif fid == 1:
8315 
        if ftype == TType.STRUCT:
8316 
          self.cex = CatalogServiceException()
8317 
          self.cex.read(iprot)
8318 
        else:
8319 
          iprot.skip(ftype)
8320 
      else:
8321 
        iprot.skip(ftype)
8322 
      iprot.readFieldEnd()
8323 
    iprot.readStructEnd()
8324 
 
8325 
  def write(self, oprot):
8326 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8327 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8328 
      return
8329 
    oprot.writeStructBegin('updateItem_result')
8330 
    if self.success is not None:
8331 
      oprot.writeFieldBegin('success', TType.I64, 0)
8332 
      oprot.writeI64(self.success)
8333 
      oprot.writeFieldEnd()
8334 
    if self.cex is not None:
8335 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8336 
      self.cex.write(oprot)
8337 
      oprot.writeFieldEnd()
8338 
    oprot.writeFieldStop()
8339 
    oprot.writeStructEnd()
8340 
 
8341 
  def validate(self):
8342 
    return
8343 
 
8344 
 
8345 
  def __repr__(self):
8346 
    L = ['%s=%r' % (key, value)
8347 
      for key, value in self.__dict__.iteritems()]
8348 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8349 
 
8350 
  def __eq__(self, other):
8351 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8352 
 
8353 
  def __ne__(self, other):
8354 
    return not (self == other)
8355 
 
8356 
class isActive_args:
8357 
  """
8358 
  Attributes:
8359 
   - itemId
8360 
  """
8361 
 
8362 
  thrift_spec = (
8363 
    None, # 0
8364 
    (1, TType.I64, 'itemId', None, None, ), # 1
8365 
  )
8366 
 
8367 
  def __init__(self, itemId=None,):
8368 
    self.itemId = itemId
8369 
 
8370 
  def read(self, iprot):
8371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8373 
      return
8374 
    iprot.readStructBegin()
8375 
    while True:
8376 
      (fname, ftype, fid) = iprot.readFieldBegin()
8377 
      if ftype == TType.STOP:
8378 
        break
8379 
      if fid == 1:
8380 
        if ftype == TType.I64:
8381 
          self.itemId = iprot.readI64();
8382 
        else:
8383 
          iprot.skip(ftype)
8384 
      else:
8385 
        iprot.skip(ftype)
8386 
      iprot.readFieldEnd()
8387 
    iprot.readStructEnd()
8388 
 
8389 
  def write(self, oprot):
8390 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8391 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8392 
      return
8393 
    oprot.writeStructBegin('isActive_args')
8394 
    if self.itemId is not None:
8395 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
8396 
      oprot.writeI64(self.itemId)
8397 
      oprot.writeFieldEnd()
8398 
    oprot.writeFieldStop()
8399 
    oprot.writeStructEnd()
8400 
 
8401 
  def validate(self):
8402 
    return
8403 
 
8404 
 
8405 
  def __repr__(self):
8406 
    L = ['%s=%r' % (key, value)
8407 
      for key, value in self.__dict__.iteritems()]
8408 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8409 
 
8410 
  def __eq__(self, other):
8411 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8412 
 
8413 
  def __ne__(self, other):
8414 
    return not (self == other)
8415 
 
8416 
class isActive_result:
8417 
  """
8418 
  Attributes:
8419 
   - success
8420 
   - isex
8421 
  """
8422 
 
8423 
  thrift_spec = (
8424 
    (0, TType.STRUCT, 'success', (ItemShippingInfo, ItemShippingInfo.thrift_spec), None, ), # 0
8425 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8426 
  )
8427 
 
8428 
  def __init__(self, success=None, isex=None,):
8429 
    self.success = success
8430 
    self.isex = isex
8431 
 
8432 
  def read(self, iprot):
8433 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8434 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8435 
      return
8436 
    iprot.readStructBegin()
8437 
    while True:
8438 
      (fname, ftype, fid) = iprot.readFieldBegin()
8439 
      if ftype == TType.STOP:
8440 
        break
8441 
      if fid == 0:
8442 
        if ftype == TType.STRUCT:
8443 
          self.success = ItemShippingInfo()
8444 
          self.success.read(iprot)
8445 
        else:
8446 
          iprot.skip(ftype)
8447 
      elif fid == 1:
8448 
        if ftype == TType.STRUCT:
8449 
          self.isex = CatalogServiceException()
8450 
          self.isex.read(iprot)
8451 
        else:
8452 
          iprot.skip(ftype)
8453 
      else:
8454 
        iprot.skip(ftype)
8455 
      iprot.readFieldEnd()
8456 
    iprot.readStructEnd()
8457 
 
8458 
  def write(self, oprot):
8459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8461 
      return
8462 
    oprot.writeStructBegin('isActive_result')
8463 
    if self.success is not None:
8464 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8465 
      self.success.write(oprot)
8466 
      oprot.writeFieldEnd()
8467 
    if self.isex is not None:
8468 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8469 
      self.isex.write(oprot)
8470 
      oprot.writeFieldEnd()
8471 
    oprot.writeFieldStop()
8472 
    oprot.writeStructEnd()
8473 
 
8474 
  def validate(self):
8475 
    return
8476 
 
8477 
 
8478 
  def __repr__(self):
8479 
    L = ['%s=%r' % (key, value)
8480 
      for key, value in self.__dict__.iteritems()]
8481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8482 
 
8483 
  def __eq__(self, other):
8484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8485 
 
8486 
  def __ne__(self, other):
8487 
    return not (self == other)
8488 
 
7438 amit.gupta 8489 
class getItemsStatus_args:
8490 
  """
8491 
  Attributes:
8492 
   - itemIds
8493 
  """
8494 
 
8495 
  thrift_spec = (
8496 
    None, # 0
8497 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
8498 
  )
8499 
 
8500 
  def __init__(self, itemIds=None,):
8501 
    self.itemIds = itemIds
8502 
 
8503 
  def read(self, iprot):
8504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8506 
      return
8507 
    iprot.readStructBegin()
8508 
    while True:
8509 
      (fname, ftype, fid) = iprot.readFieldBegin()
8510 
      if ftype == TType.STOP:
8511 
        break
8512 
      if fid == 1:
8513 
        if ftype == TType.LIST:
8514 
          self.itemIds = []
8590 kshitij.so 8515 
          (_etype33, _size30) = iprot.readListBegin()
8516 
          for _i34 in xrange(_size30):
8517 
            _elem35 = iprot.readI64();
8518 
            self.itemIds.append(_elem35)
7438 amit.gupta 8519 
          iprot.readListEnd()
8520 
        else:
8521 
          iprot.skip(ftype)
8522 
      else:
8523 
        iprot.skip(ftype)
8524 
      iprot.readFieldEnd()
8525 
    iprot.readStructEnd()
8526 
 
8527 
  def write(self, oprot):
8528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8530 
      return
8531 
    oprot.writeStructBegin('getItemsStatus_args')
8532 
    if self.itemIds is not None:
8533 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
8534 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
8590 kshitij.so 8535 
      for iter36 in self.itemIds:
8536 
        oprot.writeI64(iter36)
7438 amit.gupta 8537 
      oprot.writeListEnd()
8538 
      oprot.writeFieldEnd()
8539 
    oprot.writeFieldStop()
8540 
    oprot.writeStructEnd()
8541 
 
8542 
  def validate(self):
8543 
    return
8544 
 
8545 
 
8546 
  def __repr__(self):
8547 
    L = ['%s=%r' % (key, value)
8548 
      for key, value in self.__dict__.iteritems()]
8549 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8550 
 
8551 
  def __eq__(self, other):
8552 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8553 
 
8554 
  def __ne__(self, other):
8555 
    return not (self == other)
8556 
 
8557 
class getItemsStatus_result:
8558 
  """
8559 
  Attributes:
8560 
   - success
8561 
   - isex
8562 
  """
8563 
 
8564 
  thrift_spec = (
8565 
    (0, TType.MAP, 'success', (TType.I64,None,TType.BOOL,None), None, ), # 0
8566 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8567 
  )
8568 
 
8569 
  def __init__(self, success=None, isex=None,):
8570 
    self.success = success
8571 
    self.isex = isex
8572 
 
8573 
  def read(self, iprot):
8574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8576 
      return
8577 
    iprot.readStructBegin()
8578 
    while True:
8579 
      (fname, ftype, fid) = iprot.readFieldBegin()
8580 
      if ftype == TType.STOP:
8581 
        break
8582 
      if fid == 0:
8583 
        if ftype == TType.MAP:
8584 
          self.success = {}
8590 kshitij.so 8585 
          (_ktype38, _vtype39, _size37 ) = iprot.readMapBegin()
8586 
          for _i41 in xrange(_size37):
8587 
            _key42 = iprot.readI64();
8588 
            _val43 = iprot.readBool();
8589 
            self.success[_key42] = _val43
7438 amit.gupta 8590 
          iprot.readMapEnd()
8591 
        else:
8592 
          iprot.skip(ftype)
8593 
      elif fid == 1:
8594 
        if ftype == TType.STRUCT:
8595 
          self.isex = CatalogServiceException()
8596 
          self.isex.read(iprot)
8597 
        else:
8598 
          iprot.skip(ftype)
8599 
      else:
8600 
        iprot.skip(ftype)
8601 
      iprot.readFieldEnd()
8602 
    iprot.readStructEnd()
8603 
 
8604 
  def write(self, oprot):
8605 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8606 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8607 
      return
8608 
    oprot.writeStructBegin('getItemsStatus_result')
8609 
    if self.success is not None:
8610 
      oprot.writeFieldBegin('success', TType.MAP, 0)
8611 
      oprot.writeMapBegin(TType.I64, TType.BOOL, len(self.success))
8590 kshitij.so 8612 
      for kiter44,viter45 in self.success.items():
8613 
        oprot.writeI64(kiter44)
8614 
        oprot.writeBool(viter45)
7438 amit.gupta 8615 
      oprot.writeMapEnd()
8616 
      oprot.writeFieldEnd()
8617 
    if self.isex is not None:
8618 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8619 
      self.isex.write(oprot)
8620 
      oprot.writeFieldEnd()
8621 
    oprot.writeFieldStop()
8622 
    oprot.writeStructEnd()
8623 
 
8624 
  def validate(self):
8625 
    return
8626 
 
8627 
 
8628 
  def __repr__(self):
8629 
    L = ['%s=%r' % (key, value)
8630 
      for key, value in self.__dict__.iteritems()]
8631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8632 
 
8633 
  def __eq__(self, other):
8634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8635 
 
8636 
  def __ne__(self, other):
8637 
    return not (self == other)
8638 
 
5944 mandeep.dh 8639 
class getItemStatusDescription_args:
8640 
  """
8641 
  Attributes:
8642 
   - itemId
8643 
  """
8644 
 
8645 
  thrift_spec = (
8646 
    None, # 0
8647 
    (1, TType.I64, 'itemId', None, None, ), # 1
8648 
  )
8649 
 
8650 
  def __init__(self, itemId=None,):
8651 
    self.itemId = itemId
8652 
 
8653 
  def read(self, iprot):
8654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8656 
      return
8657 
    iprot.readStructBegin()
8658 
    while True:
8659 
      (fname, ftype, fid) = iprot.readFieldBegin()
8660 
      if ftype == TType.STOP:
8661 
        break
8662 
      if fid == 1:
8663 
        if ftype == TType.I64:
8664 
          self.itemId = iprot.readI64();
8665 
        else:
8666 
          iprot.skip(ftype)
8667 
      else:
8668 
        iprot.skip(ftype)
8669 
      iprot.readFieldEnd()
8670 
    iprot.readStructEnd()
8671 
 
8672 
  def write(self, oprot):
8673 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8674 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8675 
      return
8676 
    oprot.writeStructBegin('getItemStatusDescription_args')
8677 
    if self.itemId is not None:
8678 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
8679 
      oprot.writeI64(self.itemId)
8680 
      oprot.writeFieldEnd()
8681 
    oprot.writeFieldStop()
8682 
    oprot.writeStructEnd()
8683 
 
8684 
  def validate(self):
8685 
    return
8686 
 
8687 
 
8688 
  def __repr__(self):
8689 
    L = ['%s=%r' % (key, value)
8690 
      for key, value in self.__dict__.iteritems()]
8691 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8692 
 
8693 
  def __eq__(self, other):
8694 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8695 
 
8696 
  def __ne__(self, other):
8697 
    return not (self == other)
8698 
 
8699 
class getItemStatusDescription_result:
8700 
  """
8701 
  Attributes:
8702 
   - success
8703 
   - isex
8704 
  """
8705 
 
8706 
  thrift_spec = (
8707 
    (0, TType.STRING, 'success', None, None, ), # 0
8708 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8709 
  )
8710 
 
8711 
  def __init__(self, success=None, isex=None,):
8712 
    self.success = success
8713 
    self.isex = isex
8714 
 
8715 
  def read(self, iprot):
8716 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8717 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8718 
      return
8719 
    iprot.readStructBegin()
8720 
    while True:
8721 
      (fname, ftype, fid) = iprot.readFieldBegin()
8722 
      if ftype == TType.STOP:
8723 
        break
8724 
      if fid == 0:
8725 
        if ftype == TType.STRING:
8726 
          self.success = iprot.readString();
8727 
        else:
8728 
          iprot.skip(ftype)
8729 
      elif fid == 1:
8730 
        if ftype == TType.STRUCT:
8731 
          self.isex = CatalogServiceException()
8732 
          self.isex.read(iprot)
8733 
        else:
8734 
          iprot.skip(ftype)
8735 
      else:
8736 
        iprot.skip(ftype)
8737 
      iprot.readFieldEnd()
8738 
    iprot.readStructEnd()
8739 
 
8740 
  def write(self, oprot):
8741 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8742 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8743 
      return
8744 
    oprot.writeStructBegin('getItemStatusDescription_result')
8745 
    if self.success is not None:
8746 
      oprot.writeFieldBegin('success', TType.STRING, 0)
8747 
      oprot.writeString(self.success)
8748 
      oprot.writeFieldEnd()
8749 
    if self.isex is not None:
8750 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8751 
      self.isex.write(oprot)
8752 
      oprot.writeFieldEnd()
8753 
    oprot.writeFieldStop()
8754 
    oprot.writeStructEnd()
8755 
 
8756 
  def validate(self):
8757 
    return
8758 
 
8759 
 
8760 
  def __repr__(self):
8761 
    L = ['%s=%r' % (key, value)
8762 
      for key, value in self.__dict__.iteritems()]
8763 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8764 
 
8765 
  def __eq__(self, other):
8766 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8767 
 
8768 
  def __ne__(self, other):
8769 
    return not (self == other)
8770 
 
8771 
class startItemOn_args:
8772 
  """
8773 
  Attributes:
8774 
   - item_id
8775 
   - timestamp
8776 
  """
8777 
 
8778 
  thrift_spec = (
8779 
    None, # 0
8780 
    (1, TType.I64, 'item_id', None, None, ), # 1
8781 
    (2, TType.I64, 'timestamp', None, None, ), # 2
8782 
  )
8783 
 
8784 
  def __init__(self, item_id=None, timestamp=None,):
8785 
    self.item_id = item_id
8786 
    self.timestamp = timestamp
8787 
 
8788 
  def read(self, iprot):
8789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8791 
      return
8792 
    iprot.readStructBegin()
8793 
    while True:
8794 
      (fname, ftype, fid) = iprot.readFieldBegin()
8795 
      if ftype == TType.STOP:
8796 
        break
8797 
      if fid == 1:
8798 
        if ftype == TType.I64:
8799 
          self.item_id = iprot.readI64();
8800 
        else:
8801 
          iprot.skip(ftype)
8802 
      elif fid == 2:
8803 
        if ftype == TType.I64:
8804 
          self.timestamp = iprot.readI64();
8805 
        else:
8806 
          iprot.skip(ftype)
8807 
      else:
8808 
        iprot.skip(ftype)
8809 
      iprot.readFieldEnd()
8810 
    iprot.readStructEnd()
8811 
 
8812 
  def write(self, oprot):
8813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8815 
      return
8816 
    oprot.writeStructBegin('startItemOn_args')
8817 
    if self.item_id is not None:
8818 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
8819 
      oprot.writeI64(self.item_id)
8820 
      oprot.writeFieldEnd()
8821 
    if self.timestamp is not None:
8822 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
8823 
      oprot.writeI64(self.timestamp)
8824 
      oprot.writeFieldEnd()
8825 
    oprot.writeFieldStop()
8826 
    oprot.writeStructEnd()
8827 
 
8828 
  def validate(self):
8829 
    return
8830 
 
8831 
 
8832 
  def __repr__(self):
8833 
    L = ['%s=%r' % (key, value)
8834 
      for key, value in self.__dict__.iteritems()]
8835 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8836 
 
8837 
  def __eq__(self, other):
8838 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8839 
 
8840 
  def __ne__(self, other):
8841 
    return not (self == other)
8842 
 
8843 
class startItemOn_result:
8844 
  """
8845 
  Attributes:
8846 
   - cex
8847 
  """
8848 
 
8849 
  thrift_spec = (
8850 
    None, # 0
8851 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8852 
  )
8853 
 
8854 
  def __init__(self, cex=None,):
8855 
    self.cex = cex
8856 
 
8857 
  def read(self, iprot):
8858 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8859 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8860 
      return
8861 
    iprot.readStructBegin()
8862 
    while True:
8863 
      (fname, ftype, fid) = iprot.readFieldBegin()
8864 
      if ftype == TType.STOP:
8865 
        break
8866 
      if fid == 1:
8867 
        if ftype == TType.STRUCT:
8868 
          self.cex = CatalogServiceException()
8869 
          self.cex.read(iprot)
8870 
        else:
8871 
          iprot.skip(ftype)
8872 
      else:
8873 
        iprot.skip(ftype)
8874 
      iprot.readFieldEnd()
8875 
    iprot.readStructEnd()
8876 
 
8877 
  def write(self, oprot):
8878 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8879 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8880 
      return
8881 
    oprot.writeStructBegin('startItemOn_result')
8882 
    if self.cex is not None:
8883 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8884 
      self.cex.write(oprot)
8885 
      oprot.writeFieldEnd()
8886 
    oprot.writeFieldStop()
8887 
    oprot.writeStructEnd()
8888 
 
8889 
  def validate(self):
8890 
    return
8891 
 
8892 
 
8893 
  def __repr__(self):
8894 
    L = ['%s=%r' % (key, value)
8895 
      for key, value in self.__dict__.iteritems()]
8896 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8897 
 
8898 
  def __eq__(self, other):
8899 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8900 
 
8901 
  def __ne__(self, other):
8902 
    return not (self == other)
8903 
 
8904 
class retireItemOn_args:
8905 
  """
8906 
  Attributes:
8907 
   - item_id
8908 
   - timestamp
8909 
  """
8910 
 
8911 
  thrift_spec = (
8912 
    None, # 0
8913 
    (1, TType.I64, 'item_id', None, None, ), # 1
8914 
    (2, TType.I64, 'timestamp', None, None, ), # 2
8915 
  )
8916 
 
8917 
  def __init__(self, item_id=None, timestamp=None,):
8918 
    self.item_id = item_id
8919 
    self.timestamp = timestamp
8920 
 
8921 
  def read(self, iprot):
8922 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8923 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8924 
      return
8925 
    iprot.readStructBegin()
8926 
    while True:
8927 
      (fname, ftype, fid) = iprot.readFieldBegin()
8928 
      if ftype == TType.STOP:
8929 
        break
8930 
      if fid == 1:
8931 
        if ftype == TType.I64:
8932 
          self.item_id = iprot.readI64();
8933 
        else:
8934 
          iprot.skip(ftype)
8935 
      elif fid == 2:
8936 
        if ftype == TType.I64:
8937 
          self.timestamp = iprot.readI64();
8938 
        else:
8939 
          iprot.skip(ftype)
8940 
      else:
8941 
        iprot.skip(ftype)
8942 
      iprot.readFieldEnd()
8943 
    iprot.readStructEnd()
8944 
 
8945 
  def write(self, oprot):
8946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8948 
      return
8949 
    oprot.writeStructBegin('retireItemOn_args')
8950 
    if self.item_id is not None:
8951 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
8952 
      oprot.writeI64(self.item_id)
8953 
      oprot.writeFieldEnd()
8954 
    if self.timestamp is not None:
8955 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
8956 
      oprot.writeI64(self.timestamp)
8957 
      oprot.writeFieldEnd()
8958 
    oprot.writeFieldStop()
8959 
    oprot.writeStructEnd()
8960 
 
8961 
  def validate(self):
8962 
    return
8963 
 
8964 
 
8965 
  def __repr__(self):
8966 
    L = ['%s=%r' % (key, value)
8967 
      for key, value in self.__dict__.iteritems()]
8968 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8969 
 
8970 
  def __eq__(self, other):
8971 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8972 
 
8973 
  def __ne__(self, other):
8974 
    return not (self == other)
8975 
 
8976 
class retireItemOn_result:
8977 
  """
8978 
  Attributes:
8979 
   - cex
8980 
  """
8981 
 
8982 
  thrift_spec = (
8983 
    None, # 0
8984 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8985 
  )
8986 
 
8987 
  def __init__(self, cex=None,):
8988 
    self.cex = cex
8989 
 
8990 
  def read(self, iprot):
8991 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8992 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8993 
      return
8994 
    iprot.readStructBegin()
8995 
    while True:
8996 
      (fname, ftype, fid) = iprot.readFieldBegin()
8997 
      if ftype == TType.STOP:
8998 
        break
8999 
      if fid == 1:
9000 
        if ftype == TType.STRUCT:
9001 
          self.cex = CatalogServiceException()
9002 
          self.cex.read(iprot)
9003 
        else:
9004 
          iprot.skip(ftype)
9005 
      else:
9006 
        iprot.skip(ftype)
9007 
      iprot.readFieldEnd()
9008 
    iprot.readStructEnd()
9009 
 
9010 
  def write(self, oprot):
9011 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9012 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9013 
      return
9014 
    oprot.writeStructBegin('retireItemOn_result')
9015 
    if self.cex is not None:
9016 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9017 
      self.cex.write(oprot)
9018 
      oprot.writeFieldEnd()
9019 
    oprot.writeFieldStop()
9020 
    oprot.writeStructEnd()
9021 
 
9022 
  def validate(self):
9023 
    return
9024 
 
9025 
 
9026 
  def __repr__(self):
9027 
    L = ['%s=%r' % (key, value)
9028 
      for key, value in self.__dict__.iteritems()]
9029 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9030 
 
9031 
  def __eq__(self, other):
9032 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9033 
 
9034 
  def __ne__(self, other):
9035 
    return not (self == other)
9036 
 
9037 
class changeItemStatus_args:
9038 
  """
9039 
  Attributes:
9040 
   - item_id
9041 
   - timestamp
9042 
   - newstatus
9043 
  """
9044 
 
9045 
  thrift_spec = (
9046 
    None, # 0
9047 
    (1, TType.I64, 'item_id', None, None, ), # 1
9048 
    (2, TType.I64, 'timestamp', None, None, ), # 2
9049 
    (3, TType.I32, 'newstatus', None, None, ), # 3
9050 
  )
9051 
 
9052 
  def __init__(self, item_id=None, timestamp=None, newstatus=None,):
9053 
    self.item_id = item_id
9054 
    self.timestamp = timestamp
9055 
    self.newstatus = newstatus
9056 
 
9057 
  def read(self, iprot):
9058 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9059 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9060 
      return
9061 
    iprot.readStructBegin()
9062 
    while True:
9063 
      (fname, ftype, fid) = iprot.readFieldBegin()
9064 
      if ftype == TType.STOP:
9065 
        break
9066 
      if fid == 1:
9067 
        if ftype == TType.I64:
9068 
          self.item_id = iprot.readI64();
9069 
        else:
9070 
          iprot.skip(ftype)
9071 
      elif fid == 2:
9072 
        if ftype == TType.I64:
9073 
          self.timestamp = iprot.readI64();
9074 
        else:
9075 
          iprot.skip(ftype)
9076 
      elif fid == 3:
9077 
        if ftype == TType.I32:
9078 
          self.newstatus = iprot.readI32();
9079 
        else:
9080 
          iprot.skip(ftype)
9081 
      else:
9082 
        iprot.skip(ftype)
9083 
      iprot.readFieldEnd()
9084 
    iprot.readStructEnd()
9085 
 
9086 
  def write(self, oprot):
9087 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9088 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9089 
      return
9090 
    oprot.writeStructBegin('changeItemStatus_args')
9091 
    if self.item_id is not None:
9092 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
9093 
      oprot.writeI64(self.item_id)
9094 
      oprot.writeFieldEnd()
9095 
    if self.timestamp is not None:
9096 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
9097 
      oprot.writeI64(self.timestamp)
9098 
      oprot.writeFieldEnd()
9099 
    if self.newstatus is not None:
9100 
      oprot.writeFieldBegin('newstatus', TType.I32, 3)
9101 
      oprot.writeI32(self.newstatus)
9102 
      oprot.writeFieldEnd()
9103 
    oprot.writeFieldStop()
9104 
    oprot.writeStructEnd()
9105 
 
9106 
  def validate(self):
9107 
    return
9108 
 
9109 
 
9110 
  def __repr__(self):
9111 
    L = ['%s=%r' % (key, value)
9112 
      for key, value in self.__dict__.iteritems()]
9113 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9114 
 
9115 
  def __eq__(self, other):
9116 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9117 
 
9118 
  def __ne__(self, other):
9119 
    return not (self == other)
9120 
 
9121 
class changeItemStatus_result:
9122 
  """
9123 
  Attributes:
9124 
   - cex
9125 
  """
9126 
 
9127 
  thrift_spec = (
9128 
    None, # 0
9129 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9130 
  )
9131 
 
9132 
  def __init__(self, cex=None,):
9133 
    self.cex = cex
9134 
 
9135 
  def read(self, iprot):
9136 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9137 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9138 
      return
9139 
    iprot.readStructBegin()
9140 
    while True:
9141 
      (fname, ftype, fid) = iprot.readFieldBegin()
9142 
      if ftype == TType.STOP:
9143 
        break
9144 
      if fid == 1:
9145 
        if ftype == TType.STRUCT:
9146 
          self.cex = CatalogServiceException()
9147 
          self.cex.read(iprot)
9148 
        else:
9149 
          iprot.skip(ftype)
9150 
      else:
9151 
        iprot.skip(ftype)
9152 
      iprot.readFieldEnd()
9153 
    iprot.readStructEnd()
9154 
 
9155 
  def write(self, oprot):
9156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9158 
      return
9159 
    oprot.writeStructBegin('changeItemStatus_result')
9160 
    if self.cex is not None:
9161 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9162 
      self.cex.write(oprot)
9163 
      oprot.writeFieldEnd()
9164 
    oprot.writeFieldStop()
9165 
    oprot.writeStructEnd()
9166 
 
9167 
  def validate(self):
9168 
    return
9169 
 
9170 
 
9171 
  def __repr__(self):
9172 
    L = ['%s=%r' % (key, value)
9173 
      for key, value in self.__dict__.iteritems()]
9174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9175 
 
9176 
  def __eq__(self, other):
9177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9178 
 
9179 
  def __ne__(self, other):
9180 
    return not (self == other)
9181 
 
9182 
class getItem_args:
9183 
  """
9184 
  Attributes:
9185 
   - item_id
9186 
  """
9187 
 
9188 
  thrift_spec = (
9189 
    None, # 0
9190 
    (1, TType.I64, 'item_id', None, None, ), # 1
9191 
  )
9192 
 
9193 
  def __init__(self, item_id=None,):
9194 
    self.item_id = item_id
9195 
 
9196 
  def read(self, iprot):
9197 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9198 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9199 
      return
9200 
    iprot.readStructBegin()
9201 
    while True:
9202 
      (fname, ftype, fid) = iprot.readFieldBegin()
9203 
      if ftype == TType.STOP:
9204 
        break
9205 
      if fid == 1:
9206 
        if ftype == TType.I64:
9207 
          self.item_id = iprot.readI64();
9208 
        else:
9209 
          iprot.skip(ftype)
9210 
      else:
9211 
        iprot.skip(ftype)
9212 
      iprot.readFieldEnd()
9213 
    iprot.readStructEnd()
9214 
 
9215 
  def write(self, oprot):
9216 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9217 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9218 
      return
9219 
    oprot.writeStructBegin('getItem_args')
9220 
    if self.item_id is not None:
9221 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
9222 
      oprot.writeI64(self.item_id)
9223 
      oprot.writeFieldEnd()
9224 
    oprot.writeFieldStop()
9225 
    oprot.writeStructEnd()
9226 
 
9227 
  def validate(self):
9228 
    return
9229 
 
9230 
 
9231 
  def __repr__(self):
9232 
    L = ['%s=%r' % (key, value)
9233 
      for key, value in self.__dict__.iteritems()]
9234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9235 
 
9236 
  def __eq__(self, other):
9237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9238 
 
9239 
  def __ne__(self, other):
9240 
    return not (self == other)
9241 
 
9242 
class getItem_result:
9243 
  """
9244 
  Attributes:
9245 
   - success
9246 
   - cex
9247 
  """
9248 
 
9249 
  thrift_spec = (
9250 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
9251 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9252 
  )
9253 
 
9254 
  def __init__(self, success=None, cex=None,):
9255 
    self.success = success
9256 
    self.cex = cex
9257 
 
9258 
  def read(self, iprot):
9259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9261 
      return
9262 
    iprot.readStructBegin()
9263 
    while True:
9264 
      (fname, ftype, fid) = iprot.readFieldBegin()
9265 
      if ftype == TType.STOP:
9266 
        break
9267 
      if fid == 0:
9268 
        if ftype == TType.STRUCT:
9269 
          self.success = Item()
9270 
          self.success.read(iprot)
9271 
        else:
9272 
          iprot.skip(ftype)
9273 
      elif fid == 1:
9274 
        if ftype == TType.STRUCT:
9275 
          self.cex = CatalogServiceException()
9276 
          self.cex.read(iprot)
9277 
        else:
9278 
          iprot.skip(ftype)
9279 
      else:
9280 
        iprot.skip(ftype)
9281 
      iprot.readFieldEnd()
9282 
    iprot.readStructEnd()
9283 
 
9284 
  def write(self, oprot):
9285 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9286 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9287 
      return
9288 
    oprot.writeStructBegin('getItem_result')
9289 
    if self.success is not None:
9290 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9291 
      self.success.write(oprot)
9292 
      oprot.writeFieldEnd()
9293 
    if self.cex is not None:
9294 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9295 
      self.cex.write(oprot)
9296 
      oprot.writeFieldEnd()
9297 
    oprot.writeFieldStop()
9298 
    oprot.writeStructEnd()
9299 
 
9300 
  def validate(self):
9301 
    return
9302 
 
9303 
 
9304 
  def __repr__(self):
9305 
    L = ['%s=%r' % (key, value)
9306 
      for key, value in self.__dict__.iteritems()]
9307 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9308 
 
9309 
  def __eq__(self, other):
9310 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9311 
 
9312 
  def __ne__(self, other):
9313 
    return not (self == other)
9314 
 
9315 
class getItemsByCatalogId_args:
9316 
  """
9317 
  Attributes:
9318 
   - catalog_item_id
9319 
  """
9320 
 
9321 
  thrift_spec = (
9322 
    None, # 0
9323 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
9324 
  )
9325 
 
9326 
  def __init__(self, catalog_item_id=None,):
9327 
    self.catalog_item_id = catalog_item_id
9328 
 
9329 
  def read(self, iprot):
9330 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9331 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9332 
      return
9333 
    iprot.readStructBegin()
9334 
    while True:
9335 
      (fname, ftype, fid) = iprot.readFieldBegin()
9336 
      if ftype == TType.STOP:
9337 
        break
9338 
      if fid == 1:
9339 
        if ftype == TType.I64:
9340 
          self.catalog_item_id = iprot.readI64();
9341 
        else:
9342 
          iprot.skip(ftype)
9343 
      else:
9344 
        iprot.skip(ftype)
9345 
      iprot.readFieldEnd()
9346 
    iprot.readStructEnd()
9347 
 
9348 
  def write(self, oprot):
9349 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9350 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9351 
      return
9352 
    oprot.writeStructBegin('getItemsByCatalogId_args')
9353 
    if self.catalog_item_id is not None:
9354 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
9355 
      oprot.writeI64(self.catalog_item_id)
9356 
      oprot.writeFieldEnd()
9357 
    oprot.writeFieldStop()
9358 
    oprot.writeStructEnd()
9359 
 
9360 
  def validate(self):
9361 
    return
9362 
 
9363 
 
9364 
  def __repr__(self):
9365 
    L = ['%s=%r' % (key, value)
9366 
      for key, value in self.__dict__.iteritems()]
9367 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9368 
 
9369 
  def __eq__(self, other):
9370 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9371 
 
9372 
  def __ne__(self, other):
9373 
    return not (self == other)
9374 
 
9375 
class getItemsByCatalogId_result:
9376 
  """
9377 
  Attributes:
9378 
   - success
9379 
   - cex
9380 
  """
9381 
 
9382 
  thrift_spec = (
9383 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9384 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9385 
  )
9386 
 
9387 
  def __init__(self, success=None, cex=None,):
9388 
    self.success = success
9389 
    self.cex = cex
9390 
 
9391 
  def read(self, iprot):
9392 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9393 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9394 
      return
9395 
    iprot.readStructBegin()
9396 
    while True:
9397 
      (fname, ftype, fid) = iprot.readFieldBegin()
9398 
      if ftype == TType.STOP:
9399 
        break
9400 
      if fid == 0:
9401 
        if ftype == TType.LIST:
9402 
          self.success = []
8590 kshitij.so 9403 
          (_etype49, _size46) = iprot.readListBegin()
9404 
          for _i50 in xrange(_size46):
9405 
            _elem51 = Item()
9406 
            _elem51.read(iprot)
9407 
            self.success.append(_elem51)
5944 mandeep.dh 9408 
          iprot.readListEnd()
9409 
        else:
9410 
          iprot.skip(ftype)
9411 
      elif fid == 1:
9412 
        if ftype == TType.STRUCT:
9413 
          self.cex = CatalogServiceException()
9414 
          self.cex.read(iprot)
9415 
        else:
9416 
          iprot.skip(ftype)
9417 
      else:
9418 
        iprot.skip(ftype)
9419 
      iprot.readFieldEnd()
9420 
    iprot.readStructEnd()
9421 
 
9422 
  def write(self, oprot):
9423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9425 
      return
9426 
    oprot.writeStructBegin('getItemsByCatalogId_result')
9427 
    if self.success is not None:
9428 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9429 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9430 
      for iter52 in self.success:
9431 
        iter52.write(oprot)
5944 mandeep.dh 9432 
      oprot.writeListEnd()
9433 
      oprot.writeFieldEnd()
9434 
    if self.cex is not None:
9435 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9436 
      self.cex.write(oprot)
9437 
      oprot.writeFieldEnd()
9438 
    oprot.writeFieldStop()
9439 
    oprot.writeStructEnd()
9440 
 
9441 
  def validate(self):
9442 
    return
9443 
 
9444 
 
9445 
  def __repr__(self):
9446 
    L = ['%s=%r' % (key, value)
9447 
      for key, value in self.__dict__.iteritems()]
9448 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9449 
 
9450 
  def __eq__(self, other):
9451 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9452 
 
9453 
  def __ne__(self, other):
9454 
    return not (self == other)
9455 
 
9456 
class getValidItemsByCatalogId_args:
9457 
  """
9458 
  Attributes:
9459 
   - catalog_item_id
9460 
  """
9461 
 
9462 
  thrift_spec = (
9463 
    None, # 0
9464 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
9465 
  )
9466 
 
9467 
  def __init__(self, catalog_item_id=None,):
9468 
    self.catalog_item_id = catalog_item_id
9469 
 
9470 
  def read(self, iprot):
9471 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9472 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9473 
      return
9474 
    iprot.readStructBegin()
9475 
    while True:
9476 
      (fname, ftype, fid) = iprot.readFieldBegin()
9477 
      if ftype == TType.STOP:
9478 
        break
9479 
      if fid == 1:
9480 
        if ftype == TType.I64:
9481 
          self.catalog_item_id = iprot.readI64();
9482 
        else:
9483 
          iprot.skip(ftype)
9484 
      else:
9485 
        iprot.skip(ftype)
9486 
      iprot.readFieldEnd()
9487 
    iprot.readStructEnd()
9488 
 
9489 
  def write(self, oprot):
9490 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9491 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9492 
      return
9493 
    oprot.writeStructBegin('getValidItemsByCatalogId_args')
9494 
    if self.catalog_item_id is not None:
9495 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
9496 
      oprot.writeI64(self.catalog_item_id)
9497 
      oprot.writeFieldEnd()
9498 
    oprot.writeFieldStop()
9499 
    oprot.writeStructEnd()
9500 
 
9501 
  def validate(self):
9502 
    return
9503 
 
9504 
 
9505 
  def __repr__(self):
9506 
    L = ['%s=%r' % (key, value)
9507 
      for key, value in self.__dict__.iteritems()]
9508 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9509 
 
9510 
  def __eq__(self, other):
9511 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9512 
 
9513 
  def __ne__(self, other):
9514 
    return not (self == other)
9515 
 
9516 
class getValidItemsByCatalogId_result:
9517 
  """
9518 
  Attributes:
9519 
   - success
9520 
   - cex
9521 
  """
9522 
 
9523 
  thrift_spec = (
9524 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9525 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9526 
  )
9527 
 
9528 
  def __init__(self, success=None, cex=None,):
9529 
    self.success = success
9530 
    self.cex = cex
9531 
 
9532 
  def read(self, iprot):
9533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9535 
      return
9536 
    iprot.readStructBegin()
9537 
    while True:
9538 
      (fname, ftype, fid) = iprot.readFieldBegin()
9539 
      if ftype == TType.STOP:
9540 
        break
9541 
      if fid == 0:
9542 
        if ftype == TType.LIST:
9543 
          self.success = []
8590 kshitij.so 9544 
          (_etype56, _size53) = iprot.readListBegin()
9545 
          for _i57 in xrange(_size53):
9546 
            _elem58 = Item()
9547 
            _elem58.read(iprot)
9548 
            self.success.append(_elem58)
5944 mandeep.dh 9549 
          iprot.readListEnd()
9550 
        else:
9551 
          iprot.skip(ftype)
9552 
      elif fid == 1:
9553 
        if ftype == TType.STRUCT:
9554 
          self.cex = CatalogServiceException()
9555 
          self.cex.read(iprot)
9556 
        else:
9557 
          iprot.skip(ftype)
9558 
      else:
9559 
        iprot.skip(ftype)
9560 
      iprot.readFieldEnd()
9561 
    iprot.readStructEnd()
9562 
 
9563 
  def write(self, oprot):
9564 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9565 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9566 
      return
9567 
    oprot.writeStructBegin('getValidItemsByCatalogId_result')
9568 
    if self.success is not None:
9569 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9570 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9571 
      for iter59 in self.success:
9572 
        iter59.write(oprot)
5944 mandeep.dh 9573 
      oprot.writeListEnd()
9574 
      oprot.writeFieldEnd()
9575 
    if self.cex is not None:
9576 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9577 
      self.cex.write(oprot)
9578 
      oprot.writeFieldEnd()
9579 
    oprot.writeFieldStop()
9580 
    oprot.writeStructEnd()
9581 
 
9582 
  def validate(self):
9583 
    return
9584 
 
9585 
 
9586 
  def __repr__(self):
9587 
    L = ['%s=%r' % (key, value)
9588 
      for key, value in self.__dict__.iteritems()]
9589 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9590 
 
9591 
  def __eq__(self, other):
9592 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9593 
 
9594 
  def __ne__(self, other):
9595 
    return not (self == other)
9596 
 
9597 
class getAllItems_args:
9598 
  """
9599 
  Attributes:
9600 
   - isActive
9601 
  """
9602 
 
9603 
  thrift_spec = (
9604 
    None, # 0
9605 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
9606 
  )
9607 
 
9608 
  def __init__(self, isActive=None,):
9609 
    self.isActive = isActive
9610 
 
9611 
  def read(self, iprot):
9612 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9613 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9614 
      return
9615 
    iprot.readStructBegin()
9616 
    while True:
9617 
      (fname, ftype, fid) = iprot.readFieldBegin()
9618 
      if ftype == TType.STOP:
9619 
        break
9620 
      if fid == 1:
9621 
        if ftype == TType.BOOL:
9622 
          self.isActive = iprot.readBool();
9623 
        else:
9624 
          iprot.skip(ftype)
9625 
      else:
9626 
        iprot.skip(ftype)
9627 
      iprot.readFieldEnd()
9628 
    iprot.readStructEnd()
9629 
 
9630 
  def write(self, oprot):
9631 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9632 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9633 
      return
9634 
    oprot.writeStructBegin('getAllItems_args')
9635 
    if self.isActive is not None:
9636 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
9637 
      oprot.writeBool(self.isActive)
9638 
      oprot.writeFieldEnd()
9639 
    oprot.writeFieldStop()
9640 
    oprot.writeStructEnd()
9641 
 
9642 
  def validate(self):
9643 
    return
9644 
 
9645 
 
9646 
  def __repr__(self):
9647 
    L = ['%s=%r' % (key, value)
9648 
      for key, value in self.__dict__.iteritems()]
9649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9650 
 
9651 
  def __eq__(self, other):
9652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9653 
 
9654 
  def __ne__(self, other):
9655 
    return not (self == other)
9656 
 
9657 
class getAllItems_result:
9658 
  """
9659 
  Attributes:
9660 
   - success
9661 
   - cex
9662 
  """
9663 
 
9664 
  thrift_spec = (
9665 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9666 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9667 
  )
9668 
 
9669 
  def __init__(self, success=None, cex=None,):
9670 
    self.success = success
9671 
    self.cex = cex
9672 
 
9673 
  def read(self, iprot):
9674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9676 
      return
9677 
    iprot.readStructBegin()
9678 
    while True:
9679 
      (fname, ftype, fid) = iprot.readFieldBegin()
9680 
      if ftype == TType.STOP:
9681 
        break
9682 
      if fid == 0:
9683 
        if ftype == TType.LIST:
9684 
          self.success = []
8590 kshitij.so 9685 
          (_etype63, _size60) = iprot.readListBegin()
9686 
          for _i64 in xrange(_size60):
9687 
            _elem65 = Item()
9688 
            _elem65.read(iprot)
9689 
            self.success.append(_elem65)
5944 mandeep.dh 9690 
          iprot.readListEnd()
9691 
        else:
9692 
          iprot.skip(ftype)
9693 
      elif fid == 1:
9694 
        if ftype == TType.STRUCT:
9695 
          self.cex = CatalogServiceException()
9696 
          self.cex.read(iprot)
9697 
        else:
9698 
          iprot.skip(ftype)
9699 
      else:
9700 
        iprot.skip(ftype)
9701 
      iprot.readFieldEnd()
9702 
    iprot.readStructEnd()
9703 
 
9704 
  def write(self, oprot):
9705 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9706 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9707 
      return
9708 
    oprot.writeStructBegin('getAllItems_result')
9709 
    if self.success is not None:
9710 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9711 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9712 
      for iter66 in self.success:
9713 
        iter66.write(oprot)
5944 mandeep.dh 9714 
      oprot.writeListEnd()
9715 
      oprot.writeFieldEnd()
9716 
    if self.cex is not None:
9717 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9718 
      self.cex.write(oprot)
9719 
      oprot.writeFieldEnd()
9720 
    oprot.writeFieldStop()
9721 
    oprot.writeStructEnd()
9722 
 
9723 
  def validate(self):
9724 
    return
9725 
 
9726 
 
9727 
  def __repr__(self):
9728 
    L = ['%s=%r' % (key, value)
9729 
      for key, value in self.__dict__.iteritems()]
9730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9731 
 
9732 
  def __eq__(self, other):
9733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9734 
 
9735 
  def __ne__(self, other):
9736 
    return not (self == other)
9737 
 
9738 
class getAllItemsByStatus_args:
9739 
  """
9740 
  Attributes:
9741 
   - itemStatus
9742 
  """
9743 
 
9744 
  thrift_spec = (
9745 
    None, # 0
9746 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
9747 
  )
9748 
 
9749 
  def __init__(self, itemStatus=None,):
9750 
    self.itemStatus = itemStatus
9751 
 
9752 
  def read(self, iprot):
9753 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9754 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9755 
      return
9756 
    iprot.readStructBegin()
9757 
    while True:
9758 
      (fname, ftype, fid) = iprot.readFieldBegin()
9759 
      if ftype == TType.STOP:
9760 
        break
9761 
      if fid == 1:
9762 
        if ftype == TType.I32:
9763 
          self.itemStatus = iprot.readI32();
9764 
        else:
9765 
          iprot.skip(ftype)
9766 
      else:
9767 
        iprot.skip(ftype)
9768 
      iprot.readFieldEnd()
9769 
    iprot.readStructEnd()
9770 
 
9771 
  def write(self, oprot):
9772 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9773 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9774 
      return
9775 
    oprot.writeStructBegin('getAllItemsByStatus_args')
9776 
    if self.itemStatus is not None:
9777 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
9778 
      oprot.writeI32(self.itemStatus)
9779 
      oprot.writeFieldEnd()
9780 
    oprot.writeFieldStop()
9781 
    oprot.writeStructEnd()
9782 
 
9783 
  def validate(self):
9784 
    return
9785 
 
9786 
 
9787 
  def __repr__(self):
9788 
    L = ['%s=%r' % (key, value)
9789 
      for key, value in self.__dict__.iteritems()]
9790 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9791 
 
9792 
  def __eq__(self, other):
9793 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9794 
 
9795 
  def __ne__(self, other):
9796 
    return not (self == other)
9797 
 
9798 
class getAllItemsByStatus_result:
9799 
  """
9800 
  Attributes:
9801 
   - success
9802 
   - cex
9803 
  """
9804 
 
9805 
  thrift_spec = (
9806 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9807 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9808 
  )
9809 
 
9810 
  def __init__(self, success=None, cex=None,):
9811 
    self.success = success
9812 
    self.cex = cex
9813 
 
9814 
  def read(self, iprot):
9815 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9816 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9817 
      return
9818 
    iprot.readStructBegin()
9819 
    while True:
9820 
      (fname, ftype, fid) = iprot.readFieldBegin()
9821 
      if ftype == TType.STOP:
9822 
        break
9823 
      if fid == 0:
9824 
        if ftype == TType.LIST:
9825 
          self.success = []
8590 kshitij.so 9826 
          (_etype70, _size67) = iprot.readListBegin()
9827 
          for _i71 in xrange(_size67):
9828 
            _elem72 = Item()
9829 
            _elem72.read(iprot)
9830 
            self.success.append(_elem72)
5944 mandeep.dh 9831 
          iprot.readListEnd()
9832 
        else:
9833 
          iprot.skip(ftype)
9834 
      elif fid == 1:
9835 
        if ftype == TType.STRUCT:
9836 
          self.cex = CatalogServiceException()
9837 
          self.cex.read(iprot)
9838 
        else:
9839 
          iprot.skip(ftype)
9840 
      else:
9841 
        iprot.skip(ftype)
9842 
      iprot.readFieldEnd()
9843 
    iprot.readStructEnd()
9844 
 
9845 
  def write(self, oprot):
9846 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9847 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9848 
      return
9849 
    oprot.writeStructBegin('getAllItemsByStatus_result')
9850 
    if self.success is not None:
9851 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9852 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9853 
      for iter73 in self.success:
9854 
        iter73.write(oprot)
5944 mandeep.dh 9855 
      oprot.writeListEnd()
9856 
      oprot.writeFieldEnd()
9857 
    if self.cex is not None:
9858 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9859 
      self.cex.write(oprot)
9860 
      oprot.writeFieldEnd()
9861 
    oprot.writeFieldStop()
9862 
    oprot.writeStructEnd()
9863 
 
9864 
  def validate(self):
9865 
    return
9866 
 
9867 
 
9868 
  def __repr__(self):
9869 
    L = ['%s=%r' % (key, value)
9870 
      for key, value in self.__dict__.iteritems()]
9871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9872 
 
9873 
  def __eq__(self, other):
9874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9875 
 
9876 
  def __ne__(self, other):
9877 
    return not (self == other)
9878 
 
9879 
class markItemAsContentComplete_args:
9880 
  """
9881 
  Attributes:
9882 
   - entityId
9883 
   - category
9884 
   - brand
9885 
   - modelName
9886 
   - modelNumber
9253 rajveer 9887 
   - isAndroid
5944 mandeep.dh 9888 
  """
9889 
 
9890 
  thrift_spec = (
9891 
    None, # 0
9892 
    (1, TType.I64, 'entityId', None, None, ), # 1
9893 
    (2, TType.I64, 'category', None, None, ), # 2
9894 
    (3, TType.STRING, 'brand', None, None, ), # 3
9895 
    (4, TType.STRING, 'modelName', None, None, ), # 4
9896 
    (5, TType.STRING, 'modelNumber', None, None, ), # 5
9253 rajveer 9897 
    (6, TType.BOOL, 'isAndroid', None, None, ), # 6
5944 mandeep.dh 9898 
  )
9899 
 
9253 rajveer 9900 
  def __init__(self, entityId=None, category=None, brand=None, modelName=None, modelNumber=None, isAndroid=None,):
5944 mandeep.dh 9901 
    self.entityId = entityId
9902 
    self.category = category
9903 
    self.brand = brand
9904 
    self.modelName = modelName
9905 
    self.modelNumber = modelNumber
9253 rajveer 9906 
    self.isAndroid = isAndroid
5944 mandeep.dh 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 == 1:
9918 
        if ftype == TType.I64:
9919 
          self.entityId = iprot.readI64();
9920 
        else:
9921 
          iprot.skip(ftype)
9922 
      elif fid == 2:
9923 
        if ftype == TType.I64:
9924 
          self.category = iprot.readI64();
9925 
        else:
9926 
          iprot.skip(ftype)
9927 
      elif fid == 3:
9928 
        if ftype == TType.STRING:
9929 
          self.brand = iprot.readString();
9930 
        else:
9931 
          iprot.skip(ftype)
9932 
      elif fid == 4:
9933 
        if ftype == TType.STRING:
9934 
          self.modelName = iprot.readString();
9935 
        else:
9936 
          iprot.skip(ftype)
9937 
      elif fid == 5:
9938 
        if ftype == TType.STRING:
9939 
          self.modelNumber = iprot.readString();
9940 
        else:
9941 
          iprot.skip(ftype)
9253 rajveer 9942 
      elif fid == 6:
9943 
        if ftype == TType.BOOL:
9944 
          self.isAndroid = iprot.readBool();
9945 
        else:
9946 
          iprot.skip(ftype)
5944 mandeep.dh 9947 
      else:
9948 
        iprot.skip(ftype)
9949 
      iprot.readFieldEnd()
9950 
    iprot.readStructEnd()
9951 
 
9952 
  def write(self, oprot):
9953 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9954 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9955 
      return
9956 
    oprot.writeStructBegin('markItemAsContentComplete_args')
9957 
    if self.entityId is not None:
9958 
      oprot.writeFieldBegin('entityId', TType.I64, 1)
9959 
      oprot.writeI64(self.entityId)
9960 
      oprot.writeFieldEnd()
9961 
    if self.category is not None:
9962 
      oprot.writeFieldBegin('category', TType.I64, 2)
9963 
      oprot.writeI64(self.category)
9964 
      oprot.writeFieldEnd()
9965 
    if self.brand is not None:
9966 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9967 
      oprot.writeString(self.brand)
9968 
      oprot.writeFieldEnd()
9969 
    if self.modelName is not None:
9970 
      oprot.writeFieldBegin('modelName', TType.STRING, 4)
9971 
      oprot.writeString(self.modelName)
9972 
      oprot.writeFieldEnd()
9973 
    if self.modelNumber is not None:
9974 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 5)
9975 
      oprot.writeString(self.modelNumber)
9976 
      oprot.writeFieldEnd()
9253 rajveer 9977 
    if self.isAndroid is not None:
9978 
      oprot.writeFieldBegin('isAndroid', TType.BOOL, 6)
9979 
      oprot.writeBool(self.isAndroid)
9980 
      oprot.writeFieldEnd()
5944 mandeep.dh 9981 
    oprot.writeFieldStop()
9982 
    oprot.writeStructEnd()
9983 
 
9984 
  def validate(self):
9985 
    return
9986 
 
9987 
 
9988 
  def __repr__(self):
9989 
    L = ['%s=%r' % (key, value)
9990 
      for key, value in self.__dict__.iteritems()]
9991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9992 
 
9993 
  def __eq__(self, other):
9994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9995 
 
9996 
  def __ne__(self, other):
9997 
    return not (self == other)
9998 
 
9999 
class markItemAsContentComplete_result:
10000 
  """
10001 
  Attributes:
10002 
   - success
10003 
   - cex
10004 
  """
10005 
 
10006 
  thrift_spec = (
10007 
    (0, TType.BOOL, 'success', None, None, ), # 0
10008 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10009 
  )
10010 
 
10011 
  def __init__(self, success=None, cex=None,):
10012 
    self.success = success
10013 
    self.cex = cex
10014 
 
10015 
  def read(self, iprot):
10016 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10017 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10018 
      return
10019 
    iprot.readStructBegin()
10020 
    while True:
10021 
      (fname, ftype, fid) = iprot.readFieldBegin()
10022 
      if ftype == TType.STOP:
10023 
        break
10024 
      if fid == 0:
10025 
        if ftype == TType.BOOL:
10026 
          self.success = iprot.readBool();
10027 
        else:
10028 
          iprot.skip(ftype)
10029 
      elif fid == 1:
10030 
        if ftype == TType.STRUCT:
10031 
          self.cex = CatalogServiceException()
10032 
          self.cex.read(iprot)
10033 
        else:
10034 
          iprot.skip(ftype)
10035 
      else:
10036 
        iprot.skip(ftype)
10037 
      iprot.readFieldEnd()
10038 
    iprot.readStructEnd()
10039 
 
10040 
  def write(self, oprot):
10041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10043 
      return
10044 
    oprot.writeStructBegin('markItemAsContentComplete_result')
10045 
    if self.success is not None:
10046 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10047 
      oprot.writeBool(self.success)
10048 
      oprot.writeFieldEnd()
10049 
    if self.cex is not None:
10050 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10051 
      self.cex.write(oprot)
10052 
      oprot.writeFieldEnd()
10053 
    oprot.writeFieldStop()
10054 
    oprot.writeStructEnd()
10055 
 
10056 
  def validate(self):
10057 
    return
10058 
 
10059 
 
10060 
  def __repr__(self):
10061 
    L = ['%s=%r' % (key, value)
10062 
      for key, value in self.__dict__.iteritems()]
10063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10064 
 
10065 
  def __eq__(self, other):
10066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10067 
 
10068 
  def __ne__(self, other):
10069 
    return not (self == other)
10070 
 
10071 
class getAllItemsInRange_args:
10072 
  """
10073 
  Attributes:
10074 
   - offset
10075 
   - limit
10076 
  """
10077 
 
10078 
  thrift_spec = (
10079 
    None, # 0
10080 
    (1, TType.I64, 'offset', None, None, ), # 1
10081 
    (2, TType.I64, 'limit', None, None, ), # 2
10082 
  )
10083 
 
10084 
  def __init__(self, offset=None, limit=None,):
10085 
    self.offset = offset
10086 
    self.limit = limit
10087 
 
10088 
  def read(self, iprot):
10089 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10090 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10091 
      return
10092 
    iprot.readStructBegin()
10093 
    while True:
10094 
      (fname, ftype, fid) = iprot.readFieldBegin()
10095 
      if ftype == TType.STOP:
10096 
        break
10097 
      if fid == 1:
10098 
        if ftype == TType.I64:
10099 
          self.offset = iprot.readI64();
10100 
        else:
10101 
          iprot.skip(ftype)
10102 
      elif fid == 2:
10103 
        if ftype == TType.I64:
10104 
          self.limit = iprot.readI64();
10105 
        else:
10106 
          iprot.skip(ftype)
10107 
      else:
10108 
        iprot.skip(ftype)
10109 
      iprot.readFieldEnd()
10110 
    iprot.readStructEnd()
10111 
 
10112 
  def write(self, oprot):
10113 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10114 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10115 
      return
10116 
    oprot.writeStructBegin('getAllItemsInRange_args')
10117 
    if self.offset is not None:
10118 
      oprot.writeFieldBegin('offset', TType.I64, 1)
10119 
      oprot.writeI64(self.offset)
10120 
      oprot.writeFieldEnd()
10121 
    if self.limit is not None:
10122 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10123 
      oprot.writeI64(self.limit)
10124 
      oprot.writeFieldEnd()
10125 
    oprot.writeFieldStop()
10126 
    oprot.writeStructEnd()
10127 
 
10128 
  def validate(self):
10129 
    return
10130 
 
10131 
 
10132 
  def __repr__(self):
10133 
    L = ['%s=%r' % (key, value)
10134 
      for key, value in self.__dict__.iteritems()]
10135 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10136 
 
10137 
  def __eq__(self, other):
10138 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10139 
 
10140 
  def __ne__(self, other):
10141 
    return not (self == other)
10142 
 
10143 
class getAllItemsInRange_result:
10144 
  """
10145 
  Attributes:
10146 
   - success
10147 
   - cex
10148 
  """
10149 
 
10150 
  thrift_spec = (
10151 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10152 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10153 
  )
10154 
 
10155 
  def __init__(self, success=None, cex=None,):
10156 
    self.success = success
10157 
    self.cex = cex
10158 
 
10159 
  def read(self, iprot):
10160 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10161 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10162 
      return
10163 
    iprot.readStructBegin()
10164 
    while True:
10165 
      (fname, ftype, fid) = iprot.readFieldBegin()
10166 
      if ftype == TType.STOP:
10167 
        break
10168 
      if fid == 0:
10169 
        if ftype == TType.LIST:
10170 
          self.success = []
8590 kshitij.so 10171 
          (_etype77, _size74) = iprot.readListBegin()
10172 
          for _i78 in xrange(_size74):
10173 
            _elem79 = Item()
10174 
            _elem79.read(iprot)
10175 
            self.success.append(_elem79)
5944 mandeep.dh 10176 
          iprot.readListEnd()
10177 
        else:
10178 
          iprot.skip(ftype)
10179 
      elif fid == 1:
10180 
        if ftype == TType.STRUCT:
10181 
          self.cex = CatalogServiceException()
10182 
          self.cex.read(iprot)
10183 
        else:
10184 
          iprot.skip(ftype)
10185 
      else:
10186 
        iprot.skip(ftype)
10187 
      iprot.readFieldEnd()
10188 
    iprot.readStructEnd()
10189 
 
10190 
  def write(self, oprot):
10191 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10192 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10193 
      return
10194 
    oprot.writeStructBegin('getAllItemsInRange_result')
10195 
    if self.success is not None:
10196 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10197 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10198 
      for iter80 in self.success:
10199 
        iter80.write(oprot)
5944 mandeep.dh 10200 
      oprot.writeListEnd()
10201 
      oprot.writeFieldEnd()
10202 
    if self.cex is not None:
10203 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10204 
      self.cex.write(oprot)
10205 
      oprot.writeFieldEnd()
10206 
    oprot.writeFieldStop()
10207 
    oprot.writeStructEnd()
10208 
 
10209 
  def validate(self):
10210 
    return
10211 
 
10212 
 
10213 
  def __repr__(self):
10214 
    L = ['%s=%r' % (key, value)
10215 
      for key, value in self.__dict__.iteritems()]
10216 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10217 
 
10218 
  def __eq__(self, other):
10219 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10220 
 
10221 
  def __ne__(self, other):
10222 
    return not (self == other)
10223 
 
10224 
class getAllItemsByStatusInRange_args:
10225 
  """
10226 
  Attributes:
10227 
   - itemStatus
10228 
   - offset
10229 
   - limit
10230 
  """
10231 
 
10232 
  thrift_spec = (
10233 
    None, # 0
10234 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
10235 
    (2, TType.I64, 'offset', None, None, ), # 2
10236 
    (3, TType.I64, 'limit', None, None, ), # 3
10237 
  )
10238 
 
10239 
  def __init__(self, itemStatus=None, offset=None, limit=None,):
10240 
    self.itemStatus = itemStatus
10241 
    self.offset = offset
10242 
    self.limit = limit
10243 
 
10244 
  def read(self, iprot):
10245 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10246 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10247 
      return
10248 
    iprot.readStructBegin()
10249 
    while True:
10250 
      (fname, ftype, fid) = iprot.readFieldBegin()
10251 
      if ftype == TType.STOP:
10252 
        break
10253 
      if fid == 1:
10254 
        if ftype == TType.I32:
10255 
          self.itemStatus = iprot.readI32();
10256 
        else:
10257 
          iprot.skip(ftype)
10258 
      elif fid == 2:
10259 
        if ftype == TType.I64:
10260 
          self.offset = iprot.readI64();
10261 
        else:
10262 
          iprot.skip(ftype)
10263 
      elif fid == 3:
10264 
        if ftype == TType.I64:
10265 
          self.limit = iprot.readI64();
10266 
        else:
10267 
          iprot.skip(ftype)
10268 
      else:
10269 
        iprot.skip(ftype)
10270 
      iprot.readFieldEnd()
10271 
    iprot.readStructEnd()
10272 
 
10273 
  def write(self, oprot):
10274 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10275 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10276 
      return
10277 
    oprot.writeStructBegin('getAllItemsByStatusInRange_args')
10278 
    if self.itemStatus is not None:
10279 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
10280 
      oprot.writeI32(self.itemStatus)
10281 
      oprot.writeFieldEnd()
10282 
    if self.offset is not None:
10283 
      oprot.writeFieldBegin('offset', TType.I64, 2)
10284 
      oprot.writeI64(self.offset)
10285 
      oprot.writeFieldEnd()
10286 
    if self.limit is not None:
10287 
      oprot.writeFieldBegin('limit', TType.I64, 3)
10288 
      oprot.writeI64(self.limit)
10289 
      oprot.writeFieldEnd()
10290 
    oprot.writeFieldStop()
10291 
    oprot.writeStructEnd()
10292 
 
10293 
  def validate(self):
10294 
    return
10295 
 
10296 
 
10297 
  def __repr__(self):
10298 
    L = ['%s=%r' % (key, value)
10299 
      for key, value in self.__dict__.iteritems()]
10300 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10301 
 
10302 
  def __eq__(self, other):
10303 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10304 
 
10305 
  def __ne__(self, other):
10306 
    return not (self == other)
10307 
 
10308 
class getAllItemsByStatusInRange_result:
10309 
  """
10310 
  Attributes:
10311 
   - success
10312 
   - cex
10313 
  """
10314 
 
10315 
  thrift_spec = (
10316 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10317 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10318 
  )
10319 
 
10320 
  def __init__(self, success=None, cex=None,):
10321 
    self.success = success
10322 
    self.cex = cex
10323 
 
10324 
  def read(self, iprot):
10325 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10326 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10327 
      return
10328 
    iprot.readStructBegin()
10329 
    while True:
10330 
      (fname, ftype, fid) = iprot.readFieldBegin()
10331 
      if ftype == TType.STOP:
10332 
        break
10333 
      if fid == 0:
10334 
        if ftype == TType.LIST:
10335 
          self.success = []
8590 kshitij.so 10336 
          (_etype84, _size81) = iprot.readListBegin()
10337 
          for _i85 in xrange(_size81):
10338 
            _elem86 = Item()
10339 
            _elem86.read(iprot)
10340 
            self.success.append(_elem86)
5944 mandeep.dh 10341 
          iprot.readListEnd()
10342 
        else:
10343 
          iprot.skip(ftype)
10344 
      elif fid == 1:
10345 
        if ftype == TType.STRUCT:
10346 
          self.cex = CatalogServiceException()
10347 
          self.cex.read(iprot)
10348 
        else:
10349 
          iprot.skip(ftype)
10350 
      else:
10351 
        iprot.skip(ftype)
10352 
      iprot.readFieldEnd()
10353 
    iprot.readStructEnd()
10354 
 
10355 
  def write(self, oprot):
10356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10358 
      return
10359 
    oprot.writeStructBegin('getAllItemsByStatusInRange_result')
10360 
    if self.success is not None:
10361 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10362 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10363 
      for iter87 in self.success:
10364 
        iter87.write(oprot)
5944 mandeep.dh 10365 
      oprot.writeListEnd()
10366 
      oprot.writeFieldEnd()
10367 
    if self.cex is not None:
10368 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10369 
      self.cex.write(oprot)
10370 
      oprot.writeFieldEnd()
10371 
    oprot.writeFieldStop()
10372 
    oprot.writeStructEnd()
10373 
 
10374 
  def validate(self):
10375 
    return
10376 
 
10377 
 
10378 
  def __repr__(self):
10379 
    L = ['%s=%r' % (key, value)
10380 
      for key, value in self.__dict__.iteritems()]
10381 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10382 
 
10383 
  def __eq__(self, other):
10384 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10385 
 
10386 
  def __ne__(self, other):
10387 
    return not (self == other)
10388 
 
10389 
class getItemCountByStatus_args:
10390 
  """
10391 
  Attributes:
10392 
   - useStatus
10393 
   - itemStatus
10394 
  """
10395 
 
10396 
  thrift_spec = (
10397 
    None, # 0
10398 
    (1, TType.BOOL, 'useStatus', None, None, ), # 1
10399 
    (2, TType.I32, 'itemStatus', None, None, ), # 2
10400 
  )
10401 
 
10402 
  def __init__(self, useStatus=None, itemStatus=None,):
10403 
    self.useStatus = useStatus
10404 
    self.itemStatus = itemStatus
10405 
 
10406 
  def read(self, iprot):
10407 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10408 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10409 
      return
10410 
    iprot.readStructBegin()
10411 
    while True:
10412 
      (fname, ftype, fid) = iprot.readFieldBegin()
10413 
      if ftype == TType.STOP:
10414 
        break
10415 
      if fid == 1:
10416 
        if ftype == TType.BOOL:
10417 
          self.useStatus = iprot.readBool();
10418 
        else:
10419 
          iprot.skip(ftype)
10420 
      elif fid == 2:
10421 
        if ftype == TType.I32:
10422 
          self.itemStatus = iprot.readI32();
10423 
        else:
10424 
          iprot.skip(ftype)
10425 
      else:
10426 
        iprot.skip(ftype)
10427 
      iprot.readFieldEnd()
10428 
    iprot.readStructEnd()
10429 
 
10430 
  def write(self, oprot):
10431 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10432 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10433 
      return
10434 
    oprot.writeStructBegin('getItemCountByStatus_args')
10435 
    if self.useStatus is not None:
10436 
      oprot.writeFieldBegin('useStatus', TType.BOOL, 1)
10437 
      oprot.writeBool(self.useStatus)
10438 
      oprot.writeFieldEnd()
10439 
    if self.itemStatus is not None:
10440 
      oprot.writeFieldBegin('itemStatus', TType.I32, 2)
10441 
      oprot.writeI32(self.itemStatus)
10442 
      oprot.writeFieldEnd()
10443 
    oprot.writeFieldStop()
10444 
    oprot.writeStructEnd()
10445 
 
10446 
  def validate(self):
10447 
    return
10448 
 
10449 
 
10450 
  def __repr__(self):
10451 
    L = ['%s=%r' % (key, value)
10452 
      for key, value in self.__dict__.iteritems()]
10453 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10454 
 
10455 
  def __eq__(self, other):
10456 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10457 
 
10458 
  def __ne__(self, other):
10459 
    return not (self == other)
10460 
 
10461 
class getItemCountByStatus_result:
10462 
  """
10463 
  Attributes:
10464 
   - success
10465 
  """
10466 
 
10467 
  thrift_spec = (
10468 
    (0, TType.I32, 'success', None, None, ), # 0
10469 
  )
10470 
 
10471 
  def __init__(self, success=None,):
10472 
    self.success = success
10473 
 
10474 
  def read(self, iprot):
10475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10477 
      return
10478 
    iprot.readStructBegin()
10479 
    while True:
10480 
      (fname, ftype, fid) = iprot.readFieldBegin()
10481 
      if ftype == TType.STOP:
10482 
        break
10483 
      if fid == 0:
10484 
        if ftype == TType.I32:
10485 
          self.success = iprot.readI32();
10486 
        else:
10487 
          iprot.skip(ftype)
10488 
      else:
10489 
        iprot.skip(ftype)
10490 
      iprot.readFieldEnd()
10491 
    iprot.readStructEnd()
10492 
 
10493 
  def write(self, oprot):
10494 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10495 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10496 
      return
10497 
    oprot.writeStructBegin('getItemCountByStatus_result')
10498 
    if self.success is not None:
10499 
      oprot.writeFieldBegin('success', TType.I32, 0)
10500 
      oprot.writeI32(self.success)
10501 
      oprot.writeFieldEnd()
10502 
    oprot.writeFieldStop()
10503 
    oprot.writeStructEnd()
10504 
 
10505 
  def validate(self):
10506 
    return
10507 
 
10508 
 
10509 
  def __repr__(self):
10510 
    L = ['%s=%r' % (key, value)
10511 
      for key, value in self.__dict__.iteritems()]
10512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10513 
 
10514 
  def __eq__(self, other):
10515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10516 
 
10517 
  def __ne__(self, other):
10518 
    return not (self == other)
10519 
 
10520 
class getBestSellers_args:
10521 
 
10522 
  thrift_spec = (
10523 
  )
10524 
 
10525 
  def read(self, iprot):
10526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10528 
      return
10529 
    iprot.readStructBegin()
10530 
    while True:
10531 
      (fname, ftype, fid) = iprot.readFieldBegin()
10532 
      if ftype == TType.STOP:
10533 
        break
10534 
      else:
10535 
        iprot.skip(ftype)
10536 
      iprot.readFieldEnd()
10537 
    iprot.readStructEnd()
10538 
 
10539 
  def write(self, oprot):
10540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10542 
      return
10543 
    oprot.writeStructBegin('getBestSellers_args')
10544 
    oprot.writeFieldStop()
10545 
    oprot.writeStructEnd()
10546 
 
10547 
  def validate(self):
10548 
    return
10549 
 
10550 
 
10551 
  def __repr__(self):
10552 
    L = ['%s=%r' % (key, value)
10553 
      for key, value in self.__dict__.iteritems()]
10554 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10555 
 
10556 
  def __eq__(self, other):
10557 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10558 
 
10559 
  def __ne__(self, other):
10560 
    return not (self == other)
10561 
 
10562 
class getBestSellers_result:
10563 
  """
10564 
  Attributes:
10565 
   - success
10566 
   - isex
10567 
  """
10568 
 
10569 
  thrift_spec = (
10570 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10571 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10572 
  )
10573 
 
10574 
  def __init__(self, success=None, isex=None,):
10575 
    self.success = success
10576 
    self.isex = isex
10577 
 
10578 
  def read(self, iprot):
10579 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10580 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10581 
      return
10582 
    iprot.readStructBegin()
10583 
    while True:
10584 
      (fname, ftype, fid) = iprot.readFieldBegin()
10585 
      if ftype == TType.STOP:
10586 
        break
10587 
      if fid == 0:
10588 
        if ftype == TType.LIST:
10589 
          self.success = []
8590 kshitij.so 10590 
          (_etype91, _size88) = iprot.readListBegin()
10591 
          for _i92 in xrange(_size88):
10592 
            _elem93 = Item()
10593 
            _elem93.read(iprot)
10594 
            self.success.append(_elem93)
5944 mandeep.dh 10595 
          iprot.readListEnd()
10596 
        else:
10597 
          iprot.skip(ftype)
10598 
      elif fid == 1:
10599 
        if ftype == TType.STRUCT:
10600 
          self.isex = CatalogServiceException()
10601 
          self.isex.read(iprot)
10602 
        else:
10603 
          iprot.skip(ftype)
10604 
      else:
10605 
        iprot.skip(ftype)
10606 
      iprot.readFieldEnd()
10607 
    iprot.readStructEnd()
10608 
 
10609 
  def write(self, oprot):
10610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10612 
      return
10613 
    oprot.writeStructBegin('getBestSellers_result')
10614 
    if self.success is not None:
10615 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10616 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10617 
      for iter94 in self.success:
10618 
        iter94.write(oprot)
5944 mandeep.dh 10619 
      oprot.writeListEnd()
10620 
      oprot.writeFieldEnd()
10621 
    if self.isex is not None:
10622 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
10623 
      self.isex.write(oprot)
10624 
      oprot.writeFieldEnd()
10625 
    oprot.writeFieldStop()
10626 
    oprot.writeStructEnd()
10627 
 
10628 
  def validate(self):
10629 
    return
10630 
 
10631 
 
10632 
  def __repr__(self):
10633 
    L = ['%s=%r' % (key, value)
10634 
      for key, value in self.__dict__.iteritems()]
10635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10636 
 
10637 
  def __eq__(self, other):
10638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10639 
 
10640 
  def __ne__(self, other):
10641 
    return not (self == other)
10642 
 
10643 
class getBestSellersCatalogIds_args:
10644 
  """
10645 
  Attributes:
10646 
   - beginIndex
10647 
   - totalItems
10648 
   - brand
10649 
   - category
10650 
  """
10651 
 
10652 
  thrift_spec = (
10653 
    None, # 0
10654 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
10655 
    (2, TType.I64, 'totalItems', None, None, ), # 2
10656 
    (3, TType.STRING, 'brand', None, None, ), # 3
10657 
    (4, TType.I64, 'category', None, None, ), # 4
10658 
  )
10659 
 
10660 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
10661 
    self.beginIndex = beginIndex
10662 
    self.totalItems = totalItems
10663 
    self.brand = brand
10664 
    self.category = category
10665 
 
10666 
  def read(self, iprot):
10667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10669 
      return
10670 
    iprot.readStructBegin()
10671 
    while True:
10672 
      (fname, ftype, fid) = iprot.readFieldBegin()
10673 
      if ftype == TType.STOP:
10674 
        break
10675 
      if fid == 1:
10676 
        if ftype == TType.I64:
10677 
          self.beginIndex = iprot.readI64();
10678 
        else:
10679 
          iprot.skip(ftype)
10680 
      elif fid == 2:
10681 
        if ftype == TType.I64:
10682 
          self.totalItems = iprot.readI64();
10683 
        else:
10684 
          iprot.skip(ftype)
10685 
      elif fid == 3:
10686 
        if ftype == TType.STRING:
10687 
          self.brand = iprot.readString();
10688 
        else:
10689 
          iprot.skip(ftype)
10690 
      elif fid == 4:
10691 
        if ftype == TType.I64:
10692 
          self.category = iprot.readI64();
10693 
        else:
10694 
          iprot.skip(ftype)
10695 
      else:
10696 
        iprot.skip(ftype)
10697 
      iprot.readFieldEnd()
10698 
    iprot.readStructEnd()
10699 
 
10700 
  def write(self, oprot):
10701 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10702 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10703 
      return
10704 
    oprot.writeStructBegin('getBestSellersCatalogIds_args')
10705 
    if self.beginIndex is not None:
10706 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
10707 
      oprot.writeI64(self.beginIndex)
10708 
      oprot.writeFieldEnd()
10709 
    if self.totalItems is not None:
10710 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
10711 
      oprot.writeI64(self.totalItems)
10712 
      oprot.writeFieldEnd()
10713 
    if self.brand is not None:
10714 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
10715 
      oprot.writeString(self.brand)
10716 
      oprot.writeFieldEnd()
10717 
    if self.category is not None:
10718 
      oprot.writeFieldBegin('category', TType.I64, 4)
10719 
      oprot.writeI64(self.category)
10720 
      oprot.writeFieldEnd()
10721 
    oprot.writeFieldStop()
10722 
    oprot.writeStructEnd()
10723 
 
10724 
  def validate(self):
10725 
    return
10726 
 
10727 
 
10728 
  def __repr__(self):
10729 
    L = ['%s=%r' % (key, value)
10730 
      for key, value in self.__dict__.iteritems()]
10731 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10732 
 
10733 
  def __eq__(self, other):
10734 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10735 
 
10736 
  def __ne__(self, other):
10737 
    return not (self == other)
10738 
 
10739 
class getBestSellersCatalogIds_result:
10740 
  """
10741 
  Attributes:
10742 
   - success
10743 
   - cex
10744 
  """
10745 
 
10746 
  thrift_spec = (
10747 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10748 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10749 
  )
10750 
 
10751 
  def __init__(self, success=None, cex=None,):
10752 
    self.success = success
10753 
    self.cex = cex
10754 
 
10755 
  def read(self, iprot):
10756 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10757 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10758 
      return
10759 
    iprot.readStructBegin()
10760 
    while True:
10761 
      (fname, ftype, fid) = iprot.readFieldBegin()
10762 
      if ftype == TType.STOP:
10763 
        break
10764 
      if fid == 0:
10765 
        if ftype == TType.LIST:
10766 
          self.success = []
8590 kshitij.so 10767 
          (_etype98, _size95) = iprot.readListBegin()
10768 
          for _i99 in xrange(_size95):
10769 
            _elem100 = iprot.readI64();
10770 
            self.success.append(_elem100)
5944 mandeep.dh 10771 
          iprot.readListEnd()
10772 
        else:
10773 
          iprot.skip(ftype)
10774 
      elif fid == 1:
10775 
        if ftype == TType.STRUCT:
10776 
          self.cex = CatalogServiceException()
10777 
          self.cex.read(iprot)
10778 
        else:
10779 
          iprot.skip(ftype)
10780 
      else:
10781 
        iprot.skip(ftype)
10782 
      iprot.readFieldEnd()
10783 
    iprot.readStructEnd()
10784 
 
10785 
  def write(self, oprot):
10786 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10787 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10788 
      return
10789 
    oprot.writeStructBegin('getBestSellersCatalogIds_result')
10790 
    if self.success is not None:
10791 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10792 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 10793 
      for iter101 in self.success:
10794 
        oprot.writeI64(iter101)
5944 mandeep.dh 10795 
      oprot.writeListEnd()
10796 
      oprot.writeFieldEnd()
10797 
    if self.cex is not None:
10798 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10799 
      self.cex.write(oprot)
10800 
      oprot.writeFieldEnd()
10801 
    oprot.writeFieldStop()
10802 
    oprot.writeStructEnd()
10803 
 
10804 
  def validate(self):
10805 
    return
10806 
 
10807 
 
10808 
  def __repr__(self):
10809 
    L = ['%s=%r' % (key, value)
10810 
      for key, value in self.__dict__.iteritems()]
10811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10812 
 
10813 
  def __eq__(self, other):
10814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10815 
 
10816 
  def __ne__(self, other):
10817 
    return not (self == other)
10818 
 
10819 
class getBestSellersCount_args:
10820 
 
10821 
  thrift_spec = (
10822 
  )
10823 
 
10824 
  def read(self, iprot):
10825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10827 
      return
10828 
    iprot.readStructBegin()
10829 
    while True:
10830 
      (fname, ftype, fid) = iprot.readFieldBegin()
10831 
      if ftype == TType.STOP:
10832 
        break
10833 
      else:
10834 
        iprot.skip(ftype)
10835 
      iprot.readFieldEnd()
10836 
    iprot.readStructEnd()
10837 
 
10838 
  def write(self, oprot):
10839 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10840 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10841 
      return
10842 
    oprot.writeStructBegin('getBestSellersCount_args')
10843 
    oprot.writeFieldStop()
10844 
    oprot.writeStructEnd()
10845 
 
10846 
  def validate(self):
10847 
    return
10848 
 
10849 
 
10850 
  def __repr__(self):
10851 
    L = ['%s=%r' % (key, value)
10852 
      for key, value in self.__dict__.iteritems()]
10853 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10854 
 
10855 
  def __eq__(self, other):
10856 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10857 
 
10858 
  def __ne__(self, other):
10859 
    return not (self == other)
10860 
 
10861 
class getBestSellersCount_result:
10862 
  """
10863 
  Attributes:
10864 
   - success
10865 
   - cex
10866 
  """
10867 
 
10868 
  thrift_spec = (
10869 
    (0, TType.I64, 'success', None, None, ), # 0
10870 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10871 
  )
10872 
 
10873 
  def __init__(self, success=None, cex=None,):
10874 
    self.success = success
10875 
    self.cex = cex
10876 
 
10877 
  def read(self, iprot):
10878 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10879 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10880 
      return
10881 
    iprot.readStructBegin()
10882 
    while True:
10883 
      (fname, ftype, fid) = iprot.readFieldBegin()
10884 
      if ftype == TType.STOP:
10885 
        break
10886 
      if fid == 0:
10887 
        if ftype == TType.I64:
10888 
          self.success = iprot.readI64();
10889 
        else:
10890 
          iprot.skip(ftype)
10891 
      elif fid == 1:
10892 
        if ftype == TType.STRUCT:
10893 
          self.cex = CatalogServiceException()
10894 
          self.cex.read(iprot)
10895 
        else:
10896 
          iprot.skip(ftype)
10897 
      else:
10898 
        iprot.skip(ftype)
10899 
      iprot.readFieldEnd()
10900 
    iprot.readStructEnd()
10901 
 
10902 
  def write(self, oprot):
10903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10905 
      return
10906 
    oprot.writeStructBegin('getBestSellersCount_result')
10907 
    if self.success is not None:
10908 
      oprot.writeFieldBegin('success', TType.I64, 0)
10909 
      oprot.writeI64(self.success)
10910 
      oprot.writeFieldEnd()
10911 
    if self.cex is not None:
10912 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10913 
      self.cex.write(oprot)
10914 
      oprot.writeFieldEnd()
10915 
    oprot.writeFieldStop()
10916 
    oprot.writeStructEnd()
10917 
 
10918 
  def validate(self):
10919 
    return
10920 
 
10921 
 
10922 
  def __repr__(self):
10923 
    L = ['%s=%r' % (key, value)
10924 
      for key, value in self.__dict__.iteritems()]
10925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10926 
 
10927 
  def __eq__(self, other):
10928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10929 
 
10930 
  def __ne__(self, other):
10931 
    return not (self == other)
10932 
 
10933 
class getBestDeals_args:
10934 
 
10935 
  thrift_spec = (
10936 
  )
10937 
 
10938 
  def read(self, iprot):
10939 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10940 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10941 
      return
10942 
    iprot.readStructBegin()
10943 
    while True:
10944 
      (fname, ftype, fid) = iprot.readFieldBegin()
10945 
      if ftype == TType.STOP:
10946 
        break
10947 
      else:
10948 
        iprot.skip(ftype)
10949 
      iprot.readFieldEnd()
10950 
    iprot.readStructEnd()
10951 
 
10952 
  def write(self, oprot):
10953 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10954 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10955 
      return
10956 
    oprot.writeStructBegin('getBestDeals_args')
10957 
    oprot.writeFieldStop()
10958 
    oprot.writeStructEnd()
10959 
 
10960 
  def validate(self):
10961 
    return
10962 
 
10963 
 
10964 
  def __repr__(self):
10965 
    L = ['%s=%r' % (key, value)
10966 
      for key, value in self.__dict__.iteritems()]
10967 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10968 
 
10969 
  def __eq__(self, other):
10970 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10971 
 
10972 
  def __ne__(self, other):
10973 
    return not (self == other)
10974 
 
10975 
class getBestDeals_result:
10976 
  """
10977 
  Attributes:
10978 
   - success
10979 
   - isex
10980 
  """
10981 
 
10982 
  thrift_spec = (
10983 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10984 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10985 
  )
10986 
 
10987 
  def __init__(self, success=None, isex=None,):
10988 
    self.success = success
10989 
    self.isex = isex
10990 
 
10991 
  def read(self, iprot):
10992 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10993 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10994 
      return
10995 
    iprot.readStructBegin()
10996 
    while True:
10997 
      (fname, ftype, fid) = iprot.readFieldBegin()
10998 
      if ftype == TType.STOP:
10999 
        break
11000 
      if fid == 0:
11001 
        if ftype == TType.LIST:
11002 
          self.success = []
8590 kshitij.so 11003 
          (_etype105, _size102) = iprot.readListBegin()
11004 
          for _i106 in xrange(_size102):
11005 
            _elem107 = Item()
11006 
            _elem107.read(iprot)
11007 
            self.success.append(_elem107)
5944 mandeep.dh 11008 
          iprot.readListEnd()
11009 
        else:
11010 
          iprot.skip(ftype)
11011 
      elif fid == 1:
11012 
        if ftype == TType.STRUCT:
11013 
          self.isex = CatalogServiceException()
11014 
          self.isex.read(iprot)
11015 
        else:
11016 
          iprot.skip(ftype)
11017 
      else:
11018 
        iprot.skip(ftype)
11019 
      iprot.readFieldEnd()
11020 
    iprot.readStructEnd()
11021 
 
11022 
  def write(self, oprot):
11023 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11024 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11025 
      return
11026 
    oprot.writeStructBegin('getBestDeals_result')
11027 
    if self.success is not None:
11028 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11029 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 11030 
      for iter108 in self.success:
11031 
        iter108.write(oprot)
5944 mandeep.dh 11032 
      oprot.writeListEnd()
11033 
      oprot.writeFieldEnd()
11034 
    if self.isex is not None:
11035 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
11036 
      self.isex.write(oprot)
11037 
      oprot.writeFieldEnd()
11038 
    oprot.writeFieldStop()
11039 
    oprot.writeStructEnd()
11040 
 
11041 
  def validate(self):
11042 
    return
11043 
 
11044 
 
11045 
  def __repr__(self):
11046 
    L = ['%s=%r' % (key, value)
11047 
      for key, value in self.__dict__.iteritems()]
11048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11049 
 
11050 
  def __eq__(self, other):
11051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11052 
 
11053 
  def __ne__(self, other):
11054 
    return not (self == other)
11055 
 
11056 
class getBestDealsCatalogIds_args:
11057 
  """
11058 
  Attributes:
11059 
   - beginIndex
11060 
   - totalItems
11061 
   - brand
11062 
   - category
11063 
  """
11064 
 
11065 
  thrift_spec = (
11066 
    None, # 0
11067 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
11068 
    (2, TType.I64, 'totalItems', None, None, ), # 2
11069 
    (3, TType.STRING, 'brand', None, None, ), # 3
11070 
    (4, TType.I64, 'category', None, None, ), # 4
11071 
  )
11072 
 
11073 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
11074 
    self.beginIndex = beginIndex
11075 
    self.totalItems = totalItems
11076 
    self.brand = brand
11077 
    self.category = category
11078 
 
11079 
  def read(self, iprot):
11080 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11081 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11082 
      return
11083 
    iprot.readStructBegin()
11084 
    while True:
11085 
      (fname, ftype, fid) = iprot.readFieldBegin()
11086 
      if ftype == TType.STOP:
11087 
        break
11088 
      if fid == 1:
11089 
        if ftype == TType.I64:
11090 
          self.beginIndex = iprot.readI64();
11091 
        else:
11092 
          iprot.skip(ftype)
11093 
      elif fid == 2:
11094 
        if ftype == TType.I64:
11095 
          self.totalItems = iprot.readI64();
11096 
        else:
11097 
          iprot.skip(ftype)
11098 
      elif fid == 3:
11099 
        if ftype == TType.STRING:
11100 
          self.brand = iprot.readString();
11101 
        else:
11102 
          iprot.skip(ftype)
11103 
      elif fid == 4:
11104 
        if ftype == TType.I64:
11105 
          self.category = iprot.readI64();
11106 
        else:
11107 
          iprot.skip(ftype)
11108 
      else:
11109 
        iprot.skip(ftype)
11110 
      iprot.readFieldEnd()
11111 
    iprot.readStructEnd()
11112 
 
11113 
  def write(self, oprot):
11114 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11115 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11116 
      return
11117 
    oprot.writeStructBegin('getBestDealsCatalogIds_args')
11118 
    if self.beginIndex is not None:
11119 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
11120 
      oprot.writeI64(self.beginIndex)
11121 
      oprot.writeFieldEnd()
11122 
    if self.totalItems is not None:
11123 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
11124 
      oprot.writeI64(self.totalItems)
11125 
      oprot.writeFieldEnd()
11126 
    if self.brand is not None:
11127 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
11128 
      oprot.writeString(self.brand)
11129 
      oprot.writeFieldEnd()
11130 
    if self.category is not None:
11131 
      oprot.writeFieldBegin('category', TType.I64, 4)
11132 
      oprot.writeI64(self.category)
11133 
      oprot.writeFieldEnd()
11134 
    oprot.writeFieldStop()
11135 
    oprot.writeStructEnd()
11136 
 
11137 
  def validate(self):
11138 
    return
11139 
 
11140 
 
11141 
  def __repr__(self):
11142 
    L = ['%s=%r' % (key, value)
11143 
      for key, value in self.__dict__.iteritems()]
11144 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11145 
 
11146 
  def __eq__(self, other):
11147 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11148 
 
11149 
  def __ne__(self, other):
11150 
    return not (self == other)
11151 
 
11152 
class getBestDealsCatalogIds_result:
11153 
  """
11154 
  Attributes:
11155 
   - success
11156 
   - cex
11157 
  """
11158 
 
11159 
  thrift_spec = (
11160 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11161 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11162 
  )
11163 
 
11164 
  def __init__(self, success=None, cex=None,):
11165 
    self.success = success
11166 
    self.cex = cex
11167 
 
11168 
  def read(self, iprot):
11169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11171 
      return
11172 
    iprot.readStructBegin()
11173 
    while True:
11174 
      (fname, ftype, fid) = iprot.readFieldBegin()
11175 
      if ftype == TType.STOP:
11176 
        break
11177 
      if fid == 0:
11178 
        if ftype == TType.LIST:
11179 
          self.success = []
8590 kshitij.so 11180 
          (_etype112, _size109) = iprot.readListBegin()
11181 
          for _i113 in xrange(_size109):
11182 
            _elem114 = iprot.readI64();
11183 
            self.success.append(_elem114)
5944 mandeep.dh 11184 
          iprot.readListEnd()
11185 
        else:
11186 
          iprot.skip(ftype)
11187 
      elif fid == 1:
11188 
        if ftype == TType.STRUCT:
11189 
          self.cex = CatalogServiceException()
11190 
          self.cex.read(iprot)
11191 
        else:
11192 
          iprot.skip(ftype)
11193 
      else:
11194 
        iprot.skip(ftype)
11195 
      iprot.readFieldEnd()
11196 
    iprot.readStructEnd()
11197 
 
11198 
  def write(self, oprot):
11199 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11200 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11201 
      return
11202 
    oprot.writeStructBegin('getBestDealsCatalogIds_result')
11203 
    if self.success is not None:
11204 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11205 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 11206 
      for iter115 in self.success:
11207 
        oprot.writeI64(iter115)
5944 mandeep.dh 11208 
      oprot.writeListEnd()
11209 
      oprot.writeFieldEnd()
11210 
    if self.cex is not None:
11211 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11212 
      self.cex.write(oprot)
11213 
      oprot.writeFieldEnd()
11214 
    oprot.writeFieldStop()
11215 
    oprot.writeStructEnd()
11216 
 
11217 
  def validate(self):
11218 
    return
11219 
 
11220 
 
11221 
  def __repr__(self):
11222 
    L = ['%s=%r' % (key, value)
11223 
      for key, value in self.__dict__.iteritems()]
11224 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11225 
 
11226 
  def __eq__(self, other):
11227 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11228 
 
11229 
  def __ne__(self, other):
11230 
    return not (self == other)
11231 
 
11232 
class getBestDealsCount_args:
11233 
 
11234 
  thrift_spec = (
11235 
  )
11236 
 
11237 
  def read(self, iprot):
11238 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11239 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11240 
      return
11241 
    iprot.readStructBegin()
11242 
    while True:
11243 
      (fname, ftype, fid) = iprot.readFieldBegin()
11244 
      if ftype == TType.STOP:
11245 
        break
11246 
      else:
11247 
        iprot.skip(ftype)
11248 
      iprot.readFieldEnd()
11249 
    iprot.readStructEnd()
11250 
 
11251 
  def write(self, oprot):
11252 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11253 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11254 
      return
11255 
    oprot.writeStructBegin('getBestDealsCount_args')
11256 
    oprot.writeFieldStop()
11257 
    oprot.writeStructEnd()
11258 
 
11259 
  def validate(self):
11260 
    return
11261 
 
11262 
 
11263 
  def __repr__(self):
11264 
    L = ['%s=%r' % (key, value)
11265 
      for key, value in self.__dict__.iteritems()]
11266 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11267 
 
11268 
  def __eq__(self, other):
11269 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11270 
 
11271 
  def __ne__(self, other):
11272 
    return not (self == other)
11273 
 
11274 
class getBestDealsCount_result:
11275 
  """
11276 
  Attributes:
11277 
   - success
11278 
   - cex
11279 
  """
11280 
 
11281 
  thrift_spec = (
11282 
    (0, TType.I64, 'success', None, None, ), # 0
11283 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11284 
  )
11285 
 
11286 
  def __init__(self, success=None, cex=None,):
11287 
    self.success = success
11288 
    self.cex = cex
11289 
 
11290 
  def read(self, iprot):
11291 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11292 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11293 
      return
11294 
    iprot.readStructBegin()
11295 
    while True:
11296 
      (fname, ftype, fid) = iprot.readFieldBegin()
11297 
      if ftype == TType.STOP:
11298 
        break
11299 
      if fid == 0:
11300 
        if ftype == TType.I64:
11301 
          self.success = iprot.readI64();
11302 
        else:
11303 
          iprot.skip(ftype)
11304 
      elif fid == 1:
11305 
        if ftype == TType.STRUCT:
11306 
          self.cex = CatalogServiceException()
11307 
          self.cex.read(iprot)
11308 
        else:
11309 
          iprot.skip(ftype)
11310 
      else:
11311 
        iprot.skip(ftype)
11312 
      iprot.readFieldEnd()
11313 
    iprot.readStructEnd()
11314 
 
11315 
  def write(self, oprot):
11316 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11317 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11318 
      return
11319 
    oprot.writeStructBegin('getBestDealsCount_result')
11320 
    if self.success is not None:
11321 
      oprot.writeFieldBegin('success', TType.I64, 0)
11322 
      oprot.writeI64(self.success)
11323 
      oprot.writeFieldEnd()
11324 
    if self.cex is not None:
11325 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11326 
      self.cex.write(oprot)
11327 
      oprot.writeFieldEnd()
11328 
    oprot.writeFieldStop()
11329 
    oprot.writeStructEnd()
11330 
 
11331 
  def validate(self):
11332 
    return
11333 
 
11334 
 
11335 
  def __repr__(self):
11336 
    L = ['%s=%r' % (key, value)
11337 
      for key, value in self.__dict__.iteritems()]
11338 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11339 
 
11340 
  def __eq__(self, other):
11341 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11342 
 
11343 
  def __ne__(self, other):
11344 
    return not (self == other)
11345 
 
11346 
class getComingSoon_args:
11347 
 
11348 
  thrift_spec = (
11349 
  )
11350 
 
11351 
  def read(self, iprot):
11352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11354 
      return
11355 
    iprot.readStructBegin()
11356 
    while True:
11357 
      (fname, ftype, fid) = iprot.readFieldBegin()
11358 
      if ftype == TType.STOP:
11359 
        break
11360 
      else:
11361 
        iprot.skip(ftype)
11362 
      iprot.readFieldEnd()
11363 
    iprot.readStructEnd()
11364 
 
11365 
  def write(self, oprot):
11366 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11367 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11368 
      return
11369 
    oprot.writeStructBegin('getComingSoon_args')
11370 
    oprot.writeFieldStop()
11371 
    oprot.writeStructEnd()
11372 
 
11373 
  def validate(self):
11374 
    return
11375 
 
11376 
 
11377 
  def __repr__(self):
11378 
    L = ['%s=%r' % (key, value)
11379 
      for key, value in self.__dict__.iteritems()]
11380 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11381 
 
11382 
  def __eq__(self, other):
11383 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11384 
 
11385 
  def __ne__(self, other):
11386 
    return not (self == other)
11387 
 
11388 
class getComingSoon_result:
11389 
  """
11390 
  Attributes:
11391 
   - success
11392 
   - isex
11393 
  """
11394 
 
11395 
  thrift_spec = (
11396 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11397 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11398 
  )
11399 
 
11400 
  def __init__(self, success=None, isex=None,):
11401 
    self.success = success
11402 
    self.isex = isex
11403 
 
11404 
  def read(self, iprot):
11405 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11406 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11407 
      return
11408 
    iprot.readStructBegin()
11409 
    while True:
11410 
      (fname, ftype, fid) = iprot.readFieldBegin()
11411 
      if ftype == TType.STOP:
11412 
        break
11413 
      if fid == 0:
11414 
        if ftype == TType.LIST:
11415 
          self.success = []
8590 kshitij.so 11416 
          (_etype119, _size116) = iprot.readListBegin()
11417 
          for _i120 in xrange(_size116):
11418 
            _elem121 = Item()
11419 
            _elem121.read(iprot)
11420 
            self.success.append(_elem121)
5944 mandeep.dh 11421 
          iprot.readListEnd()
11422 
        else:
11423 
          iprot.skip(ftype)
11424 
      elif fid == 1:
11425 
        if ftype == TType.STRUCT:
11426 
          self.isex = CatalogServiceException()
11427 
          self.isex.read(iprot)
11428 
        else:
11429 
          iprot.skip(ftype)
11430 
      else:
11431 
        iprot.skip(ftype)
11432 
      iprot.readFieldEnd()
11433 
    iprot.readStructEnd()
11434 
 
11435 
  def write(self, oprot):
11436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11438 
      return
11439 
    oprot.writeStructBegin('getComingSoon_result')
11440 
    if self.success is not None:
11441 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11442 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 11443 
      for iter122 in self.success:
11444 
        iter122.write(oprot)
5944 mandeep.dh 11445 
      oprot.writeListEnd()
11446 
      oprot.writeFieldEnd()
11447 
    if self.isex is not None:
11448 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
11449 
      self.isex.write(oprot)
11450 
      oprot.writeFieldEnd()
11451 
    oprot.writeFieldStop()
11452 
    oprot.writeStructEnd()
11453 
 
11454 
  def validate(self):
11455 
    return
11456 
 
11457 
 
11458 
  def __repr__(self):
11459 
    L = ['%s=%r' % (key, value)
11460 
      for key, value in self.__dict__.iteritems()]
11461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11462 
 
11463 
  def __eq__(self, other):
11464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11465 
 
11466 
  def __ne__(self, other):
11467 
    return not (self == other)
11468 
 
11469 
class getComingSoonCatalogIds_args:
11470 
  """
11471 
  Attributes:
11472 
   - beginIndex
11473 
   - totalItems
11474 
   - brand
11475 
   - category
11476 
  """
11477 
 
11478 
  thrift_spec = (
11479 
    None, # 0
11480 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
11481 
    (2, TType.I64, 'totalItems', None, None, ), # 2
11482 
    (3, TType.STRING, 'brand', None, None, ), # 3
11483 
    (4, TType.I64, 'category', None, None, ), # 4
11484 
  )
11485 
 
11486 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
11487 
    self.beginIndex = beginIndex
11488 
    self.totalItems = totalItems
11489 
    self.brand = brand
11490 
    self.category = category
11491 
 
11492 
  def read(self, iprot):
11493 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11494 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11495 
      return
11496 
    iprot.readStructBegin()
11497 
    while True:
11498 
      (fname, ftype, fid) = iprot.readFieldBegin()
11499 
      if ftype == TType.STOP:
11500 
        break
11501 
      if fid == 1:
11502 
        if ftype == TType.I64:
11503 
          self.beginIndex = iprot.readI64();
11504 
        else:
11505 
          iprot.skip(ftype)
11506 
      elif fid == 2:
11507 
        if ftype == TType.I64:
11508 
          self.totalItems = iprot.readI64();
11509 
        else:
11510 
          iprot.skip(ftype)
11511 
      elif fid == 3:
11512 
        if ftype == TType.STRING:
11513 
          self.brand = iprot.readString();
11514 
        else:
11515 
          iprot.skip(ftype)
11516 
      elif fid == 4:
11517 
        if ftype == TType.I64:
11518 
          self.category = iprot.readI64();
11519 
        else:
11520 
          iprot.skip(ftype)
11521 
      else:
11522 
        iprot.skip(ftype)
11523 
      iprot.readFieldEnd()
11524 
    iprot.readStructEnd()
11525 
 
11526 
  def write(self, oprot):
11527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11529 
      return
11530 
    oprot.writeStructBegin('getComingSoonCatalogIds_args')
11531 
    if self.beginIndex is not None:
11532 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
11533 
      oprot.writeI64(self.beginIndex)
11534 
      oprot.writeFieldEnd()
11535 
    if self.totalItems is not None:
11536 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
11537 
      oprot.writeI64(self.totalItems)
11538 
      oprot.writeFieldEnd()
11539 
    if self.brand is not None:
11540 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
11541 
      oprot.writeString(self.brand)
11542 
      oprot.writeFieldEnd()
11543 
    if self.category is not None:
11544 
      oprot.writeFieldBegin('category', TType.I64, 4)
11545 
      oprot.writeI64(self.category)
11546 
      oprot.writeFieldEnd()
11547 
    oprot.writeFieldStop()
11548 
    oprot.writeStructEnd()
11549 
 
11550 
  def validate(self):
11551 
    return
11552 
 
11553 
 
11554 
  def __repr__(self):
11555 
    L = ['%s=%r' % (key, value)
11556 
      for key, value in self.__dict__.iteritems()]
11557 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11558 
 
11559 
  def __eq__(self, other):
11560 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11561 
 
11562 
  def __ne__(self, other):
11563 
    return not (self == other)
11564 
 
11565 
class getComingSoonCatalogIds_result:
11566 
  """
11567 
  Attributes:
11568 
   - success
11569 
   - cex
11570 
  """
11571 
 
11572 
  thrift_spec = (
11573 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11574 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11575 
  )
11576 
 
11577 
  def __init__(self, success=None, cex=None,):
11578 
    self.success = success
11579 
    self.cex = cex
11580 
 
11581 
  def read(self, iprot):
11582 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11583 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11584 
      return
11585 
    iprot.readStructBegin()
11586 
    while True:
11587 
      (fname, ftype, fid) = iprot.readFieldBegin()
11588 
      if ftype == TType.STOP:
11589 
        break
11590 
      if fid == 0:
11591 
        if ftype == TType.LIST:
11592 
          self.success = []
8590 kshitij.so 11593 
          (_etype126, _size123) = iprot.readListBegin()
11594 
          for _i127 in xrange(_size123):
11595 
            _elem128 = iprot.readI64();
11596 
            self.success.append(_elem128)
5944 mandeep.dh 11597 
          iprot.readListEnd()
11598 
        else:
11599 
          iprot.skip(ftype)
11600 
      elif fid == 1:
11601 
        if ftype == TType.STRUCT:
11602 
          self.cex = CatalogServiceException()
11603 
          self.cex.read(iprot)
11604 
        else:
11605 
          iprot.skip(ftype)
11606 
      else:
11607 
        iprot.skip(ftype)
11608 
      iprot.readFieldEnd()
11609 
    iprot.readStructEnd()
11610 
 
11611 
  def write(self, oprot):
11612 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11613 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11614 
      return
11615 
    oprot.writeStructBegin('getComingSoonCatalogIds_result')
11616 
    if self.success is not None:
11617 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11618 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 11619 
      for iter129 in self.success:
11620 
        oprot.writeI64(iter129)
5944 mandeep.dh 11621 
      oprot.writeListEnd()
11622 
      oprot.writeFieldEnd()
11623 
    if self.cex is not None:
11624 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11625 
      self.cex.write(oprot)
11626 
      oprot.writeFieldEnd()
11627 
    oprot.writeFieldStop()
11628 
    oprot.writeStructEnd()
11629 
 
11630 
  def validate(self):
11631 
    return
11632 
 
11633 
 
11634 
  def __repr__(self):
11635 
    L = ['%s=%r' % (key, value)
11636 
      for key, value in self.__dict__.iteritems()]
11637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11638 
 
11639 
  def __eq__(self, other):
11640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11641 
 
11642 
  def __ne__(self, other):
11643 
    return not (self == other)
11644 
 
11645 
class getComingSoonCount_args:
11646 
 
11647 
  thrift_spec = (
11648 
  )
11649 
 
11650 
  def read(self, iprot):
11651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11653 
      return
11654 
    iprot.readStructBegin()
11655 
    while True:
11656 
      (fname, ftype, fid) = iprot.readFieldBegin()
11657 
      if ftype == TType.STOP:
11658 
        break
11659 
      else:
11660 
        iprot.skip(ftype)
11661 
      iprot.readFieldEnd()
11662 
    iprot.readStructEnd()
11663 
 
11664 
  def write(self, oprot):
11665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11667 
      return
11668 
    oprot.writeStructBegin('getComingSoonCount_args')
11669 
    oprot.writeFieldStop()
11670 
    oprot.writeStructEnd()
11671 
 
11672 
  def validate(self):
11673 
    return
11674 
 
11675 
 
11676 
  def __repr__(self):
11677 
    L = ['%s=%r' % (key, value)
11678 
      for key, value in self.__dict__.iteritems()]
11679 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11680 
 
11681 
  def __eq__(self, other):
11682 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11683 
 
11684 
  def __ne__(self, other):
11685 
    return not (self == other)
11686 
 
11687 
class getComingSoonCount_result:
11688 
  """
11689 
  Attributes:
11690 
   - success
11691 
   - cex
11692 
  """
11693 
 
11694 
  thrift_spec = (
11695 
    (0, TType.I64, 'success', None, None, ), # 0
11696 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11697 
  )
11698 
 
11699 
  def __init__(self, success=None, cex=None,):
11700 
    self.success = success
11701 
    self.cex = cex
11702 
 
11703 
  def read(self, iprot):
11704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11706 
      return
11707 
    iprot.readStructBegin()
11708 
    while True:
11709 
      (fname, ftype, fid) = iprot.readFieldBegin()
11710 
      if ftype == TType.STOP:
11711 
        break
11712 
      if fid == 0:
11713 
        if ftype == TType.I64:
11714 
          self.success = iprot.readI64();
11715 
        else:
11716 
          iprot.skip(ftype)
11717 
      elif fid == 1:
11718 
        if ftype == TType.STRUCT:
11719 
          self.cex = CatalogServiceException()
11720 
          self.cex.read(iprot)
11721 
        else:
11722 
          iprot.skip(ftype)
11723 
      else:
11724 
        iprot.skip(ftype)
11725 
      iprot.readFieldEnd()
11726 
    iprot.readStructEnd()
11727 
 
11728 
  def write(self, oprot):
11729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11731 
      return
11732 
    oprot.writeStructBegin('getComingSoonCount_result')
11733 
    if self.success is not None:
11734 
      oprot.writeFieldBegin('success', TType.I64, 0)
11735 
      oprot.writeI64(self.success)
11736 
      oprot.writeFieldEnd()
11737 
    if self.cex is not None:
11738 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11739 
      self.cex.write(oprot)
11740 
      oprot.writeFieldEnd()
11741 
    oprot.writeFieldStop()
11742 
    oprot.writeStructEnd()
11743 
 
11744 
  def validate(self):
11745 
    return
11746 
 
11747 
 
11748 
  def __repr__(self):
11749 
    L = ['%s=%r' % (key, value)
11750 
      for key, value in self.__dict__.iteritems()]
11751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11752 
 
11753 
  def __eq__(self, other):
11754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11755 
 
11756 
  def __ne__(self, other):
11757 
    return not (self == other)
11758 
 
11759 
class getLatestArrivals_args:
11760 
 
11761 
  thrift_spec = (
11762 
  )
11763 
 
11764 
  def read(self, iprot):
11765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11767 
      return
11768 
    iprot.readStructBegin()
11769 
    while True:
11770 
      (fname, ftype, fid) = iprot.readFieldBegin()
11771 
      if ftype == TType.STOP:
11772 
        break
11773 
      else:
11774 
        iprot.skip(ftype)
11775 
      iprot.readFieldEnd()
11776 
    iprot.readStructEnd()
11777 
 
11778 
  def write(self, oprot):
11779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11781 
      return
11782 
    oprot.writeStructBegin('getLatestArrivals_args')
11783 
    oprot.writeFieldStop()
11784 
    oprot.writeStructEnd()
11785 
 
11786 
  def validate(self):
11787 
    return
11788 
 
11789 
 
11790 
  def __repr__(self):
11791 
    L = ['%s=%r' % (key, value)
11792 
      for key, value in self.__dict__.iteritems()]
11793 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11794 
 
11795 
  def __eq__(self, other):
11796 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11797 
 
11798 
  def __ne__(self, other):
11799 
    return not (self == other)
11800 
 
11801 
class getLatestArrivals_result:
11802 
  """
11803 
  Attributes:
11804 
   - success
11805 
   - isex
11806 
  """
11807 
 
11808 
  thrift_spec = (
11809 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11810 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11811 
  )
11812 
 
11813 
  def __init__(self, success=None, isex=None,):
11814 
    self.success = success
11815 
    self.isex = isex
11816 
 
11817 
  def read(self, iprot):
11818 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11819 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11820 
      return
11821 
    iprot.readStructBegin()
11822 
    while True:
11823 
      (fname, ftype, fid) = iprot.readFieldBegin()
11824 
      if ftype == TType.STOP:
11825 
        break
11826 
      if fid == 0:
11827 
        if ftype == TType.LIST:
11828 
          self.success = []
8590 kshitij.so 11829 
          (_etype133, _size130) = iprot.readListBegin()
11830 
          for _i134 in xrange(_size130):
11831 
            _elem135 = Item()
11832 
            _elem135.read(iprot)
11833 
            self.success.append(_elem135)
5944 mandeep.dh 11834 
          iprot.readListEnd()
11835 
        else:
11836 
          iprot.skip(ftype)
11837 
      elif fid == 1:
11838 
        if ftype == TType.STRUCT:
11839 
          self.isex = CatalogServiceException()
11840 
          self.isex.read(iprot)
11841 
        else:
11842 
          iprot.skip(ftype)
11843 
      else:
11844 
        iprot.skip(ftype)
11845 
      iprot.readFieldEnd()
11846 
    iprot.readStructEnd()
11847 
 
11848 
  def write(self, oprot):
11849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11851 
      return
11852 
    oprot.writeStructBegin('getLatestArrivals_result')
11853 
    if self.success is not None:
11854 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11855 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 11856 
      for iter136 in self.success:
11857 
        iter136.write(oprot)
5944 mandeep.dh 11858 
      oprot.writeListEnd()
11859 
      oprot.writeFieldEnd()
11860 
    if self.isex is not None:
11861 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
11862 
      self.isex.write(oprot)
11863 
      oprot.writeFieldEnd()
11864 
    oprot.writeFieldStop()
11865 
    oprot.writeStructEnd()
11866 
 
11867 
  def validate(self):
11868 
    return
11869 
 
11870 
 
11871 
  def __repr__(self):
11872 
    L = ['%s=%r' % (key, value)
11873 
      for key, value in self.__dict__.iteritems()]
11874 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11875 
 
11876 
  def __eq__(self, other):
11877 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11878 
 
11879 
  def __ne__(self, other):
11880 
    return not (self == other)
11881 
 
11882 
class getLatestArrivalsCatalogIds_args:
11883 
  """
11884 
  Attributes:
11885 
   - beginIndex
11886 
   - totalItems
11887 
   - brand
11888 
   - categories
11889 
  """
11890 
 
11891 
  thrift_spec = (
11892 
    None, # 0
11893 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
11894 
    (2, TType.I64, 'totalItems', None, None, ), # 2
11895 
    (3, TType.STRING, 'brand', None, None, ), # 3
11896 
    (4, TType.LIST, 'categories', (TType.I64,None), None, ), # 4
11897 
  )
11898 
 
11899 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, categories=None,):
11900 
    self.beginIndex = beginIndex
11901 
    self.totalItems = totalItems
11902 
    self.brand = brand
11903 
    self.categories = categories
11904 
 
11905 
  def read(self, iprot):
11906 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11907 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11908 
      return
11909 
    iprot.readStructBegin()
11910 
    while True:
11911 
      (fname, ftype, fid) = iprot.readFieldBegin()
11912 
      if ftype == TType.STOP:
11913 
        break
11914 
      if fid == 1:
11915 
        if ftype == TType.I64:
11916 
          self.beginIndex = iprot.readI64();
11917 
        else:
11918 
          iprot.skip(ftype)
11919 
      elif fid == 2:
11920 
        if ftype == TType.I64:
11921 
          self.totalItems = iprot.readI64();
11922 
        else:
11923 
          iprot.skip(ftype)
11924 
      elif fid == 3:
11925 
        if ftype == TType.STRING:
11926 
          self.brand = iprot.readString();
11927 
        else:
11928 
          iprot.skip(ftype)
11929 
      elif fid == 4:
11930 
        if ftype == TType.LIST:
11931 
          self.categories = []
8590 kshitij.so 11932 
          (_etype140, _size137) = iprot.readListBegin()
11933 
          for _i141 in xrange(_size137):
11934 
            _elem142 = iprot.readI64();
11935 
            self.categories.append(_elem142)
5944 mandeep.dh 11936 
          iprot.readListEnd()
11937 
        else:
11938 
          iprot.skip(ftype)
11939 
      else:
11940 
        iprot.skip(ftype)
11941 
      iprot.readFieldEnd()
11942 
    iprot.readStructEnd()
11943 
 
11944 
  def write(self, oprot):
11945 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11946 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11947 
      return
11948 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_args')
11949 
    if self.beginIndex is not None:
11950 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
11951 
      oprot.writeI64(self.beginIndex)
11952 
      oprot.writeFieldEnd()
11953 
    if self.totalItems is not None:
11954 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
11955 
      oprot.writeI64(self.totalItems)
11956 
      oprot.writeFieldEnd()
11957 
    if self.brand is not None:
11958 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
11959 
      oprot.writeString(self.brand)
11960 
      oprot.writeFieldEnd()
11961 
    if self.categories is not None:
11962 
      oprot.writeFieldBegin('categories', TType.LIST, 4)
11963 
      oprot.writeListBegin(TType.I64, len(self.categories))
8590 kshitij.so 11964 
      for iter143 in self.categories:
11965 
        oprot.writeI64(iter143)
5944 mandeep.dh 11966 
      oprot.writeListEnd()
11967 
      oprot.writeFieldEnd()
11968 
    oprot.writeFieldStop()
11969 
    oprot.writeStructEnd()
11970 
 
11971 
  def validate(self):
11972 
    return
11973 
 
11974 
 
11975 
  def __repr__(self):
11976 
    L = ['%s=%r' % (key, value)
11977 
      for key, value in self.__dict__.iteritems()]
11978 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11979 
 
11980 
  def __eq__(self, other):
11981 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11982 
 
11983 
  def __ne__(self, other):
11984 
    return not (self == other)
11985 
 
11986 
class getLatestArrivalsCatalogIds_result:
11987 
  """
11988 
  Attributes:
11989 
   - success
11990 
   - cex
11991 
  """
11992 
 
11993 
  thrift_spec = (
11994 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11995 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11996 
  )
11997 
 
11998 
  def __init__(self, success=None, cex=None,):
11999 
    self.success = success
12000 
    self.cex = cex
12001 
 
12002 
  def read(self, iprot):
12003 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12004 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12005 
      return
12006 
    iprot.readStructBegin()
12007 
    while True:
12008 
      (fname, ftype, fid) = iprot.readFieldBegin()
12009 
      if ftype == TType.STOP:
12010 
        break
12011 
      if fid == 0:
12012 
        if ftype == TType.LIST:
12013 
          self.success = []
8590 kshitij.so 12014 
          (_etype147, _size144) = iprot.readListBegin()
12015 
          for _i148 in xrange(_size144):
12016 
            _elem149 = iprot.readI64();
12017 
            self.success.append(_elem149)
5944 mandeep.dh 12018 
          iprot.readListEnd()
12019 
        else:
12020 
          iprot.skip(ftype)
12021 
      elif fid == 1:
12022 
        if ftype == TType.STRUCT:
12023 
          self.cex = CatalogServiceException()
12024 
          self.cex.read(iprot)
12025 
        else:
12026 
          iprot.skip(ftype)
12027 
      else:
12028 
        iprot.skip(ftype)
12029 
      iprot.readFieldEnd()
12030 
    iprot.readStructEnd()
12031 
 
12032 
  def write(self, oprot):
12033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12035 
      return
12036 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_result')
12037 
    if self.success is not None:
12038 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12039 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 12040 
      for iter150 in self.success:
12041 
        oprot.writeI64(iter150)
5944 mandeep.dh 12042 
      oprot.writeListEnd()
12043 
      oprot.writeFieldEnd()
12044 
    if self.cex is not None:
12045 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
12046 
      self.cex.write(oprot)
12047 
      oprot.writeFieldEnd()
12048 
    oprot.writeFieldStop()
12049 
    oprot.writeStructEnd()
12050 
 
12051 
  def validate(self):
12052 
    return
12053 
 
12054 
 
12055 
  def __repr__(self):
12056 
    L = ['%s=%r' % (key, value)
12057 
      for key, value in self.__dict__.iteritems()]
12058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12059 
 
12060 
  def __eq__(self, other):
12061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12062 
 
12063 
  def __ne__(self, other):
12064 
    return not (self == other)
12065 
 
12066 
class getLatestArrivalsCount_args:
12067 
 
12068 
  thrift_spec = (
12069 
  )
12070 
 
12071 
  def read(self, iprot):
12072 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12073 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12074 
      return
12075 
    iprot.readStructBegin()
12076 
    while True:
12077 
      (fname, ftype, fid) = iprot.readFieldBegin()
12078 
      if ftype == TType.STOP:
12079 
        break
12080 
      else:
12081 
        iprot.skip(ftype)
12082 
      iprot.readFieldEnd()
12083 
    iprot.readStructEnd()
12084 
 
12085 
  def write(self, oprot):
12086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12088 
      return
12089 
    oprot.writeStructBegin('getLatestArrivalsCount_args')
12090 
    oprot.writeFieldStop()
12091 
    oprot.writeStructEnd()
12092 
 
12093 
  def validate(self):
12094 
    return
12095 
 
12096 
 
12097 
  def __repr__(self):
12098 
    L = ['%s=%r' % (key, value)
12099 
      for key, value in self.__dict__.iteritems()]
12100 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12101 
 
12102 
  def __eq__(self, other):
12103 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12104 
 
12105 
  def __ne__(self, other):
12106 
    return not (self == other)
12107 
 
12108 
class getLatestArrivalsCount_result:
12109 
  """
12110 
  Attributes:
12111 
   - success
12112 
   - cex
12113 
  """
12114 
 
12115 
  thrift_spec = (
12116 
    (0, TType.I64, 'success', None, None, ), # 0
12117 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12118 
  )
12119 
 
12120 
  def __init__(self, success=None, cex=None,):
12121 
    self.success = success
12122 
    self.cex = cex
12123 
 
12124 
  def read(self, iprot):
12125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12127 
      return
12128 
    iprot.readStructBegin()
12129 
    while True:
12130 
      (fname, ftype, fid) = iprot.readFieldBegin()
12131 
      if ftype == TType.STOP:
12132 
        break
12133 
      if fid == 0:
12134 
        if ftype == TType.I64:
12135 
          self.success = iprot.readI64();
12136 
        else:
12137 
          iprot.skip(ftype)
12138 
      elif fid == 1:
12139 
        if ftype == TType.STRUCT:
12140 
          self.cex = CatalogServiceException()
12141 
          self.cex.read(iprot)
12142 
        else:
12143 
          iprot.skip(ftype)
12144 
      else:
12145 
        iprot.skip(ftype)
12146 
      iprot.readFieldEnd()
12147 
    iprot.readStructEnd()
12148 
 
12149 
  def write(self, oprot):
12150 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12151 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12152 
      return
12153 
    oprot.writeStructBegin('getLatestArrivalsCount_result')
12154 
    if self.success is not None:
12155 
      oprot.writeFieldBegin('success', TType.I64, 0)
12156 
      oprot.writeI64(self.success)
12157 
      oprot.writeFieldEnd()
12158 
    if self.cex is not None:
12159 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
12160 
      self.cex.write(oprot)
12161 
      oprot.writeFieldEnd()
12162 
    oprot.writeFieldStop()
12163 
    oprot.writeStructEnd()
12164 
 
12165 
  def validate(self):
12166 
    return
12167 
 
12168 
 
12169 
  def __repr__(self):
12170 
    L = ['%s=%r' % (key, value)
12171 
      for key, value in self.__dict__.iteritems()]
12172 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12173 
 
12174 
  def __eq__(self, other):
12175 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12176 
 
12177 
  def __ne__(self, other):
12178 
    return not (self == other)
12179 
 
12180 
class generateNewEntityID_args:
12181 
 
12182 
  thrift_spec = (
12183 
  )
12184 
 
12185 
  def read(self, iprot):
12186 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12187 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12188 
      return
12189 
    iprot.readStructBegin()
12190 
    while True:
12191 
      (fname, ftype, fid) = iprot.readFieldBegin()
12192 
      if ftype == TType.STOP:
12193 
        break
12194 
      else:
12195 
        iprot.skip(ftype)
12196 
      iprot.readFieldEnd()
12197 
    iprot.readStructEnd()
12198 
 
12199 
  def write(self, oprot):
12200 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12201 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12202 
      return
12203 
    oprot.writeStructBegin('generateNewEntityID_args')
12204 
    oprot.writeFieldStop()
12205 
    oprot.writeStructEnd()
12206 
 
12207 
  def validate(self):
12208 
    return
12209 
 
12210 
 
12211 
  def __repr__(self):
12212 
    L = ['%s=%r' % (key, value)
12213 
      for key, value in self.__dict__.iteritems()]
12214 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12215 
 
12216 
  def __eq__(self, other):
12217 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12218 
 
12219 
  def __ne__(self, other):
12220 
    return not (self == other)
12221 
 
12222 
class generateNewEntityID_result:
12223 
  """
12224 
  Attributes:
12225 
   - success
12226 
  """
12227 
 
12228 
  thrift_spec = (
12229 
    (0, TType.I64, 'success', None, None, ), # 0
12230 
  )
12231 
 
12232 
  def __init__(self, success=None,):
12233 
    self.success = success
12234 
 
12235 
  def read(self, iprot):
12236 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12237 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12238 
      return
12239 
    iprot.readStructBegin()
12240 
    while True:
12241 
      (fname, ftype, fid) = iprot.readFieldBegin()
12242 
      if ftype == TType.STOP:
12243 
        break
12244 
      if fid == 0:
12245 
        if ftype == TType.I64:
12246 
          self.success = iprot.readI64();
12247 
        else:
12248 
          iprot.skip(ftype)
12249 
      else:
12250 
        iprot.skip(ftype)
12251 
      iprot.readFieldEnd()
12252 
    iprot.readStructEnd()
12253 
 
12254 
  def write(self, oprot):
12255 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12256 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12257 
      return
12258 
    oprot.writeStructBegin('generateNewEntityID_result')
12259 
    if self.success is not None:
12260 
      oprot.writeFieldBegin('success', TType.I64, 0)
12261 
      oprot.writeI64(self.success)
12262 
      oprot.writeFieldEnd()
12263 
    oprot.writeFieldStop()
12264 
    oprot.writeStructEnd()
12265 
 
12266 
  def validate(self):
12267 
    return
12268 
 
12269 
 
12270 
  def __repr__(self):
12271 
    L = ['%s=%r' % (key, value)
12272 
      for key, value in self.__dict__.iteritems()]
12273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12274 
 
12275 
  def __eq__(self, other):
12276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12277 
 
12278 
  def __ne__(self, other):
12279 
    return not (self == other)
12280 
 
12281 
class addCategory_args:
12282 
  """
12283 
  Attributes:
12284 
   - category
12285 
  """
12286 
 
12287 
  thrift_spec = (
12288 
    None, # 0
12289 
    (1, TType.STRUCT, 'category', (Category, Category.thrift_spec), None, ), # 1
12290 
  )
12291 
 
12292 
  def __init__(self, category=None,):
12293 
    self.category = category
12294 
 
12295 
  def read(self, iprot):
12296 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12297 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12298 
      return
12299 
    iprot.readStructBegin()
12300 
    while True:
12301 
      (fname, ftype, fid) = iprot.readFieldBegin()
12302 
      if ftype == TType.STOP:
12303 
        break
12304 
      if fid == 1:
12305 
        if ftype == TType.STRUCT:
12306 
          self.category = Category()
12307 
          self.category.read(iprot)
12308 
        else:
12309 
          iprot.skip(ftype)
12310 
      else:
12311 
        iprot.skip(ftype)
12312 
      iprot.readFieldEnd()
12313 
    iprot.readStructEnd()
12314 
 
12315 
  def write(self, oprot):
12316 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12317 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12318 
      return
12319 
    oprot.writeStructBegin('addCategory_args')
12320 
    if self.category is not None:
12321 
      oprot.writeFieldBegin('category', TType.STRUCT, 1)
12322 
      self.category.write(oprot)
12323 
      oprot.writeFieldEnd()
12324 
    oprot.writeFieldStop()
12325 
    oprot.writeStructEnd()
12326 
 
12327 
  def validate(self):
12328 
    return
12329 
 
12330 
 
12331 
  def __repr__(self):
12332 
    L = ['%s=%r' % (key, value)
12333 
      for key, value in self.__dict__.iteritems()]
12334 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12335 
 
12336 
  def __eq__(self, other):
12337 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12338 
 
12339 
  def __ne__(self, other):
12340 
    return not (self == other)
12341 
 
12342 
class addCategory_result:
12343 
  """
12344 
  Attributes:
12345 
   - success
12346 
  """
12347 
 
12348 
  thrift_spec = (
12349 
    (0, TType.BOOL, 'success', None, None, ), # 0
12350 
  )
12351 
 
12352 
  def __init__(self, success=None,):
12353 
    self.success = success
12354 
 
12355 
  def read(self, iprot):
12356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12358 
      return
12359 
    iprot.readStructBegin()
12360 
    while True:
12361 
      (fname, ftype, fid) = iprot.readFieldBegin()
12362 
      if ftype == TType.STOP:
12363 
        break
12364 
      if fid == 0:
12365 
        if ftype == TType.BOOL:
12366 
          self.success = iprot.readBool();
12367 
        else:
12368 
          iprot.skip(ftype)
12369 
      else:
12370 
        iprot.skip(ftype)
12371 
      iprot.readFieldEnd()
12372 
    iprot.readStructEnd()
12373 
 
12374 
  def write(self, oprot):
12375 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12376 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12377 
      return
12378 
    oprot.writeStructBegin('addCategory_result')
12379 
    if self.success is not None:
12380 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12381 
      oprot.writeBool(self.success)
12382 
      oprot.writeFieldEnd()
12383 
    oprot.writeFieldStop()
12384 
    oprot.writeStructEnd()
12385 
 
12386 
  def validate(self):
12387 
    return
12388 
 
12389 
 
12390 
  def __repr__(self):
12391 
    L = ['%s=%r' % (key, value)
12392 
      for key, value in self.__dict__.iteritems()]
12393 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12394 
 
12395 
  def __eq__(self, other):
12396 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12397 
 
12398 
  def __ne__(self, other):
12399 
    return not (self == other)
12400 
 
12401 
class getCategory_args:
12402 
  """
12403 
  Attributes:
12404 
   - id
12405 
  """
12406 
 
12407 
  thrift_spec = (
12408 
    None, # 0
12409 
    (1, TType.I64, 'id', None, None, ), # 1
12410 
  )
12411 
 
12412 
  def __init__(self, id=None,):
12413 
    self.id = id
12414 
 
12415 
  def read(self, iprot):
12416 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12417 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12418 
      return
12419 
    iprot.readStructBegin()
12420 
    while True:
12421 
      (fname, ftype, fid) = iprot.readFieldBegin()
12422 
      if ftype == TType.STOP:
12423 
        break
12424 
      if fid == 1:
12425 
        if ftype == TType.I64:
12426 
          self.id = iprot.readI64();
12427 
        else:
12428 
          iprot.skip(ftype)
12429 
      else:
12430 
        iprot.skip(ftype)
12431 
      iprot.readFieldEnd()
12432 
    iprot.readStructEnd()
12433 
 
12434 
  def write(self, oprot):
12435 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12436 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12437 
      return
12438 
    oprot.writeStructBegin('getCategory_args')
12439 
    if self.id is not None:
12440 
      oprot.writeFieldBegin('id', TType.I64, 1)
12441 
      oprot.writeI64(self.id)
12442 
      oprot.writeFieldEnd()
12443 
    oprot.writeFieldStop()
12444 
    oprot.writeStructEnd()
12445 
 
12446 
  def validate(self):
12447 
    return
12448 
 
12449 
 
12450 
  def __repr__(self):
12451 
    L = ['%s=%r' % (key, value)
12452 
      for key, value in self.__dict__.iteritems()]
12453 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12454 
 
12455 
  def __eq__(self, other):
12456 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12457 
 
12458 
  def __ne__(self, other):
12459 
    return not (self == other)
12460 
 
12461 
class getCategory_result:
12462 
  """
12463 
  Attributes:
12464 
   - success
12465 
  """
12466 
 
12467 
  thrift_spec = (
12468 
    (0, TType.STRUCT, 'success', (Category, Category.thrift_spec), None, ), # 0
12469 
  )
12470 
 
12471 
  def __init__(self, success=None,):
12472 
    self.success = success
12473 
 
12474 
  def read(self, iprot):
12475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12477 
      return
12478 
    iprot.readStructBegin()
12479 
    while True:
12480 
      (fname, ftype, fid) = iprot.readFieldBegin()
12481 
      if ftype == TType.STOP:
12482 
        break
12483 
      if fid == 0:
12484 
        if ftype == TType.STRUCT:
12485 
          self.success = Category()
12486 
          self.success.read(iprot)
12487 
        else:
12488 
          iprot.skip(ftype)
12489 
      else:
12490 
        iprot.skip(ftype)
12491 
      iprot.readFieldEnd()
12492 
    iprot.readStructEnd()
12493 
 
12494 
  def write(self, oprot):
12495 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12496 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12497 
      return
12498 
    oprot.writeStructBegin('getCategory_result')
12499 
    if self.success is not None:
12500 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12501 
      self.success.write(oprot)
12502 
      oprot.writeFieldEnd()
12503 
    oprot.writeFieldStop()
12504 
    oprot.writeStructEnd()
12505 
 
12506 
  def validate(self):
12507 
    return
12508 
 
12509 
 
12510 
  def __repr__(self):
12511 
    L = ['%s=%r' % (key, value)
12512 
      for key, value in self.__dict__.iteritems()]
12513 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12514 
 
12515 
  def __eq__(self, other):
12516 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12517 
 
12518 
  def __ne__(self, other):
12519 
    return not (self == other)
12520 
 
12521 
class getAllCategories_args:
12522 
 
12523 
  thrift_spec = (
12524 
  )
12525 
 
12526 
  def read(self, iprot):
12527 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12528 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12529 
      return
12530 
    iprot.readStructBegin()
12531 
    while True:
12532 
      (fname, ftype, fid) = iprot.readFieldBegin()
12533 
      if ftype == TType.STOP:
12534 
        break
12535 
      else:
12536 
        iprot.skip(ftype)
12537 
      iprot.readFieldEnd()
12538 
    iprot.readStructEnd()
12539 
 
12540 
  def write(self, oprot):
12541 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12542 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12543 
      return
12544 
    oprot.writeStructBegin('getAllCategories_args')
12545 
    oprot.writeFieldStop()
12546 
    oprot.writeStructEnd()
12547 
 
12548 
  def validate(self):
12549 
    return
12550 
 
12551 
 
12552 
  def __repr__(self):
12553 
    L = ['%s=%r' % (key, value)
12554 
      for key, value in self.__dict__.iteritems()]
12555 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12556 
 
12557 
  def __eq__(self, other):
12558 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12559 
 
12560 
  def __ne__(self, other):
12561 
    return not (self == other)
12562 
 
12563 
class getAllCategories_result:
12564 
  """
12565 
  Attributes:
12566 
   - success
12567 
  """
12568 
 
12569 
  thrift_spec = (
12570 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
12571 
  )
12572 
 
12573 
  def __init__(self, success=None,):
12574 
    self.success = success
12575 
 
12576 
  def read(self, iprot):
12577 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12578 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12579 
      return
12580 
    iprot.readStructBegin()
12581 
    while True:
12582 
      (fname, ftype, fid) = iprot.readFieldBegin()
12583 
      if ftype == TType.STOP:
12584 
        break
12585 
      if fid == 0:
12586 
        if ftype == TType.LIST:
12587 
          self.success = []
8590 kshitij.so 12588 
          (_etype154, _size151) = iprot.readListBegin()
12589 
          for _i155 in xrange(_size151):
12590 
            _elem156 = Category()
12591 
            _elem156.read(iprot)
12592 
            self.success.append(_elem156)
5944 mandeep.dh 12593 
          iprot.readListEnd()
12594 
        else:
12595 
          iprot.skip(ftype)
12596 
      else:
12597 
        iprot.skip(ftype)
12598 
      iprot.readFieldEnd()
12599 
    iprot.readStructEnd()
12600 
 
12601 
  def write(self, oprot):
12602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12604 
      return
12605 
    oprot.writeStructBegin('getAllCategories_result')
12606 
    if self.success is not None:
12607 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12608 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 12609 
      for iter157 in self.success:
12610 
        iter157.write(oprot)
5944 mandeep.dh 12611 
      oprot.writeListEnd()
12612 
      oprot.writeFieldEnd()
12613 
    oprot.writeFieldStop()
12614 
    oprot.writeStructEnd()
12615 
 
12616 
  def validate(self):
12617 
    return
12618 
 
12619 
 
12620 
  def __repr__(self):
12621 
    L = ['%s=%r' % (key, value)
12622 
      for key, value in self.__dict__.iteritems()]
12623 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12624 
 
12625 
  def __eq__(self, other):
12626 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12627 
 
12628 
  def __ne__(self, other):
12629 
    return not (self == other)
12630 
 
12631 
class getAllSimilarItems_args:
12632 
  """
12633 
  Attributes:
12634 
   - itemId
12635 
  """
12636 
 
12637 
  thrift_spec = (
12638 
    None, # 0
12639 
    (1, TType.I64, 'itemId', None, None, ), # 1
12640 
  )
12641 
 
12642 
  def __init__(self, itemId=None,):
12643 
    self.itemId = itemId
12644 
 
12645 
  def read(self, iprot):
12646 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12647 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12648 
      return
12649 
    iprot.readStructBegin()
12650 
    while True:
12651 
      (fname, ftype, fid) = iprot.readFieldBegin()
12652 
      if ftype == TType.STOP:
12653 
        break
12654 
      if fid == 1:
12655 
        if ftype == TType.I64:
12656 
          self.itemId = iprot.readI64();
12657 
        else:
12658 
          iprot.skip(ftype)
12659 
      else:
12660 
        iprot.skip(ftype)
12661 
      iprot.readFieldEnd()
12662 
    iprot.readStructEnd()
12663 
 
12664 
  def write(self, oprot):
12665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12667 
      return
12668 
    oprot.writeStructBegin('getAllSimilarItems_args')
12669 
    if self.itemId is not None:
12670 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12671 
      oprot.writeI64(self.itemId)
12672 
      oprot.writeFieldEnd()
12673 
    oprot.writeFieldStop()
12674 
    oprot.writeStructEnd()
12675 
 
12676 
  def validate(self):
12677 
    return
12678 
 
12679 
 
12680 
  def __repr__(self):
12681 
    L = ['%s=%r' % (key, value)
12682 
      for key, value in self.__dict__.iteritems()]
12683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12684 
 
12685 
  def __eq__(self, other):
12686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12687 
 
12688 
  def __ne__(self, other):
12689 
    return not (self == other)
12690 
 
12691 
class getAllSimilarItems_result:
12692 
  """
12693 
  Attributes:
12694 
   - success
12695 
  """
12696 
 
12697 
  thrift_spec = (
12698 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12699 
  )
12700 
 
12701 
  def __init__(self, success=None,):
12702 
    self.success = success
12703 
 
12704 
  def read(self, iprot):
12705 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12706 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12707 
      return
12708 
    iprot.readStructBegin()
12709 
    while True:
12710 
      (fname, ftype, fid) = iprot.readFieldBegin()
12711 
      if ftype == TType.STOP:
12712 
        break
12713 
      if fid == 0:
12714 
        if ftype == TType.LIST:
12715 
          self.success = []
8590 kshitij.so 12716 
          (_etype161, _size158) = iprot.readListBegin()
12717 
          for _i162 in xrange(_size158):
12718 
            _elem163 = Item()
12719 
            _elem163.read(iprot)
12720 
            self.success.append(_elem163)
5944 mandeep.dh 12721 
          iprot.readListEnd()
12722 
        else:
12723 
          iprot.skip(ftype)
12724 
      else:
12725 
        iprot.skip(ftype)
12726 
      iprot.readFieldEnd()
12727 
    iprot.readStructEnd()
12728 
 
12729 
  def write(self, oprot):
12730 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12731 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12732 
      return
12733 
    oprot.writeStructBegin('getAllSimilarItems_result')
12734 
    if self.success is not None:
12735 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12736 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 12737 
      for iter164 in self.success:
12738 
        iter164.write(oprot)
5944 mandeep.dh 12739 
      oprot.writeListEnd()
12740 
      oprot.writeFieldEnd()
12741 
    oprot.writeFieldStop()
12742 
    oprot.writeStructEnd()
12743 
 
12744 
  def validate(self):
12745 
    return
12746 
 
12747 
 
12748 
  def __repr__(self):
12749 
    L = ['%s=%r' % (key, value)
12750 
      for key, value in self.__dict__.iteritems()]
12751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12752 
 
12753 
  def __eq__(self, other):
12754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12755 
 
12756 
  def __ne__(self, other):
12757 
    return not (self == other)
12758 
 
12759 
class addSimilarItem_args:
12760 
  """
12761 
  Attributes:
12762 
   - itemId
12763 
   - catalogItemId
12764 
  """
12765 
 
12766 
  thrift_spec = (
12767 
    None, # 0
12768 
    (1, TType.I64, 'itemId', None, None, ), # 1
12769 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
12770 
  )
12771 
 
12772 
  def __init__(self, itemId=None, catalogItemId=None,):
12773 
    self.itemId = itemId
12774 
    self.catalogItemId = catalogItemId
12775 
 
12776 
  def read(self, iprot):
12777 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12778 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12779 
      return
12780 
    iprot.readStructBegin()
12781 
    while True:
12782 
      (fname, ftype, fid) = iprot.readFieldBegin()
12783 
      if ftype == TType.STOP:
12784 
        break
12785 
      if fid == 1:
12786 
        if ftype == TType.I64:
12787 
          self.itemId = iprot.readI64();
12788 
        else:
12789 
          iprot.skip(ftype)
12790 
      elif fid == 2:
12791 
        if ftype == TType.I64:
12792 
          self.catalogItemId = iprot.readI64();
12793 
        else:
12794 
          iprot.skip(ftype)
12795 
      else:
12796 
        iprot.skip(ftype)
12797 
      iprot.readFieldEnd()
12798 
    iprot.readStructEnd()
12799 
 
12800 
  def write(self, oprot):
12801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12803 
      return
12804 
    oprot.writeStructBegin('addSimilarItem_args')
12805 
    if self.itemId is not None:
12806 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12807 
      oprot.writeI64(self.itemId)
12808 
      oprot.writeFieldEnd()
12809 
    if self.catalogItemId is not None:
12810 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
12811 
      oprot.writeI64(self.catalogItemId)
12812 
      oprot.writeFieldEnd()
12813 
    oprot.writeFieldStop()
12814 
    oprot.writeStructEnd()
12815 
 
12816 
  def validate(self):
12817 
    return
12818 
 
12819 
 
12820 
  def __repr__(self):
12821 
    L = ['%s=%r' % (key, value)
12822 
      for key, value in self.__dict__.iteritems()]
12823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12824 
 
12825 
  def __eq__(self, other):
12826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12827 
 
12828 
  def __ne__(self, other):
12829 
    return not (self == other)
12830 
 
12831 
class addSimilarItem_result:
12832 
  """
12833 
  Attributes:
12834 
   - success
12835 
   - cex
12836 
  """
12837 
 
12838 
  thrift_spec = (
12839 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
12840 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12841 
  )
12842 
 
12843 
  def __init__(self, success=None, cex=None,):
12844 
    self.success = success
12845 
    self.cex = cex
12846 
 
12847 
  def read(self, iprot):
12848 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12849 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12850 
      return
12851 
    iprot.readStructBegin()
12852 
    while True:
12853 
      (fname, ftype, fid) = iprot.readFieldBegin()
12854 
      if ftype == TType.STOP:
12855 
        break
12856 
      if fid == 0:
12857 
        if ftype == TType.STRUCT:
12858 
          self.success = Item()
12859 
          self.success.read(iprot)
12860 
        else:
12861 
          iprot.skip(ftype)
12862 
      elif fid == 1:
12863 
        if ftype == TType.STRUCT:
12864 
          self.cex = CatalogServiceException()
12865 
          self.cex.read(iprot)
12866 
        else:
12867 
          iprot.skip(ftype)
12868 
      else:
12869 
        iprot.skip(ftype)
12870 
      iprot.readFieldEnd()
12871 
    iprot.readStructEnd()
12872 
 
12873 
  def write(self, oprot):
12874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12876 
      return
12877 
    oprot.writeStructBegin('addSimilarItem_result')
12878 
    if self.success is not None:
12879 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12880 
      self.success.write(oprot)
12881 
      oprot.writeFieldEnd()
12882 
    if self.cex is not None:
12883 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
12884 
      self.cex.write(oprot)
12885 
      oprot.writeFieldEnd()
12886 
    oprot.writeFieldStop()
12887 
    oprot.writeStructEnd()
12888 
 
12889 
  def validate(self):
12890 
    return
12891 
 
12892 
 
12893 
  def __repr__(self):
12894 
    L = ['%s=%r' % (key, value)
12895 
      for key, value in self.__dict__.iteritems()]
12896 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12897 
 
12898 
  def __eq__(self, other):
12899 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12900 
 
12901 
  def __ne__(self, other):
12902 
    return not (self == other)
12903 
 
6512 kshitij.so 12904 
class addTag_args:
12905 
  """
12906 
  Attributes:
12907 
   - displayName
12908 
   - itemId
12909 
  """
12910 
 
12911 
  thrift_spec = (
12912 
    None, # 0
12913 
    (1, TType.STRING, 'displayName', None, None, ), # 1
12914 
    (2, TType.I64, 'itemId', None, None, ), # 2
12915 
  )
12916 
 
12917 
  def __init__(self, displayName=None, itemId=None,):
12918 
    self.displayName = displayName
12919 
    self.itemId = itemId
12920 
 
12921 
  def read(self, iprot):
12922 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12923 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12924 
      return
12925 
    iprot.readStructBegin()
12926 
    while True:
12927 
      (fname, ftype, fid) = iprot.readFieldBegin()
12928 
      if ftype == TType.STOP:
12929 
        break
12930 
      if fid == 1:
12931 
        if ftype == TType.STRING:
12932 
          self.displayName = iprot.readString();
12933 
        else:
12934 
          iprot.skip(ftype)
12935 
      elif fid == 2:
12936 
        if ftype == TType.I64:
12937 
          self.itemId = iprot.readI64();
12938 
        else:
12939 
          iprot.skip(ftype)
12940 
      else:
12941 
        iprot.skip(ftype)
12942 
      iprot.readFieldEnd()
12943 
    iprot.readStructEnd()
12944 
 
12945 
  def write(self, oprot):
12946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12948 
      return
12949 
    oprot.writeStructBegin('addTag_args')
12950 
    if self.displayName is not None:
12951 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
12952 
      oprot.writeString(self.displayName)
12953 
      oprot.writeFieldEnd()
12954 
    if self.itemId is not None:
12955 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12956 
      oprot.writeI64(self.itemId)
12957 
      oprot.writeFieldEnd()
12958 
    oprot.writeFieldStop()
12959 
    oprot.writeStructEnd()
12960 
 
12961 
  def validate(self):
12962 
    return
12963 
 
12964 
 
12965 
  def __repr__(self):
12966 
    L = ['%s=%r' % (key, value)
12967 
      for key, value in self.__dict__.iteritems()]
12968 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12969 
 
12970 
  def __eq__(self, other):
12971 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12972 
 
12973 
  def __ne__(self, other):
12974 
    return not (self == other)
12975 
 
12976 
class addTag_result:
12977 
  """
12978 
  Attributes:
12979 
   - success
12980 
  """
12981 
 
12982 
  thrift_spec = (
12983 
    (0, TType.BOOL, 'success', None, None, ), # 0
12984 
  )
12985 
 
12986 
  def __init__(self, success=None,):
12987 
    self.success = success
12988 
 
12989 
  def read(self, iprot):
12990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12992 
      return
12993 
    iprot.readStructBegin()
12994 
    while True:
12995 
      (fname, ftype, fid) = iprot.readFieldBegin()
12996 
      if ftype == TType.STOP:
12997 
        break
12998 
      if fid == 0:
12999 
        if ftype == TType.BOOL:
13000 
          self.success = iprot.readBool();
13001 
        else:
13002 
          iprot.skip(ftype)
13003 
      else:
13004 
        iprot.skip(ftype)
13005 
      iprot.readFieldEnd()
13006 
    iprot.readStructEnd()
13007 
 
13008 
  def write(self, oprot):
13009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13011 
      return
13012 
    oprot.writeStructBegin('addTag_result')
13013 
    if self.success is not None:
13014 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13015 
      oprot.writeBool(self.success)
13016 
      oprot.writeFieldEnd()
13017 
    oprot.writeFieldStop()
13018 
    oprot.writeStructEnd()
13019 
 
13020 
  def validate(self):
13021 
    return
13022 
 
13023 
 
13024 
  def __repr__(self):
13025 
    L = ['%s=%r' % (key, value)
13026 
      for key, value in self.__dict__.iteritems()]
13027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13028 
 
13029 
  def __eq__(self, other):
13030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13031 
 
13032 
  def __ne__(self, other):
13033 
    return not (self == other)
13034 
 
13035 
class deleteEntityTag_args:
13036 
  """
13037 
  Attributes:
13038 
   - displayName
13039 
   - itemId
13040 
  """
13041 
 
13042 
  thrift_spec = (
13043 
    None, # 0
13044 
    (1, TType.STRING, 'displayName', None, None, ), # 1
13045 
    (2, TType.I64, 'itemId', None, None, ), # 2
13046 
  )
13047 
 
13048 
  def __init__(self, displayName=None, itemId=None,):
13049 
    self.displayName = displayName
13050 
    self.itemId = itemId
13051 
 
13052 
  def read(self, iprot):
13053 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13054 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13055 
      return
13056 
    iprot.readStructBegin()
13057 
    while True:
13058 
      (fname, ftype, fid) = iprot.readFieldBegin()
13059 
      if ftype == TType.STOP:
13060 
        break
13061 
      if fid == 1:
13062 
        if ftype == TType.STRING:
13063 
          self.displayName = iprot.readString();
13064 
        else:
13065 
          iprot.skip(ftype)
13066 
      elif fid == 2:
13067 
        if ftype == TType.I64:
13068 
          self.itemId = iprot.readI64();
13069 
        else:
13070 
          iprot.skip(ftype)
13071 
      else:
13072 
        iprot.skip(ftype)
13073 
      iprot.readFieldEnd()
13074 
    iprot.readStructEnd()
13075 
 
13076 
  def write(self, oprot):
13077 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13078 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13079 
      return
13080 
    oprot.writeStructBegin('deleteEntityTag_args')
13081 
    if self.displayName is not None:
13082 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
13083 
      oprot.writeString(self.displayName)
13084 
      oprot.writeFieldEnd()
13085 
    if self.itemId is not None:
13086 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
13087 
      oprot.writeI64(self.itemId)
13088 
      oprot.writeFieldEnd()
13089 
    oprot.writeFieldStop()
13090 
    oprot.writeStructEnd()
13091 
 
13092 
  def validate(self):
13093 
    return
13094 
 
13095 
 
13096 
  def __repr__(self):
13097 
    L = ['%s=%r' % (key, value)
13098 
      for key, value in self.__dict__.iteritems()]
13099 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13100 
 
13101 
  def __eq__(self, other):
13102 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13103 
 
13104 
  def __ne__(self, other):
13105 
    return not (self == other)
13106 
 
13107 
class deleteEntityTag_result:
13108 
  """
13109 
  Attributes:
13110 
   - success
13111 
  """
13112 
 
13113 
  thrift_spec = (
13114 
    (0, TType.BOOL, 'success', None, None, ), # 0
13115 
  )
13116 
 
13117 
  def __init__(self, success=None,):
13118 
    self.success = success
13119 
 
13120 
  def read(self, iprot):
13121 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13122 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13123 
      return
13124 
    iprot.readStructBegin()
13125 
    while True:
13126 
      (fname, ftype, fid) = iprot.readFieldBegin()
13127 
      if ftype == TType.STOP:
13128 
        break
13129 
      if fid == 0:
13130 
        if ftype == TType.BOOL:
13131 
          self.success = iprot.readBool();
13132 
        else:
13133 
          iprot.skip(ftype)
13134 
      else:
13135 
        iprot.skip(ftype)
13136 
      iprot.readFieldEnd()
13137 
    iprot.readStructEnd()
13138 
 
13139 
  def write(self, oprot):
13140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13142 
      return
13143 
    oprot.writeStructBegin('deleteEntityTag_result')
13144 
    if self.success is not None:
13145 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13146 
      oprot.writeBool(self.success)
13147 
      oprot.writeFieldEnd()
13148 
    oprot.writeFieldStop()
13149 
    oprot.writeStructEnd()
13150 
 
13151 
  def validate(self):
13152 
    return
13153 
 
13154 
 
13155 
  def __repr__(self):
13156 
    L = ['%s=%r' % (key, value)
13157 
      for key, value in self.__dict__.iteritems()]
13158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13159 
 
13160 
  def __eq__(self, other):
13161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13162 
 
13163 
  def __ne__(self, other):
13164 
    return not (self == other)
13165 
 
13166 
class deleteTag_args:
13167 
  """
13168 
  Attributes:
13169 
   - displayName
13170 
  """
13171 
 
13172 
  thrift_spec = (
13173 
    None, # 0
13174 
    (1, TType.STRING, 'displayName', None, None, ), # 1
13175 
  )
13176 
 
13177 
  def __init__(self, displayName=None,):
13178 
    self.displayName = displayName
13179 
 
13180 
  def read(self, iprot):
13181 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13182 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13183 
      return
13184 
    iprot.readStructBegin()
13185 
    while True:
13186 
      (fname, ftype, fid) = iprot.readFieldBegin()
13187 
      if ftype == TType.STOP:
13188 
        break
13189 
      if fid == 1:
13190 
        if ftype == TType.STRING:
13191 
          self.displayName = iprot.readString();
13192 
        else:
13193 
          iprot.skip(ftype)
13194 
      else:
13195 
        iprot.skip(ftype)
13196 
      iprot.readFieldEnd()
13197 
    iprot.readStructEnd()
13198 
 
13199 
  def write(self, oprot):
13200 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13201 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13202 
      return
13203 
    oprot.writeStructBegin('deleteTag_args')
13204 
    if self.displayName is not None:
13205 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
13206 
      oprot.writeString(self.displayName)
13207 
      oprot.writeFieldEnd()
13208 
    oprot.writeFieldStop()
13209 
    oprot.writeStructEnd()
13210 
 
13211 
  def validate(self):
13212 
    return
13213 
 
13214 
 
13215 
  def __repr__(self):
13216 
    L = ['%s=%r' % (key, value)
13217 
      for key, value in self.__dict__.iteritems()]
13218 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13219 
 
13220 
  def __eq__(self, other):
13221 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13222 
 
13223 
  def __ne__(self, other):
13224 
    return not (self == other)
13225 
 
13226 
class deleteTag_result:
13227 
  """
13228 
  Attributes:
13229 
   - success
13230 
  """
13231 
 
13232 
  thrift_spec = (
13233 
    (0, TType.BOOL, 'success', None, None, ), # 0
13234 
  )
13235 
 
13236 
  def __init__(self, success=None,):
13237 
    self.success = success
13238 
 
13239 
  def read(self, iprot):
13240 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13241 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13242 
      return
13243 
    iprot.readStructBegin()
13244 
    while True:
13245 
      (fname, ftype, fid) = iprot.readFieldBegin()
13246 
      if ftype == TType.STOP:
13247 
        break
13248 
      if fid == 0:
13249 
        if ftype == TType.BOOL:
13250 
          self.success = iprot.readBool();
13251 
        else:
13252 
          iprot.skip(ftype)
13253 
      else:
13254 
        iprot.skip(ftype)
13255 
      iprot.readFieldEnd()
13256 
    iprot.readStructEnd()
13257 
 
13258 
  def write(self, oprot):
13259 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13260 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13261 
      return
13262 
    oprot.writeStructBegin('deleteTag_result')
13263 
    if self.success is not None:
13264 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13265 
      oprot.writeBool(self.success)
13266 
      oprot.writeFieldEnd()
13267 
    oprot.writeFieldStop()
13268 
    oprot.writeStructEnd()
13269 
 
13270 
  def validate(self):
13271 
    return
13272 
 
13273 
 
13274 
  def __repr__(self):
13275 
    L = ['%s=%r' % (key, value)
13276 
      for key, value in self.__dict__.iteritems()]
13277 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13278 
 
13279 
  def __eq__(self, other):
13280 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13281 
 
13282 
  def __ne__(self, other):
13283 
    return not (self == other)
13284 
 
13285 
class getAllTags_args:
13286 
 
13287 
  thrift_spec = (
13288 
  )
13289 
 
13290 
  def read(self, iprot):
13291 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13292 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13293 
      return
13294 
    iprot.readStructBegin()
13295 
    while True:
13296 
      (fname, ftype, fid) = iprot.readFieldBegin()
13297 
      if ftype == TType.STOP:
13298 
        break
13299 
      else:
13300 
        iprot.skip(ftype)
13301 
      iprot.readFieldEnd()
13302 
    iprot.readStructEnd()
13303 
 
13304 
  def write(self, oprot):
13305 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13306 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13307 
      return
13308 
    oprot.writeStructBegin('getAllTags_args')
13309 
    oprot.writeFieldStop()
13310 
    oprot.writeStructEnd()
13311 
 
13312 
  def validate(self):
13313 
    return
13314 
 
13315 
 
13316 
  def __repr__(self):
13317 
    L = ['%s=%r' % (key, value)
13318 
      for key, value in self.__dict__.iteritems()]
13319 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13320 
 
13321 
  def __eq__(self, other):
13322 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13323 
 
13324 
  def __ne__(self, other):
13325 
    return not (self == other)
13326 
 
13327 
class getAllTags_result:
13328 
  """
13329 
  Attributes:
13330 
   - success
13331 
  """
13332 
 
13333 
  thrift_spec = (
13334 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
13335 
  )
13336 
 
13337 
  def __init__(self, success=None,):
13338 
    self.success = success
13339 
 
13340 
  def read(self, iprot):
13341 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13342 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13343 
      return
13344 
    iprot.readStructBegin()
13345 
    while True:
13346 
      (fname, ftype, fid) = iprot.readFieldBegin()
13347 
      if ftype == TType.STOP:
13348 
        break
13349 
      if fid == 0:
13350 
        if ftype == TType.LIST:
13351 
          self.success = []
8590 kshitij.so 13352 
          (_etype168, _size165) = iprot.readListBegin()
13353 
          for _i169 in xrange(_size165):
13354 
            _elem170 = iprot.readString();
13355 
            self.success.append(_elem170)
6512 kshitij.so 13356 
          iprot.readListEnd()
13357 
        else:
13358 
          iprot.skip(ftype)
13359 
      else:
13360 
        iprot.skip(ftype)
13361 
      iprot.readFieldEnd()
13362 
    iprot.readStructEnd()
13363 
 
13364 
  def write(self, oprot):
13365 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13366 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13367 
      return
13368 
    oprot.writeStructBegin('getAllTags_result')
13369 
    if self.success is not None:
13370 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13371 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 13372 
      for iter171 in self.success:
13373 
        oprot.writeString(iter171)
6512 kshitij.so 13374 
      oprot.writeListEnd()
13375 
      oprot.writeFieldEnd()
13376 
    oprot.writeFieldStop()
13377 
    oprot.writeStructEnd()
13378 
 
13379 
  def validate(self):
13380 
    return
13381 
 
13382 
 
13383 
  def __repr__(self):
13384 
    L = ['%s=%r' % (key, value)
13385 
      for key, value in self.__dict__.iteritems()]
13386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13387 
 
13388 
  def __eq__(self, other):
13389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13390 
 
13391 
  def __ne__(self, other):
13392 
    return not (self == other)
13393 
 
13394 
class getAllEntitiesByTagName_args:
13395 
  """
13396 
  Attributes:
13397 
   - displayName
13398 
  """
13399 
 
13400 
  thrift_spec = (
13401 
    None, # 0
13402 
    (1, TType.STRING, 'displayName', None, None, ), # 1
13403 
  )
13404 
 
13405 
  def __init__(self, displayName=None,):
13406 
    self.displayName = displayName
13407 
 
13408 
  def read(self, iprot):
13409 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13410 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13411 
      return
13412 
    iprot.readStructBegin()
13413 
    while True:
13414 
      (fname, ftype, fid) = iprot.readFieldBegin()
13415 
      if ftype == TType.STOP:
13416 
        break
13417 
      if fid == 1:
13418 
        if ftype == TType.STRING:
13419 
          self.displayName = iprot.readString();
13420 
        else:
13421 
          iprot.skip(ftype)
13422 
      else:
13423 
        iprot.skip(ftype)
13424 
      iprot.readFieldEnd()
13425 
    iprot.readStructEnd()
13426 
 
13427 
  def write(self, oprot):
13428 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13429 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13430 
      return
13431 
    oprot.writeStructBegin('getAllEntitiesByTagName_args')
13432 
    if self.displayName is not None:
13433 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
13434 
      oprot.writeString(self.displayName)
13435 
      oprot.writeFieldEnd()
13436 
    oprot.writeFieldStop()
13437 
    oprot.writeStructEnd()
13438 
 
13439 
  def validate(self):
13440 
    return
13441 
 
13442 
 
13443 
  def __repr__(self):
13444 
    L = ['%s=%r' % (key, value)
13445 
      for key, value in self.__dict__.iteritems()]
13446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13447 
 
13448 
  def __eq__(self, other):
13449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13450 
 
13451 
  def __ne__(self, other):
13452 
    return not (self == other)
13453 
 
13454 
class getAllEntitiesByTagName_result:
13455 
  """
13456 
  Attributes:
13457 
   - success
13458 
  """
13459 
 
13460 
  thrift_spec = (
13461 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
13462 
  )
13463 
 
13464 
  def __init__(self, success=None,):
13465 
    self.success = success
13466 
 
13467 
  def read(self, iprot):
13468 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13469 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13470 
      return
13471 
    iprot.readStructBegin()
13472 
    while True:
13473 
      (fname, ftype, fid) = iprot.readFieldBegin()
13474 
      if ftype == TType.STOP:
13475 
        break
13476 
      if fid == 0:
13477 
        if ftype == TType.LIST:
13478 
          self.success = []
8590 kshitij.so 13479 
          (_etype175, _size172) = iprot.readListBegin()
13480 
          for _i176 in xrange(_size172):
13481 
            _elem177 = iprot.readI64();
13482 
            self.success.append(_elem177)
6512 kshitij.so 13483 
          iprot.readListEnd()
13484 
        else:
13485 
          iprot.skip(ftype)
13486 
      else:
13487 
        iprot.skip(ftype)
13488 
      iprot.readFieldEnd()
13489 
    iprot.readStructEnd()
13490 
 
13491 
  def write(self, oprot):
13492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13494 
      return
13495 
    oprot.writeStructBegin('getAllEntitiesByTagName_result')
13496 
    if self.success is not None:
13497 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13498 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 13499 
      for iter178 in self.success:
13500 
        oprot.writeI64(iter178)
6512 kshitij.so 13501 
      oprot.writeListEnd()
13502 
      oprot.writeFieldEnd()
13503 
    oprot.writeFieldStop()
13504 
    oprot.writeStructEnd()
13505 
 
13506 
  def validate(self):
13507 
    return
13508 
 
13509 
 
13510 
  def __repr__(self):
13511 
    L = ['%s=%r' % (key, value)
13512 
      for key, value in self.__dict__.iteritems()]
13513 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13514 
 
13515 
  def __eq__(self, other):
13516 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13517 
 
13518 
  def __ne__(self, other):
13519 
    return not (self == other)
13520 
 
6845 amit.gupta 13521 
class getAllEntityTags_args:
13522 
 
13523 
  thrift_spec = (
13524 
  )
13525 
 
13526 
  def read(self, iprot):
13527 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13528 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13529 
      return
13530 
    iprot.readStructBegin()
13531 
    while True:
13532 
      (fname, ftype, fid) = iprot.readFieldBegin()
13533 
      if ftype == TType.STOP:
13534 
        break
13535 
      else:
13536 
        iprot.skip(ftype)
13537 
      iprot.readFieldEnd()
13538 
    iprot.readStructEnd()
13539 
 
13540 
  def write(self, oprot):
13541 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13542 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13543 
      return
13544 
    oprot.writeStructBegin('getAllEntityTags_args')
13545 
    oprot.writeFieldStop()
13546 
    oprot.writeStructEnd()
13547 
 
13548 
  def validate(self):
13549 
    return
13550 
 
13551 
 
13552 
  def __repr__(self):
13553 
    L = ['%s=%r' % (key, value)
13554 
      for key, value in self.__dict__.iteritems()]
13555 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13556 
 
13557 
  def __eq__(self, other):
13558 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13559 
 
13560 
  def __ne__(self, other):
13561 
    return not (self == other)
13562 
 
13563 
class getAllEntityTags_result:
13564 
  """
13565 
  Attributes:
13566 
   - success
13567 
  """
13568 
 
13569 
  thrift_spec = (
13570 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRING,None)), None, ), # 0
13571 
  )
13572 
 
13573 
  def __init__(self, success=None,):
13574 
    self.success = success
13575 
 
13576 
  def read(self, iprot):
13577 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13578 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13579 
      return
13580 
    iprot.readStructBegin()
13581 
    while True:
13582 
      (fname, ftype, fid) = iprot.readFieldBegin()
13583 
      if ftype == TType.STOP:
13584 
        break
13585 
      if fid == 0:
13586 
        if ftype == TType.MAP:
13587 
          self.success = {}
8590 kshitij.so 13588 
          (_ktype180, _vtype181, _size179 ) = iprot.readMapBegin()
13589 
          for _i183 in xrange(_size179):
13590 
            _key184 = iprot.readI64();
13591 
            _val185 = []
13592 
            (_etype189, _size186) = iprot.readListBegin()
13593 
            for _i190 in xrange(_size186):
13594 
              _elem191 = iprot.readString();
13595 
              _val185.append(_elem191)
6845 amit.gupta 13596 
            iprot.readListEnd()
8590 kshitij.so 13597 
            self.success[_key184] = _val185
6845 amit.gupta 13598 
          iprot.readMapEnd()
13599 
        else:
13600 
          iprot.skip(ftype)
13601 
      else:
13602 
        iprot.skip(ftype)
13603 
      iprot.readFieldEnd()
13604 
    iprot.readStructEnd()
13605 
 
13606 
  def write(self, oprot):
13607 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13608 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13609 
      return
13610 
    oprot.writeStructBegin('getAllEntityTags_result')
13611 
    if self.success is not None:
13612 
      oprot.writeFieldBegin('success', TType.MAP, 0)
13613 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
8590 kshitij.so 13614 
      for kiter192,viter193 in self.success.items():
13615 
        oprot.writeI64(kiter192)
13616 
        oprot.writeListBegin(TType.STRING, len(viter193))
13617 
        for iter194 in viter193:
13618 
          oprot.writeString(iter194)
6845 amit.gupta 13619 
        oprot.writeListEnd()
13620 
      oprot.writeMapEnd()
13621 
      oprot.writeFieldEnd()
13622 
    oprot.writeFieldStop()
13623 
    oprot.writeStructEnd()
13624 
 
13625 
  def validate(self):
13626 
    return
13627 
 
13628 
 
13629 
  def __repr__(self):
13630 
    L = ['%s=%r' % (key, value)
13631 
      for key, value in self.__dict__.iteritems()]
13632 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13633 
 
13634 
  def __eq__(self, other):
13635 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13636 
 
13637 
  def __ne__(self, other):
13638 
    return not (self == other)
13639 
 
6850 kshitij.so 13640 
class addBanner_args:
13641 
  """
13642 
  Attributes:
8590 kshitij.so 13643 
   - bannerCongregate
6850 kshitij.so 13644 
  """
13645 
 
13646 
  thrift_spec = (
13647 
    None, # 0
8590 kshitij.so 13648 
    (1, TType.STRUCT, 'bannerCongregate', (BannerCongregate, BannerCongregate.thrift_spec), None, ), # 1
6850 kshitij.so 13649 
  )
13650 
 
8590 kshitij.so 13651 
  def __init__(self, bannerCongregate=None,):
13652 
    self.bannerCongregate = bannerCongregate
6850 kshitij.so 13653 
 
13654 
  def read(self, iprot):
13655 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13656 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13657 
      return
13658 
    iprot.readStructBegin()
13659 
    while True:
13660 
      (fname, ftype, fid) = iprot.readFieldBegin()
13661 
      if ftype == TType.STOP:
13662 
        break
13663 
      if fid == 1:
8579 kshitij.so 13664 
        if ftype == TType.STRUCT:
8590 kshitij.so 13665 
          self.bannerCongregate = BannerCongregate()
13666 
          self.bannerCongregate.read(iprot)
6850 kshitij.so 13667 
        else:
13668 
          iprot.skip(ftype)
8579 kshitij.so 13669 
      else:
13670 
        iprot.skip(ftype)
13671 
      iprot.readFieldEnd()
13672 
    iprot.readStructEnd()
13673 
 
13674 
  def write(self, oprot):
13675 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13676 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13677 
      return
13678 
    oprot.writeStructBegin('addBanner_args')
8590 kshitij.so 13679 
    if self.bannerCongregate is not None:
13680 
      oprot.writeFieldBegin('bannerCongregate', TType.STRUCT, 1)
13681 
      self.bannerCongregate.write(oprot)
8579 kshitij.so 13682 
      oprot.writeFieldEnd()
13683 
    oprot.writeFieldStop()
13684 
    oprot.writeStructEnd()
13685 
 
13686 
  def validate(self):
13687 
    return
13688 
 
13689 
 
13690 
  def __repr__(self):
13691 
    L = ['%s=%r' % (key, value)
13692 
      for key, value in self.__dict__.iteritems()]
13693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13694 
 
13695 
  def __eq__(self, other):
13696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13697 
 
13698 
  def __ne__(self, other):
13699 
    return not (self == other)
13700 
 
13701 
class addBanner_result:
10097 kshitij.so 13702 
  """
13703 
  Attributes:
13704 
   - success
13705 
  """
8579 kshitij.so 13706 
 
13707 
  thrift_spec = (
10097 kshitij.so 13708 
    (0, TType.BOOL, 'success', None, None, ), # 0
8579 kshitij.so 13709 
  )
13710 
 
10097 kshitij.so 13711 
  def __init__(self, success=None,):
13712 
    self.success = success
13713 
 
8579 kshitij.so 13714 
  def read(self, iprot):
13715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13717 
      return
13718 
    iprot.readStructBegin()
13719 
    while True:
13720 
      (fname, ftype, fid) = iprot.readFieldBegin()
13721 
      if ftype == TType.STOP:
13722 
        break
10097 kshitij.so 13723 
      if fid == 0:
13724 
        if ftype == TType.BOOL:
13725 
          self.success = iprot.readBool();
13726 
        else:
13727 
          iprot.skip(ftype)
8579 kshitij.so 13728 
      else:
13729 
        iprot.skip(ftype)
13730 
      iprot.readFieldEnd()
13731 
    iprot.readStructEnd()
13732 
 
13733 
  def write(self, oprot):
13734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13736 
      return
13737 
    oprot.writeStructBegin('addBanner_result')
10097 kshitij.so 13738 
    if self.success is not None:
13739 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13740 
      oprot.writeBool(self.success)
13741 
      oprot.writeFieldEnd()
8579 kshitij.so 13742 
    oprot.writeFieldStop()
13743 
    oprot.writeStructEnd()
13744 
 
13745 
  def validate(self):
13746 
    return
13747 
 
13748 
 
13749 
  def __repr__(self):
13750 
    L = ['%s=%r' % (key, value)
13751 
      for key, value in self.__dict__.iteritems()]
13752 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13753 
 
13754 
  def __eq__(self, other):
13755 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13756 
 
13757 
  def __ne__(self, other):
13758 
    return not (self == other)
13759 
 
13760 
class updateBanner_args:
13761 
  """
13762 
  Attributes:
13763 
   - banner
13764 
  """
13765 
 
13766 
  thrift_spec = (
13767 
    None, # 0
13768 
    (1, TType.STRUCT, 'banner', (Banner, Banner.thrift_spec), None, ), # 1
13769 
  )
13770 
 
13771 
  def __init__(self, banner=None,):
13772 
    self.banner = banner
13773 
 
13774 
  def read(self, iprot):
13775 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13776 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13777 
      return
13778 
    iprot.readStructBegin()
13779 
    while True:
13780 
      (fname, ftype, fid) = iprot.readFieldBegin()
13781 
      if ftype == TType.STOP:
13782 
        break
13783 
      if fid == 1:
13784 
        if ftype == TType.STRUCT:
13785 
          self.banner = Banner()
13786 
          self.banner.read(iprot)
6850 kshitij.so 13787 
        else:
13788 
          iprot.skip(ftype)
13789 
      else:
13790 
        iprot.skip(ftype)
13791 
      iprot.readFieldEnd()
13792 
    iprot.readStructEnd()
13793 
 
13794 
  def write(self, oprot):
13795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13797 
      return
8579 kshitij.so 13798 
    oprot.writeStructBegin('updateBanner_args')
13799 
    if self.banner is not None:
13800 
      oprot.writeFieldBegin('banner', TType.STRUCT, 1)
13801 
      self.banner.write(oprot)
6850 kshitij.so 13802 
      oprot.writeFieldEnd()
13803 
    oprot.writeFieldStop()
13804 
    oprot.writeStructEnd()
13805 
 
13806 
  def validate(self):
13807 
    return
13808 
 
13809 
 
13810 
  def __repr__(self):
13811 
    L = ['%s=%r' % (key, value)
13812 
      for key, value in self.__dict__.iteritems()]
13813 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13814 
 
13815 
  def __eq__(self, other):
13816 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13817 
 
13818 
  def __ne__(self, other):
13819 
    return not (self == other)
13820 
 
8579 kshitij.so 13821 
class updateBanner_result:
6850 kshitij.so 13822 
  """
13823 
  Attributes:
13824 
   - success
13825 
  """
13826 
 
13827 
  thrift_spec = (
13828 
    (0, TType.BOOL, 'success', None, None, ), # 0
13829 
  )
13830 
 
13831 
  def __init__(self, success=None,):
13832 
    self.success = success
13833 
 
13834 
  def read(self, iprot):
13835 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13836 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13837 
      return
13838 
    iprot.readStructBegin()
13839 
    while True:
13840 
      (fname, ftype, fid) = iprot.readFieldBegin()
13841 
      if ftype == TType.STOP:
13842 
        break
13843 
      if fid == 0:
13844 
        if ftype == TType.BOOL:
13845 
          self.success = iprot.readBool();
13846 
        else:
13847 
          iprot.skip(ftype)
13848 
      else:
13849 
        iprot.skip(ftype)
13850 
      iprot.readFieldEnd()
13851 
    iprot.readStructEnd()
13852 
 
13853 
  def write(self, oprot):
13854 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13855 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13856 
      return
8579 kshitij.so 13857 
    oprot.writeStructBegin('updateBanner_result')
6850 kshitij.so 13858 
    if self.success is not None:
13859 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13860 
      oprot.writeBool(self.success)
13861 
      oprot.writeFieldEnd()
13862 
    oprot.writeFieldStop()
13863 
    oprot.writeStructEnd()
13864 
 
13865 
  def validate(self):
13866 
    return
13867 
 
13868 
 
13869 
  def __repr__(self):
13870 
    L = ['%s=%r' % (key, value)
13871 
      for key, value in self.__dict__.iteritems()]
13872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13873 
 
13874 
  def __eq__(self, other):
13875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13876 
 
13877 
  def __ne__(self, other):
13878 
    return not (self == other)
13879 
 
13880 
class getAllBanners_args:
13881 
 
13882 
  thrift_spec = (
13883 
  )
13884 
 
13885 
  def read(self, iprot):
13886 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13887 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13888 
      return
13889 
    iprot.readStructBegin()
13890 
    while True:
13891 
      (fname, ftype, fid) = iprot.readFieldBegin()
13892 
      if ftype == TType.STOP:
13893 
        break
13894 
      else:
13895 
        iprot.skip(ftype)
13896 
      iprot.readFieldEnd()
13897 
    iprot.readStructEnd()
13898 
 
13899 
  def write(self, oprot):
13900 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13901 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13902 
      return
13903 
    oprot.writeStructBegin('getAllBanners_args')
13904 
    oprot.writeFieldStop()
13905 
    oprot.writeStructEnd()
13906 
 
13907 
  def validate(self):
13908 
    return
13909 
 
13910 
 
13911 
  def __repr__(self):
13912 
    L = ['%s=%r' % (key, value)
13913 
      for key, value in self.__dict__.iteritems()]
13914 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13915 
 
13916 
  def __eq__(self, other):
13917 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13918 
 
13919 
  def __ne__(self, other):
13920 
    return not (self == other)
13921 
 
13922 
class getAllBanners_result:
13923 
  """
13924 
  Attributes:
13925 
   - success
13926 
  """
13927 
 
13928 
  thrift_spec = (
8579 kshitij.so 13929 
    (0, TType.LIST, 'success', (TType.STRUCT,(Banner, Banner.thrift_spec)), None, ), # 0
6850 kshitij.so 13930 
  )
13931 
 
13932 
  def __init__(self, success=None,):
13933 
    self.success = success
13934 
 
13935 
  def read(self, iprot):
13936 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13937 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13938 
      return
13939 
    iprot.readStructBegin()
13940 
    while True:
13941 
      (fname, ftype, fid) = iprot.readFieldBegin()
13942 
      if ftype == TType.STOP:
13943 
        break
13944 
      if fid == 0:
13945 
        if ftype == TType.LIST:
13946 
          self.success = []
8590 kshitij.so 13947 
          (_etype198, _size195) = iprot.readListBegin()
13948 
          for _i199 in xrange(_size195):
13949 
            _elem200 = Banner()
13950 
            _elem200.read(iprot)
13951 
            self.success.append(_elem200)
6850 kshitij.so 13952 
          iprot.readListEnd()
13953 
        else:
13954 
          iprot.skip(ftype)
13955 
      else:
13956 
        iprot.skip(ftype)
13957 
      iprot.readFieldEnd()
13958 
    iprot.readStructEnd()
13959 
 
13960 
  def write(self, oprot):
13961 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13962 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13963 
      return
13964 
    oprot.writeStructBegin('getAllBanners_result')
13965 
    if self.success is not None:
13966 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8579 kshitij.so 13967 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 13968 
      for iter201 in self.success:
13969 
        iter201.write(oprot)
6850 kshitij.so 13970 
      oprot.writeListEnd()
13971 
      oprot.writeFieldEnd()
13972 
    oprot.writeFieldStop()
13973 
    oprot.writeStructEnd()
13974 
 
13975 
  def validate(self):
13976 
    return
13977 
 
13978 
 
13979 
  def __repr__(self):
13980 
    L = ['%s=%r' % (key, value)
13981 
      for key, value in self.__dict__.iteritems()]
13982 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13983 
 
13984 
  def __eq__(self, other):
13985 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13986 
 
13987 
  def __ne__(self, other):
13988 
    return not (self == other)
13989 
 
13990 
class deleteBanner_args:
13991 
  """
13992 
  Attributes:
13993 
   - bannerName
9155 kshitij.so 13994 
   - bannerType
6850 kshitij.so 13995 
  """
13996 
 
13997 
  thrift_spec = (
13998 
    None, # 0
13999 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 14000 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6850 kshitij.so 14001 
  )
14002 
 
9155 kshitij.so 14003 
  def __init__(self, bannerName=None, bannerType=None,):
6850 kshitij.so 14004 
    self.bannerName = bannerName
9155 kshitij.so 14005 
    self.bannerType = bannerType
6850 kshitij.so 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 
      if fid == 1:
14017 
        if ftype == TType.STRING:
14018 
          self.bannerName = iprot.readString();
14019 
        else:
14020 
          iprot.skip(ftype)
9155 kshitij.so 14021 
      elif fid == 2:
14022 
        if ftype == TType.I32:
14023 
          self.bannerType = iprot.readI32();
14024 
        else:
14025 
          iprot.skip(ftype)
6850 kshitij.so 14026 
      else:
14027 
        iprot.skip(ftype)
14028 
      iprot.readFieldEnd()
14029 
    iprot.readStructEnd()
14030 
 
14031 
  def write(self, oprot):
14032 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14033 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14034 
      return
14035 
    oprot.writeStructBegin('deleteBanner_args')
14036 
    if self.bannerName is not None:
14037 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
14038 
      oprot.writeString(self.bannerName)
14039 
      oprot.writeFieldEnd()
9155 kshitij.so 14040 
    if self.bannerType is not None:
14041 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
14042 
      oprot.writeI32(self.bannerType)
14043 
      oprot.writeFieldEnd()
6850 kshitij.so 14044 
    oprot.writeFieldStop()
14045 
    oprot.writeStructEnd()
14046 
 
14047 
  def validate(self):
14048 
    return
14049 
 
14050 
 
14051 
  def __repr__(self):
14052 
    L = ['%s=%r' % (key, value)
14053 
      for key, value in self.__dict__.iteritems()]
14054 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14055 
 
14056 
  def __eq__(self, other):
14057 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14058 
 
14059 
  def __ne__(self, other):
14060 
    return not (self == other)
14061 
 
14062 
class deleteBanner_result:
14063 
  """
14064 
  Attributes:
14065 
   - success
14066 
  """
14067 
 
14068 
  thrift_spec = (
14069 
    (0, TType.BOOL, 'success', None, None, ), # 0
14070 
  )
14071 
 
14072 
  def __init__(self, success=None,):
14073 
    self.success = success
14074 
 
14075 
  def read(self, iprot):
14076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14078 
      return
14079 
    iprot.readStructBegin()
14080 
    while True:
14081 
      (fname, ftype, fid) = iprot.readFieldBegin()
14082 
      if ftype == TType.STOP:
14083 
        break
14084 
      if fid == 0:
14085 
        if ftype == TType.BOOL:
14086 
          self.success = iprot.readBool();
14087 
        else:
14088 
          iprot.skip(ftype)
14089 
      else:
14090 
        iprot.skip(ftype)
14091 
      iprot.readFieldEnd()
14092 
    iprot.readStructEnd()
14093 
 
14094 
  def write(self, oprot):
14095 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14096 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14097 
      return
14098 
    oprot.writeStructBegin('deleteBanner_result')
14099 
    if self.success is not None:
14100 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14101 
      oprot.writeBool(self.success)
14102 
      oprot.writeFieldEnd()
14103 
    oprot.writeFieldStop()
14104 
    oprot.writeStructEnd()
14105 
 
14106 
  def validate(self):
14107 
    return
14108 
 
14109 
 
14110 
  def __repr__(self):
14111 
    L = ['%s=%r' % (key, value)
14112 
      for key, value in self.__dict__.iteritems()]
14113 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14114 
 
14115 
  def __eq__(self, other):
14116 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14117 
 
14118 
  def __ne__(self, other):
14119 
    return not (self == other)
14120 
 
14121 
class getBannerDetails_args:
14122 
  """
14123 
  Attributes:
14124 
   - bannerName
9155 kshitij.so 14125 
   - bannerType
6850 kshitij.so 14126 
  """
14127 
 
14128 
  thrift_spec = (
14129 
    None, # 0
14130 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 14131 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6850 kshitij.so 14132 
  )
14133 
 
9155 kshitij.so 14134 
  def __init__(self, bannerName=None, bannerType=None,):
6850 kshitij.so 14135 
    self.bannerName = bannerName
9155 kshitij.so 14136 
    self.bannerType = bannerType
6850 kshitij.so 14137 
 
14138 
  def read(self, iprot):
14139 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14140 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14141 
      return
14142 
    iprot.readStructBegin()
14143 
    while True:
14144 
      (fname, ftype, fid) = iprot.readFieldBegin()
14145 
      if ftype == TType.STOP:
14146 
        break
14147 
      if fid == 1:
14148 
        if ftype == TType.STRING:
14149 
          self.bannerName = iprot.readString();
14150 
        else:
14151 
          iprot.skip(ftype)
9155 kshitij.so 14152 
      elif fid == 2:
14153 
        if ftype == TType.I32:
14154 
          self.bannerType = iprot.readI32();
14155 
        else:
14156 
          iprot.skip(ftype)
6850 kshitij.so 14157 
      else:
14158 
        iprot.skip(ftype)
14159 
      iprot.readFieldEnd()
14160 
    iprot.readStructEnd()
14161 
 
14162 
  def write(self, oprot):
14163 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14164 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14165 
      return
14166 
    oprot.writeStructBegin('getBannerDetails_args')
14167 
    if self.bannerName is not None:
14168 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
14169 
      oprot.writeString(self.bannerName)
14170 
      oprot.writeFieldEnd()
9155 kshitij.so 14171 
    if self.bannerType is not None:
14172 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
14173 
      oprot.writeI32(self.bannerType)
14174 
      oprot.writeFieldEnd()
6850 kshitij.so 14175 
    oprot.writeFieldStop()
14176 
    oprot.writeStructEnd()
14177 
 
14178 
  def validate(self):
14179 
    return
14180 
 
14181 
 
14182 
  def __repr__(self):
14183 
    L = ['%s=%r' % (key, value)
14184 
      for key, value in self.__dict__.iteritems()]
14185 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14186 
 
14187 
  def __eq__(self, other):
14188 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14189 
 
14190 
  def __ne__(self, other):
14191 
    return not (self == other)
14192 
 
14193 
class getBannerDetails_result:
14194 
  """
14195 
  Attributes:
14196 
   - success
14197 
  """
14198 
 
14199 
  thrift_spec = (
14200 
    (0, TType.STRUCT, 'success', (Banner, Banner.thrift_spec), None, ), # 0
14201 
  )
14202 
 
14203 
  def __init__(self, success=None,):
14204 
    self.success = success
14205 
 
14206 
  def read(self, iprot):
14207 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14208 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14209 
      return
14210 
    iprot.readStructBegin()
14211 
    while True:
14212 
      (fname, ftype, fid) = iprot.readFieldBegin()
14213 
      if ftype == TType.STOP:
14214 
        break
14215 
      if fid == 0:
14216 
        if ftype == TType.STRUCT:
14217 
          self.success = Banner()
14218 
          self.success.read(iprot)
14219 
        else:
14220 
          iprot.skip(ftype)
14221 
      else:
14222 
        iprot.skip(ftype)
14223 
      iprot.readFieldEnd()
14224 
    iprot.readStructEnd()
14225 
 
14226 
  def write(self, oprot):
14227 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14228 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14229 
      return
14230 
    oprot.writeStructBegin('getBannerDetails_result')
14231 
    if self.success is not None:
14232 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14233 
      self.success.write(oprot)
14234 
      oprot.writeFieldEnd()
14235 
    oprot.writeFieldStop()
14236 
    oprot.writeStructEnd()
14237 
 
14238 
  def validate(self):
14239 
    return
14240 
 
14241 
 
14242 
  def __repr__(self):
14243 
    L = ['%s=%r' % (key, value)
14244 
      for key, value in self.__dict__.iteritems()]
14245 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14246 
 
14247 
  def __eq__(self, other):
14248 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14249 
 
14250 
  def __ne__(self, other):
14251 
    return not (self == other)
14252 
 
14253 
class getActiveBanners_args:
14254 
 
14255 
  thrift_spec = (
14256 
  )
14257 
 
14258 
  def read(self, iprot):
14259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14261 
      return
14262 
    iprot.readStructBegin()
14263 
    while True:
14264 
      (fname, ftype, fid) = iprot.readFieldBegin()
14265 
      if ftype == TType.STOP:
14266 
        break
14267 
      else:
14268 
        iprot.skip(ftype)
14269 
      iprot.readFieldEnd()
14270 
    iprot.readStructEnd()
14271 
 
14272 
  def write(self, oprot):
14273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14275 
      return
14276 
    oprot.writeStructBegin('getActiveBanners_args')
14277 
    oprot.writeFieldStop()
14278 
    oprot.writeStructEnd()
14279 
 
14280 
  def validate(self):
14281 
    return
14282 
 
14283 
 
14284 
  def __repr__(self):
14285 
    L = ['%s=%r' % (key, value)
14286 
      for key, value in self.__dict__.iteritems()]
14287 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14288 
 
14289 
  def __eq__(self, other):
14290 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14291 
 
14292 
  def __ne__(self, other):
14293 
    return not (self == other)
14294 
 
14295 
class getActiveBanners_result:
14296 
  """
14297 
  Attributes:
14298 
   - success
14299 
  """
14300 
 
14301 
  thrift_spec = (
8579 kshitij.so 14302 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
6850 kshitij.so 14303 
  )
14304 
 
14305 
  def __init__(self, success=None,):
14306 
    self.success = success
14307 
 
14308 
  def read(self, iprot):
14309 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14310 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14311 
      return
14312 
    iprot.readStructBegin()
14313 
    while True:
14314 
      (fname, ftype, fid) = iprot.readFieldBegin()
14315 
      if ftype == TType.STOP:
14316 
        break
14317 
      if fid == 0:
8579 kshitij.so 14318 
        if ftype == TType.MAP:
14319 
          self.success = {}
8590 kshitij.so 14320 
          (_ktype203, _vtype204, _size202 ) = iprot.readMapBegin()
14321 
          for _i206 in xrange(_size202):
14322 
            _key207 = iprot.readString();
14323 
            _val208 = []
14324 
            (_etype212, _size209) = iprot.readListBegin()
14325 
            for _i213 in xrange(_size209):
14326 
              _elem214 = Banner()
14327 
              _elem214.read(iprot)
14328 
              _val208.append(_elem214)
8579 kshitij.so 14329 
            iprot.readListEnd()
8590 kshitij.so 14330 
            self.success[_key207] = _val208
8579 kshitij.so 14331 
          iprot.readMapEnd()
6850 kshitij.so 14332 
        else:
14333 
          iprot.skip(ftype)
14334 
      else:
14335 
        iprot.skip(ftype)
14336 
      iprot.readFieldEnd()
14337 
    iprot.readStructEnd()
14338 
 
14339 
  def write(self, oprot):
14340 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14341 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14342 
      return
14343 
    oprot.writeStructBegin('getActiveBanners_result')
14344 
    if self.success is not None:
8579 kshitij.so 14345 
      oprot.writeFieldBegin('success', TType.MAP, 0)
14346 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
8590 kshitij.so 14347 
      for kiter215,viter216 in self.success.items():
14348 
        oprot.writeString(kiter215)
14349 
        oprot.writeListBegin(TType.STRUCT, len(viter216))
14350 
        for iter217 in viter216:
14351 
          iter217.write(oprot)
8579 kshitij.so 14352 
        oprot.writeListEnd()
14353 
      oprot.writeMapEnd()
6850 kshitij.so 14354 
      oprot.writeFieldEnd()
14355 
    oprot.writeFieldStop()
14356 
    oprot.writeStructEnd()
14357 
 
14358 
  def validate(self):
14359 
    return
14360 
 
14361 
 
14362 
  def __repr__(self):
14363 
    L = ['%s=%r' % (key, value)
14364 
      for key, value in self.__dict__.iteritems()]
14365 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14366 
 
14367 
  def __eq__(self, other):
14368 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14369 
 
14370 
  def __ne__(self, other):
14371 
    return not (self == other)
14372 
 
6849 kshitij.so 14373 
class addBannerMap_args:
14374 
  """
14375 
  Attributes:
8579 kshitij.so 14376 
   - bannerMaps
6849 kshitij.so 14377 
  """
14378 
 
14379 
  thrift_spec = (
14380 
    None, # 0
8579 kshitij.so 14381 
    (1, TType.LIST, 'bannerMaps', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 1
6849 kshitij.so 14382 
  )
14383 
 
8579 kshitij.so 14384 
  def __init__(self, bannerMaps=None,):
14385 
    self.bannerMaps = bannerMaps
6849 kshitij.so 14386 
 
14387 
  def read(self, iprot):
14388 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14389 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14390 
      return
14391 
    iprot.readStructBegin()
14392 
    while True:
14393 
      (fname, ftype, fid) = iprot.readFieldBegin()
14394 
      if ftype == TType.STOP:
14395 
        break
14396 
      if fid == 1:
8579 kshitij.so 14397 
        if ftype == TType.LIST:
14398 
          self.bannerMaps = []
8590 kshitij.so 14399 
          (_etype221, _size218) = iprot.readListBegin()
14400 
          for _i222 in xrange(_size218):
14401 
            _elem223 = BannerMap()
14402 
            _elem223.read(iprot)
14403 
            self.bannerMaps.append(_elem223)
8579 kshitij.so 14404 
          iprot.readListEnd()
6849 kshitij.so 14405 
        else:
14406 
          iprot.skip(ftype)
8579 kshitij.so 14407 
      else:
14408 
        iprot.skip(ftype)
14409 
      iprot.readFieldEnd()
14410 
    iprot.readStructEnd()
14411 
 
14412 
  def write(self, oprot):
14413 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14414 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14415 
      return
14416 
    oprot.writeStructBegin('addBannerMap_args')
14417 
    if self.bannerMaps is not None:
14418 
      oprot.writeFieldBegin('bannerMaps', TType.LIST, 1)
14419 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerMaps))
8590 kshitij.so 14420 
      for iter224 in self.bannerMaps:
14421 
        iter224.write(oprot)
8579 kshitij.so 14422 
      oprot.writeListEnd()
14423 
      oprot.writeFieldEnd()
14424 
    oprot.writeFieldStop()
14425 
    oprot.writeStructEnd()
14426 
 
14427 
  def validate(self):
14428 
    return
14429 
 
14430 
 
14431 
  def __repr__(self):
14432 
    L = ['%s=%r' % (key, value)
14433 
      for key, value in self.__dict__.iteritems()]
14434 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14435 
 
14436 
  def __eq__(self, other):
14437 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14438 
 
14439 
  def __ne__(self, other):
14440 
    return not (self == other)
14441 
 
14442 
class addBannerMap_result:
14443 
  """
14444 
  Attributes:
14445 
   - success
14446 
  """
14447 
 
14448 
  thrift_spec = (
14449 
    (0, TType.BOOL, 'success', None, None, ), # 0
14450 
  )
14451 
 
14452 
  def __init__(self, success=None,):
14453 
    self.success = success
14454 
 
14455 
  def read(self, iprot):
14456 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14457 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14458 
      return
14459 
    iprot.readStructBegin()
14460 
    while True:
14461 
      (fname, ftype, fid) = iprot.readFieldBegin()
14462 
      if ftype == TType.STOP:
14463 
        break
14464 
      if fid == 0:
14465 
        if ftype == TType.BOOL:
14466 
          self.success = iprot.readBool();
6849 kshitij.so 14467 
        else:
14468 
          iprot.skip(ftype)
8579 kshitij.so 14469 
      else:
14470 
        iprot.skip(ftype)
14471 
      iprot.readFieldEnd()
14472 
    iprot.readStructEnd()
14473 
 
14474 
  def write(self, oprot):
14475 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14476 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14477 
      return
14478 
    oprot.writeStructBegin('addBannerMap_result')
14479 
    if self.success is not None:
14480 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14481 
      oprot.writeBool(self.success)
14482 
      oprot.writeFieldEnd()
14483 
    oprot.writeFieldStop()
14484 
    oprot.writeStructEnd()
14485 
 
14486 
  def validate(self):
14487 
    return
14488 
 
14489 
 
14490 
  def __repr__(self):
14491 
    L = ['%s=%r' % (key, value)
14492 
      for key, value in self.__dict__.iteritems()]
14493 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14494 
 
14495 
  def __eq__(self, other):
14496 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14497 
 
14498 
  def __ne__(self, other):
14499 
    return not (self == other)
14500 
 
14501 
class updateBannerMap_args:
14502 
  """
14503 
  Attributes:
14504 
   - bannerMap
14505 
  """
14506 
 
14507 
  thrift_spec = (
14508 
    None, # 0
14509 
    (1, TType.STRUCT, 'bannerMap', (BannerMap, BannerMap.thrift_spec), None, ), # 1
14510 
  )
14511 
 
14512 
  def __init__(self, bannerMap=None,):
14513 
    self.bannerMap = bannerMap
14514 
 
14515 
  def read(self, iprot):
14516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14518 
      return
14519 
    iprot.readStructBegin()
14520 
    while True:
14521 
      (fname, ftype, fid) = iprot.readFieldBegin()
14522 
      if ftype == TType.STOP:
14523 
        break
14524 
      if fid == 1:
14525 
        if ftype == TType.STRUCT:
14526 
          self.bannerMap = BannerMap()
14527 
          self.bannerMap.read(iprot)
6849 kshitij.so 14528 
        else:
14529 
          iprot.skip(ftype)
14530 
      else:
14531 
        iprot.skip(ftype)
14532 
      iprot.readFieldEnd()
14533 
    iprot.readStructEnd()
14534 
 
14535 
  def write(self, oprot):
14536 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14537 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14538 
      return
8579 kshitij.so 14539 
    oprot.writeStructBegin('updateBannerMap_args')
14540 
    if self.bannerMap is not None:
14541 
      oprot.writeFieldBegin('bannerMap', TType.STRUCT, 1)
14542 
      self.bannerMap.write(oprot)
6849 kshitij.so 14543 
      oprot.writeFieldEnd()
14544 
    oprot.writeFieldStop()
14545 
    oprot.writeStructEnd()
14546 
 
14547 
  def validate(self):
14548 
    return
14549 
 
14550 
 
14551 
  def __repr__(self):
14552 
    L = ['%s=%r' % (key, value)
14553 
      for key, value in self.__dict__.iteritems()]
14554 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14555 
 
14556 
  def __eq__(self, other):
14557 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14558 
 
14559 
  def __ne__(self, other):
14560 
    return not (self == other)
14561 
 
8579 kshitij.so 14562 
class updateBannerMap_result:
6849 kshitij.so 14563 
  """
14564 
  Attributes:
14565 
   - success
14566 
  """
14567 
 
14568 
  thrift_spec = (
14569 
    (0, TType.BOOL, 'success', None, None, ), # 0
14570 
  )
14571 
 
14572 
  def __init__(self, success=None,):
14573 
    self.success = success
14574 
 
14575 
  def read(self, iprot):
14576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14578 
      return
14579 
    iprot.readStructBegin()
14580 
    while True:
14581 
      (fname, ftype, fid) = iprot.readFieldBegin()
14582 
      if ftype == TType.STOP:
14583 
        break
14584 
      if fid == 0:
14585 
        if ftype == TType.BOOL:
14586 
          self.success = iprot.readBool();
14587 
        else:
14588 
          iprot.skip(ftype)
14589 
      else:
14590 
        iprot.skip(ftype)
14591 
      iprot.readFieldEnd()
14592 
    iprot.readStructEnd()
14593 
 
14594 
  def write(self, oprot):
14595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14597 
      return
8579 kshitij.so 14598 
    oprot.writeStructBegin('updateBannerMap_result')
6849 kshitij.so 14599 
    if self.success is not None:
14600 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14601 
      oprot.writeBool(self.success)
14602 
      oprot.writeFieldEnd()
14603 
    oprot.writeFieldStop()
14604 
    oprot.writeStructEnd()
14605 
 
14606 
  def validate(self):
14607 
    return
14608 
 
14609 
 
14610 
  def __repr__(self):
14611 
    L = ['%s=%r' % (key, value)
14612 
      for key, value in self.__dict__.iteritems()]
14613 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14614 
 
14615 
  def __eq__(self, other):
14616 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14617 
 
14618 
  def __ne__(self, other):
14619 
    return not (self == other)
14620 
 
14621 
class deleteBannerMap_args:
14622 
  """
14623 
  Attributes:
14624 
   - bannerName
14625 
  """
14626 
 
14627 
  thrift_spec = (
14628 
    None, # 0
14629 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
14630 
  )
14631 
 
14632 
  def __init__(self, bannerName=None,):
14633 
    self.bannerName = bannerName
14634 
 
14635 
  def read(self, iprot):
14636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14638 
      return
14639 
    iprot.readStructBegin()
14640 
    while True:
14641 
      (fname, ftype, fid) = iprot.readFieldBegin()
14642 
      if ftype == TType.STOP:
14643 
        break
14644 
      if fid == 1:
14645 
        if ftype == TType.STRING:
14646 
          self.bannerName = iprot.readString();
14647 
        else:
14648 
          iprot.skip(ftype)
14649 
      else:
14650 
        iprot.skip(ftype)
14651 
      iprot.readFieldEnd()
14652 
    iprot.readStructEnd()
14653 
 
14654 
  def write(self, oprot):
14655 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14656 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14657 
      return
14658 
    oprot.writeStructBegin('deleteBannerMap_args')
14659 
    if self.bannerName is not None:
14660 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
14661 
      oprot.writeString(self.bannerName)
14662 
      oprot.writeFieldEnd()
14663 
    oprot.writeFieldStop()
14664 
    oprot.writeStructEnd()
14665 
 
14666 
  def validate(self):
14667 
    return
14668 
 
14669 
 
14670 
  def __repr__(self):
14671 
    L = ['%s=%r' % (key, value)
14672 
      for key, value in self.__dict__.iteritems()]
14673 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14674 
 
14675 
  def __eq__(self, other):
14676 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14677 
 
14678 
  def __ne__(self, other):
14679 
    return not (self == other)
14680 
 
14681 
class deleteBannerMap_result:
14682 
  """
14683 
  Attributes:
14684 
   - success
14685 
  """
14686 
 
14687 
  thrift_spec = (
14688 
    (0, TType.BOOL, 'success', None, None, ), # 0
14689 
  )
14690 
 
14691 
  def __init__(self, success=None,):
14692 
    self.success = success
14693 
 
14694 
  def read(self, iprot):
14695 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14696 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14697 
      return
14698 
    iprot.readStructBegin()
14699 
    while True:
14700 
      (fname, ftype, fid) = iprot.readFieldBegin()
14701 
      if ftype == TType.STOP:
14702 
        break
14703 
      if fid == 0:
14704 
        if ftype == TType.BOOL:
14705 
          self.success = iprot.readBool();
14706 
        else:
14707 
          iprot.skip(ftype)
14708 
      else:
14709 
        iprot.skip(ftype)
14710 
      iprot.readFieldEnd()
14711 
    iprot.readStructEnd()
14712 
 
14713 
  def write(self, oprot):
14714 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14715 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14716 
      return
14717 
    oprot.writeStructBegin('deleteBannerMap_result')
14718 
    if self.success is not None:
14719 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14720 
      oprot.writeBool(self.success)
14721 
      oprot.writeFieldEnd()
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 getBannerMapDetails_args:
14741 
  """
14742 
  Attributes:
14743 
   - bannerName
9155 kshitij.so 14744 
   - bannerType
6849 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
6849 kshitij.so 14751 
  )
14752 
 
9155 kshitij.so 14753 
  def __init__(self, bannerName=None, bannerType=None,):
6849 kshitij.so 14754 
    self.bannerName = bannerName
9155 kshitij.so 14755 
    self.bannerType = bannerType
6849 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)
6849 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('getBannerMapDetails_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()
6849 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 getBannerMapDetails_result:
14813 
  """
14814 
  Attributes:
14815 
   - success
14816 
  """
14817 
 
14818 
  thrift_spec = (
14819 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerMap, BannerMap.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 
          (_etype228, _size225) = iprot.readListBegin()
14838 
          for _i229 in xrange(_size225):
14839 
            _elem230 = BannerMap()
14840 
            _elem230.read(iprot)
14841 
            self.success.append(_elem230)
6849 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('getBannerMapDetails_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 iter231 in self.success:
14859 
        iter231.write(oprot)
6849 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 
 
8579 kshitij.so 14880 
class addBannerUri_args:
14881 
  """
14882 
  Attributes:
14883 
   - bannerUriMappings
14884 
  """
14885 
 
14886 
  thrift_spec = (
14887 
    None, # 0
14888 
    (1, TType.LIST, 'bannerUriMappings', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 1
14889 
  )
14890 
 
14891 
  def __init__(self, bannerUriMappings=None,):
14892 
    self.bannerUriMappings = bannerUriMappings
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.LIST:
14905 
          self.bannerUriMappings = []
8590 kshitij.so 14906 
          (_etype235, _size232) = iprot.readListBegin()
14907 
          for _i236 in xrange(_size232):
14908 
            _elem237 = BannerUriMapping()
14909 
            _elem237.read(iprot)
14910 
            self.bannerUriMappings.append(_elem237)
8579 kshitij.so 14911 
          iprot.readListEnd()
14912 
        else:
14913 
          iprot.skip(ftype)
14914 
      else:
14915 
        iprot.skip(ftype)
14916 
      iprot.readFieldEnd()
14917 
    iprot.readStructEnd()
14918 
 
14919 
  def write(self, oprot):
14920 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14921 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14922 
      return
14923 
    oprot.writeStructBegin('addBannerUri_args')
14924 
    if self.bannerUriMappings is not None:
14925 
      oprot.writeFieldBegin('bannerUriMappings', TType.LIST, 1)
14926 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerUriMappings))
8590 kshitij.so 14927 
      for iter238 in self.bannerUriMappings:
14928 
        iter238.write(oprot)
8579 kshitij.so 14929 
      oprot.writeListEnd()
14930 
      oprot.writeFieldEnd()
14931 
    oprot.writeFieldStop()
14932 
    oprot.writeStructEnd()
14933 
 
14934 
  def validate(self):
14935 
    return
14936 
 
14937 
 
14938 
  def __repr__(self):
14939 
    L = ['%s=%r' % (key, value)
14940 
      for key, value in self.__dict__.iteritems()]
14941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14942 
 
14943 
  def __eq__(self, other):
14944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14945 
 
14946 
  def __ne__(self, other):
14947 
    return not (self == other)
14948 
 
14949 
class addBannerUri_result:
14950 
 
14951 
  thrift_spec = (
14952 
  )
14953 
 
14954 
  def read(self, iprot):
14955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14957 
      return
14958 
    iprot.readStructBegin()
14959 
    while True:
14960 
      (fname, ftype, fid) = iprot.readFieldBegin()
14961 
      if ftype == TType.STOP:
14962 
        break
14963 
      else:
14964 
        iprot.skip(ftype)
14965 
      iprot.readFieldEnd()
14966 
    iprot.readStructEnd()
14967 
 
14968 
  def write(self, oprot):
14969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14971 
      return
14972 
    oprot.writeStructBegin('addBannerUri_result')
14973 
    oprot.writeFieldStop()
14974 
    oprot.writeStructEnd()
14975 
 
14976 
  def validate(self):
14977 
    return
14978 
 
14979 
 
14980 
  def __repr__(self):
14981 
    L = ['%s=%r' % (key, value)
14982 
      for key, value in self.__dict__.iteritems()]
14983 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14984 
 
14985 
  def __eq__(self, other):
14986 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14987 
 
14988 
  def __ne__(self, other):
14989 
    return not (self == other)
14990 
 
14991 
class getUriMapping_args:
14992 
  """
14993 
  Attributes:
14994 
   - bannerName
9155 kshitij.so 14995 
   - bannerType
8579 kshitij.so 14996 
  """
14997 
 
14998 
  thrift_spec = (
14999 
    None, # 0
15000 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 15001 
    (2, TType.I32, 'bannerType', None, None, ), # 2
8579 kshitij.so 15002 
  )
15003 
 
9155 kshitij.so 15004 
  def __init__(self, bannerName=None, bannerType=None,):
8579 kshitij.so 15005 
    self.bannerName = bannerName
9155 kshitij.so 15006 
    self.bannerType = bannerType
8579 kshitij.so 15007 
 
15008 
  def read(self, iprot):
15009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15011 
      return
15012 
    iprot.readStructBegin()
15013 
    while True:
15014 
      (fname, ftype, fid) = iprot.readFieldBegin()
15015 
      if ftype == TType.STOP:
15016 
        break
15017 
      if fid == 1:
15018 
        if ftype == TType.STRING:
15019 
          self.bannerName = iprot.readString();
15020 
        else:
15021 
          iprot.skip(ftype)
9155 kshitij.so 15022 
      elif fid == 2:
15023 
        if ftype == TType.I32:
15024 
          self.bannerType = iprot.readI32();
15025 
        else:
15026 
          iprot.skip(ftype)
8579 kshitij.so 15027 
      else:
15028 
        iprot.skip(ftype)
15029 
      iprot.readFieldEnd()
15030 
    iprot.readStructEnd()
15031 
 
15032 
  def write(self, oprot):
15033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15035 
      return
15036 
    oprot.writeStructBegin('getUriMapping_args')
15037 
    if self.bannerName is not None:
15038 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
15039 
      oprot.writeString(self.bannerName)
15040 
      oprot.writeFieldEnd()
9155 kshitij.so 15041 
    if self.bannerType is not None:
15042 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
15043 
      oprot.writeI32(self.bannerType)
15044 
      oprot.writeFieldEnd()
8579 kshitij.so 15045 
    oprot.writeFieldStop()
15046 
    oprot.writeStructEnd()
15047 
 
15048 
  def validate(self):
15049 
    return
15050 
 
15051 
 
15052 
  def __repr__(self):
15053 
    L = ['%s=%r' % (key, value)
15054 
      for key, value in self.__dict__.iteritems()]
15055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15056 
 
15057 
  def __eq__(self, other):
15058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15059 
 
15060 
  def __ne__(self, other):
15061 
    return not (self == other)
15062 
 
15063 
class getUriMapping_result:
15064 
  """
15065 
  Attributes:
15066 
   - success
15067 
  """
15068 
 
15069 
  thrift_spec = (
15070 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 0
15071 
  )
15072 
 
15073 
  def __init__(self, success=None,):
15074 
    self.success = success
15075 
 
15076 
  def read(self, iprot):
15077 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15078 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15079 
      return
15080 
    iprot.readStructBegin()
15081 
    while True:
15082 
      (fname, ftype, fid) = iprot.readFieldBegin()
15083 
      if ftype == TType.STOP:
15084 
        break
15085 
      if fid == 0:
15086 
        if ftype == TType.LIST:
15087 
          self.success = []
8590 kshitij.so 15088 
          (_etype242, _size239) = iprot.readListBegin()
15089 
          for _i243 in xrange(_size239):
15090 
            _elem244 = BannerUriMapping()
15091 
            _elem244.read(iprot)
15092 
            self.success.append(_elem244)
8579 kshitij.so 15093 
          iprot.readListEnd()
15094 
        else:
15095 
          iprot.skip(ftype)
15096 
      else:
15097 
        iprot.skip(ftype)
15098 
      iprot.readFieldEnd()
15099 
    iprot.readStructEnd()
15100 
 
15101 
  def write(self, oprot):
15102 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15103 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15104 
      return
15105 
    oprot.writeStructBegin('getUriMapping_result')
15106 
    if self.success is not None:
15107 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15108 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 15109 
      for iter245 in self.success:
15110 
        iter245.write(oprot)
8579 kshitij.so 15111 
      oprot.writeListEnd()
15112 
      oprot.writeFieldEnd()
15113 
    oprot.writeFieldStop()
15114 
    oprot.writeStructEnd()
15115 
 
15116 
  def validate(self):
15117 
    return
15118 
 
15119 
 
15120 
  def __repr__(self):
15121 
    L = ['%s=%r' % (key, value)
15122 
      for key, value in self.__dict__.iteritems()]
15123 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15124 
 
15125 
  def __eq__(self, other):
15126 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15127 
 
15128 
  def __ne__(self, other):
15129 
    return not (self == other)
15130 
 
15131 
class addCampaign_args:
15132 
  """
15133 
  Attributes:
15134 
   - campaign
15135 
  """
15136 
 
15137 
  thrift_spec = (
15138 
    None, # 0
15139 
    (1, TType.STRUCT, 'campaign', (Campaign, Campaign.thrift_spec), None, ), # 1
15140 
  )
15141 
 
15142 
  def __init__(self, campaign=None,):
15143 
    self.campaign = campaign
15144 
 
15145 
  def read(self, iprot):
15146 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15147 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15148 
      return
15149 
    iprot.readStructBegin()
15150 
    while True:
15151 
      (fname, ftype, fid) = iprot.readFieldBegin()
15152 
      if ftype == TType.STOP:
15153 
        break
15154 
      if fid == 1:
15155 
        if ftype == TType.STRUCT:
15156 
          self.campaign = Campaign()
15157 
          self.campaign.read(iprot)
15158 
        else:
15159 
          iprot.skip(ftype)
15160 
      else:
15161 
        iprot.skip(ftype)
15162 
      iprot.readFieldEnd()
15163 
    iprot.readStructEnd()
15164 
 
15165 
  def write(self, oprot):
15166 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15167 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15168 
      return
15169 
    oprot.writeStructBegin('addCampaign_args')
15170 
    if self.campaign is not None:
15171 
      oprot.writeFieldBegin('campaign', TType.STRUCT, 1)
15172 
      self.campaign.write(oprot)
15173 
      oprot.writeFieldEnd()
15174 
    oprot.writeFieldStop()
15175 
    oprot.writeStructEnd()
15176 
 
15177 
  def validate(self):
15178 
    return
15179 
 
15180 
 
15181 
  def __repr__(self):
15182 
    L = ['%s=%r' % (key, value)
15183 
      for key, value in self.__dict__.iteritems()]
15184 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15185 
 
15186 
  def __eq__(self, other):
15187 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15188 
 
15189 
  def __ne__(self, other):
15190 
    return not (self == other)
15191 
 
15192 
class addCampaign_result:
15193 
 
15194 
  thrift_spec = (
15195 
  )
15196 
 
15197 
  def read(self, iprot):
15198 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15199 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15200 
      return
15201 
    iprot.readStructBegin()
15202 
    while True:
15203 
      (fname, ftype, fid) = iprot.readFieldBegin()
15204 
      if ftype == TType.STOP:
15205 
        break
15206 
      else:
15207 
        iprot.skip(ftype)
15208 
      iprot.readFieldEnd()
15209 
    iprot.readStructEnd()
15210 
 
15211 
  def write(self, oprot):
15212 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15213 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15214 
      return
15215 
    oprot.writeStructBegin('addCampaign_result')
15216 
    oprot.writeFieldStop()
15217 
    oprot.writeStructEnd()
15218 
 
15219 
  def validate(self):
15220 
    return
15221 
 
15222 
 
15223 
  def __repr__(self):
15224 
    L = ['%s=%r' % (key, value)
15225 
      for key, value in self.__dict__.iteritems()]
15226 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15227 
 
15228 
  def __eq__(self, other):
15229 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15230 
 
15231 
  def __ne__(self, other):
15232 
    return not (self == other)
15233 
 
15234 
class getCampaigns_args:
15235 
  """
15236 
  Attributes:
15237 
   - campaignName
15238 
  """
15239 
 
15240 
  thrift_spec = (
15241 
    None, # 0
15242 
    (1, TType.STRING, 'campaignName', None, None, ), # 1
15243 
  )
15244 
 
15245 
  def __init__(self, campaignName=None,):
15246 
    self.campaignName = campaignName
15247 
 
15248 
  def read(self, iprot):
15249 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15250 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15251 
      return
15252 
    iprot.readStructBegin()
15253 
    while True:
15254 
      (fname, ftype, fid) = iprot.readFieldBegin()
15255 
      if ftype == TType.STOP:
15256 
        break
15257 
      if fid == 1:
15258 
        if ftype == TType.STRING:
15259 
          self.campaignName = iprot.readString();
15260 
        else:
15261 
          iprot.skip(ftype)
15262 
      else:
15263 
        iprot.skip(ftype)
15264 
      iprot.readFieldEnd()
15265 
    iprot.readStructEnd()
15266 
 
15267 
  def write(self, oprot):
15268 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15269 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15270 
      return
15271 
    oprot.writeStructBegin('getCampaigns_args')
15272 
    if self.campaignName is not None:
15273 
      oprot.writeFieldBegin('campaignName', TType.STRING, 1)
15274 
      oprot.writeString(self.campaignName)
15275 
      oprot.writeFieldEnd()
15276 
    oprot.writeFieldStop()
15277 
    oprot.writeStructEnd()
15278 
 
15279 
  def validate(self):
15280 
    return
15281 
 
15282 
 
15283 
  def __repr__(self):
15284 
    L = ['%s=%r' % (key, value)
15285 
      for key, value in self.__dict__.iteritems()]
15286 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15287 
 
15288 
  def __eq__(self, other):
15289 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15290 
 
15291 
  def __ne__(self, other):
15292 
    return not (self == other)
15293 
 
15294 
class getCampaigns_result:
15295 
  """
15296 
  Attributes:
15297 
   - success
15298 
  """
15299 
 
15300 
  thrift_spec = (
15301 
    (0, TType.LIST, 'success', (TType.STRUCT,(Campaign, Campaign.thrift_spec)), None, ), # 0
15302 
  )
15303 
 
15304 
  def __init__(self, success=None,):
15305 
    self.success = success
15306 
 
15307 
  def read(self, iprot):
15308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15310 
      return
15311 
    iprot.readStructBegin()
15312 
    while True:
15313 
      (fname, ftype, fid) = iprot.readFieldBegin()
15314 
      if ftype == TType.STOP:
15315 
        break
15316 
      if fid == 0:
15317 
        if ftype == TType.LIST:
15318 
          self.success = []
8590 kshitij.so 15319 
          (_etype249, _size246) = iprot.readListBegin()
15320 
          for _i250 in xrange(_size246):
15321 
            _elem251 = Campaign()
15322 
            _elem251.read(iprot)
15323 
            self.success.append(_elem251)
8579 kshitij.so 15324 
          iprot.readListEnd()
15325 
        else:
15326 
          iprot.skip(ftype)
15327 
      else:
15328 
        iprot.skip(ftype)
15329 
      iprot.readFieldEnd()
15330 
    iprot.readStructEnd()
15331 
 
15332 
  def write(self, oprot):
15333 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15334 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15335 
      return
15336 
    oprot.writeStructBegin('getCampaigns_result')
15337 
    if self.success is not None:
15338 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15339 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 15340 
      for iter252 in self.success:
15341 
        iter252.write(oprot)
8579 kshitij.so 15342 
      oprot.writeListEnd()
15343 
      oprot.writeFieldEnd()
15344 
    oprot.writeFieldStop()
15345 
    oprot.writeStructEnd()
15346 
 
15347 
  def validate(self):
15348 
    return
15349 
 
15350 
 
15351 
  def __repr__(self):
15352 
    L = ['%s=%r' % (key, value)
15353 
      for key, value in self.__dict__.iteritems()]
15354 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15355 
 
15356 
  def __eq__(self, other):
15357 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15358 
 
15359 
  def __ne__(self, other):
15360 
    return not (self == other)
15361 
 
15362 
class deleteCampaign_args:
15363 
  """
15364 
  Attributes:
15365 
   - campaignId
15366 
  """
15367 
 
15368 
  thrift_spec = (
15369 
    None, # 0
15370 
    (1, TType.I64, 'campaignId', None, None, ), # 1
15371 
  )
15372 
 
15373 
  def __init__(self, campaignId=None,):
15374 
    self.campaignId = campaignId
15375 
 
15376 
  def read(self, iprot):
15377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15379 
      return
15380 
    iprot.readStructBegin()
15381 
    while True:
15382 
      (fname, ftype, fid) = iprot.readFieldBegin()
15383 
      if ftype == TType.STOP:
15384 
        break
15385 
      if fid == 1:
15386 
        if ftype == TType.I64:
15387 
          self.campaignId = iprot.readI64();
15388 
        else:
15389 
          iprot.skip(ftype)
15390 
      else:
15391 
        iprot.skip(ftype)
15392 
      iprot.readFieldEnd()
15393 
    iprot.readStructEnd()
15394 
 
15395 
  def write(self, oprot):
15396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15398 
      return
15399 
    oprot.writeStructBegin('deleteCampaign_args')
15400 
    if self.campaignId is not None:
15401 
      oprot.writeFieldBegin('campaignId', TType.I64, 1)
15402 
      oprot.writeI64(self.campaignId)
15403 
      oprot.writeFieldEnd()
15404 
    oprot.writeFieldStop()
15405 
    oprot.writeStructEnd()
15406 
 
15407 
  def validate(self):
15408 
    return
15409 
 
15410 
 
15411 
  def __repr__(self):
15412 
    L = ['%s=%r' % (key, value)
15413 
      for key, value in self.__dict__.iteritems()]
15414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15415 
 
15416 
  def __eq__(self, other):
15417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15418 
 
15419 
  def __ne__(self, other):
15420 
    return not (self == other)
15421 
 
15422 
class deleteCampaign_result:
15423 
 
15424 
  thrift_spec = (
15425 
  )
15426 
 
15427 
  def read(self, iprot):
15428 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15429 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15430 
      return
15431 
    iprot.readStructBegin()
15432 
    while True:
15433 
      (fname, ftype, fid) = iprot.readFieldBegin()
15434 
      if ftype == TType.STOP:
15435 
        break
15436 
      else:
15437 
        iprot.skip(ftype)
15438 
      iprot.readFieldEnd()
15439 
    iprot.readStructEnd()
15440 
 
15441 
  def write(self, oprot):
15442 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15443 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15444 
      return
15445 
    oprot.writeStructBegin('deleteCampaign_result')
15446 
    oprot.writeFieldStop()
15447 
    oprot.writeStructEnd()
15448 
 
15449 
  def validate(self):
15450 
    return
15451 
 
15452 
 
15453 
  def __repr__(self):
15454 
    L = ['%s=%r' % (key, value)
15455 
      for key, value in self.__dict__.iteritems()]
15456 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15457 
 
15458 
  def __eq__(self, other):
15459 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15460 
 
15461 
  def __ne__(self, other):
15462 
    return not (self == other)
15463 
 
15464 
class getAllCampaigns_args:
15465 
 
15466 
  thrift_spec = (
15467 
  )
15468 
 
15469 
  def read(self, iprot):
15470 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15471 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15472 
      return
15473 
    iprot.readStructBegin()
15474 
    while True:
15475 
      (fname, ftype, fid) = iprot.readFieldBegin()
15476 
      if ftype == TType.STOP:
15477 
        break
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('getAllCampaigns_args')
15488 
    oprot.writeFieldStop()
15489 
    oprot.writeStructEnd()
15490 
 
15491 
  def validate(self):
15492 
    return
15493 
 
15494 
 
15495 
  def __repr__(self):
15496 
    L = ['%s=%r' % (key, value)
15497 
      for key, value in self.__dict__.iteritems()]
15498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15499 
 
15500 
  def __eq__(self, other):
15501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15502 
 
15503 
  def __ne__(self, other):
15504 
    return not (self == other)
15505 
 
15506 
class getAllCampaigns_result:
15507 
  """
15508 
  Attributes:
15509 
   - success
15510 
  """
15511 
 
15512 
  thrift_spec = (
15513 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
15514 
  )
15515 
 
15516 
  def __init__(self, success=None,):
15517 
    self.success = success
15518 
 
15519 
  def read(self, iprot):
15520 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15521 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15522 
      return
15523 
    iprot.readStructBegin()
15524 
    while True:
15525 
      (fname, ftype, fid) = iprot.readFieldBegin()
15526 
      if ftype == TType.STOP:
15527 
        break
15528 
      if fid == 0:
15529 
        if ftype == TType.LIST:
15530 
          self.success = []
8590 kshitij.so 15531 
          (_etype256, _size253) = iprot.readListBegin()
15532 
          for _i257 in xrange(_size253):
15533 
            _elem258 = iprot.readString();
15534 
            self.success.append(_elem258)
8579 kshitij.so 15535 
          iprot.readListEnd()
15536 
        else:
15537 
          iprot.skip(ftype)
15538 
      else:
15539 
        iprot.skip(ftype)
15540 
      iprot.readFieldEnd()
15541 
    iprot.readStructEnd()
15542 
 
15543 
  def write(self, oprot):
15544 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15545 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15546 
      return
15547 
    oprot.writeStructBegin('getAllCampaigns_result')
15548 
    if self.success is not None:
15549 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15550 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 15551 
      for iter259 in self.success:
15552 
        oprot.writeString(iter259)
8579 kshitij.so 15553 
      oprot.writeListEnd()
15554 
      oprot.writeFieldEnd()
15555 
    oprot.writeFieldStop()
15556 
    oprot.writeStructEnd()
15557 
 
15558 
  def validate(self):
15559 
    return
15560 
 
15561 
 
15562 
  def __repr__(self):
15563 
    L = ['%s=%r' % (key, value)
15564 
      for key, value in self.__dict__.iteritems()]
15565 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15566 
 
15567 
  def __eq__(self, other):
15568 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15569 
 
15570 
  def __ne__(self, other):
15571 
    return not (self == other)
15572 
 
9155 kshitij.so 15573 
class getActiveBannersForMobileSite_args:
15574 
 
15575 
  thrift_spec = (
15576 
  )
15577 
 
15578 
  def read(self, iprot):
15579 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15580 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15581 
      return
15582 
    iprot.readStructBegin()
15583 
    while True:
15584 
      (fname, ftype, fid) = iprot.readFieldBegin()
15585 
      if ftype == TType.STOP:
15586 
        break
15587 
      else:
15588 
        iprot.skip(ftype)
15589 
      iprot.readFieldEnd()
15590 
    iprot.readStructEnd()
15591 
 
15592 
  def write(self, oprot):
15593 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15594 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15595 
      return
15596 
    oprot.writeStructBegin('getActiveBannersForMobileSite_args')
15597 
    oprot.writeFieldStop()
15598 
    oprot.writeStructEnd()
15599 
 
15600 
  def validate(self):
15601 
    return
15602 
 
15603 
 
15604 
  def __repr__(self):
15605 
    L = ['%s=%r' % (key, value)
15606 
      for key, value in self.__dict__.iteritems()]
15607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15608 
 
15609 
  def __eq__(self, other):
15610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15611 
 
15612 
  def __ne__(self, other):
15613 
    return not (self == other)
15614 
 
15615 
class getActiveBannersForMobileSite_result:
15616 
  """
15617 
  Attributes:
15618 
   - success
15619 
  """
15620 
 
15621 
  thrift_spec = (
15622 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
15623 
  )
15624 
 
15625 
  def __init__(self, success=None,):
15626 
    self.success = success
15627 
 
15628 
  def read(self, iprot):
15629 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15630 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15631 
      return
15632 
    iprot.readStructBegin()
15633 
    while True:
15634 
      (fname, ftype, fid) = iprot.readFieldBegin()
15635 
      if ftype == TType.STOP:
15636 
        break
15637 
      if fid == 0:
15638 
        if ftype == TType.MAP:
15639 
          self.success = {}
15640 
          (_ktype261, _vtype262, _size260 ) = iprot.readMapBegin()
15641 
          for _i264 in xrange(_size260):
15642 
            _key265 = iprot.readString();
15643 
            _val266 = []
15644 
            (_etype270, _size267) = iprot.readListBegin()
15645 
            for _i271 in xrange(_size267):
15646 
              _elem272 = Banner()
15647 
              _elem272.read(iprot)
15648 
              _val266.append(_elem272)
15649 
            iprot.readListEnd()
15650 
            self.success[_key265] = _val266
15651 
          iprot.readMapEnd()
15652 
        else:
15653 
          iprot.skip(ftype)
15654 
      else:
15655 
        iprot.skip(ftype)
15656 
      iprot.readFieldEnd()
15657 
    iprot.readStructEnd()
15658 
 
15659 
  def write(self, oprot):
15660 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15661 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15662 
      return
15663 
    oprot.writeStructBegin('getActiveBannersForMobileSite_result')
15664 
    if self.success is not None:
15665 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15666 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
15667 
      for kiter273,viter274 in self.success.items():
15668 
        oprot.writeString(kiter273)
15669 
        oprot.writeListBegin(TType.STRUCT, len(viter274))
15670 
        for iter275 in viter274:
15671 
          iter275.write(oprot)
15672 
        oprot.writeListEnd()
15673 
      oprot.writeMapEnd()
15674 
      oprot.writeFieldEnd()
15675 
    oprot.writeFieldStop()
15676 
    oprot.writeStructEnd()
15677 
 
15678 
  def validate(self):
15679 
    return
15680 
 
15681 
 
15682 
  def __repr__(self):
15683 
    L = ['%s=%r' % (key, value)
15684 
      for key, value in self.__dict__.iteritems()]
15685 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15686 
 
15687 
  def __eq__(self, other):
15688 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15689 
 
15690 
  def __ne__(self, other):
15691 
    return not (self == other)
15692 
 
5944 mandeep.dh 15693 
class deleteSimilarItem_args:
15694 
  """
15695 
  Attributes:
15696 
   - itemId
15697 
   - catalogItemId
15698 
  """
15699 
 
15700 
  thrift_spec = (
15701 
    None, # 0
15702 
    (1, TType.I64, 'itemId', None, None, ), # 1
15703 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
15704 
  )
15705 
 
15706 
  def __init__(self, itemId=None, catalogItemId=None,):
15707 
    self.itemId = itemId
15708 
    self.catalogItemId = catalogItemId
15709 
 
15710 
  def read(self, iprot):
15711 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15712 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15713 
      return
15714 
    iprot.readStructBegin()
15715 
    while True:
15716 
      (fname, ftype, fid) = iprot.readFieldBegin()
15717 
      if ftype == TType.STOP:
15718 
        break
15719 
      if fid == 1:
15720 
        if ftype == TType.I64:
15721 
          self.itemId = iprot.readI64();
15722 
        else:
15723 
          iprot.skip(ftype)
15724 
      elif fid == 2:
15725 
        if ftype == TType.I64:
15726 
          self.catalogItemId = iprot.readI64();
15727 
        else:
15728 
          iprot.skip(ftype)
15729 
      else:
15730 
        iprot.skip(ftype)
15731 
      iprot.readFieldEnd()
15732 
    iprot.readStructEnd()
15733 
 
15734 
  def write(self, oprot):
15735 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15736 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15737 
      return
15738 
    oprot.writeStructBegin('deleteSimilarItem_args')
15739 
    if self.itemId is not None:
15740 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15741 
      oprot.writeI64(self.itemId)
15742 
      oprot.writeFieldEnd()
15743 
    if self.catalogItemId is not None:
15744 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
15745 
      oprot.writeI64(self.catalogItemId)
15746 
      oprot.writeFieldEnd()
15747 
    oprot.writeFieldStop()
15748 
    oprot.writeStructEnd()
15749 
 
15750 
  def validate(self):
15751 
    return
15752 
 
15753 
 
15754 
  def __repr__(self):
15755 
    L = ['%s=%r' % (key, value)
15756 
      for key, value in self.__dict__.iteritems()]
15757 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15758 
 
15759 
  def __eq__(self, other):
15760 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15761 
 
15762 
  def __ne__(self, other):
15763 
    return not (self == other)
15764 
 
15765 
class deleteSimilarItem_result:
15766 
  """
15767 
  Attributes:
15768 
   - success
15769 
   - cex
15770 
  """
15771 
 
15772 
  thrift_spec = (
15773 
    (0, TType.BOOL, 'success', None, None, ), # 0
15774 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
15775 
  )
15776 
 
15777 
  def __init__(self, success=None, cex=None,):
15778 
    self.success = success
15779 
    self.cex = cex
15780 
 
15781 
  def read(self, iprot):
15782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15784 
      return
15785 
    iprot.readStructBegin()
15786 
    while True:
15787 
      (fname, ftype, fid) = iprot.readFieldBegin()
15788 
      if ftype == TType.STOP:
15789 
        break
15790 
      if fid == 0:
15791 
        if ftype == TType.BOOL:
15792 
          self.success = iprot.readBool();
15793 
        else:
15794 
          iprot.skip(ftype)
15795 
      elif fid == 1:
15796 
        if ftype == TType.STRUCT:
15797 
          self.cex = CatalogServiceException()
15798 
          self.cex.read(iprot)
15799 
        else:
15800 
          iprot.skip(ftype)
15801 
      else:
15802 
        iprot.skip(ftype)
15803 
      iprot.readFieldEnd()
15804 
    iprot.readStructEnd()
15805 
 
15806 
  def write(self, oprot):
15807 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15808 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15809 
      return
15810 
    oprot.writeStructBegin('deleteSimilarItem_result')
15811 
    if self.success is not None:
15812 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15813 
      oprot.writeBool(self.success)
15814 
      oprot.writeFieldEnd()
15815 
    if self.cex is not None:
15816 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15817 
      self.cex.write(oprot)
15818 
      oprot.writeFieldEnd()
15819 
    oprot.writeFieldStop()
15820 
    oprot.writeStructEnd()
15821 
 
15822 
  def validate(self):
15823 
    return
15824 
 
15825 
 
15826 
  def __repr__(self):
15827 
    L = ['%s=%r' % (key, value)
15828 
      for key, value in self.__dict__.iteritems()]
15829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15830 
 
15831 
  def __eq__(self, other):
15832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15833 
 
15834 
  def __ne__(self, other):
15835 
    return not (self == other)
15836 
 
15837 
class checkSimilarItem_args:
15838 
  """
15839 
  Attributes:
15840 
   - brand
15841 
   - modelNumber
15842 
   - modelName
15843 
   - color
15844 
  """
15845 
 
15846 
  thrift_spec = (
15847 
    None, # 0
15848 
    (1, TType.STRING, 'brand', None, None, ), # 1
15849 
    (2, TType.STRING, 'modelNumber', None, None, ), # 2
15850 
    (3, TType.STRING, 'modelName', None, None, ), # 3
15851 
    (4, TType.STRING, 'color', None, None, ), # 4
15852 
  )
15853 
 
15854 
  def __init__(self, brand=None, modelNumber=None, modelName=None, color=None,):
15855 
    self.brand = brand
15856 
    self.modelNumber = modelNumber
15857 
    self.modelName = modelName
15858 
    self.color = color
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.STRING:
15871 
          self.brand = iprot.readString();
15872 
        else:
15873 
          iprot.skip(ftype)
15874 
      elif fid == 2:
15875 
        if ftype == TType.STRING:
15876 
          self.modelNumber = iprot.readString();
15877 
        else:
15878 
          iprot.skip(ftype)
15879 
      elif fid == 3:
15880 
        if ftype == TType.STRING:
15881 
          self.modelName = iprot.readString();
15882 
        else:
15883 
          iprot.skip(ftype)
15884 
      elif fid == 4:
15885 
        if ftype == TType.STRING:
15886 
          self.color = iprot.readString();
15887 
        else:
15888 
          iprot.skip(ftype)
15889 
      else:
15890 
        iprot.skip(ftype)
15891 
      iprot.readFieldEnd()
15892 
    iprot.readStructEnd()
15893 
 
15894 
  def write(self, oprot):
15895 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15896 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15897 
      return
15898 
    oprot.writeStructBegin('checkSimilarItem_args')
15899 
    if self.brand is not None:
15900 
      oprot.writeFieldBegin('brand', TType.STRING, 1)
15901 
      oprot.writeString(self.brand)
15902 
      oprot.writeFieldEnd()
15903 
    if self.modelNumber is not None:
15904 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 2)
15905 
      oprot.writeString(self.modelNumber)
15906 
      oprot.writeFieldEnd()
15907 
    if self.modelName is not None:
15908 
      oprot.writeFieldBegin('modelName', TType.STRING, 3)
15909 
      oprot.writeString(self.modelName)
15910 
      oprot.writeFieldEnd()
15911 
    if self.color is not None:
15912 
      oprot.writeFieldBegin('color', TType.STRING, 4)
15913 
      oprot.writeString(self.color)
15914 
      oprot.writeFieldEnd()
15915 
    oprot.writeFieldStop()
15916 
    oprot.writeStructEnd()
15917 
 
15918 
  def validate(self):
15919 
    return
15920 
 
15921 
 
15922 
  def __repr__(self):
15923 
    L = ['%s=%r' % (key, value)
15924 
      for key, value in self.__dict__.iteritems()]
15925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15926 
 
15927 
  def __eq__(self, other):
15928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15929 
 
15930 
  def __ne__(self, other):
15931 
    return not (self == other)
15932 
 
15933 
class checkSimilarItem_result:
15934 
  """
15935 
  Attributes:
15936 
   - success
15937 
  """
15938 
 
15939 
  thrift_spec = (
15940 
    (0, TType.I64, 'success', None, None, ), # 0
15941 
  )
15942 
 
15943 
  def __init__(self, success=None,):
15944 
    self.success = success
15945 
 
15946 
  def read(self, iprot):
15947 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15948 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15949 
      return
15950 
    iprot.readStructBegin()
15951 
    while True:
15952 
      (fname, ftype, fid) = iprot.readFieldBegin()
15953 
      if ftype == TType.STOP:
15954 
        break
15955 
      if fid == 0:
15956 
        if ftype == TType.I64:
15957 
          self.success = iprot.readI64();
15958 
        else:
15959 
          iprot.skip(ftype)
15960 
      else:
15961 
        iprot.skip(ftype)
15962 
      iprot.readFieldEnd()
15963 
    iprot.readStructEnd()
15964 
 
15965 
  def write(self, oprot):
15966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15968 
      return
15969 
    oprot.writeStructBegin('checkSimilarItem_result')
15970 
    if self.success is not None:
15971 
      oprot.writeFieldBegin('success', TType.I64, 0)
15972 
      oprot.writeI64(self.success)
15973 
      oprot.writeFieldEnd()
15974 
    oprot.writeFieldStop()
15975 
    oprot.writeStructEnd()
15976 
 
15977 
  def validate(self):
15978 
    return
15979 
 
15980 
 
15981 
  def __repr__(self):
15982 
    L = ['%s=%r' % (key, value)
15983 
      for key, value in self.__dict__.iteritems()]
15984 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15985 
 
15986 
  def __eq__(self, other):
15987 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15988 
 
15989 
  def __ne__(self, other):
15990 
    return not (self == other)
15991 
 
15992 
class validateRiskyStatus_args:
15993 
  """
15994 
  Attributes:
15995 
   - itemId
15996 
  """
15997 
 
15998 
  thrift_spec = (
15999 
    None, # 0
16000 
    (1, TType.I64, 'itemId', None, None, ), # 1
16001 
  )
16002 
 
16003 
  def __init__(self, itemId=None,):
16004 
    self.itemId = itemId
16005 
 
16006 
  def read(self, iprot):
16007 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16008 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16009 
      return
16010 
    iprot.readStructBegin()
16011 
    while True:
16012 
      (fname, ftype, fid) = iprot.readFieldBegin()
16013 
      if ftype == TType.STOP:
16014 
        break
16015 
      if fid == 1:
16016 
        if ftype == TType.I64:
16017 
          self.itemId = iprot.readI64();
16018 
        else:
16019 
          iprot.skip(ftype)
16020 
      else:
16021 
        iprot.skip(ftype)
16022 
      iprot.readFieldEnd()
16023 
    iprot.readStructEnd()
16024 
 
16025 
  def write(self, oprot):
16026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16028 
      return
16029 
    oprot.writeStructBegin('validateRiskyStatus_args')
16030 
    if self.itemId is not None:
16031 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16032 
      oprot.writeI64(self.itemId)
16033 
      oprot.writeFieldEnd()
16034 
    oprot.writeFieldStop()
16035 
    oprot.writeStructEnd()
16036 
 
16037 
  def validate(self):
16038 
    return
16039 
 
16040 
 
16041 
  def __repr__(self):
16042 
    L = ['%s=%r' % (key, value)
16043 
      for key, value in self.__dict__.iteritems()]
16044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16045 
 
16046 
  def __eq__(self, other):
16047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16048 
 
16049 
  def __ne__(self, other):
16050 
    return not (self == other)
16051 
 
16052 
class validateRiskyStatus_result:
16053 
 
16054 
  thrift_spec = (
16055 
  )
16056 
 
16057 
  def read(self, iprot):
16058 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16059 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16060 
      return
16061 
    iprot.readStructBegin()
16062 
    while True:
16063 
      (fname, ftype, fid) = iprot.readFieldBegin()
16064 
      if ftype == TType.STOP:
16065 
        break
16066 
      else:
16067 
        iprot.skip(ftype)
16068 
      iprot.readFieldEnd()
16069 
    iprot.readStructEnd()
16070 
 
16071 
  def write(self, oprot):
16072 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16073 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16074 
      return
16075 
    oprot.writeStructBegin('validateRiskyStatus_result')
16076 
    oprot.writeFieldStop()
16077 
    oprot.writeStructEnd()
16078 
 
16079 
  def validate(self):
16080 
    return
16081 
 
16082 
 
16083 
  def __repr__(self):
16084 
    L = ['%s=%r' % (key, value)
16085 
      for key, value in self.__dict__.iteritems()]
16086 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16087 
 
16088 
  def __eq__(self, other):
16089 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16090 
 
16091 
  def __ne__(self, other):
16092 
    return not (self == other)
16093 
 
16094 
class changeItemRiskyFlag_args:
16095 
  """
16096 
  Attributes:
16097 
   - itemId
16098 
   - risky
16099 
  """
16100 
 
16101 
  thrift_spec = (
16102 
    None, # 0
16103 
    (1, TType.I64, 'itemId', None, None, ), # 1
16104 
    (2, TType.BOOL, 'risky', None, None, ), # 2
16105 
  )
16106 
 
16107 
  def __init__(self, itemId=None, risky=None,):
16108 
    self.itemId = itemId
16109 
    self.risky = risky
16110 
 
16111 
  def read(self, iprot):
16112 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16113 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16114 
      return
16115 
    iprot.readStructBegin()
16116 
    while True:
16117 
      (fname, ftype, fid) = iprot.readFieldBegin()
16118 
      if ftype == TType.STOP:
16119 
        break
16120 
      if fid == 1:
16121 
        if ftype == TType.I64:
16122 
          self.itemId = iprot.readI64();
16123 
        else:
16124 
          iprot.skip(ftype)
16125 
      elif fid == 2:
16126 
        if ftype == TType.BOOL:
16127 
          self.risky = iprot.readBool();
16128 
        else:
16129 
          iprot.skip(ftype)
16130 
      else:
16131 
        iprot.skip(ftype)
16132 
      iprot.readFieldEnd()
16133 
    iprot.readStructEnd()
16134 
 
16135 
  def write(self, oprot):
16136 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16137 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16138 
      return
16139 
    oprot.writeStructBegin('changeItemRiskyFlag_args')
16140 
    if self.itemId is not None:
16141 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16142 
      oprot.writeI64(self.itemId)
16143 
      oprot.writeFieldEnd()
16144 
    if self.risky is not None:
16145 
      oprot.writeFieldBegin('risky', TType.BOOL, 2)
16146 
      oprot.writeBool(self.risky)
16147 
      oprot.writeFieldEnd()
16148 
    oprot.writeFieldStop()
16149 
    oprot.writeStructEnd()
16150 
 
16151 
  def validate(self):
16152 
    return
16153 
 
16154 
 
16155 
  def __repr__(self):
16156 
    L = ['%s=%r' % (key, value)
16157 
      for key, value in self.__dict__.iteritems()]
16158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16159 
 
16160 
  def __eq__(self, other):
16161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16162 
 
16163 
  def __ne__(self, other):
16164 
    return not (self == other)
16165 
 
16166 
class changeItemRiskyFlag_result:
16167 
 
16168 
  thrift_spec = (
16169 
  )
16170 
 
16171 
  def read(self, iprot):
16172 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16173 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16174 
      return
16175 
    iprot.readStructBegin()
16176 
    while True:
16177 
      (fname, ftype, fid) = iprot.readFieldBegin()
16178 
      if ftype == TType.STOP:
16179 
        break
16180 
      else:
16181 
        iprot.skip(ftype)
16182 
      iprot.readFieldEnd()
16183 
    iprot.readStructEnd()
16184 
 
16185 
  def write(self, oprot):
16186 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16187 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16188 
      return
16189 
    oprot.writeStructBegin('changeItemRiskyFlag_result')
16190 
    oprot.writeFieldStop()
16191 
    oprot.writeStructEnd()
16192 
 
16193 
  def validate(self):
16194 
    return
16195 
 
16196 
 
16197 
  def __repr__(self):
16198 
    L = ['%s=%r' % (key, value)
16199 
      for key, value in self.__dict__.iteritems()]
16200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16201 
 
16202 
  def __eq__(self, other):
16203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16204 
 
16205 
  def __ne__(self, other):
16206 
    return not (self == other)
16207 
 
16208 
class getItemsByRiskyFlag_args:
16209 
 
16210 
  thrift_spec = (
16211 
  )
16212 
 
16213 
  def read(self, iprot):
16214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16216 
      return
16217 
    iprot.readStructBegin()
16218 
    while True:
16219 
      (fname, ftype, fid) = iprot.readFieldBegin()
16220 
      if ftype == TType.STOP:
16221 
        break
16222 
      else:
16223 
        iprot.skip(ftype)
16224 
      iprot.readFieldEnd()
16225 
    iprot.readStructEnd()
16226 
 
16227 
  def write(self, oprot):
16228 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16229 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16230 
      return
16231 
    oprot.writeStructBegin('getItemsByRiskyFlag_args')
16232 
    oprot.writeFieldStop()
16233 
    oprot.writeStructEnd()
16234 
 
16235 
  def validate(self):
16236 
    return
16237 
 
16238 
 
16239 
  def __repr__(self):
16240 
    L = ['%s=%r' % (key, value)
16241 
      for key, value in self.__dict__.iteritems()]
16242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16243 
 
16244 
  def __eq__(self, other):
16245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16246 
 
16247 
  def __ne__(self, other):
16248 
    return not (self == other)
16249 
 
16250 
class getItemsByRiskyFlag_result:
16251 
  """
16252 
  Attributes:
16253 
   - success
16254 
  """
16255 
 
16256 
  thrift_spec = (
16257 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
16258 
  )
16259 
 
16260 
  def __init__(self, success=None,):
16261 
    self.success = success
16262 
 
16263 
  def read(self, iprot):
16264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16266 
      return
16267 
    iprot.readStructBegin()
16268 
    while True:
16269 
      (fname, ftype, fid) = iprot.readFieldBegin()
16270 
      if ftype == TType.STOP:
16271 
        break
16272 
      if fid == 0:
16273 
        if ftype == TType.LIST:
16274 
          self.success = []
9155 kshitij.so 16275 
          (_etype279, _size276) = iprot.readListBegin()
16276 
          for _i280 in xrange(_size276):
16277 
            _elem281 = Item()
16278 
            _elem281.read(iprot)
16279 
            self.success.append(_elem281)
5944 mandeep.dh 16280 
          iprot.readListEnd()
16281 
        else:
16282 
          iprot.skip(ftype)
16283 
      else:
16284 
        iprot.skip(ftype)
16285 
      iprot.readFieldEnd()
16286 
    iprot.readStructEnd()
16287 
 
16288 
  def write(self, oprot):
16289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16291 
      return
16292 
    oprot.writeStructBegin('getItemsByRiskyFlag_result')
16293 
    if self.success is not None:
16294 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16295 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16296 
      for iter282 in self.success:
16297 
        iter282.write(oprot)
5944 mandeep.dh 16298 
      oprot.writeListEnd()
16299 
      oprot.writeFieldEnd()
16300 
    oprot.writeFieldStop()
16301 
    oprot.writeStructEnd()
16302 
 
16303 
  def validate(self):
16304 
    return
16305 
 
16306 
 
16307 
  def __repr__(self):
16308 
    L = ['%s=%r' % (key, value)
16309 
      for key, value in self.__dict__.iteritems()]
16310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16311 
 
16312 
  def __eq__(self, other):
16313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16314 
 
16315 
  def __ne__(self, other):
16316 
    return not (self == other)
16317 
 
16318 
class getItemsForMasterSheet_args:
16319 
  """
16320 
  Attributes:
16321 
   - category
16322 
   - brand
16323 
  """
16324 
 
16325 
  thrift_spec = (
16326 
    None, # 0
16327 
    (1, TType.STRING, 'category', None, None, ), # 1
16328 
    (2, TType.STRING, 'brand', None, None, ), # 2
16329 
  )
16330 
 
16331 
  def __init__(self, category=None, brand=None,):
16332 
    self.category = category
16333 
    self.brand = brand
16334 
 
16335 
  def read(self, iprot):
16336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16338 
      return
16339 
    iprot.readStructBegin()
16340 
    while True:
16341 
      (fname, ftype, fid) = iprot.readFieldBegin()
16342 
      if ftype == TType.STOP:
16343 
        break
16344 
      if fid == 1:
16345 
        if ftype == TType.STRING:
16346 
          self.category = iprot.readString();
16347 
        else:
16348 
          iprot.skip(ftype)
16349 
      elif fid == 2:
16350 
        if ftype == TType.STRING:
16351 
          self.brand = iprot.readString();
16352 
        else:
16353 
          iprot.skip(ftype)
16354 
      else:
16355 
        iprot.skip(ftype)
16356 
      iprot.readFieldEnd()
16357 
    iprot.readStructEnd()
16358 
 
16359 
  def write(self, oprot):
16360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16362 
      return
16363 
    oprot.writeStructBegin('getItemsForMasterSheet_args')
16364 
    if self.category is not None:
16365 
      oprot.writeFieldBegin('category', TType.STRING, 1)
16366 
      oprot.writeString(self.category)
16367 
      oprot.writeFieldEnd()
16368 
    if self.brand is not None:
16369 
      oprot.writeFieldBegin('brand', TType.STRING, 2)
16370 
      oprot.writeString(self.brand)
16371 
      oprot.writeFieldEnd()
16372 
    oprot.writeFieldStop()
16373 
    oprot.writeStructEnd()
16374 
 
16375 
  def validate(self):
16376 
    return
16377 
 
16378 
 
16379 
  def __repr__(self):
16380 
    L = ['%s=%r' % (key, value)
16381 
      for key, value in self.__dict__.iteritems()]
16382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16383 
 
16384 
  def __eq__(self, other):
16385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16386 
 
16387 
  def __ne__(self, other):
16388 
    return not (self == other)
16389 
 
16390 
class getItemsForMasterSheet_result:
16391 
  """
16392 
  Attributes:
16393 
   - success
16394 
  """
16395 
 
16396 
  thrift_spec = (
16397 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
16398 
  )
16399 
 
16400 
  def __init__(self, success=None,):
16401 
    self.success = success
16402 
 
16403 
  def read(self, iprot):
16404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16406 
      return
16407 
    iprot.readStructBegin()
16408 
    while True:
16409 
      (fname, ftype, fid) = iprot.readFieldBegin()
16410 
      if ftype == TType.STOP:
16411 
        break
16412 
      if fid == 0:
16413 
        if ftype == TType.LIST:
16414 
          self.success = []
9155 kshitij.so 16415 
          (_etype286, _size283) = iprot.readListBegin()
16416 
          for _i287 in xrange(_size283):
16417 
            _elem288 = Item()
16418 
            _elem288.read(iprot)
16419 
            self.success.append(_elem288)
5944 mandeep.dh 16420 
          iprot.readListEnd()
16421 
        else:
16422 
          iprot.skip(ftype)
16423 
      else:
16424 
        iprot.skip(ftype)
16425 
      iprot.readFieldEnd()
16426 
    iprot.readStructEnd()
16427 
 
16428 
  def write(self, oprot):
16429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16431 
      return
16432 
    oprot.writeStructBegin('getItemsForMasterSheet_result')
16433 
    if self.success is not None:
16434 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16435 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16436 
      for iter289 in self.success:
16437 
        iter289.write(oprot)
5944 mandeep.dh 16438 
      oprot.writeListEnd()
16439 
      oprot.writeFieldEnd()
16440 
    oprot.writeFieldStop()
16441 
    oprot.writeStructEnd()
16442 
 
16443 
  def validate(self):
16444 
    return
16445 
 
16446 
 
16447 
  def __repr__(self):
16448 
    L = ['%s=%r' % (key, value)
16449 
      for key, value in self.__dict__.iteritems()]
16450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16451 
 
16452 
  def __eq__(self, other):
16453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16454 
 
16455 
  def __ne__(self, other):
16456 
    return not (self == other)
16457 
 
16458 
class getSimilarItemsCatalogIds_args:
16459 
  """
16460 
  Attributes:
16461 
   - beginIndex
16462 
   - totalItems
16463 
   - itemId
16464 
  """
16465 
 
16466 
  thrift_spec = (
16467 
    None, # 0
16468 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
16469 
    (2, TType.I64, 'totalItems', None, None, ), # 2
16470 
    (3, TType.I64, 'itemId', None, None, ), # 3
16471 
  )
16472 
 
16473 
  def __init__(self, beginIndex=None, totalItems=None, itemId=None,):
16474 
    self.beginIndex = beginIndex
16475 
    self.totalItems = totalItems
16476 
    self.itemId = itemId
16477 
 
16478 
  def read(self, iprot):
16479 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16480 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16481 
      return
16482 
    iprot.readStructBegin()
16483 
    while True:
16484 
      (fname, ftype, fid) = iprot.readFieldBegin()
16485 
      if ftype == TType.STOP:
16486 
        break
16487 
      if fid == 1:
16488 
        if ftype == TType.I64:
16489 
          self.beginIndex = iprot.readI64();
16490 
        else:
16491 
          iprot.skip(ftype)
16492 
      elif fid == 2:
16493 
        if ftype == TType.I64:
16494 
          self.totalItems = iprot.readI64();
16495 
        else:
16496 
          iprot.skip(ftype)
16497 
      elif fid == 3:
16498 
        if ftype == TType.I64:
16499 
          self.itemId = iprot.readI64();
16500 
        else:
16501 
          iprot.skip(ftype)
16502 
      else:
16503 
        iprot.skip(ftype)
16504 
      iprot.readFieldEnd()
16505 
    iprot.readStructEnd()
16506 
 
16507 
  def write(self, oprot):
16508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16510 
      return
16511 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_args')
16512 
    if self.beginIndex is not None:
16513 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
16514 
      oprot.writeI64(self.beginIndex)
16515 
      oprot.writeFieldEnd()
16516 
    if self.totalItems is not None:
16517 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
16518 
      oprot.writeI64(self.totalItems)
16519 
      oprot.writeFieldEnd()
16520 
    if self.itemId is not None:
16521 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
16522 
      oprot.writeI64(self.itemId)
16523 
      oprot.writeFieldEnd()
16524 
    oprot.writeFieldStop()
16525 
    oprot.writeStructEnd()
16526 
 
16527 
  def validate(self):
16528 
    return
16529 
 
16530 
 
16531 
  def __repr__(self):
16532 
    L = ['%s=%r' % (key, value)
16533 
      for key, value in self.__dict__.iteritems()]
16534 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16535 
 
16536 
  def __eq__(self, other):
16537 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16538 
 
16539 
  def __ne__(self, other):
16540 
    return not (self == other)
16541 
 
16542 
class getSimilarItemsCatalogIds_result:
16543 
  """
16544 
  Attributes:
16545 
   - success
16546 
  """
16547 
 
16548 
  thrift_spec = (
16549 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
16550 
  )
16551 
 
16552 
  def __init__(self, success=None,):
16553 
    self.success = success
16554 
 
16555 
  def read(self, iprot):
16556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16558 
      return
16559 
    iprot.readStructBegin()
16560 
    while True:
16561 
      (fname, ftype, fid) = iprot.readFieldBegin()
16562 
      if ftype == TType.STOP:
16563 
        break
16564 
      if fid == 0:
16565 
        if ftype == TType.LIST:
16566 
          self.success = []
9155 kshitij.so 16567 
          (_etype293, _size290) = iprot.readListBegin()
16568 
          for _i294 in xrange(_size290):
16569 
            _elem295 = iprot.readI64();
16570 
            self.success.append(_elem295)
5944 mandeep.dh 16571 
          iprot.readListEnd()
16572 
        else:
16573 
          iprot.skip(ftype)
16574 
      else:
16575 
        iprot.skip(ftype)
16576 
      iprot.readFieldEnd()
16577 
    iprot.readStructEnd()
16578 
 
16579 
  def write(self, oprot):
16580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16582 
      return
16583 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_result')
16584 
    if self.success is not None:
16585 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16586 
      oprot.writeListBegin(TType.I64, len(self.success))
9155 kshitij.so 16587 
      for iter296 in self.success:
16588 
        oprot.writeI64(iter296)
5944 mandeep.dh 16589 
      oprot.writeListEnd()
16590 
      oprot.writeFieldEnd()
16591 
    oprot.writeFieldStop()
16592 
    oprot.writeStructEnd()
16593 
 
16594 
  def validate(self):
16595 
    return
16596 
 
16597 
 
16598 
  def __repr__(self):
16599 
    L = ['%s=%r' % (key, value)
16600 
      for key, value in self.__dict__.iteritems()]
16601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16602 
 
16603 
  def __eq__(self, other):
16604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16605 
 
16606 
  def __ne__(self, other):
16607 
    return not (self == other)
16608 
 
16609 
class addProductNotification_args:
16610 
  """
16611 
  Attributes:
16612 
   - itemId
16613 
   - email
16614 
  """
16615 
 
16616 
  thrift_spec = None
16617 
  def __init__(self, itemId=None, email=None,):
16618 
    self.itemId = itemId
16619 
    self.email = email
16620 
 
16621 
  def read(self, iprot):
16622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16624 
      return
16625 
    iprot.readStructBegin()
16626 
    while True:
16627 
      (fname, ftype, fid) = iprot.readFieldBegin()
16628 
      if ftype == TType.STOP:
16629 
        break
16630 
      if fid == -1:
16631 
        if ftype == TType.I64:
16632 
          self.itemId = iprot.readI64();
16633 
        else:
16634 
          iprot.skip(ftype)
16635 
      elif fid == -2:
16636 
        if ftype == TType.STRING:
16637 
          self.email = iprot.readString();
16638 
        else:
16639 
          iprot.skip(ftype)
16640 
      else:
16641 
        iprot.skip(ftype)
16642 
      iprot.readFieldEnd()
16643 
    iprot.readStructEnd()
16644 
 
16645 
  def write(self, oprot):
16646 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16647 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16648 
      return
16649 
    oprot.writeStructBegin('addProductNotification_args')
16650 
    if self.email is not None:
16651 
      oprot.writeFieldBegin('email', TType.STRING, -2)
16652 
      oprot.writeString(self.email)
16653 
      oprot.writeFieldEnd()
16654 
    if self.itemId is not None:
16655 
      oprot.writeFieldBegin('itemId', TType.I64, -1)
16656 
      oprot.writeI64(self.itemId)
16657 
      oprot.writeFieldEnd()
16658 
    oprot.writeFieldStop()
16659 
    oprot.writeStructEnd()
16660 
 
16661 
  def validate(self):
16662 
    return
16663 
 
16664 
 
16665 
  def __repr__(self):
16666 
    L = ['%s=%r' % (key, value)
16667 
      for key, value in self.__dict__.iteritems()]
16668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16669 
 
16670 
  def __eq__(self, other):
16671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16672 
 
16673 
  def __ne__(self, other):
16674 
    return not (self == other)
16675 
 
16676 
class addProductNotification_result:
16677 
  """
16678 
  Attributes:
16679 
   - success
16680 
  """
16681 
 
16682 
  thrift_spec = (
16683 
    (0, TType.BOOL, 'success', None, None, ), # 0
16684 
  )
16685 
 
16686 
  def __init__(self, success=None,):
16687 
    self.success = success
16688 
 
16689 
  def read(self, iprot):
16690 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16691 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16692 
      return
16693 
    iprot.readStructBegin()
16694 
    while True:
16695 
      (fname, ftype, fid) = iprot.readFieldBegin()
16696 
      if ftype == TType.STOP:
16697 
        break
16698 
      if fid == 0:
16699 
        if ftype == TType.BOOL:
16700 
          self.success = iprot.readBool();
16701 
        else:
16702 
          iprot.skip(ftype)
16703 
      else:
16704 
        iprot.skip(ftype)
16705 
      iprot.readFieldEnd()
16706 
    iprot.readStructEnd()
16707 
 
16708 
  def write(self, oprot):
16709 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16710 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16711 
      return
16712 
    oprot.writeStructBegin('addProductNotification_result')
16713 
    if self.success is not None:
16714 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16715 
      oprot.writeBool(self.success)
16716 
      oprot.writeFieldEnd()
16717 
    oprot.writeFieldStop()
16718 
    oprot.writeStructEnd()
16719 
 
16720 
  def validate(self):
16721 
    return
16722 
 
16723 
 
16724 
  def __repr__(self):
16725 
    L = ['%s=%r' % (key, value)
16726 
      for key, value in self.__dict__.iteritems()]
16727 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16728 
 
16729 
  def __eq__(self, other):
16730 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16731 
 
16732 
  def __ne__(self, other):
16733 
    return not (self == other)
16734 
 
16735 
class sendProductNotifications_args:
16736 
 
16737 
  thrift_spec = (
16738 
  )
16739 
 
16740 
  def read(self, iprot):
16741 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16742 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16743 
      return
16744 
    iprot.readStructBegin()
16745 
    while True:
16746 
      (fname, ftype, fid) = iprot.readFieldBegin()
16747 
      if ftype == TType.STOP:
16748 
        break
16749 
      else:
16750 
        iprot.skip(ftype)
16751 
      iprot.readFieldEnd()
16752 
    iprot.readStructEnd()
16753 
 
16754 
  def write(self, oprot):
16755 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16756 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16757 
      return
16758 
    oprot.writeStructBegin('sendProductNotifications_args')
16759 
    oprot.writeFieldStop()
16760 
    oprot.writeStructEnd()
16761 
 
16762 
  def validate(self):
16763 
    return
16764 
 
16765 
 
16766 
  def __repr__(self):
16767 
    L = ['%s=%r' % (key, value)
16768 
      for key, value in self.__dict__.iteritems()]
16769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16770 
 
16771 
  def __eq__(self, other):
16772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16773 
 
16774 
  def __ne__(self, other):
16775 
    return not (self == other)
16776 
 
16777 
class sendProductNotifications_result:
16778 
  """
16779 
  Attributes:
16780 
   - success
16781 
  """
16782 
 
16783 
  thrift_spec = (
16784 
    (0, TType.BOOL, 'success', None, None, ), # 0
16785 
  )
16786 
 
16787 
  def __init__(self, success=None,):
16788 
    self.success = success
16789 
 
16790 
  def read(self, iprot):
16791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16793 
      return
16794 
    iprot.readStructBegin()
16795 
    while True:
16796 
      (fname, ftype, fid) = iprot.readFieldBegin()
16797 
      if ftype == TType.STOP:
16798 
        break
16799 
      if fid == 0:
16800 
        if ftype == TType.BOOL:
16801 
          self.success = iprot.readBool();
16802 
        else:
16803 
          iprot.skip(ftype)
16804 
      else:
16805 
        iprot.skip(ftype)
16806 
      iprot.readFieldEnd()
16807 
    iprot.readStructEnd()
16808 
 
16809 
  def write(self, oprot):
16810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16812 
      return
16813 
    oprot.writeStructBegin('sendProductNotifications_result')
16814 
    if self.success is not None:
16815 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16816 
      oprot.writeBool(self.success)
16817 
      oprot.writeFieldEnd()
16818 
    oprot.writeFieldStop()
16819 
    oprot.writeStructEnd()
16820 
 
16821 
  def validate(self):
16822 
    return
16823 
 
16824 
 
16825 
  def __repr__(self):
16826 
    L = ['%s=%r' % (key, value)
16827 
      for key, value in self.__dict__.iteritems()]
16828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16829 
 
16830 
  def __eq__(self, other):
16831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16832 
 
16833 
  def __ne__(self, other):
16834 
    return not (self == other)
16835 
 
16836 
class getAllBrandsByCategory_args:
16837 
  """
16838 
  Attributes:
16839 
   - categoryId
16840 
  """
16841 
 
16842 
  thrift_spec = (
16843 
    None, # 0
16844 
    (1, TType.I64, 'categoryId', None, None, ), # 1
16845 
  )
16846 
 
16847 
  def __init__(self, categoryId=None,):
16848 
    self.categoryId = categoryId
16849 
 
16850 
  def read(self, iprot):
16851 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16852 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16853 
      return
16854 
    iprot.readStructBegin()
16855 
    while True:
16856 
      (fname, ftype, fid) = iprot.readFieldBegin()
16857 
      if ftype == TType.STOP:
16858 
        break
16859 
      if fid == 1:
16860 
        if ftype == TType.I64:
16861 
          self.categoryId = iprot.readI64();
16862 
        else:
16863 
          iprot.skip(ftype)
16864 
      else:
16865 
        iprot.skip(ftype)
16866 
      iprot.readFieldEnd()
16867 
    iprot.readStructEnd()
16868 
 
16869 
  def write(self, oprot):
16870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16872 
      return
16873 
    oprot.writeStructBegin('getAllBrandsByCategory_args')
16874 
    if self.categoryId is not None:
16875 
      oprot.writeFieldBegin('categoryId', TType.I64, 1)
16876 
      oprot.writeI64(self.categoryId)
16877 
      oprot.writeFieldEnd()
16878 
    oprot.writeFieldStop()
16879 
    oprot.writeStructEnd()
16880 
 
16881 
  def validate(self):
16882 
    return
16883 
 
16884 
 
16885 
  def __repr__(self):
16886 
    L = ['%s=%r' % (key, value)
16887 
      for key, value in self.__dict__.iteritems()]
16888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16889 
 
16890 
  def __eq__(self, other):
16891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16892 
 
16893 
  def __ne__(self, other):
16894 
    return not (self == other)
16895 
 
16896 
class getAllBrandsByCategory_result:
16897 
  """
16898 
  Attributes:
16899 
   - success
16900 
  """
16901 
 
16902 
  thrift_spec = (
16903 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
16904 
  )
16905 
 
16906 
  def __init__(self, success=None,):
16907 
    self.success = success
16908 
 
16909 
  def read(self, iprot):
16910 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16911 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16912 
      return
16913 
    iprot.readStructBegin()
16914 
    while True:
16915 
      (fname, ftype, fid) = iprot.readFieldBegin()
16916 
      if ftype == TType.STOP:
16917 
        break
16918 
      if fid == 0:
16919 
        if ftype == TType.LIST:
16920 
          self.success = []
9155 kshitij.so 16921 
          (_etype300, _size297) = iprot.readListBegin()
16922 
          for _i301 in xrange(_size297):
16923 
            _elem302 = iprot.readString();
16924 
            self.success.append(_elem302)
5944 mandeep.dh 16925 
          iprot.readListEnd()
16926 
        else:
16927 
          iprot.skip(ftype)
16928 
      else:
16929 
        iprot.skip(ftype)
16930 
      iprot.readFieldEnd()
16931 
    iprot.readStructEnd()
16932 
 
16933 
  def write(self, oprot):
16934 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16935 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16936 
      return
16937 
    oprot.writeStructBegin('getAllBrandsByCategory_result')
16938 
    if self.success is not None:
16939 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16940 
      oprot.writeListBegin(TType.STRING, len(self.success))
9155 kshitij.so 16941 
      for iter303 in self.success:
16942 
        oprot.writeString(iter303)
5944 mandeep.dh 16943 
      oprot.writeListEnd()
16944 
      oprot.writeFieldEnd()
16945 
    oprot.writeFieldStop()
16946 
    oprot.writeStructEnd()
16947 
 
16948 
  def validate(self):
16949 
    return
16950 
 
16951 
 
16952 
  def __repr__(self):
16953 
    L = ['%s=%r' % (key, value)
16954 
      for key, value in self.__dict__.iteritems()]
16955 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16956 
 
16957 
  def __eq__(self, other):
16958 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16959 
 
16960 
  def __ne__(self, other):
16961 
    return not (self == other)
16962 
 
16963 
class getAllBrands_args:
16964 
 
16965 
  thrift_spec = (
16966 
  )
16967 
 
16968 
  def read(self, iprot):
16969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16971 
      return
16972 
    iprot.readStructBegin()
16973 
    while True:
16974 
      (fname, ftype, fid) = iprot.readFieldBegin()
16975 
      if ftype == TType.STOP:
16976 
        break
16977 
      else:
16978 
        iprot.skip(ftype)
16979 
      iprot.readFieldEnd()
16980 
    iprot.readStructEnd()
16981 
 
16982 
  def write(self, oprot):
16983 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16984 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16985 
      return
16986 
    oprot.writeStructBegin('getAllBrands_args')
16987 
    oprot.writeFieldStop()
16988 
    oprot.writeStructEnd()
16989 
 
16990 
  def validate(self):
16991 
    return
16992 
 
16993 
 
16994 
  def __repr__(self):
16995 
    L = ['%s=%r' % (key, value)
16996 
      for key, value in self.__dict__.iteritems()]
16997 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16998 
 
16999 
  def __eq__(self, other):
17000 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17001 
 
17002 
  def __ne__(self, other):
17003 
    return not (self == other)
17004 
 
17005 
class getAllBrands_result:
17006 
  """
17007 
  Attributes:
17008 
   - success
17009 
  """
17010 
 
17011 
  thrift_spec = (
17012 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
17013 
  )
17014 
 
17015 
  def __init__(self, success=None,):
17016 
    self.success = success
17017 
 
17018 
  def read(self, iprot):
17019 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17020 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17021 
      return
17022 
    iprot.readStructBegin()
17023 
    while True:
17024 
      (fname, ftype, fid) = iprot.readFieldBegin()
17025 
      if ftype == TType.STOP:
17026 
        break
17027 
      if fid == 0:
17028 
        if ftype == TType.LIST:
17029 
          self.success = []
9155 kshitij.so 17030 
          (_etype307, _size304) = iprot.readListBegin()
17031 
          for _i308 in xrange(_size304):
17032 
            _elem309 = iprot.readString();
17033 
            self.success.append(_elem309)
5944 mandeep.dh 17034 
          iprot.readListEnd()
17035 
        else:
17036 
          iprot.skip(ftype)
17037 
      else:
17038 
        iprot.skip(ftype)
17039 
      iprot.readFieldEnd()
17040 
    iprot.readStructEnd()
17041 
 
17042 
  def write(self, oprot):
17043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17045 
      return
17046 
    oprot.writeStructBegin('getAllBrands_result')
17047 
    if self.success is not None:
17048 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17049 
      oprot.writeListBegin(TType.STRING, len(self.success))
9155 kshitij.so 17050 
      for iter310 in self.success:
17051 
        oprot.writeString(iter310)
5944 mandeep.dh 17052 
      oprot.writeListEnd()
17053 
      oprot.writeFieldEnd()
17054 
    oprot.writeFieldStop()
17055 
    oprot.writeStructEnd()
17056 
 
17057 
  def validate(self):
17058 
    return
17059 
 
17060 
 
17061 
  def __repr__(self):
17062 
    L = ['%s=%r' % (key, value)
17063 
      for key, value in self.__dict__.iteritems()]
17064 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17065 
 
17066 
  def __eq__(self, other):
17067 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17068 
 
17069 
  def __ne__(self, other):
17070 
    return not (self == other)
17071 
 
17072 
class getAllSources_args:
17073 
 
17074 
  thrift_spec = (
17075 
  )
17076 
 
17077 
  def read(self, iprot):
17078 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17079 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17080 
      return
17081 
    iprot.readStructBegin()
17082 
    while True:
17083 
      (fname, ftype, fid) = iprot.readFieldBegin()
17084 
      if ftype == TType.STOP:
17085 
        break
17086 
      else:
17087 
        iprot.skip(ftype)
17088 
      iprot.readFieldEnd()
17089 
    iprot.readStructEnd()
17090 
 
17091 
  def write(self, oprot):
17092 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17093 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17094 
      return
17095 
    oprot.writeStructBegin('getAllSources_args')
17096 
    oprot.writeFieldStop()
17097 
    oprot.writeStructEnd()
17098 
 
17099 
  def validate(self):
17100 
    return
17101 
 
17102 
 
17103 
  def __repr__(self):
17104 
    L = ['%s=%r' % (key, value)
17105 
      for key, value in self.__dict__.iteritems()]
17106 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17107 
 
17108 
  def __eq__(self, other):
17109 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17110 
 
17111 
  def __ne__(self, other):
17112 
    return not (self == other)
17113 
 
17114 
class getAllSources_result:
17115 
  """
17116 
  Attributes:
17117 
   - success
17118 
  """
17119 
 
17120 
  thrift_spec = (
17121 
    (0, TType.LIST, 'success', (TType.STRUCT,(Source, Source.thrift_spec)), None, ), # 0
17122 
  )
17123 
 
17124 
  def __init__(self, success=None,):
17125 
    self.success = success
17126 
 
17127 
  def read(self, iprot):
17128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17130 
      return
17131 
    iprot.readStructBegin()
17132 
    while True:
17133 
      (fname, ftype, fid) = iprot.readFieldBegin()
17134 
      if ftype == TType.STOP:
17135 
        break
17136 
      if fid == 0:
17137 
        if ftype == TType.LIST:
17138 
          self.success = []
9155 kshitij.so 17139 
          (_etype314, _size311) = iprot.readListBegin()
17140 
          for _i315 in xrange(_size311):
17141 
            _elem316 = Source()
17142 
            _elem316.read(iprot)
17143 
            self.success.append(_elem316)
5944 mandeep.dh 17144 
          iprot.readListEnd()
17145 
        else:
17146 
          iprot.skip(ftype)
17147 
      else:
17148 
        iprot.skip(ftype)
17149 
      iprot.readFieldEnd()
17150 
    iprot.readStructEnd()
17151 
 
17152 
  def write(self, oprot):
17153 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17154 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17155 
      return
17156 
    oprot.writeStructBegin('getAllSources_result')
17157 
    if self.success is not None:
17158 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17159 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 17160 
      for iter317 in self.success:
17161 
        iter317.write(oprot)
5944 mandeep.dh 17162 
      oprot.writeListEnd()
17163 
      oprot.writeFieldEnd()
17164 
    oprot.writeFieldStop()
17165 
    oprot.writeStructEnd()
17166 
 
17167 
  def validate(self):
17168 
    return
17169 
 
17170 
 
17171 
  def __repr__(self):
17172 
    L = ['%s=%r' % (key, value)
17173 
      for key, value in self.__dict__.iteritems()]
17174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17175 
 
17176 
  def __eq__(self, other):
17177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17178 
 
17179 
  def __ne__(self, other):
17180 
    return not (self == other)
17181 
 
17182 
class getItemPricingBySource_args:
17183 
  """
17184 
  Attributes:
17185 
   - itemId
17186 
   - sourceId
17187 
  """
17188 
 
17189 
  thrift_spec = (
17190 
    None, # 0
17191 
    (1, TType.I64, 'itemId', None, None, ), # 1
17192 
    (2, TType.I64, 'sourceId', None, None, ), # 2
17193 
  )
17194 
 
17195 
  def __init__(self, itemId=None, sourceId=None,):
17196 
    self.itemId = itemId
17197 
    self.sourceId = sourceId
17198 
 
17199 
  def read(self, iprot):
17200 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17201 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17202 
      return
17203 
    iprot.readStructBegin()
17204 
    while True:
17205 
      (fname, ftype, fid) = iprot.readFieldBegin()
17206 
      if ftype == TType.STOP:
17207 
        break
17208 
      if fid == 1:
17209 
        if ftype == TType.I64:
17210 
          self.itemId = iprot.readI64();
17211 
        else:
17212 
          iprot.skip(ftype)
17213 
      elif fid == 2:
17214 
        if ftype == TType.I64:
17215 
          self.sourceId = iprot.readI64();
17216 
        else:
17217 
          iprot.skip(ftype)
17218 
      else:
17219 
        iprot.skip(ftype)
17220 
      iprot.readFieldEnd()
17221 
    iprot.readStructEnd()
17222 
 
17223 
  def write(self, oprot):
17224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17226 
      return
17227 
    oprot.writeStructBegin('getItemPricingBySource_args')
17228 
    if self.itemId is not None:
17229 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17230 
      oprot.writeI64(self.itemId)
17231 
      oprot.writeFieldEnd()
17232 
    if self.sourceId is not None:
17233 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
17234 
      oprot.writeI64(self.sourceId)
17235 
      oprot.writeFieldEnd()
17236 
    oprot.writeFieldStop()
17237 
    oprot.writeStructEnd()
17238 
 
17239 
  def validate(self):
17240 
    return
17241 
 
17242 
 
17243 
  def __repr__(self):
17244 
    L = ['%s=%r' % (key, value)
17245 
      for key, value in self.__dict__.iteritems()]
17246 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17247 
 
17248 
  def __eq__(self, other):
17249 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17250 
 
17251 
  def __ne__(self, other):
17252 
    return not (self == other)
17253 
 
17254 
class getItemPricingBySource_result:
17255 
  """
17256 
  Attributes:
17257 
   - success
17258 
   - cex
17259 
  """
17260 
 
17261 
  thrift_spec = (
17262 
    (0, TType.STRUCT, 'success', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 0
17263 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17264 
  )
17265 
 
17266 
  def __init__(self, success=None, cex=None,):
17267 
    self.success = success
17268 
    self.cex = cex
17269 
 
17270 
  def read(self, iprot):
17271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17273 
      return
17274 
    iprot.readStructBegin()
17275 
    while True:
17276 
      (fname, ftype, fid) = iprot.readFieldBegin()
17277 
      if ftype == TType.STOP:
17278 
        break
17279 
      if fid == 0:
17280 
        if ftype == TType.STRUCT:
17281 
          self.success = SourceItemPricing()
17282 
          self.success.read(iprot)
17283 
        else:
17284 
          iprot.skip(ftype)
17285 
      elif fid == 1:
17286 
        if ftype == TType.STRUCT:
17287 
          self.cex = CatalogServiceException()
17288 
          self.cex.read(iprot)
17289 
        else:
17290 
          iprot.skip(ftype)
17291 
      else:
17292 
        iprot.skip(ftype)
17293 
      iprot.readFieldEnd()
17294 
    iprot.readStructEnd()
17295 
 
17296 
  def write(self, oprot):
17297 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17298 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17299 
      return
17300 
    oprot.writeStructBegin('getItemPricingBySource_result')
17301 
    if self.success is not None:
17302 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17303 
      self.success.write(oprot)
17304 
      oprot.writeFieldEnd()
17305 
    if self.cex is not None:
17306 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17307 
      self.cex.write(oprot)
17308 
      oprot.writeFieldEnd()
17309 
    oprot.writeFieldStop()
17310 
    oprot.writeStructEnd()
17311 
 
17312 
  def validate(self):
17313 
    return
17314 
 
17315 
 
17316 
  def __repr__(self):
17317 
    L = ['%s=%r' % (key, value)
17318 
      for key, value in self.__dict__.iteritems()]
17319 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17320 
 
17321 
  def __eq__(self, other):
17322 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17323 
 
17324 
  def __ne__(self, other):
17325 
    return not (self == other)
17326 
 
17327 
class addSourceItemPricing_args:
17328 
  """
17329 
  Attributes:
17330 
   - sourceItemPricing
17331 
  """
17332 
 
17333 
  thrift_spec = (
17334 
    None, # 0
17335 
    (1, TType.STRUCT, 'sourceItemPricing', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 1
17336 
  )
17337 
 
17338 
  def __init__(self, sourceItemPricing=None,):
17339 
    self.sourceItemPricing = sourceItemPricing
17340 
 
17341 
  def read(self, iprot):
17342 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17343 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17344 
      return
17345 
    iprot.readStructBegin()
17346 
    while True:
17347 
      (fname, ftype, fid) = iprot.readFieldBegin()
17348 
      if ftype == TType.STOP:
17349 
        break
17350 
      if fid == 1:
17351 
        if ftype == TType.STRUCT:
17352 
          self.sourceItemPricing = SourceItemPricing()
17353 
          self.sourceItemPricing.read(iprot)
17354 
        else:
17355 
          iprot.skip(ftype)
17356 
      else:
17357 
        iprot.skip(ftype)
17358 
      iprot.readFieldEnd()
17359 
    iprot.readStructEnd()
17360 
 
17361 
  def write(self, oprot):
17362 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17363 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17364 
      return
17365 
    oprot.writeStructBegin('addSourceItemPricing_args')
17366 
    if self.sourceItemPricing is not None:
17367 
      oprot.writeFieldBegin('sourceItemPricing', TType.STRUCT, 1)
17368 
      self.sourceItemPricing.write(oprot)
17369 
      oprot.writeFieldEnd()
17370 
    oprot.writeFieldStop()
17371 
    oprot.writeStructEnd()
17372 
 
17373 
  def validate(self):
17374 
    return
17375 
 
17376 
 
17377 
  def __repr__(self):
17378 
    L = ['%s=%r' % (key, value)
17379 
      for key, value in self.__dict__.iteritems()]
17380 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17381 
 
17382 
  def __eq__(self, other):
17383 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17384 
 
17385 
  def __ne__(self, other):
17386 
    return not (self == other)
17387 
 
17388 
class addSourceItemPricing_result:
17389 
  """
17390 
  Attributes:
17391 
   - cex
17392 
  """
17393 
 
17394 
  thrift_spec = (
17395 
    None, # 0
17396 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17397 
  )
17398 
 
17399 
  def __init__(self, cex=None,):
17400 
    self.cex = cex
17401 
 
17402 
  def read(self, iprot):
17403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17405 
      return
17406 
    iprot.readStructBegin()
17407 
    while True:
17408 
      (fname, ftype, fid) = iprot.readFieldBegin()
17409 
      if ftype == TType.STOP:
17410 
        break
17411 
      if fid == 1:
17412 
        if ftype == TType.STRUCT:
17413 
          self.cex = CatalogServiceException()
17414 
          self.cex.read(iprot)
17415 
        else:
17416 
          iprot.skip(ftype)
17417 
      else:
17418 
        iprot.skip(ftype)
17419 
      iprot.readFieldEnd()
17420 
    iprot.readStructEnd()
17421 
 
17422 
  def write(self, oprot):
17423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17425 
      return
17426 
    oprot.writeStructBegin('addSourceItemPricing_result')
17427 
    if self.cex is not None:
17428 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17429 
      self.cex.write(oprot)
17430 
      oprot.writeFieldEnd()
17431 
    oprot.writeFieldStop()
17432 
    oprot.writeStructEnd()
17433 
 
17434 
  def validate(self):
17435 
    return
17436 
 
17437 
 
17438 
  def __repr__(self):
17439 
    L = ['%s=%r' % (key, value)
17440 
      for key, value in self.__dict__.iteritems()]
17441 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17442 
 
17443 
  def __eq__(self, other):
17444 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17445 
 
17446 
  def __ne__(self, other):
17447 
    return not (self == other)
17448 
 
17449 
class getAllSourcePricing_args:
17450 
  """
17451 
  Attributes:
17452 
   - itemId
17453 
  """
17454 
 
17455 
  thrift_spec = (
17456 
    None, # 0
17457 
    (1, TType.I64, 'itemId', None, None, ), # 1
17458 
  )
17459 
 
17460 
  def __init__(self, itemId=None,):
17461 
    self.itemId = itemId
17462 
 
17463 
  def read(self, iprot):
17464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17466 
      return
17467 
    iprot.readStructBegin()
17468 
    while True:
17469 
      (fname, ftype, fid) = iprot.readFieldBegin()
17470 
      if ftype == TType.STOP:
17471 
        break
17472 
      if fid == 1:
17473 
        if ftype == TType.I64:
17474 
          self.itemId = iprot.readI64();
17475 
        else:
17476 
          iprot.skip(ftype)
17477 
      else:
17478 
        iprot.skip(ftype)
17479 
      iprot.readFieldEnd()
17480 
    iprot.readStructEnd()
17481 
 
17482 
  def write(self, oprot):
17483 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17484 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17485 
      return
17486 
    oprot.writeStructBegin('getAllSourcePricing_args')
17487 
    if self.itemId is not None:
17488 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17489 
      oprot.writeI64(self.itemId)
17490 
      oprot.writeFieldEnd()
17491 
    oprot.writeFieldStop()
17492 
    oprot.writeStructEnd()
17493 
 
17494 
  def validate(self):
17495 
    return
17496 
 
17497 
 
17498 
  def __repr__(self):
17499 
    L = ['%s=%r' % (key, value)
17500 
      for key, value in self.__dict__.iteritems()]
17501 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17502 
 
17503 
  def __eq__(self, other):
17504 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17505 
 
17506 
  def __ne__(self, other):
17507 
    return not (self == other)
17508 
 
17509 
class getAllSourcePricing_result:
17510 
  """
17511 
  Attributes:
17512 
   - success
17513 
   - cex
17514 
  """
17515 
 
17516 
  thrift_spec = (
17517 
    (0, TType.LIST, 'success', (TType.STRUCT,(SourceItemPricing, SourceItemPricing.thrift_spec)), None, ), # 0
17518 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17519 
  )
17520 
 
17521 
  def __init__(self, success=None, cex=None,):
17522 
    self.success = success
17523 
    self.cex = cex
17524 
 
17525 
  def read(self, iprot):
17526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17528 
      return
17529 
    iprot.readStructBegin()
17530 
    while True:
17531 
      (fname, ftype, fid) = iprot.readFieldBegin()
17532 
      if ftype == TType.STOP:
17533 
        break
17534 
      if fid == 0:
17535 
        if ftype == TType.LIST:
17536 
          self.success = []
9155 kshitij.so 17537 
          (_etype321, _size318) = iprot.readListBegin()
17538 
          for _i322 in xrange(_size318):
17539 
            _elem323 = SourceItemPricing()
17540 
            _elem323.read(iprot)
17541 
            self.success.append(_elem323)
5944 mandeep.dh 17542 
          iprot.readListEnd()
17543 
        else:
17544 
          iprot.skip(ftype)
17545 
      elif fid == 1:
17546 
        if ftype == TType.STRUCT:
17547 
          self.cex = CatalogServiceException()
17548 
          self.cex.read(iprot)
17549 
        else:
17550 
          iprot.skip(ftype)
17551 
      else:
17552 
        iprot.skip(ftype)
17553 
      iprot.readFieldEnd()
17554 
    iprot.readStructEnd()
17555 
 
17556 
  def write(self, oprot):
17557 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17558 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17559 
      return
17560 
    oprot.writeStructBegin('getAllSourcePricing_result')
17561 
    if self.success is not None:
17562 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17563 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 17564 
      for iter324 in self.success:
17565 
        iter324.write(oprot)
5944 mandeep.dh 17566 
      oprot.writeListEnd()
17567 
      oprot.writeFieldEnd()
17568 
    if self.cex is not None:
17569 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17570 
      self.cex.write(oprot)
17571 
      oprot.writeFieldEnd()
17572 
    oprot.writeFieldStop()
17573 
    oprot.writeStructEnd()
17574 
 
17575 
  def validate(self):
17576 
    return
17577 
 
17578 
 
17579 
  def __repr__(self):
17580 
    L = ['%s=%r' % (key, value)
17581 
      for key, value in self.__dict__.iteritems()]
17582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17583 
 
17584 
  def __eq__(self, other):
17585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17586 
 
17587 
  def __ne__(self, other):
17588 
    return not (self == other)
17589 
 
17590 
class getItemForSource_args:
17591 
  """
17592 
  Attributes:
17593 
   - item_id
17594 
   - sourceId
17595 
  """
17596 
 
17597 
  thrift_spec = (
17598 
    None, # 0
17599 
    (1, TType.I64, 'item_id', None, None, ), # 1
17600 
    (2, TType.I64, 'sourceId', None, None, ), # 2
17601 
  )
17602 
 
17603 
  def __init__(self, item_id=None, sourceId=None,):
17604 
    self.item_id = item_id
17605 
    self.sourceId = sourceId
17606 
 
17607 
  def read(self, iprot):
17608 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17609 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17610 
      return
17611 
    iprot.readStructBegin()
17612 
    while True:
17613 
      (fname, ftype, fid) = iprot.readFieldBegin()
17614 
      if ftype == TType.STOP:
17615 
        break
17616 
      if fid == 1:
17617 
        if ftype == TType.I64:
17618 
          self.item_id = iprot.readI64();
17619 
        else:
17620 
          iprot.skip(ftype)
17621 
      elif fid == 2:
17622 
        if ftype == TType.I64:
17623 
          self.sourceId = iprot.readI64();
17624 
        else:
17625 
          iprot.skip(ftype)
17626 
      else:
17627 
        iprot.skip(ftype)
17628 
      iprot.readFieldEnd()
17629 
    iprot.readStructEnd()
17630 
 
17631 
  def write(self, oprot):
17632 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17633 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17634 
      return
17635 
    oprot.writeStructBegin('getItemForSource_args')
17636 
    if self.item_id is not None:
17637 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
17638 
      oprot.writeI64(self.item_id)
17639 
      oprot.writeFieldEnd()
17640 
    if self.sourceId is not None:
17641 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
17642 
      oprot.writeI64(self.sourceId)
17643 
      oprot.writeFieldEnd()
17644 
    oprot.writeFieldStop()
17645 
    oprot.writeStructEnd()
17646 
 
17647 
  def validate(self):
17648 
    return
17649 
 
17650 
 
17651 
  def __repr__(self):
17652 
    L = ['%s=%r' % (key, value)
17653 
      for key, value in self.__dict__.iteritems()]
17654 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17655 
 
17656 
  def __eq__(self, other):
17657 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17658 
 
17659 
  def __ne__(self, other):
17660 
    return not (self == other)
17661 
 
17662 
class getItemForSource_result:
17663 
  """
17664 
  Attributes:
17665 
   - success
17666 
   - cex
17667 
  """
17668 
 
17669 
  thrift_spec = (
17670 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
17671 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17672 
  )
17673 
 
17674 
  def __init__(self, success=None, cex=None,):
17675 
    self.success = success
17676 
    self.cex = cex
17677 
 
17678 
  def read(self, iprot):
17679 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17680 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17681 
      return
17682 
    iprot.readStructBegin()
17683 
    while True:
17684 
      (fname, ftype, fid) = iprot.readFieldBegin()
17685 
      if ftype == TType.STOP:
17686 
        break
17687 
      if fid == 0:
17688 
        if ftype == TType.STRUCT:
17689 
          self.success = Item()
17690 
          self.success.read(iprot)
17691 
        else:
17692 
          iprot.skip(ftype)
17693 
      elif fid == 1:
17694 
        if ftype == TType.STRUCT:
17695 
          self.cex = CatalogServiceException()
17696 
          self.cex.read(iprot)
17697 
        else:
17698 
          iprot.skip(ftype)
17699 
      else:
17700 
        iprot.skip(ftype)
17701 
      iprot.readFieldEnd()
17702 
    iprot.readStructEnd()
17703 
 
17704 
  def write(self, oprot):
17705 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17706 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17707 
      return
17708 
    oprot.writeStructBegin('getItemForSource_result')
17709 
    if self.success is not None:
17710 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17711 
      self.success.write(oprot)
17712 
      oprot.writeFieldEnd()
17713 
    if self.cex is not None:
17714 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17715 
      self.cex.write(oprot)
17716 
      oprot.writeFieldEnd()
17717 
    oprot.writeFieldStop()
17718 
    oprot.writeStructEnd()
17719 
 
17720 
  def validate(self):
17721 
    return
17722 
 
17723 
 
17724 
  def __repr__(self):
17725 
    L = ['%s=%r' % (key, value)
17726 
      for key, value in self.__dict__.iteritems()]
17727 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17728 
 
17729 
  def __eq__(self, other):
17730 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17731 
 
17732 
  def __ne__(self, other):
17733 
    return not (self == other)
17734 
 
17735 
class searchItemsInRange_args:
17736 
  """
17737 
  Attributes:
17738 
   - searchTerms
17739 
   - offset
17740 
   - limit
17741 
  """
17742 
 
17743 
  thrift_spec = (
17744 
    None, # 0
17745 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
17746 
    (2, TType.I64, 'offset', None, None, ), # 2
17747 
    (3, TType.I64, 'limit', None, None, ), # 3
17748 
  )
17749 
 
17750 
  def __init__(self, searchTerms=None, offset=None, limit=None,):
17751 
    self.searchTerms = searchTerms
17752 
    self.offset = offset
17753 
    self.limit = limit
17754 
 
17755 
  def read(self, iprot):
17756 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17757 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17758 
      return
17759 
    iprot.readStructBegin()
17760 
    while True:
17761 
      (fname, ftype, fid) = iprot.readFieldBegin()
17762 
      if ftype == TType.STOP:
17763 
        break
17764 
      if fid == 1:
17765 
        if ftype == TType.LIST:
17766 
          self.searchTerms = []
9155 kshitij.so 17767 
          (_etype328, _size325) = iprot.readListBegin()
17768 
          for _i329 in xrange(_size325):
17769 
            _elem330 = iprot.readString();
17770 
            self.searchTerms.append(_elem330)
5944 mandeep.dh 17771 
          iprot.readListEnd()
17772 
        else:
17773 
          iprot.skip(ftype)
17774 
      elif fid == 2:
17775 
        if ftype == TType.I64:
17776 
          self.offset = iprot.readI64();
17777 
        else:
17778 
          iprot.skip(ftype)
17779 
      elif fid == 3:
17780 
        if ftype == TType.I64:
17781 
          self.limit = iprot.readI64();
17782 
        else:
17783 
          iprot.skip(ftype)
17784 
      else:
17785 
        iprot.skip(ftype)
17786 
      iprot.readFieldEnd()
17787 
    iprot.readStructEnd()
17788 
 
17789 
  def write(self, oprot):
17790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17792 
      return
17793 
    oprot.writeStructBegin('searchItemsInRange_args')
17794 
    if self.searchTerms is not None:
17795 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
17796 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
9155 kshitij.so 17797 
      for iter331 in self.searchTerms:
17798 
        oprot.writeString(iter331)
5944 mandeep.dh 17799 
      oprot.writeListEnd()
17800 
      oprot.writeFieldEnd()
17801 
    if self.offset is not None:
17802 
      oprot.writeFieldBegin('offset', TType.I64, 2)
17803 
      oprot.writeI64(self.offset)
17804 
      oprot.writeFieldEnd()
17805 
    if self.limit is not None:
17806 
      oprot.writeFieldBegin('limit', TType.I64, 3)
17807 
      oprot.writeI64(self.limit)
17808 
      oprot.writeFieldEnd()
17809 
    oprot.writeFieldStop()
17810 
    oprot.writeStructEnd()
17811 
 
17812 
  def validate(self):
17813 
    return
17814 
 
17815 
 
17816 
  def __repr__(self):
17817 
    L = ['%s=%r' % (key, value)
17818 
      for key, value in self.__dict__.iteritems()]
17819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17820 
 
17821 
  def __eq__(self, other):
17822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17823 
 
17824 
  def __ne__(self, other):
17825 
    return not (self == other)
17826 
 
17827 
class searchItemsInRange_result:
17828 
  """
17829 
  Attributes:
17830 
   - success
17831 
  """
17832 
 
17833 
  thrift_spec = (
17834 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
17835 
  )
17836 
 
17837 
  def __init__(self, success=None,):
17838 
    self.success = success
17839 
 
17840 
  def read(self, iprot):
17841 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17842 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17843 
      return
17844 
    iprot.readStructBegin()
17845 
    while True:
17846 
      (fname, ftype, fid) = iprot.readFieldBegin()
17847 
      if ftype == TType.STOP:
17848 
        break
17849 
      if fid == 0:
17850 
        if ftype == TType.LIST:
17851 
          self.success = []
9155 kshitij.so 17852 
          (_etype335, _size332) = iprot.readListBegin()
17853 
          for _i336 in xrange(_size332):
17854 
            _elem337 = Item()
17855 
            _elem337.read(iprot)
17856 
            self.success.append(_elem337)
5944 mandeep.dh 17857 
          iprot.readListEnd()
17858 
        else:
17859 
          iprot.skip(ftype)
17860 
      else:
17861 
        iprot.skip(ftype)
17862 
      iprot.readFieldEnd()
17863 
    iprot.readStructEnd()
17864 
 
17865 
  def write(self, oprot):
17866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17868 
      return
17869 
    oprot.writeStructBegin('searchItemsInRange_result')
17870 
    if self.success is not None:
17871 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17872 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 17873 
      for iter338 in self.success:
17874 
        iter338.write(oprot)
5944 mandeep.dh 17875 
      oprot.writeListEnd()
17876 
      oprot.writeFieldEnd()
17877 
    oprot.writeFieldStop()
17878 
    oprot.writeStructEnd()
17879 
 
17880 
  def validate(self):
17881 
    return
17882 
 
17883 
 
17884 
  def __repr__(self):
17885 
    L = ['%s=%r' % (key, value)
17886 
      for key, value in self.__dict__.iteritems()]
17887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17888 
 
17889 
  def __eq__(self, other):
17890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17891 
 
17892 
  def __ne__(self, other):
17893 
    return not (self == other)
17894 
 
17895 
class getSearchResultCount_args:
17896 
  """
17897 
  Attributes:
17898 
   - searchTerms
17899 
  """
17900 
 
17901 
  thrift_spec = (
17902 
    None, # 0
17903 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
17904 
  )
17905 
 
17906 
  def __init__(self, searchTerms=None,):
17907 
    self.searchTerms = searchTerms
17908 
 
17909 
  def read(self, iprot):
17910 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17911 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17912 
      return
17913 
    iprot.readStructBegin()
17914 
    while True:
17915 
      (fname, ftype, fid) = iprot.readFieldBegin()
17916 
      if ftype == TType.STOP:
17917 
        break
17918 
      if fid == 1:
17919 
        if ftype == TType.LIST:
17920 
          self.searchTerms = []
9155 kshitij.so 17921 
          (_etype342, _size339) = iprot.readListBegin()
17922 
          for _i343 in xrange(_size339):
17923 
            _elem344 = iprot.readString();
17924 
            self.searchTerms.append(_elem344)
5944 mandeep.dh 17925 
          iprot.readListEnd()
17926 
        else:
17927 
          iprot.skip(ftype)
17928 
      else:
17929 
        iprot.skip(ftype)
17930 
      iprot.readFieldEnd()
17931 
    iprot.readStructEnd()
17932 
 
17933 
  def write(self, oprot):
17934 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17935 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17936 
      return
17937 
    oprot.writeStructBegin('getSearchResultCount_args')
17938 
    if self.searchTerms is not None:
17939 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
17940 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
9155 kshitij.so 17941 
      for iter345 in self.searchTerms:
17942 
        oprot.writeString(iter345)
5944 mandeep.dh 17943 
      oprot.writeListEnd()
17944 
      oprot.writeFieldEnd()
17945 
    oprot.writeFieldStop()
17946 
    oprot.writeStructEnd()
17947 
 
17948 
  def validate(self):
17949 
    return
17950 
 
17951 
 
17952 
  def __repr__(self):
17953 
    L = ['%s=%r' % (key, value)
17954 
      for key, value in self.__dict__.iteritems()]
17955 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17956 
 
17957 
  def __eq__(self, other):
17958 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17959 
 
17960 
  def __ne__(self, other):
17961 
    return not (self == other)
17962 
 
17963 
class getSearchResultCount_result:
17964 
  """
17965 
  Attributes:
17966 
   - success
17967 
  """
17968 
 
17969 
  thrift_spec = (
17970 
    (0, TType.I32, 'success', None, None, ), # 0
17971 
  )
17972 
 
17973 
  def __init__(self, success=None,):
17974 
    self.success = success
17975 
 
17976 
  def read(self, iprot):
17977 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17978 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17979 
      return
17980 
    iprot.readStructBegin()
17981 
    while True:
17982 
      (fname, ftype, fid) = iprot.readFieldBegin()
17983 
      if ftype == TType.STOP:
17984 
        break
17985 
      if fid == 0:
17986 
        if ftype == TType.I32:
17987 
          self.success = iprot.readI32();
17988 
        else:
17989 
          iprot.skip(ftype)
17990 
      else:
17991 
        iprot.skip(ftype)
17992 
      iprot.readFieldEnd()
17993 
    iprot.readStructEnd()
17994 
 
17995 
  def write(self, oprot):
17996 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17997 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17998 
      return
17999 
    oprot.writeStructBegin('getSearchResultCount_result')
18000 
    if self.success is not None:
18001 
      oprot.writeFieldBegin('success', TType.I32, 0)
18002 
      oprot.writeI32(self.success)
18003 
      oprot.writeFieldEnd()
18004 
    oprot.writeFieldStop()
18005 
    oprot.writeStructEnd()
18006 
 
18007 
  def validate(self):
18008 
    return
18009 
 
18010 
 
18011 
  def __repr__(self):
18012 
    L = ['%s=%r' % (key, value)
18013 
      for key, value in self.__dict__.iteritems()]
18014 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18015 
 
18016 
  def __eq__(self, other):
18017 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18018 
 
18019 
  def __ne__(self, other):
18020 
    return not (self == other)
18021 
 
18022 
class getProductNotifications_args:
18023 
  """
18024 
  Attributes:
18025 
   - startDateTime
18026 
  """
18027 
 
18028 
  thrift_spec = (
18029 
    None, # 0
18030 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
18031 
  )
18032 
 
18033 
  def __init__(self, startDateTime=None,):
18034 
    self.startDateTime = startDateTime
18035 
 
18036 
  def read(self, iprot):
18037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18039 
      return
18040 
    iprot.readStructBegin()
18041 
    while True:
18042 
      (fname, ftype, fid) = iprot.readFieldBegin()
18043 
      if ftype == TType.STOP:
18044 
        break
18045 
      if fid == 1:
18046 
        if ftype == TType.I64:
18047 
          self.startDateTime = iprot.readI64();
18048 
        else:
18049 
          iprot.skip(ftype)
18050 
      else:
18051 
        iprot.skip(ftype)
18052 
      iprot.readFieldEnd()
18053 
    iprot.readStructEnd()
18054 
 
18055 
  def write(self, oprot):
18056 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18057 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18058 
      return
18059 
    oprot.writeStructBegin('getProductNotifications_args')
18060 
    if self.startDateTime is not None:
18061 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
18062 
      oprot.writeI64(self.startDateTime)
18063 
      oprot.writeFieldEnd()
18064 
    oprot.writeFieldStop()
18065 
    oprot.writeStructEnd()
18066 
 
18067 
  def validate(self):
18068 
    return
18069 
 
18070 
 
18071 
  def __repr__(self):
18072 
    L = ['%s=%r' % (key, value)
18073 
      for key, value in self.__dict__.iteritems()]
18074 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18075 
 
18076 
  def __eq__(self, other):
18077 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18078 
 
18079 
  def __ne__(self, other):
18080 
    return not (self == other)
18081 
 
18082 
class getProductNotifications_result:
18083 
  """
18084 
  Attributes:
18085 
   - success
18086 
  """
18087 
 
18088 
  thrift_spec = (
18089 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequest, ProductNotificationRequest.thrift_spec)), None, ), # 0
18090 
  )
18091 
 
18092 
  def __init__(self, success=None,):
18093 
    self.success = success
18094 
 
18095 
  def read(self, iprot):
18096 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18097 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18098 
      return
18099 
    iprot.readStructBegin()
18100 
    while True:
18101 
      (fname, ftype, fid) = iprot.readFieldBegin()
18102 
      if ftype == TType.STOP:
18103 
        break
18104 
      if fid == 0:
18105 
        if ftype == TType.LIST:
18106 
          self.success = []
9155 kshitij.so 18107 
          (_etype349, _size346) = iprot.readListBegin()
18108 
          for _i350 in xrange(_size346):
18109 
            _elem351 = ProductNotificationRequest()
18110 
            _elem351.read(iprot)
18111 
            self.success.append(_elem351)
5944 mandeep.dh 18112 
          iprot.readListEnd()
18113 
        else:
18114 
          iprot.skip(ftype)
18115 
      else:
18116 
        iprot.skip(ftype)
18117 
      iprot.readFieldEnd()
18118 
    iprot.readStructEnd()
18119 
 
18120 
  def write(self, oprot):
18121 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18122 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18123 
      return
18124 
    oprot.writeStructBegin('getProductNotifications_result')
18125 
    if self.success is not None:
18126 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18127 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18128 
      for iter352 in self.success:
18129 
        iter352.write(oprot)
5944 mandeep.dh 18130 
      oprot.writeListEnd()
18131 
      oprot.writeFieldEnd()
18132 
    oprot.writeFieldStop()
18133 
    oprot.writeStructEnd()
18134 
 
18135 
  def validate(self):
18136 
    return
18137 
 
18138 
 
18139 
  def __repr__(self):
18140 
    L = ['%s=%r' % (key, value)
18141 
      for key, value in self.__dict__.iteritems()]
18142 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18143 
 
18144 
  def __eq__(self, other):
18145 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18146 
 
18147 
  def __ne__(self, other):
18148 
    return not (self == other)
18149 
 
18150 
class getProductNotificationRequestCount_args:
18151 
  """
18152 
  Attributes:
18153 
   - startDateTime
7897 amar.kumar 18154 
   - categoryId
5944 mandeep.dh 18155 
  """
18156 
 
18157 
  thrift_spec = (
18158 
    None, # 0
18159 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
7897 amar.kumar 18160 
    (2, TType.I64, 'categoryId', None, None, ), # 2
5944 mandeep.dh 18161 
  )
18162 
 
7897 amar.kumar 18163 
  def __init__(self, startDateTime=None, categoryId=None,):
5944 mandeep.dh 18164 
    self.startDateTime = startDateTime
7897 amar.kumar 18165 
    self.categoryId = categoryId
5944 mandeep.dh 18166 
 
18167 
  def read(self, iprot):
18168 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18169 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18170 
      return
18171 
    iprot.readStructBegin()
18172 
    while True:
18173 
      (fname, ftype, fid) = iprot.readFieldBegin()
18174 
      if ftype == TType.STOP:
18175 
        break
18176 
      if fid == 1:
18177 
        if ftype == TType.I64:
18178 
          self.startDateTime = iprot.readI64();
18179 
        else:
18180 
          iprot.skip(ftype)
7897 amar.kumar 18181 
      elif fid == 2:
18182 
        if ftype == TType.I64:
18183 
          self.categoryId = iprot.readI64();
18184 
        else:
18185 
          iprot.skip(ftype)
5944 mandeep.dh 18186 
      else:
18187 
        iprot.skip(ftype)
18188 
      iprot.readFieldEnd()
18189 
    iprot.readStructEnd()
18190 
 
18191 
  def write(self, oprot):
18192 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18193 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18194 
      return
18195 
    oprot.writeStructBegin('getProductNotificationRequestCount_args')
18196 
    if self.startDateTime is not None:
18197 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
18198 
      oprot.writeI64(self.startDateTime)
18199 
      oprot.writeFieldEnd()
7897 amar.kumar 18200 
    if self.categoryId is not None:
18201 
      oprot.writeFieldBegin('categoryId', TType.I64, 2)
18202 
      oprot.writeI64(self.categoryId)
18203 
      oprot.writeFieldEnd()
5944 mandeep.dh 18204 
    oprot.writeFieldStop()
18205 
    oprot.writeStructEnd()
18206 
 
18207 
  def validate(self):
18208 
    return
18209 
 
18210 
 
18211 
  def __repr__(self):
18212 
    L = ['%s=%r' % (key, value)
18213 
      for key, value in self.__dict__.iteritems()]
18214 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18215 
 
18216 
  def __eq__(self, other):
18217 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18218 
 
18219 
  def __ne__(self, other):
18220 
    return not (self == other)
18221 
 
18222 
class getProductNotificationRequestCount_result:
18223 
  """
18224 
  Attributes:
18225 
   - success
18226 
  """
18227 
 
18228 
  thrift_spec = (
18229 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequestCount, ProductNotificationRequestCount.thrift_spec)), None, ), # 0
18230 
  )
18231 
 
18232 
  def __init__(self, success=None,):
18233 
    self.success = success
18234 
 
18235 
  def read(self, iprot):
18236 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18237 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18238 
      return
18239 
    iprot.readStructBegin()
18240 
    while True:
18241 
      (fname, ftype, fid) = iprot.readFieldBegin()
18242 
      if ftype == TType.STOP:
18243 
        break
18244 
      if fid == 0:
18245 
        if ftype == TType.LIST:
18246 
          self.success = []
9155 kshitij.so 18247 
          (_etype356, _size353) = iprot.readListBegin()
18248 
          for _i357 in xrange(_size353):
18249 
            _elem358 = ProductNotificationRequestCount()
18250 
            _elem358.read(iprot)
18251 
            self.success.append(_elem358)
5944 mandeep.dh 18252 
          iprot.readListEnd()
18253 
        else:
18254 
          iprot.skip(ftype)
18255 
      else:
18256 
        iprot.skip(ftype)
18257 
      iprot.readFieldEnd()
18258 
    iprot.readStructEnd()
18259 
 
18260 
  def write(self, oprot):
18261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18263 
      return
18264 
    oprot.writeStructBegin('getProductNotificationRequestCount_result')
18265 
    if self.success is not None:
18266 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18267 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18268 
      for iter359 in self.success:
18269 
        iter359.write(oprot)
5944 mandeep.dh 18270 
      oprot.writeListEnd()
18271 
      oprot.writeFieldEnd()
18272 
    oprot.writeFieldStop()
18273 
    oprot.writeStructEnd()
18274 
 
18275 
  def validate(self):
18276 
    return
18277 
 
18278 
 
18279 
  def __repr__(self):
18280 
    L = ['%s=%r' % (key, value)
18281 
      for key, value in self.__dict__.iteritems()]
18282 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18283 
 
18284 
  def __eq__(self, other):
18285 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18286 
 
18287 
  def __ne__(self, other):
18288 
    return not (self == other)
18289 
 
18290 
class addAuthorizationLog_args:
18291 
  """
18292 
  Attributes:
18293 
   - itemId
18294 
   - username
18295 
   - reason
18296 
  """
18297 
 
18298 
  thrift_spec = (
18299 
    None, # 0
18300 
    (1, TType.I64, 'itemId', None, None, ), # 1
18301 
    (2, TType.STRING, 'username', None, None, ), # 2
18302 
    (3, TType.STRING, 'reason', None, None, ), # 3
18303 
  )
18304 
 
18305 
  def __init__(self, itemId=None, username=None, reason=None,):
18306 
    self.itemId = itemId
18307 
    self.username = username
18308 
    self.reason = reason
18309 
 
18310 
  def read(self, iprot):
18311 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18312 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18313 
      return
18314 
    iprot.readStructBegin()
18315 
    while True:
18316 
      (fname, ftype, fid) = iprot.readFieldBegin()
18317 
      if ftype == TType.STOP:
18318 
        break
18319 
      if fid == 1:
18320 
        if ftype == TType.I64:
18321 
          self.itemId = iprot.readI64();
18322 
        else:
18323 
          iprot.skip(ftype)
18324 
      elif fid == 2:
18325 
        if ftype == TType.STRING:
18326 
          self.username = iprot.readString();
18327 
        else:
18328 
          iprot.skip(ftype)
18329 
      elif fid == 3:
18330 
        if ftype == TType.STRING:
18331 
          self.reason = iprot.readString();
18332 
        else:
18333 
          iprot.skip(ftype)
18334 
      else:
18335 
        iprot.skip(ftype)
18336 
      iprot.readFieldEnd()
18337 
    iprot.readStructEnd()
18338 
 
18339 
  def write(self, oprot):
18340 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18341 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18342 
      return
18343 
    oprot.writeStructBegin('addAuthorizationLog_args')
18344 
    if self.itemId is not None:
18345 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18346 
      oprot.writeI64(self.itemId)
18347 
      oprot.writeFieldEnd()
18348 
    if self.username is not None:
18349 
      oprot.writeFieldBegin('username', TType.STRING, 2)
18350 
      oprot.writeString(self.username)
18351 
      oprot.writeFieldEnd()
18352 
    if self.reason is not None:
18353 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
18354 
      oprot.writeString(self.reason)
18355 
      oprot.writeFieldEnd()
18356 
    oprot.writeFieldStop()
18357 
    oprot.writeStructEnd()
18358 
 
18359 
  def validate(self):
18360 
    return
18361 
 
18362 
 
18363 
  def __repr__(self):
18364 
    L = ['%s=%r' % (key, value)
18365 
      for key, value in self.__dict__.iteritems()]
18366 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18367 
 
18368 
  def __eq__(self, other):
18369 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18370 
 
18371 
  def __ne__(self, other):
18372 
    return not (self == other)
18373 
 
18374 
class addAuthorizationLog_result:
18375 
  """
18376 
  Attributes:
18377 
   - success
18378 
   - cex
18379 
  """
18380 
 
18381 
  thrift_spec = (
18382 
    (0, TType.BOOL, 'success', None, None, ), # 0
18383 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
18384 
  )
18385 
 
18386 
  def __init__(self, success=None, cex=None,):
18387 
    self.success = success
18388 
    self.cex = cex
18389 
 
18390 
  def read(self, iprot):
18391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18393 
      return
18394 
    iprot.readStructBegin()
18395 
    while True:
18396 
      (fname, ftype, fid) = iprot.readFieldBegin()
18397 
      if ftype == TType.STOP:
18398 
        break
18399 
      if fid == 0:
18400 
        if ftype == TType.BOOL:
18401 
          self.success = iprot.readBool();
18402 
        else:
18403 
          iprot.skip(ftype)
18404 
      elif fid == 1:
18405 
        if ftype == TType.STRUCT:
18406 
          self.cex = CatalogServiceException()
18407 
          self.cex.read(iprot)
18408 
        else:
18409 
          iprot.skip(ftype)
18410 
      else:
18411 
        iprot.skip(ftype)
18412 
      iprot.readFieldEnd()
18413 
    iprot.readStructEnd()
18414 
 
18415 
  def write(self, oprot):
18416 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18417 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18418 
      return
18419 
    oprot.writeStructBegin('addAuthorizationLog_result')
18420 
    if self.success is not None:
18421 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18422 
      oprot.writeBool(self.success)
18423 
      oprot.writeFieldEnd()
18424 
    if self.cex is not None:
18425 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
18426 
      self.cex.write(oprot)
18427 
      oprot.writeFieldEnd()
18428 
    oprot.writeFieldStop()
18429 
    oprot.writeStructEnd()
18430 
 
18431 
  def validate(self):
18432 
    return
18433 
 
18434 
 
18435 
  def __repr__(self):
18436 
    L = ['%s=%r' % (key, value)
18437 
      for key, value in self.__dict__.iteritems()]
18438 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18439 
 
18440 
  def __eq__(self, other):
18441 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18442 
 
18443 
  def __ne__(self, other):
18444 
    return not (self == other)
18445 
 
18446 
class addupdateVoucherForItem_args:
18447 
  """
18448 
  Attributes:
18449 
   - catalog_item_id
18450 
   - voucherType
18451 
   - voucherAmount
18452 
  """
18453 
 
18454 
  thrift_spec = (
18455 
    None, # 0
18456 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
18457 
    (2, TType.I64, 'voucherType', None, None, ), # 2
18458 
    (3, TType.I64, 'voucherAmount', None, None, ), # 3
18459 
  )
18460 
 
18461 
  def __init__(self, catalog_item_id=None, voucherType=None, voucherAmount=None,):
18462 
    self.catalog_item_id = catalog_item_id
18463 
    self.voucherType = voucherType
18464 
    self.voucherAmount = voucherAmount
18465 
 
18466 
  def read(self, iprot):
18467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18469 
      return
18470 
    iprot.readStructBegin()
18471 
    while True:
18472 
      (fname, ftype, fid) = iprot.readFieldBegin()
18473 
      if ftype == TType.STOP:
18474 
        break
18475 
      if fid == 1:
18476 
        if ftype == TType.I64:
18477 
          self.catalog_item_id = iprot.readI64();
18478 
        else:
18479 
          iprot.skip(ftype)
18480 
      elif fid == 2:
18481 
        if ftype == TType.I64:
18482 
          self.voucherType = iprot.readI64();
18483 
        else:
18484 
          iprot.skip(ftype)
18485 
      elif fid == 3:
18486 
        if ftype == TType.I64:
18487 
          self.voucherAmount = iprot.readI64();
18488 
        else:
18489 
          iprot.skip(ftype)
18490 
      else:
18491 
        iprot.skip(ftype)
18492 
      iprot.readFieldEnd()
18493 
    iprot.readStructEnd()
18494 
 
18495 
  def write(self, oprot):
18496 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18497 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18498 
      return
18499 
    oprot.writeStructBegin('addupdateVoucherForItem_args')
18500 
    if self.catalog_item_id is not None:
18501 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
18502 
      oprot.writeI64(self.catalog_item_id)
18503 
      oprot.writeFieldEnd()
18504 
    if self.voucherType is not None:
18505 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
18506 
      oprot.writeI64(self.voucherType)
18507 
      oprot.writeFieldEnd()
18508 
    if self.voucherAmount is not None:
18509 
      oprot.writeFieldBegin('voucherAmount', TType.I64, 3)
18510 
      oprot.writeI64(self.voucherAmount)
18511 
      oprot.writeFieldEnd()
18512 
    oprot.writeFieldStop()
18513 
    oprot.writeStructEnd()
18514 
 
18515 
  def validate(self):
18516 
    return
18517 
 
18518 
 
18519 
  def __repr__(self):
18520 
    L = ['%s=%r' % (key, value)
18521 
      for key, value in self.__dict__.iteritems()]
18522 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18523 
 
18524 
  def __eq__(self, other):
18525 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18526 
 
18527 
  def __ne__(self, other):
18528 
    return not (self == other)
18529 
 
18530 
class addupdateVoucherForItem_result:
18531 
  """
18532 
  Attributes:
18533 
   - success
18534 
   - cex
18535 
  """
18536 
 
18537 
  thrift_spec = (
18538 
    (0, TType.BOOL, 'success', None, None, ), # 0
18539 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
18540 
  )
18541 
 
18542 
  def __init__(self, success=None, cex=None,):
18543 
    self.success = success
18544 
    self.cex = cex
18545 
 
18546 
  def read(self, iprot):
18547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18549 
      return
18550 
    iprot.readStructBegin()
18551 
    while True:
18552 
      (fname, ftype, fid) = iprot.readFieldBegin()
18553 
      if ftype == TType.STOP:
18554 
        break
18555 
      if fid == 0:
18556 
        if ftype == TType.BOOL:
18557 
          self.success = iprot.readBool();
18558 
        else:
18559 
          iprot.skip(ftype)
18560 
      elif fid == 1:
18561 
        if ftype == TType.STRUCT:
18562 
          self.cex = CatalogServiceException()
18563 
          self.cex.read(iprot)
18564 
        else:
18565 
          iprot.skip(ftype)
18566 
      else:
18567 
        iprot.skip(ftype)
18568 
      iprot.readFieldEnd()
18569 
    iprot.readStructEnd()
18570 
 
18571 
  def write(self, oprot):
18572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18574 
      return
18575 
    oprot.writeStructBegin('addupdateVoucherForItem_result')
18576 
    if self.success is not None:
18577 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18578 
      oprot.writeBool(self.success)
18579 
      oprot.writeFieldEnd()
18580 
    if self.cex is not None:
18581 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
18582 
      self.cex.write(oprot)
18583 
      oprot.writeFieldEnd()
18584 
    oprot.writeFieldStop()
18585 
    oprot.writeStructEnd()
18586 
 
18587 
  def validate(self):
18588 
    return
18589 
 
18590 
 
18591 
  def __repr__(self):
18592 
    L = ['%s=%r' % (key, value)
18593 
      for key, value in self.__dict__.iteritems()]
18594 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18595 
 
18596 
  def __eq__(self, other):
18597 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18598 
 
18599 
  def __ne__(self, other):
18600 
    return not (self == other)
18601 
 
18602 
class deleteVoucherForItem_args:
18603 
  """
18604 
  Attributes:
18605 
   - catalog_item_id
18606 
   - voucherType
18607 
  """
18608 
 
18609 
  thrift_spec = (
18610 
    None, # 0
18611 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
18612 
    (2, TType.I64, 'voucherType', None, None, ), # 2
18613 
  )
18614 
 
18615 
  def __init__(self, catalog_item_id=None, voucherType=None,):
18616 
    self.catalog_item_id = catalog_item_id
18617 
    self.voucherType = voucherType
18618 
 
18619 
  def read(self, iprot):
18620 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18621 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18622 
      return
18623 
    iprot.readStructBegin()
18624 
    while True:
18625 
      (fname, ftype, fid) = iprot.readFieldBegin()
18626 
      if ftype == TType.STOP:
18627 
        break
18628 
      if fid == 1:
18629 
        if ftype == TType.I64:
18630 
          self.catalog_item_id = iprot.readI64();
18631 
        else:
18632 
          iprot.skip(ftype)
18633 
      elif fid == 2:
18634 
        if ftype == TType.I64:
18635 
          self.voucherType = iprot.readI64();
18636 
        else:
18637 
          iprot.skip(ftype)
18638 
      else:
18639 
        iprot.skip(ftype)
18640 
      iprot.readFieldEnd()
18641 
    iprot.readStructEnd()
18642 
 
18643 
  def write(self, oprot):
18644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18646 
      return
18647 
    oprot.writeStructBegin('deleteVoucherForItem_args')
18648 
    if self.catalog_item_id is not None:
18649 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
18650 
      oprot.writeI64(self.catalog_item_id)
18651 
      oprot.writeFieldEnd()
18652 
    if self.voucherType is not None:
18653 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
18654 
      oprot.writeI64(self.voucherType)
18655 
      oprot.writeFieldEnd()
18656 
    oprot.writeFieldStop()
18657 
    oprot.writeStructEnd()
18658 
 
18659 
  def validate(self):
18660 
    return
18661 
 
18662 
 
18663 
  def __repr__(self):
18664 
    L = ['%s=%r' % (key, value)
18665 
      for key, value in self.__dict__.iteritems()]
18666 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18667 
 
18668 
  def __eq__(self, other):
18669 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18670 
 
18671 
  def __ne__(self, other):
18672 
    return not (self == other)
18673 
 
18674 
class deleteVoucherForItem_result:
18675 
  """
18676 
  Attributes:
18677 
   - success
18678 
   - cex
18679 
  """
18680 
 
18681 
  thrift_spec = (
18682 
    (0, TType.BOOL, 'success', None, None, ), # 0
18683 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
18684 
  )
18685 
 
18686 
  def __init__(self, success=None, cex=None,):
18687 
    self.success = success
18688 
    self.cex = cex
18689 
 
18690 
  def read(self, iprot):
18691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18693 
      return
18694 
    iprot.readStructBegin()
18695 
    while True:
18696 
      (fname, ftype, fid) = iprot.readFieldBegin()
18697 
      if ftype == TType.STOP:
18698 
        break
18699 
      if fid == 0:
18700 
        if ftype == TType.BOOL:
18701 
          self.success = iprot.readBool();
18702 
        else:
18703 
          iprot.skip(ftype)
18704 
      elif fid == 1:
18705 
        if ftype == TType.STRUCT:
18706 
          self.cex = CatalogServiceException()
18707 
          self.cex.read(iprot)
18708 
        else:
18709 
          iprot.skip(ftype)
18710 
      else:
18711 
        iprot.skip(ftype)
18712 
      iprot.readFieldEnd()
18713 
    iprot.readStructEnd()
18714 
 
18715 
  def write(self, oprot):
18716 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18717 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18718 
      return
18719 
    oprot.writeStructBegin('deleteVoucherForItem_result')
18720 
    if self.success is not None:
18721 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18722 
      oprot.writeBool(self.success)
18723 
      oprot.writeFieldEnd()
18724 
    if self.cex is not None:
18725 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
18726 
      self.cex.write(oprot)
18727 
      oprot.writeFieldEnd()
18728 
    oprot.writeFieldStop()
18729 
    oprot.writeStructEnd()
18730 
 
18731 
  def validate(self):
18732 
    return
18733 
 
18734 
 
18735 
  def __repr__(self):
18736 
    L = ['%s=%r' % (key, value)
18737 
      for key, value in self.__dict__.iteritems()]
18738 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18739 
 
18740 
  def __eq__(self, other):
18741 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18742 
 
18743 
  def __ne__(self, other):
18744 
    return not (self == other)
18745 
 
18746 
class getVoucherAmount_args:
18747 
  """
18748 
  Attributes:
18749 
   - itemId
18750 
   - voucherType
18751 
  """
18752 
 
18753 
  thrift_spec = (
18754 
    None, # 0
18755 
    (1, TType.I64, 'itemId', None, None, ), # 1
18756 
    (2, TType.I64, 'voucherType', None, None, ), # 2
18757 
  )
18758 
 
18759 
  def __init__(self, itemId=None, voucherType=None,):
18760 
    self.itemId = itemId
18761 
    self.voucherType = voucherType
18762 
 
18763 
  def read(self, iprot):
18764 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18765 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18766 
      return
18767 
    iprot.readStructBegin()
18768 
    while True:
18769 
      (fname, ftype, fid) = iprot.readFieldBegin()
18770 
      if ftype == TType.STOP:
18771 
        break
18772 
      if fid == 1:
18773 
        if ftype == TType.I64:
18774 
          self.itemId = iprot.readI64();
18775 
        else:
18776 
          iprot.skip(ftype)
18777 
      elif fid == 2:
18778 
        if ftype == TType.I64:
18779 
          self.voucherType = 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('getVoucherAmount_args')
18792 
    if self.itemId is not None:
18793 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18794 
      oprot.writeI64(self.itemId)
18795 
      oprot.writeFieldEnd()
18796 
    if self.voucherType is not None:
18797 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
18798 
      oprot.writeI64(self.voucherType)
18799 
      oprot.writeFieldEnd()
18800 
    oprot.writeFieldStop()
18801 
    oprot.writeStructEnd()
18802 
 
18803 
  def validate(self):
18804 
    return
18805 
 
18806 
 
18807 
  def __repr__(self):
18808 
    L = ['%s=%r' % (key, value)
18809 
      for key, value in self.__dict__.iteritems()]
18810 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18811 
 
18812 
  def __eq__(self, other):
18813 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18814 
 
18815 
  def __ne__(self, other):
18816 
    return not (self == other)
18817 
 
18818 
class getVoucherAmount_result:
18819 
  """
18820 
  Attributes:
18821 
   - success
18822 
  """
18823 
 
18824 
  thrift_spec = (
18825 
    (0, TType.I64, 'success', None, None, ), # 0
18826 
  )
18827 
 
18828 
  def __init__(self, success=None,):
18829 
    self.success = success
18830 
 
18831 
  def read(self, iprot):
18832 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18833 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18834 
      return
18835 
    iprot.readStructBegin()
18836 
    while True:
18837 
      (fname, ftype, fid) = iprot.readFieldBegin()
18838 
      if ftype == TType.STOP:
18839 
        break
18840 
      if fid == 0:
18841 
        if ftype == TType.I64:
18842 
          self.success = iprot.readI64();
18843 
        else:
18844 
          iprot.skip(ftype)
18845 
      else:
18846 
        iprot.skip(ftype)
18847 
      iprot.readFieldEnd()
18848 
    iprot.readStructEnd()
18849 
 
18850 
  def write(self, oprot):
18851 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18852 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18853 
      return
18854 
    oprot.writeStructBegin('getVoucherAmount_result')
18855 
    if self.success is not None:
18856 
      oprot.writeFieldBegin('success', TType.I64, 0)
18857 
      oprot.writeI64(self.success)
18858 
      oprot.writeFieldEnd()
18859 
    oprot.writeFieldStop()
18860 
    oprot.writeStructEnd()
18861 
 
18862 
  def validate(self):
18863 
    return
18864 
 
18865 
 
18866 
  def __repr__(self):
18867 
    L = ['%s=%r' % (key, value)
18868 
      for key, value in self.__dict__.iteritems()]
18869 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18870 
 
18871 
  def __eq__(self, other):
18872 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18873 
 
18874 
  def __ne__(self, other):
18875 
    return not (self == other)
18876 
 
18877 
class getAllItemVouchers_args:
18878 
  """
18879 
  Attributes:
18880 
   - itemId
18881 
  """
18882 
 
18883 
  thrift_spec = (
18884 
    None, # 0
18885 
    (1, TType.I64, 'itemId', None, None, ), # 1
18886 
  )
18887 
 
18888 
  def __init__(self, itemId=None,):
18889 
    self.itemId = itemId
18890 
 
18891 
  def read(self, iprot):
18892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18894 
      return
18895 
    iprot.readStructBegin()
18896 
    while True:
18897 
      (fname, ftype, fid) = iprot.readFieldBegin()
18898 
      if ftype == TType.STOP:
18899 
        break
18900 
      if fid == 1:
18901 
        if ftype == TType.I64:
18902 
          self.itemId = iprot.readI64();
18903 
        else:
18904 
          iprot.skip(ftype)
18905 
      else:
18906 
        iprot.skip(ftype)
18907 
      iprot.readFieldEnd()
18908 
    iprot.readStructEnd()
18909 
 
18910 
  def write(self, oprot):
18911 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18912 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18913 
      return
18914 
    oprot.writeStructBegin('getAllItemVouchers_args')
18915 
    if self.itemId is not None:
18916 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18917 
      oprot.writeI64(self.itemId)
18918 
      oprot.writeFieldEnd()
18919 
    oprot.writeFieldStop()
18920 
    oprot.writeStructEnd()
18921 
 
18922 
  def validate(self):
18923 
    return
18924 
 
18925 
 
18926 
  def __repr__(self):
18927 
    L = ['%s=%r' % (key, value)
18928 
      for key, value in self.__dict__.iteritems()]
18929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18930 
 
18931 
  def __eq__(self, other):
18932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18933 
 
18934 
  def __ne__(self, other):
18935 
    return not (self == other)
18936 
 
18937 
class getAllItemVouchers_result:
18938 
  """
18939 
  Attributes:
18940 
   - success
18941 
  """
18942 
 
18943 
  thrift_spec = (
18944 
    (0, TType.LIST, 'success', (TType.STRUCT,(VoucherItemMapping, VoucherItemMapping.thrift_spec)), None, ), # 0
18945 
  )
18946 
 
18947 
  def __init__(self, success=None,):
18948 
    self.success = success
18949 
 
18950 
  def read(self, iprot):
18951 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18952 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18953 
      return
18954 
    iprot.readStructBegin()
18955 
    while True:
18956 
      (fname, ftype, fid) = iprot.readFieldBegin()
18957 
      if ftype == TType.STOP:
18958 
        break
18959 
      if fid == 0:
18960 
        if ftype == TType.LIST:
18961 
          self.success = []
9155 kshitij.so 18962 
          (_etype363, _size360) = iprot.readListBegin()
18963 
          for _i364 in xrange(_size360):
18964 
            _elem365 = VoucherItemMapping()
18965 
            _elem365.read(iprot)
18966 
            self.success.append(_elem365)
5944 mandeep.dh 18967 
          iprot.readListEnd()
18968 
        else:
18969 
          iprot.skip(ftype)
18970 
      else:
18971 
        iprot.skip(ftype)
18972 
      iprot.readFieldEnd()
18973 
    iprot.readStructEnd()
18974 
 
18975 
  def write(self, oprot):
18976 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18977 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18978 
      return
18979 
    oprot.writeStructBegin('getAllItemVouchers_result')
18980 
    if self.success is not None:
18981 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18982 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18983 
      for iter366 in self.success:
18984 
        iter366.write(oprot)
5944 mandeep.dh 18985 
      oprot.writeListEnd()
18986 
      oprot.writeFieldEnd()
18987 
    oprot.writeFieldStop()
18988 
    oprot.writeStructEnd()
18989 
 
18990 
  def validate(self):
18991 
    return
18992 
 
18993 
 
18994 
  def __repr__(self):
18995 
    L = ['%s=%r' % (key, value)
18996 
      for key, value in self.__dict__.iteritems()]
18997 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18998 
 
18999 
  def __eq__(self, other):
19000 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19001 
 
19002 
  def __ne__(self, other):
19003 
    return not (self == other)
19004 
 
19005 
class isValidCatalogItemId_args:
19006 
  """
19007 
  Attributes:
19008 
   - catalog_item_id
19009 
  """
19010 
 
19011 
  thrift_spec = (
19012 
    None, # 0
19013 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
19014 
  )
19015 
 
19016 
  def __init__(self, catalog_item_id=None,):
19017 
    self.catalog_item_id = catalog_item_id
19018 
 
19019 
  def read(self, iprot):
19020 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19021 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19022 
      return
19023 
    iprot.readStructBegin()
19024 
    while True:
19025 
      (fname, ftype, fid) = iprot.readFieldBegin()
19026 
      if ftype == TType.STOP:
19027 
        break
19028 
      if fid == 1:
19029 
        if ftype == TType.I64:
19030 
          self.catalog_item_id = iprot.readI64();
19031 
        else:
19032 
          iprot.skip(ftype)
19033 
      else:
19034 
        iprot.skip(ftype)
19035 
      iprot.readFieldEnd()
19036 
    iprot.readStructEnd()
19037 
 
19038 
  def write(self, oprot):
19039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19041 
      return
19042 
    oprot.writeStructBegin('isValidCatalogItemId_args')
19043 
    if self.catalog_item_id is not None:
19044 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
19045 
      oprot.writeI64(self.catalog_item_id)
19046 
      oprot.writeFieldEnd()
19047 
    oprot.writeFieldStop()
19048 
    oprot.writeStructEnd()
19049 
 
19050 
  def validate(self):
19051 
    return
19052 
 
19053 
 
19054 
  def __repr__(self):
19055 
    L = ['%s=%r' % (key, value)
19056 
      for key, value in self.__dict__.iteritems()]
19057 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19058 
 
19059 
  def __eq__(self, other):
19060 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19061 
 
19062 
  def __ne__(self, other):
19063 
    return not (self == other)
19064 
 
19065 
class isValidCatalogItemId_result:
19066 
  """
19067 
  Attributes:
19068 
   - success
19069 
  """
19070 
 
19071 
  thrift_spec = (
19072 
    (0, TType.BOOL, 'success', None, None, ), # 0
19073 
  )
19074 
 
19075 
  def __init__(self, success=None,):
19076 
    self.success = success
19077 
 
19078 
  def read(self, iprot):
19079 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19080 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19081 
      return
19082 
    iprot.readStructBegin()
19083 
    while True:
19084 
      (fname, ftype, fid) = iprot.readFieldBegin()
19085 
      if ftype == TType.STOP:
19086 
        break
19087 
      if fid == 0:
19088 
        if ftype == TType.BOOL:
19089 
          self.success = iprot.readBool();
19090 
        else:
19091 
          iprot.skip(ftype)
19092 
      else:
19093 
        iprot.skip(ftype)
19094 
      iprot.readFieldEnd()
19095 
    iprot.readStructEnd()
19096 
 
19097 
  def write(self, oprot):
19098 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19099 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19100 
      return
19101 
    oprot.writeStructBegin('isValidCatalogItemId_result')
19102 
    if self.success is not None:
19103 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19104 
      oprot.writeBool(self.success)
19105 
      oprot.writeFieldEnd()
19106 
    oprot.writeFieldStop()
19107 
    oprot.writeStructEnd()
19108 
 
19109 
  def validate(self):
19110 
    return
19111 
 
19112 
 
19113 
  def __repr__(self):
19114 
    L = ['%s=%r' % (key, value)
19115 
      for key, value in self.__dict__.iteritems()]
19116 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19117 
 
19118 
  def __eq__(self, other):
19119 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19120 
 
19121 
  def __ne__(self, other):
19122 
    return not (self == other)
6039 amit.gupta 19123 
 
19124 
class getVatPercentageForItem_args:
19125 
  """
19126 
  Attributes:
19127 
   - itemId
7330 amit.gupta 19128 
   - stateId
6039 amit.gupta 19129 
   - price
19130 
  """
19131 
 
19132 
  thrift_spec = (
19133 
    None, # 0
19134 
    (1, TType.I64, 'itemId', None, None, ), # 1
7330 amit.gupta 19135 
    (2, TType.I64, 'stateId', None, None, ), # 2
19136 
    (3, TType.DOUBLE, 'price', None, None, ), # 3
6039 amit.gupta 19137 
  )
19138 
 
7330 amit.gupta 19139 
  def __init__(self, itemId=None, stateId=None, price=None,):
6039 amit.gupta 19140 
    self.itemId = itemId
7330 amit.gupta 19141 
    self.stateId = stateId
6039 amit.gupta 19142 
    self.price = price
19143 
 
19144 
  def read(self, iprot):
19145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19147 
      return
19148 
    iprot.readStructBegin()
19149 
    while True:
19150 
      (fname, ftype, fid) = iprot.readFieldBegin()
19151 
      if ftype == TType.STOP:
19152 
        break
19153 
      if fid == 1:
19154 
        if ftype == TType.I64:
19155 
          self.itemId = iprot.readI64();
19156 
        else:
19157 
          iprot.skip(ftype)
19158 
      elif fid == 2:
7330 amit.gupta 19159 
        if ftype == TType.I64:
19160 
          self.stateId = iprot.readI64();
19161 
        else:
19162 
          iprot.skip(ftype)
19163 
      elif fid == 3:
6039 amit.gupta 19164 
        if ftype == TType.DOUBLE:
19165 
          self.price = iprot.readDouble();
19166 
        else:
19167 
          iprot.skip(ftype)
19168 
      else:
19169 
        iprot.skip(ftype)
19170 
      iprot.readFieldEnd()
19171 
    iprot.readStructEnd()
19172 
 
19173 
  def write(self, oprot):
19174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19176 
      return
19177 
    oprot.writeStructBegin('getVatPercentageForItem_args')
19178 
    if self.itemId is not None:
19179 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19180 
      oprot.writeI64(self.itemId)
19181 
      oprot.writeFieldEnd()
7330 amit.gupta 19182 
    if self.stateId is not None:
19183 
      oprot.writeFieldBegin('stateId', TType.I64, 2)
19184 
      oprot.writeI64(self.stateId)
19185 
      oprot.writeFieldEnd()
6039 amit.gupta 19186 
    if self.price is not None:
7330 amit.gupta 19187 
      oprot.writeFieldBegin('price', TType.DOUBLE, 3)
6039 amit.gupta 19188 
      oprot.writeDouble(self.price)
19189 
      oprot.writeFieldEnd()
19190 
    oprot.writeFieldStop()
19191 
    oprot.writeStructEnd()
19192 
 
19193 
  def validate(self):
19194 
    return
19195 
 
19196 
 
19197 
  def __repr__(self):
19198 
    L = ['%s=%r' % (key, value)
19199 
      for key, value in self.__dict__.iteritems()]
19200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19201 
 
19202 
  def __eq__(self, other):
19203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19204 
 
19205 
  def __ne__(self, other):
19206 
    return not (self == other)
19207 
 
19208 
class getVatPercentageForItem_result:
19209 
  """
19210 
  Attributes:
19211 
   - success
7340 amit.gupta 19212 
   - cex
6039 amit.gupta 19213 
  """
19214 
 
19215 
  thrift_spec = (
19216 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
7340 amit.gupta 19217 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6039 amit.gupta 19218 
  )
19219 
 
7340 amit.gupta 19220 
  def __init__(self, success=None, cex=None,):
6039 amit.gupta 19221 
    self.success = success
7340 amit.gupta 19222 
    self.cex = cex
6039 amit.gupta 19223 
 
19224 
  def read(self, iprot):
19225 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19226 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19227 
      return
19228 
    iprot.readStructBegin()
19229 
    while True:
19230 
      (fname, ftype, fid) = iprot.readFieldBegin()
19231 
      if ftype == TType.STOP:
19232 
        break
19233 
      if fid == 0:
19234 
        if ftype == TType.DOUBLE:
19235 
          self.success = iprot.readDouble();
19236 
        else:
19237 
          iprot.skip(ftype)
7340 amit.gupta 19238 
      elif fid == 1:
19239 
        if ftype == TType.STRUCT:
19240 
          self.cex = CatalogServiceException()
19241 
          self.cex.read(iprot)
19242 
        else:
19243 
          iprot.skip(ftype)
6039 amit.gupta 19244 
      else:
19245 
        iprot.skip(ftype)
19246 
      iprot.readFieldEnd()
19247 
    iprot.readStructEnd()
19248 
 
19249 
  def write(self, oprot):
19250 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19251 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19252 
      return
19253 
    oprot.writeStructBegin('getVatPercentageForItem_result')
19254 
    if self.success is not None:
19255 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
19256 
      oprot.writeDouble(self.success)
19257 
      oprot.writeFieldEnd()
7340 amit.gupta 19258 
    if self.cex is not None:
19259 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
19260 
      self.cex.write(oprot)
19261 
      oprot.writeFieldEnd()
6039 amit.gupta 19262 
    oprot.writeFieldStop()
19263 
    oprot.writeStructEnd()
19264 
 
19265 
  def validate(self):
19266 
    return
19267 
 
19268 
 
19269 
  def __repr__(self):
19270 
    L = ['%s=%r' % (key, value)
19271 
      for key, value in self.__dict__.iteritems()]
19272 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19273 
 
19274 
  def __eq__(self, other):
19275 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19276 
 
19277 
  def __ne__(self, other):
19278 
    return not (self == other)
19279 
 
19280 
class getVatAmountForItem_args:
19281 
  """
19282 
  Attributes:
19283 
   - itemId
19284 
   - price
19285 
  """
19286 
 
19287 
  thrift_spec = (
19288 
    None, # 0
19289 
    (1, TType.I64, 'itemId', None, None, ), # 1
19290 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
19291 
  )
19292 
 
19293 
  def __init__(self, itemId=None, price=None,):
19294 
    self.itemId = itemId
19295 
    self.price = price
19296 
 
19297 
  def read(self, iprot):
19298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19300 
      return
19301 
    iprot.readStructBegin()
19302 
    while True:
19303 
      (fname, ftype, fid) = iprot.readFieldBegin()
19304 
      if ftype == TType.STOP:
19305 
        break
19306 
      if fid == 1:
19307 
        if ftype == TType.I64:
19308 
          self.itemId = iprot.readI64();
19309 
        else:
19310 
          iprot.skip(ftype)
19311 
      elif fid == 2:
19312 
        if ftype == TType.DOUBLE:
19313 
          self.price = iprot.readDouble();
19314 
        else:
19315 
          iprot.skip(ftype)
19316 
      else:
19317 
        iprot.skip(ftype)
19318 
      iprot.readFieldEnd()
19319 
    iprot.readStructEnd()
19320 
 
19321 
  def write(self, oprot):
19322 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19323 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19324 
      return
19325 
    oprot.writeStructBegin('getVatAmountForItem_args')
19326 
    if self.itemId is not None:
19327 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19328 
      oprot.writeI64(self.itemId)
19329 
      oprot.writeFieldEnd()
19330 
    if self.price is not None:
19331 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
19332 
      oprot.writeDouble(self.price)
19333 
      oprot.writeFieldEnd()
19334 
    oprot.writeFieldStop()
19335 
    oprot.writeStructEnd()
19336 
 
19337 
  def validate(self):
19338 
    return
19339 
 
19340 
 
19341 
  def __repr__(self):
19342 
    L = ['%s=%r' % (key, value)
19343 
      for key, value in self.__dict__.iteritems()]
19344 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19345 
 
19346 
  def __eq__(self, other):
19347 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19348 
 
19349 
  def __ne__(self, other):
19350 
    return not (self == other)
19351 
 
19352 
class getVatAmountForItem_result:
19353 
  """
19354 
  Attributes:
19355 
   - success
19356 
  """
19357 
 
19358 
  thrift_spec = (
19359 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
19360 
  )
19361 
 
19362 
  def __init__(self, success=None,):
19363 
    self.success = success
19364 
 
19365 
  def read(self, iprot):
19366 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19367 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19368 
      return
19369 
    iprot.readStructBegin()
19370 
    while True:
19371 
      (fname, ftype, fid) = iprot.readFieldBegin()
19372 
      if ftype == TType.STOP:
19373 
        break
19374 
      if fid == 0:
19375 
        if ftype == TType.DOUBLE:
19376 
          self.success = iprot.readDouble();
19377 
        else:
19378 
          iprot.skip(ftype)
19379 
      else:
19380 
        iprot.skip(ftype)
19381 
      iprot.readFieldEnd()
19382 
    iprot.readStructEnd()
19383 
 
19384 
  def write(self, oprot):
19385 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19386 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19387 
      return
19388 
    oprot.writeStructBegin('getVatAmountForItem_result')
19389 
    if self.success is not None:
19390 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
19391 
      oprot.writeDouble(self.success)
19392 
      oprot.writeFieldEnd()
19393 
    oprot.writeFieldStop()
19394 
    oprot.writeStructEnd()
19395 
 
19396 
  def validate(self):
19397 
    return
19398 
 
19399 
 
19400 
  def __repr__(self):
19401 
    L = ['%s=%r' % (key, value)
19402 
      for key, value in self.__dict__.iteritems()]
19403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19404 
 
19405 
  def __eq__(self, other):
19406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19407 
 
19408 
  def __ne__(self, other):
19409 
    return not (self == other)
6531 vikram.rag 19410 
 
19411 
class getAllIgnoredInventoryUpdateItemsList_args:
19412 
  """
19413 
  Attributes:
19414 
   - offset
19415 
   - limit
19416 
  """
19417 
 
19418 
  thrift_spec = (
19419 
    None, # 0
19420 
    (1, TType.I32, 'offset', None, None, ), # 1
19421 
    (2, TType.I32, 'limit', None, None, ), # 2
19422 
  )
19423 
 
19424 
  def __init__(self, offset=None, limit=None,):
19425 
    self.offset = offset
19426 
    self.limit = limit
19427 
 
19428 
  def read(self, iprot):
19429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19431 
      return
19432 
    iprot.readStructBegin()
19433 
    while True:
19434 
      (fname, ftype, fid) = iprot.readFieldBegin()
19435 
      if ftype == TType.STOP:
19436 
        break
19437 
      if fid == 1:
19438 
        if ftype == TType.I32:
19439 
          self.offset = iprot.readI32();
19440 
        else:
19441 
          iprot.skip(ftype)
19442 
      elif fid == 2:
19443 
        if ftype == TType.I32:
19444 
          self.limit = iprot.readI32();
19445 
        else:
19446 
          iprot.skip(ftype)
19447 
      else:
19448 
        iprot.skip(ftype)
19449 
      iprot.readFieldEnd()
19450 
    iprot.readStructEnd()
19451 
 
19452 
  def write(self, oprot):
19453 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19454 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19455 
      return
19456 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_args')
19457 
    if self.offset is not None:
19458 
      oprot.writeFieldBegin('offset', TType.I32, 1)
19459 
      oprot.writeI32(self.offset)
19460 
      oprot.writeFieldEnd()
19461 
    if self.limit is not None:
19462 
      oprot.writeFieldBegin('limit', TType.I32, 2)
19463 
      oprot.writeI32(self.limit)
19464 
      oprot.writeFieldEnd()
19465 
    oprot.writeFieldStop()
19466 
    oprot.writeStructEnd()
19467 
 
19468 
  def validate(self):
19469 
    return
19470 
 
19471 
 
19472 
  def __repr__(self):
19473 
    L = ['%s=%r' % (key, value)
19474 
      for key, value in self.__dict__.iteritems()]
19475 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19476 
 
19477 
  def __eq__(self, other):
19478 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19479 
 
19480 
  def __ne__(self, other):
19481 
    return not (self == other)
19482 
 
19483 
class getAllIgnoredInventoryUpdateItemsList_result:
19484 
  """
19485 
  Attributes:
19486 
   - success
19487 
  """
19488 
 
19489 
  thrift_spec = (
19490 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
19491 
  )
19492 
 
19493 
  def __init__(self, success=None,):
19494 
    self.success = success
19495 
 
19496 
  def read(self, iprot):
19497 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19498 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19499 
      return
19500 
    iprot.readStructBegin()
19501 
    while True:
19502 
      (fname, ftype, fid) = iprot.readFieldBegin()
19503 
      if ftype == TType.STOP:
19504 
        break
19505 
      if fid == 0:
19506 
        if ftype == TType.LIST:
19507 
          self.success = []
9155 kshitij.so 19508 
          (_etype370, _size367) = iprot.readListBegin()
19509 
          for _i371 in xrange(_size367):
19510 
            _elem372 = Item()
19511 
            _elem372.read(iprot)
19512 
            self.success.append(_elem372)
6531 vikram.rag 19513 
          iprot.readListEnd()
19514 
        else:
19515 
          iprot.skip(ftype)
19516 
      else:
19517 
        iprot.skip(ftype)
19518 
      iprot.readFieldEnd()
19519 
    iprot.readStructEnd()
19520 
 
19521 
  def write(self, oprot):
19522 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19523 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19524 
      return
19525 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_result')
19526 
    if self.success is not None:
19527 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19528 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 19529 
      for iter373 in self.success:
19530 
        iter373.write(oprot)
6531 vikram.rag 19531 
      oprot.writeListEnd()
19532 
      oprot.writeFieldEnd()
19533 
    oprot.writeFieldStop()
19534 
    oprot.writeStructEnd()
19535 
 
19536 
  def validate(self):
19537 
    return
19538 
 
19539 
 
19540 
  def __repr__(self):
19541 
    L = ['%s=%r' % (key, value)
19542 
      for key, value in self.__dict__.iteritems()]
19543 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19544 
 
19545 
  def __eq__(self, other):
19546 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19547 
 
19548 
  def __ne__(self, other):
19549 
    return not (self == other)
6805 anupam.sin 19550 
 
6821 amar.kumar 19551 
class getAllAliveItems_args:
19552 
 
19553 
  thrift_spec = (
19554 
  )
19555 
 
19556 
  def read(self, iprot):
19557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19559 
      return
19560 
    iprot.readStructBegin()
19561 
    while True:
19562 
      (fname, ftype, fid) = iprot.readFieldBegin()
19563 
      if ftype == TType.STOP:
19564 
        break
19565 
      else:
19566 
        iprot.skip(ftype)
19567 
      iprot.readFieldEnd()
19568 
    iprot.readStructEnd()
19569 
 
19570 
  def write(self, oprot):
19571 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19572 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19573 
      return
19574 
    oprot.writeStructBegin('getAllAliveItems_args')
19575 
    oprot.writeFieldStop()
19576 
    oprot.writeStructEnd()
19577 
 
19578 
  def validate(self):
19579 
    return
19580 
 
19581 
 
19582 
  def __repr__(self):
19583 
    L = ['%s=%r' % (key, value)
19584 
      for key, value in self.__dict__.iteritems()]
19585 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19586 
 
19587 
  def __eq__(self, other):
19588 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19589 
 
19590 
  def __ne__(self, other):
19591 
    return not (self == other)
19592 
 
19593 
class getAllAliveItems_result:
19594 
  """
19595 
  Attributes:
19596 
   - success
19597 
  """
19598 
 
19599 
  thrift_spec = (
19600 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
19601 
  )
19602 
 
19603 
  def __init__(self, success=None,):
19604 
    self.success = success
19605 
 
19606 
  def read(self, iprot):
19607 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19608 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19609 
      return
19610 
    iprot.readStructBegin()
19611 
    while True:
19612 
      (fname, ftype, fid) = iprot.readFieldBegin()
19613 
      if ftype == TType.STOP:
19614 
        break
19615 
      if fid == 0:
19616 
        if ftype == TType.LIST:
19617 
          self.success = []
9155 kshitij.so 19618 
          (_etype377, _size374) = iprot.readListBegin()
19619 
          for _i378 in xrange(_size374):
19620 
            _elem379 = Item()
19621 
            _elem379.read(iprot)
19622 
            self.success.append(_elem379)
6821 amar.kumar 19623 
          iprot.readListEnd()
19624 
        else:
19625 
          iprot.skip(ftype)
19626 
      else:
19627 
        iprot.skip(ftype)
19628 
      iprot.readFieldEnd()
19629 
    iprot.readStructEnd()
19630 
 
19631 
  def write(self, oprot):
19632 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19633 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19634 
      return
19635 
    oprot.writeStructBegin('getAllAliveItems_result')
19636 
    if self.success is not None:
19637 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19638 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 19639 
      for iter380 in self.success:
19640 
        iter380.write(oprot)
6821 amar.kumar 19641 
      oprot.writeListEnd()
19642 
      oprot.writeFieldEnd()
19643 
    oprot.writeFieldStop()
19644 
    oprot.writeStructEnd()
19645 
 
19646 
  def validate(self):
19647 
    return
19648 
 
19649 
 
19650 
  def __repr__(self):
19651 
    L = ['%s=%r' % (key, value)
19652 
      for key, value in self.__dict__.iteritems()]
19653 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19654 
 
19655 
  def __eq__(self, other):
19656 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19657 
 
19658 
  def __ne__(self, other):
19659 
    return not (self == other)
19660 
 
6805 anupam.sin 19661 
class getInsuranceAmount_args:
19662 
  """
19663 
  Attributes:
19664 
   - itemId
6921 anupam.sin 19665 
   - price
6805 anupam.sin 19666 
   - insurerId
19667 
   - quantity
19668 
  """
19669 
 
19670 
  thrift_spec = (
19671 
    None, # 0
19672 
    (1, TType.I64, 'itemId', None, None, ), # 1
6921 anupam.sin 19673 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
19674 
    (3, TType.I64, 'insurerId', None, None, ), # 3
19675 
    (4, TType.I64, 'quantity', None, None, ), # 4
6805 anupam.sin 19676 
  )
19677 
 
6921 anupam.sin 19678 
  def __init__(self, itemId=None, price=None, insurerId=None, quantity=None,):
6805 anupam.sin 19679 
    self.itemId = itemId
6921 anupam.sin 19680 
    self.price = price
6805 anupam.sin 19681 
    self.insurerId = insurerId
19682 
    self.quantity = quantity
19683 
 
19684 
  def read(self, iprot):
19685 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19686 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19687 
      return
19688 
    iprot.readStructBegin()
19689 
    while True:
19690 
      (fname, ftype, fid) = iprot.readFieldBegin()
19691 
      if ftype == TType.STOP:
19692 
        break
19693 
      if fid == 1:
19694 
        if ftype == TType.I64:
19695 
          self.itemId = iprot.readI64();
19696 
        else:
19697 
          iprot.skip(ftype)
19698 
      elif fid == 2:
6921 anupam.sin 19699 
        if ftype == TType.DOUBLE:
19700 
          self.price = iprot.readDouble();
19701 
        else:
19702 
          iprot.skip(ftype)
19703 
      elif fid == 3:
6805 anupam.sin 19704 
        if ftype == TType.I64:
19705 
          self.insurerId = iprot.readI64();
19706 
        else:
19707 
          iprot.skip(ftype)
6921 anupam.sin 19708 
      elif fid == 4:
6805 anupam.sin 19709 
        if ftype == TType.I64:
19710 
          self.quantity = iprot.readI64();
19711 
        else:
19712 
          iprot.skip(ftype)
19713 
      else:
19714 
        iprot.skip(ftype)
19715 
      iprot.readFieldEnd()
19716 
    iprot.readStructEnd()
19717 
 
19718 
  def write(self, oprot):
19719 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19720 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19721 
      return
19722 
    oprot.writeStructBegin('getInsuranceAmount_args')
19723 
    if self.itemId is not None:
19724 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19725 
      oprot.writeI64(self.itemId)
19726 
      oprot.writeFieldEnd()
6921 anupam.sin 19727 
    if self.price is not None:
19728 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
19729 
      oprot.writeDouble(self.price)
19730 
      oprot.writeFieldEnd()
6805 anupam.sin 19731 
    if self.insurerId is not None:
6921 anupam.sin 19732 
      oprot.writeFieldBegin('insurerId', TType.I64, 3)
6805 anupam.sin 19733 
      oprot.writeI64(self.insurerId)
19734 
      oprot.writeFieldEnd()
19735 
    if self.quantity is not None:
6921 anupam.sin 19736 
      oprot.writeFieldBegin('quantity', TType.I64, 4)
6805 anupam.sin 19737 
      oprot.writeI64(self.quantity)
19738 
      oprot.writeFieldEnd()
19739 
    oprot.writeFieldStop()
19740 
    oprot.writeStructEnd()
19741 
 
19742 
  def validate(self):
19743 
    return
19744 
 
19745 
 
19746 
  def __repr__(self):
19747 
    L = ['%s=%r' % (key, value)
19748 
      for key, value in self.__dict__.iteritems()]
19749 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19750 
 
19751 
  def __eq__(self, other):
19752 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19753 
 
19754 
  def __ne__(self, other):
19755 
    return not (self == other)
19756 
 
19757 
class getInsuranceAmount_result:
19758 
  """
19759 
  Attributes:
19760 
   - success
19761 
  """
19762 
 
19763 
  thrift_spec = (
19764 
    (0, TType.I64, 'success', None, None, ), # 0
19765 
  )
19766 
 
19767 
  def __init__(self, success=None,):
19768 
    self.success = success
19769 
 
19770 
  def read(self, iprot):
19771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19773 
      return
19774 
    iprot.readStructBegin()
19775 
    while True:
19776 
      (fname, ftype, fid) = iprot.readFieldBegin()
19777 
      if ftype == TType.STOP:
19778 
        break
19779 
      if fid == 0:
19780 
        if ftype == TType.I64:
19781 
          self.success = iprot.readI64();
19782 
        else:
19783 
          iprot.skip(ftype)
19784 
      else:
19785 
        iprot.skip(ftype)
19786 
      iprot.readFieldEnd()
19787 
    iprot.readStructEnd()
19788 
 
19789 
  def write(self, oprot):
19790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19792 
      return
19793 
    oprot.writeStructBegin('getInsuranceAmount_result')
19794 
    if self.success is not None:
19795 
      oprot.writeFieldBegin('success', TType.I64, 0)
19796 
      oprot.writeI64(self.success)
19797 
      oprot.writeFieldEnd()
19798 
    oprot.writeFieldStop()
19799 
    oprot.writeStructEnd()
19800 
 
19801 
  def validate(self):
19802 
    return
19803 
 
19804 
 
19805 
  def __repr__(self):
19806 
    L = ['%s=%r' % (key, value)
19807 
      for key, value in self.__dict__.iteritems()]
19808 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19809 
 
19810 
  def __eq__(self, other):
19811 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19812 
 
19813 
  def __ne__(self, other):
19814 
    return not (self == other)
19815 
 
19816 
class getInsurer_args:
19817 
  """
19818 
  Attributes:
19819 
   - insurerId
19820 
  """
19821 
 
19822 
  thrift_spec = (
19823 
    None, # 0
19824 
    (1, TType.I64, 'insurerId', None, None, ), # 1
19825 
  )
19826 
 
19827 
  def __init__(self, insurerId=None,):
19828 
    self.insurerId = insurerId
19829 
 
19830 
  def read(self, iprot):
19831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19833 
      return
19834 
    iprot.readStructBegin()
19835 
    while True:
19836 
      (fname, ftype, fid) = iprot.readFieldBegin()
19837 
      if ftype == TType.STOP:
19838 
        break
19839 
      if fid == 1:
19840 
        if ftype == TType.I64:
19841 
          self.insurerId = iprot.readI64();
19842 
        else:
19843 
          iprot.skip(ftype)
19844 
      else:
19845 
        iprot.skip(ftype)
19846 
      iprot.readFieldEnd()
19847 
    iprot.readStructEnd()
19848 
 
19849 
  def write(self, oprot):
19850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19852 
      return
19853 
    oprot.writeStructBegin('getInsurer_args')
19854 
    if self.insurerId is not None:
19855 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
19856 
      oprot.writeI64(self.insurerId)
19857 
      oprot.writeFieldEnd()
19858 
    oprot.writeFieldStop()
19859 
    oprot.writeStructEnd()
19860 
 
19861 
  def validate(self):
19862 
    return
19863 
 
19864 
 
19865 
  def __repr__(self):
19866 
    L = ['%s=%r' % (key, value)
19867 
      for key, value in self.__dict__.iteritems()]
19868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19869 
 
19870 
  def __eq__(self, other):
19871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19872 
 
19873 
  def __ne__(self, other):
19874 
    return not (self == other)
19875 
 
19876 
class getInsurer_result:
19877 
  """
19878 
  Attributes:
19879 
   - success
19880 
  """
19881 
 
19882 
  thrift_spec = (
19883 
    (0, TType.STRUCT, 'success', (Insurer, Insurer.thrift_spec), None, ), # 0
19884 
  )
19885 
 
19886 
  def __init__(self, success=None,):
19887 
    self.success = success
19888 
 
19889 
  def read(self, iprot):
19890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19892 
      return
19893 
    iprot.readStructBegin()
19894 
    while True:
19895 
      (fname, ftype, fid) = iprot.readFieldBegin()
19896 
      if ftype == TType.STOP:
19897 
        break
19898 
      if fid == 0:
19899 
        if ftype == TType.STRUCT:
19900 
          self.success = Insurer()
19901 
          self.success.read(iprot)
19902 
        else:
19903 
          iprot.skip(ftype)
19904 
      else:
19905 
        iprot.skip(ftype)
19906 
      iprot.readFieldEnd()
19907 
    iprot.readStructEnd()
19908 
 
19909 
  def write(self, oprot):
19910 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19911 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19912 
      return
19913 
    oprot.writeStructBegin('getInsurer_result')
19914 
    if self.success is not None:
19915 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19916 
      self.success.write(oprot)
19917 
      oprot.writeFieldEnd()
19918 
    oprot.writeFieldStop()
19919 
    oprot.writeStructEnd()
19920 
 
19921 
  def validate(self):
19922 
    return
19923 
 
19924 
 
19925 
  def __repr__(self):
19926 
    L = ['%s=%r' % (key, value)
19927 
      for key, value in self.__dict__.iteritems()]
19928 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19929 
 
19930 
  def __eq__(self, other):
19931 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19932 
 
19933 
  def __ne__(self, other):
19934 
    return not (self == other)
6838 vikram.rag 19935 
 
19936 
class getAllInsurers_args:
19937 
 
19938 
  thrift_spec = (
19939 
  )
19940 
 
19941 
  def read(self, iprot):
19942 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19943 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19944 
      return
19945 
    iprot.readStructBegin()
19946 
    while True:
19947 
      (fname, ftype, fid) = iprot.readFieldBegin()
19948 
      if ftype == TType.STOP:
19949 
        break
19950 
      else:
19951 
        iprot.skip(ftype)
19952 
      iprot.readFieldEnd()
19953 
    iprot.readStructEnd()
19954 
 
19955 
  def write(self, oprot):
19956 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19957 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19958 
      return
19959 
    oprot.writeStructBegin('getAllInsurers_args')
19960 
    oprot.writeFieldStop()
19961 
    oprot.writeStructEnd()
19962 
 
19963 
  def validate(self):
19964 
    return
19965 
 
19966 
 
19967 
  def __repr__(self):
19968 
    L = ['%s=%r' % (key, value)
19969 
      for key, value in self.__dict__.iteritems()]
19970 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19971 
 
19972 
  def __eq__(self, other):
19973 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19974 
 
19975 
  def __ne__(self, other):
19976 
    return not (self == other)
19977 
 
19978 
class getAllInsurers_result:
19979 
  """
19980 
  Attributes:
19981 
   - success
19982 
  """
19983 
 
19984 
  thrift_spec = (
19985 
    (0, TType.LIST, 'success', (TType.STRUCT,(Insurer, Insurer.thrift_spec)), None, ), # 0
19986 
  )
19987 
 
19988 
  def __init__(self, success=None,):
19989 
    self.success = success
19990 
 
19991 
  def read(self, iprot):
19992 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19993 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19994 
      return
19995 
    iprot.readStructBegin()
19996 
    while True:
19997 
      (fname, ftype, fid) = iprot.readFieldBegin()
19998 
      if ftype == TType.STOP:
19999 
        break
20000 
      if fid == 0:
20001 
        if ftype == TType.LIST:
20002 
          self.success = []
9155 kshitij.so 20003 
          (_etype384, _size381) = iprot.readListBegin()
20004 
          for _i385 in xrange(_size381):
20005 
            _elem386 = Insurer()
20006 
            _elem386.read(iprot)
20007 
            self.success.append(_elem386)
6838 vikram.rag 20008 
          iprot.readListEnd()
20009 
        else:
20010 
          iprot.skip(ftype)
20011 
      else:
20012 
        iprot.skip(ftype)
20013 
      iprot.readFieldEnd()
20014 
    iprot.readStructEnd()
20015 
 
20016 
  def write(self, oprot):
20017 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20018 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20019 
      return
20020 
    oprot.writeStructBegin('getAllInsurers_result')
20021 
    if self.success is not None:
20022 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20023 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 20024 
      for iter387 in self.success:
20025 
        iter387.write(oprot)
6838 vikram.rag 20026 
      oprot.writeListEnd()
20027 
      oprot.writeFieldEnd()
20028 
    oprot.writeFieldStop()
20029 
    oprot.writeStructEnd()
20030 
 
20031 
  def validate(self):
20032 
    return
20033 
 
20034 
 
20035 
  def __repr__(self):
20036 
    L = ['%s=%r' % (key, value)
20037 
      for key, value in self.__dict__.iteritems()]
20038 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20039 
 
20040 
  def __eq__(self, other):
20041 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20042 
 
20043 
  def __ne__(self, other):
20044 
    return not (self == other)
6962 rajveer 20045 
 
20046 
class updateInsuranceDeclaredAmount_args:
20047 
  """
20048 
  Attributes:
20049 
   - insurerId
20050 
   - amount
20051 
  """
20052 
 
20053 
  thrift_spec = (
20054 
    None, # 0
20055 
    (1, TType.I64, 'insurerId', None, None, ), # 1
20056 
    (2, TType.DOUBLE, 'amount', None, None, ), # 2
20057 
  )
20058 
 
20059 
  def __init__(self, insurerId=None, amount=None,):
20060 
    self.insurerId = insurerId
20061 
    self.amount = amount
20062 
 
20063 
  def read(self, iprot):
20064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20066 
      return
20067 
    iprot.readStructBegin()
20068 
    while True:
20069 
      (fname, ftype, fid) = iprot.readFieldBegin()
20070 
      if ftype == TType.STOP:
20071 
        break
20072 
      if fid == 1:
20073 
        if ftype == TType.I64:
20074 
          self.insurerId = iprot.readI64();
20075 
        else:
20076 
          iprot.skip(ftype)
20077 
      elif fid == 2:
20078 
        if ftype == TType.DOUBLE:
20079 
          self.amount = iprot.readDouble();
20080 
        else:
20081 
          iprot.skip(ftype)
20082 
      else:
20083 
        iprot.skip(ftype)
20084 
      iprot.readFieldEnd()
20085 
    iprot.readStructEnd()
20086 
 
20087 
  def write(self, oprot):
20088 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20089 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20090 
      return
20091 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_args')
20092 
    if self.insurerId is not None:
20093 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
20094 
      oprot.writeI64(self.insurerId)
20095 
      oprot.writeFieldEnd()
20096 
    if self.amount is not None:
20097 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 2)
20098 
      oprot.writeDouble(self.amount)
20099 
      oprot.writeFieldEnd()
20100 
    oprot.writeFieldStop()
20101 
    oprot.writeStructEnd()
20102 
 
20103 
  def validate(self):
20104 
    return
20105 
 
20106 
 
20107 
  def __repr__(self):
20108 
    L = ['%s=%r' % (key, value)
20109 
      for key, value in self.__dict__.iteritems()]
20110 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20111 
 
20112 
  def __eq__(self, other):
20113 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20114 
 
20115 
  def __ne__(self, other):
20116 
    return not (self == other)
20117 
 
20118 
class updateInsuranceDeclaredAmount_result:
20119 
 
20120 
  thrift_spec = (
20121 
  )
20122 
 
20123 
  def read(self, iprot):
20124 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20125 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20126 
      return
20127 
    iprot.readStructBegin()
20128 
    while True:
20129 
      (fname, ftype, fid) = iprot.readFieldBegin()
20130 
      if ftype == TType.STOP:
20131 
        break
20132 
      else:
20133 
        iprot.skip(ftype)
20134 
      iprot.readFieldEnd()
20135 
    iprot.readStructEnd()
20136 
 
20137 
  def write(self, oprot):
20138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20140 
      return
20141 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_result')
20142 
    oprot.writeFieldStop()
20143 
    oprot.writeStructEnd()
20144 
 
20145 
  def validate(self):
20146 
    return
20147 
 
20148 
 
20149 
  def __repr__(self):
20150 
    L = ['%s=%r' % (key, value)
20151 
      for key, value in self.__dict__.iteritems()]
20152 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20153 
 
20154 
  def __eq__(self, other):
20155 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20156 
 
20157 
  def __ne__(self, other):
20158 
    return not (self == other)
7190 amar.kumar 20159 
 
20160 
class getFreebieForItem_args:
20161 
  """
20162 
  Attributes:
20163 
   - itemId
20164 
  """
20165 
 
20166 
  thrift_spec = (
20167 
    None, # 0
20168 
    (1, TType.I64, 'itemId', None, None, ), # 1
20169 
  )
20170 
 
20171 
  def __init__(self, itemId=None,):
20172 
    self.itemId = itemId
20173 
 
20174 
  def read(self, iprot):
20175 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20176 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20177 
      return
20178 
    iprot.readStructBegin()
20179 
    while True:
20180 
      (fname, ftype, fid) = iprot.readFieldBegin()
20181 
      if ftype == TType.STOP:
20182 
        break
20183 
      if fid == 1:
20184 
        if ftype == TType.I64:
20185 
          self.itemId = iprot.readI64();
20186 
        else:
20187 
          iprot.skip(ftype)
20188 
      else:
20189 
        iprot.skip(ftype)
20190 
      iprot.readFieldEnd()
20191 
    iprot.readStructEnd()
20192 
 
20193 
  def write(self, oprot):
20194 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20195 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20196 
      return
20197 
    oprot.writeStructBegin('getFreebieForItem_args')
20198 
    if self.itemId is not None:
20199 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20200 
      oprot.writeI64(self.itemId)
20201 
      oprot.writeFieldEnd()
20202 
    oprot.writeFieldStop()
20203 
    oprot.writeStructEnd()
20204 
 
20205 
  def validate(self):
20206 
    return
20207 
 
20208 
 
20209 
  def __repr__(self):
20210 
    L = ['%s=%r' % (key, value)
20211 
      for key, value in self.__dict__.iteritems()]
20212 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20213 
 
20214 
  def __eq__(self, other):
20215 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20216 
 
20217 
  def __ne__(self, other):
20218 
    return not (self == other)
20219 
 
20220 
class getFreebieForItem_result:
20221 
  """
20222 
  Attributes:
20223 
   - success
20224 
  """
20225 
 
20226 
  thrift_spec = (
20227 
    (0, TType.I64, 'success', None, None, ), # 0
20228 
  )
20229 
 
20230 
  def __init__(self, success=None,):
20231 
    self.success = success
20232 
 
20233 
  def read(self, iprot):
20234 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20235 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20236 
      return
20237 
    iprot.readStructBegin()
20238 
    while True:
20239 
      (fname, ftype, fid) = iprot.readFieldBegin()
20240 
      if ftype == TType.STOP:
20241 
        break
20242 
      if fid == 0:
20243 
        if ftype == TType.I64:
20244 
          self.success = iprot.readI64();
20245 
        else:
20246 
          iprot.skip(ftype)
20247 
      else:
20248 
        iprot.skip(ftype)
20249 
      iprot.readFieldEnd()
20250 
    iprot.readStructEnd()
20251 
 
20252 
  def write(self, oprot):
20253 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20254 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20255 
      return
20256 
    oprot.writeStructBegin('getFreebieForItem_result')
20257 
    if self.success is not None:
20258 
      oprot.writeFieldBegin('success', TType.I64, 0)
20259 
      oprot.writeI64(self.success)
20260 
      oprot.writeFieldEnd()
20261 
    oprot.writeFieldStop()
20262 
    oprot.writeStructEnd()
20263 
 
20264 
  def validate(self):
20265 
    return
20266 
 
20267 
 
20268 
  def __repr__(self):
20269 
    L = ['%s=%r' % (key, value)
20270 
      for key, value in self.__dict__.iteritems()]
20271 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20272 
 
20273 
  def __eq__(self, other):
20274 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20275 
 
20276 
  def __ne__(self, other):
20277 
    return not (self == other)
20278 
 
20279 
class addOrUpdateFreebieForItem_args:
20280 
  """
20281 
  Attributes:
20282 
   - freebieItem
20283 
  """
20284 
 
20285 
  thrift_spec = (
20286 
    None, # 0
20287 
    (1, TType.STRUCT, 'freebieItem', (FreebieItem, FreebieItem.thrift_spec), None, ), # 1
20288 
  )
20289 
 
20290 
  def __init__(self, freebieItem=None,):
20291 
    self.freebieItem = freebieItem
20292 
 
20293 
  def read(self, iprot):
20294 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20295 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20296 
      return
20297 
    iprot.readStructBegin()
20298 
    while True:
20299 
      (fname, ftype, fid) = iprot.readFieldBegin()
20300 
      if ftype == TType.STOP:
20301 
        break
20302 
      if fid == 1:
20303 
        if ftype == TType.STRUCT:
20304 
          self.freebieItem = FreebieItem()
20305 
          self.freebieItem.read(iprot)
20306 
        else:
20307 
          iprot.skip(ftype)
20308 
      else:
20309 
        iprot.skip(ftype)
20310 
      iprot.readFieldEnd()
20311 
    iprot.readStructEnd()
20312 
 
20313 
  def write(self, oprot):
20314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20316 
      return
20317 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_args')
20318 
    if self.freebieItem is not None:
20319 
      oprot.writeFieldBegin('freebieItem', TType.STRUCT, 1)
20320 
      self.freebieItem.write(oprot)
20321 
      oprot.writeFieldEnd()
20322 
    oprot.writeFieldStop()
20323 
    oprot.writeStructEnd()
20324 
 
20325 
  def validate(self):
20326 
    return
20327 
 
20328 
 
20329 
  def __repr__(self):
20330 
    L = ['%s=%r' % (key, value)
20331 
      for key, value in self.__dict__.iteritems()]
20332 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20333 
 
20334 
  def __eq__(self, other):
20335 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20336 
 
20337 
  def __ne__(self, other):
20338 
    return not (self == other)
20339 
 
20340 
class addOrUpdateFreebieForItem_result:
20341 
 
20342 
  thrift_spec = (
20343 
  )
20344 
 
20345 
  def read(self, iprot):
20346 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20347 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20348 
      return
20349 
    iprot.readStructBegin()
20350 
    while True:
20351 
      (fname, ftype, fid) = iprot.readFieldBegin()
20352 
      if ftype == TType.STOP:
20353 
        break
20354 
      else:
20355 
        iprot.skip(ftype)
20356 
      iprot.readFieldEnd()
20357 
    iprot.readStructEnd()
20358 
 
20359 
  def write(self, oprot):
20360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20362 
      return
20363 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_result')
20364 
    oprot.writeFieldStop()
20365 
    oprot.writeStructEnd()
20366 
 
20367 
  def validate(self):
20368 
    return
20369 
 
20370 
 
20371 
  def __repr__(self):
20372 
    L = ['%s=%r' % (key, value)
20373 
      for key, value in self.__dict__.iteritems()]
20374 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20375 
 
20376 
  def __eq__(self, other):
20377 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20378 
 
20379 
  def __ne__(self, other):
20380 
    return not (self == other)
7256 rajveer 20381 
 
7272 amit.gupta 20382 
class addOrUpdateBrandInfo_args:
20383 
  """
20384 
  Attributes:
20385 
   - brandInfo
20386 
  """
20387 
 
20388 
  thrift_spec = (
20389 
    None, # 0
20390 
    (1, TType.STRUCT, 'brandInfo', (BrandInfo, BrandInfo.thrift_spec), None, ), # 1
20391 
  )
20392 
 
20393 
  def __init__(self, brandInfo=None,):
20394 
    self.brandInfo = brandInfo
20395 
 
20396 
  def read(self, iprot):
20397 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20398 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20399 
      return
20400 
    iprot.readStructBegin()
20401 
    while True:
20402 
      (fname, ftype, fid) = iprot.readFieldBegin()
20403 
      if ftype == TType.STOP:
20404 
        break
20405 
      if fid == 1:
20406 
        if ftype == TType.STRUCT:
20407 
          self.brandInfo = BrandInfo()
20408 
          self.brandInfo.read(iprot)
20409 
        else:
20410 
          iprot.skip(ftype)
20411 
      else:
20412 
        iprot.skip(ftype)
20413 
      iprot.readFieldEnd()
20414 
    iprot.readStructEnd()
20415 
 
20416 
  def write(self, oprot):
20417 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20418 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20419 
      return
20420 
    oprot.writeStructBegin('addOrUpdateBrandInfo_args')
20421 
    if self.brandInfo is not None:
20422 
      oprot.writeFieldBegin('brandInfo', TType.STRUCT, 1)
20423 
      self.brandInfo.write(oprot)
20424 
      oprot.writeFieldEnd()
20425 
    oprot.writeFieldStop()
20426 
    oprot.writeStructEnd()
20427 
 
20428 
  def validate(self):
20429 
    return
20430 
 
20431 
 
20432 
  def __repr__(self):
20433 
    L = ['%s=%r' % (key, value)
20434 
      for key, value in self.__dict__.iteritems()]
20435 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20436 
 
20437 
  def __eq__(self, other):
20438 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20439 
 
20440 
  def __ne__(self, other):
20441 
    return not (self == other)
20442 
 
20443 
class addOrUpdateBrandInfo_result:
20444 
 
20445 
  thrift_spec = (
20446 
  )
20447 
 
20448 
  def read(self, iprot):
20449 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20450 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20451 
      return
20452 
    iprot.readStructBegin()
20453 
    while True:
20454 
      (fname, ftype, fid) = iprot.readFieldBegin()
20455 
      if ftype == TType.STOP:
20456 
        break
20457 
      else:
20458 
        iprot.skip(ftype)
20459 
      iprot.readFieldEnd()
20460 
    iprot.readStructEnd()
20461 
 
20462 
  def write(self, oprot):
20463 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20464 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20465 
      return
20466 
    oprot.writeStructBegin('addOrUpdateBrandInfo_result')
20467 
    oprot.writeFieldStop()
20468 
    oprot.writeStructEnd()
20469 
 
20470 
  def validate(self):
20471 
    return
20472 
 
20473 
 
20474 
  def __repr__(self):
20475 
    L = ['%s=%r' % (key, value)
20476 
      for key, value in self.__dict__.iteritems()]
20477 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20478 
 
20479 
  def __eq__(self, other):
20480 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20481 
 
20482 
  def __ne__(self, other):
20483 
    return not (self == other)
20484 
 
20485 
class getBrandInfo_args:
20486 
 
20487 
  thrift_spec = (
20488 
  )
20489 
 
20490 
  def read(self, iprot):
20491 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20492 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20493 
      return
20494 
    iprot.readStructBegin()
20495 
    while True:
20496 
      (fname, ftype, fid) = iprot.readFieldBegin()
20497 
      if ftype == TType.STOP:
20498 
        break
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('getBrandInfo_args')
20509 
    oprot.writeFieldStop()
20510 
    oprot.writeStructEnd()
20511 
 
20512 
  def validate(self):
20513 
    return
20514 
 
20515 
 
20516 
  def __repr__(self):
20517 
    L = ['%s=%r' % (key, value)
20518 
      for key, value in self.__dict__.iteritems()]
20519 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20520 
 
20521 
  def __eq__(self, other):
20522 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20523 
 
20524 
  def __ne__(self, other):
20525 
    return not (self == other)
20526 
 
20527 
class getBrandInfo_result:
20528 
  """
20529 
  Attributes:
20530 
   - success
20531 
  """
20532 
 
20533 
  thrift_spec = (
20534 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(BrandInfo, BrandInfo.thrift_spec)), None, ), # 0
20535 
  )
20536 
 
20537 
  def __init__(self, success=None,):
20538 
    self.success = success
20539 
 
20540 
  def read(self, iprot):
20541 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20542 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20543 
      return
20544 
    iprot.readStructBegin()
20545 
    while True:
20546 
      (fname, ftype, fid) = iprot.readFieldBegin()
20547 
      if ftype == TType.STOP:
20548 
        break
20549 
      if fid == 0:
20550 
        if ftype == TType.MAP:
20551 
          self.success = {}
9155 kshitij.so 20552 
          (_ktype389, _vtype390, _size388 ) = iprot.readMapBegin()
20553 
          for _i392 in xrange(_size388):
20554 
            _key393 = iprot.readString();
20555 
            _val394 = BrandInfo()
20556 
            _val394.read(iprot)
20557 
            self.success[_key393] = _val394
7272 amit.gupta 20558 
          iprot.readMapEnd()
20559 
        else:
20560 
          iprot.skip(ftype)
20561 
      else:
20562 
        iprot.skip(ftype)
20563 
      iprot.readFieldEnd()
20564 
    iprot.readStructEnd()
20565 
 
20566 
  def write(self, oprot):
20567 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20568 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20569 
      return
20570 
    oprot.writeStructBegin('getBrandInfo_result')
20571 
    if self.success is not None:
20572 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20573 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
9155 kshitij.so 20574 
      for kiter395,viter396 in self.success.items():
20575 
        oprot.writeString(kiter395)
20576 
        viter396.write(oprot)
7272 amit.gupta 20577 
      oprot.writeMapEnd()
20578 
      oprot.writeFieldEnd()
20579 
    oprot.writeFieldStop()
20580 
    oprot.writeStructEnd()
20581 
 
20582 
  def validate(self):
20583 
    return
20584 
 
20585 
 
20586 
  def __repr__(self):
20587 
    L = ['%s=%r' % (key, value)
20588 
      for key, value in self.__dict__.iteritems()]
20589 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20590 
 
20591 
  def __eq__(self, other):
20592 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20593 
 
20594 
  def __ne__(self, other):
20595 
    return not (self == other)
20596 
 
7256 rajveer 20597 
class getStorePricing_args:
20598 
  """
20599 
  Attributes:
20600 
   - itemId
20601 
  """
20602 
 
20603 
  thrift_spec = (
20604 
    None, # 0
20605 
    (1, TType.I64, 'itemId', None, None, ), # 1
20606 
  )
20607 
 
20608 
  def __init__(self, itemId=None,):
20609 
    self.itemId = itemId
20610 
 
20611 
  def read(self, iprot):
20612 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20613 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20614 
      return
20615 
    iprot.readStructBegin()
20616 
    while True:
20617 
      (fname, ftype, fid) = iprot.readFieldBegin()
20618 
      if ftype == TType.STOP:
20619 
        break
20620 
      if fid == 1:
20621 
        if ftype == TType.I64:
20622 
          self.itemId = iprot.readI64();
20623 
        else:
20624 
          iprot.skip(ftype)
20625 
      else:
20626 
        iprot.skip(ftype)
20627 
      iprot.readFieldEnd()
20628 
    iprot.readStructEnd()
20629 
 
20630 
  def write(self, oprot):
20631 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20632 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20633 
      return
20634 
    oprot.writeStructBegin('getStorePricing_args')
20635 
    if self.itemId is not None:
20636 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20637 
      oprot.writeI64(self.itemId)
20638 
      oprot.writeFieldEnd()
20639 
    oprot.writeFieldStop()
20640 
    oprot.writeStructEnd()
20641 
 
20642 
  def validate(self):
20643 
    return
20644 
 
20645 
 
20646 
  def __repr__(self):
20647 
    L = ['%s=%r' % (key, value)
20648 
      for key, value in self.__dict__.iteritems()]
20649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20650 
 
20651 
  def __eq__(self, other):
20652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20653 
 
20654 
  def __ne__(self, other):
20655 
    return not (self == other)
20656 
 
20657 
class getStorePricing_result:
20658 
  """
20659 
  Attributes:
20660 
   - success
20661 
  """
20662 
 
20663 
  thrift_spec = (
20664 
    (0, TType.STRUCT, 'success', (StorePricing, StorePricing.thrift_spec), None, ), # 0
20665 
  )
20666 
 
20667 
  def __init__(self, success=None,):
20668 
    self.success = success
20669 
 
20670 
  def read(self, iprot):
20671 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20672 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20673 
      return
20674 
    iprot.readStructBegin()
20675 
    while True:
20676 
      (fname, ftype, fid) = iprot.readFieldBegin()
20677 
      if ftype == TType.STOP:
20678 
        break
20679 
      if fid == 0:
20680 
        if ftype == TType.STRUCT:
20681 
          self.success = StorePricing()
20682 
          self.success.read(iprot)
20683 
        else:
20684 
          iprot.skip(ftype)
20685 
      else:
20686 
        iprot.skip(ftype)
20687 
      iprot.readFieldEnd()
20688 
    iprot.readStructEnd()
20689 
 
20690 
  def write(self, oprot):
20691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20693 
      return
20694 
    oprot.writeStructBegin('getStorePricing_result')
20695 
    if self.success is not None:
20696 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20697 
      self.success.write(oprot)
20698 
      oprot.writeFieldEnd()
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)
7265 rajveer 20716 
 
7306 rajveer 20717 
class getStorePricings_args:
20718 
  """
20719 
  Attributes:
20720 
   - itemIds
20721 
  """
20722 
 
20723 
  thrift_spec = (
20724 
    None, # 0
20725 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
20726 
  )
20727 
 
20728 
  def __init__(self, itemIds=None,):
20729 
    self.itemIds = itemIds
20730 
 
20731 
  def read(self, iprot):
20732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20734 
      return
20735 
    iprot.readStructBegin()
20736 
    while True:
20737 
      (fname, ftype, fid) = iprot.readFieldBegin()
20738 
      if ftype == TType.STOP:
20739 
        break
20740 
      if fid == 1:
20741 
        if ftype == TType.LIST:
20742 
          self.itemIds = []
9155 kshitij.so 20743 
          (_etype400, _size397) = iprot.readListBegin()
20744 
          for _i401 in xrange(_size397):
20745 
            _elem402 = iprot.readI64();
20746 
            self.itemIds.append(_elem402)
7306 rajveer 20747 
          iprot.readListEnd()
20748 
        else:
20749 
          iprot.skip(ftype)
20750 
      else:
20751 
        iprot.skip(ftype)
20752 
      iprot.readFieldEnd()
20753 
    iprot.readStructEnd()
20754 
 
20755 
  def write(self, oprot):
20756 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20757 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20758 
      return
20759 
    oprot.writeStructBegin('getStorePricings_args')
20760 
    if self.itemIds is not None:
20761 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
20762 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
9155 kshitij.so 20763 
      for iter403 in self.itemIds:
20764 
        oprot.writeI64(iter403)
7306 rajveer 20765 
      oprot.writeListEnd()
20766 
      oprot.writeFieldEnd()
20767 
    oprot.writeFieldStop()
20768 
    oprot.writeStructEnd()
20769 
 
20770 
  def validate(self):
20771 
    return
20772 
 
20773 
 
20774 
  def __repr__(self):
20775 
    L = ['%s=%r' % (key, value)
20776 
      for key, value in self.__dict__.iteritems()]
20777 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20778 
 
20779 
  def __eq__(self, other):
20780 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20781 
 
20782 
  def __ne__(self, other):
20783 
    return not (self == other)
20784 
 
20785 
class getStorePricings_result:
20786 
  """
20787 
  Attributes:
20788 
   - success
20789 
  """
20790 
 
20791 
  thrift_spec = (
20792 
    (0, TType.LIST, 'success', (TType.STRUCT,(StorePricing, StorePricing.thrift_spec)), None, ), # 0
20793 
  )
20794 
 
20795 
  def __init__(self, success=None,):
20796 
    self.success = success
20797 
 
20798 
  def read(self, iprot):
20799 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20800 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20801 
      return
20802 
    iprot.readStructBegin()
20803 
    while True:
20804 
      (fname, ftype, fid) = iprot.readFieldBegin()
20805 
      if ftype == TType.STOP:
20806 
        break
20807 
      if fid == 0:
20808 
        if ftype == TType.LIST:
20809 
          self.success = []
9155 kshitij.so 20810 
          (_etype407, _size404) = iprot.readListBegin()
20811 
          for _i408 in xrange(_size404):
20812 
            _elem409 = StorePricing()
20813 
            _elem409.read(iprot)
20814 
            self.success.append(_elem409)
7306 rajveer 20815 
          iprot.readListEnd()
20816 
        else:
20817 
          iprot.skip(ftype)
20818 
      else:
20819 
        iprot.skip(ftype)
20820 
      iprot.readFieldEnd()
20821 
    iprot.readStructEnd()
20822 
 
20823 
  def write(self, oprot):
20824 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20825 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20826 
      return
20827 
    oprot.writeStructBegin('getStorePricings_result')
20828 
    if self.success is not None:
20829 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20830 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 20831 
      for iter410 in self.success:
20832 
        iter410.write(oprot)
7306 rajveer 20833 
      oprot.writeListEnd()
20834 
      oprot.writeFieldEnd()
20835 
    oprot.writeFieldStop()
20836 
    oprot.writeStructEnd()
20837 
 
20838 
  def validate(self):
20839 
    return
20840 
 
20841 
 
20842 
  def __repr__(self):
20843 
    L = ['%s=%r' % (key, value)
20844 
      for key, value in self.__dict__.iteritems()]
20845 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20846 
 
20847 
  def __eq__(self, other):
20848 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20849 
 
20850 
  def __ne__(self, other):
20851 
    return not (self == other)
20852 
 
7265 rajveer 20853 
class updateStorePricing_args:
20854 
  """
20855 
  Attributes:
20856 
   - sp
7382 rajveer 20857 
   - allColors
7265 rajveer 20858 
  """
20859 
 
20860 
  thrift_spec = (
20861 
    None, # 0
20862 
    (1, TType.STRUCT, 'sp', (StorePricing, StorePricing.thrift_spec), None, ), # 1
7382 rajveer 20863 
    (2, TType.BOOL, 'allColors', None, None, ), # 2
7265 rajveer 20864 
  )
20865 
 
7382 rajveer 20866 
  def __init__(self, sp=None, allColors=None,):
7265 rajveer 20867 
    self.sp = sp
7382 rajveer 20868 
    self.allColors = allColors
7265 rajveer 20869 
 
20870 
  def read(self, iprot):
20871 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20872 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20873 
      return
20874 
    iprot.readStructBegin()
20875 
    while True:
20876 
      (fname, ftype, fid) = iprot.readFieldBegin()
20877 
      if ftype == TType.STOP:
20878 
        break
20879 
      if fid == 1:
20880 
        if ftype == TType.STRUCT:
20881 
          self.sp = StorePricing()
20882 
          self.sp.read(iprot)
20883 
        else:
20884 
          iprot.skip(ftype)
7382 rajveer 20885 
      elif fid == 2:
20886 
        if ftype == TType.BOOL:
20887 
          self.allColors = iprot.readBool();
20888 
        else:
20889 
          iprot.skip(ftype)
7265 rajveer 20890 
      else:
20891 
        iprot.skip(ftype)
20892 
      iprot.readFieldEnd()
20893 
    iprot.readStructEnd()
20894 
 
20895 
  def write(self, oprot):
20896 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20897 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20898 
      return
20899 
    oprot.writeStructBegin('updateStorePricing_args')
20900 
    if self.sp is not None:
20901 
      oprot.writeFieldBegin('sp', TType.STRUCT, 1)
20902 
      self.sp.write(oprot)
20903 
      oprot.writeFieldEnd()
7382 rajveer 20904 
    if self.allColors is not None:
20905 
      oprot.writeFieldBegin('allColors', TType.BOOL, 2)
20906 
      oprot.writeBool(self.allColors)
20907 
      oprot.writeFieldEnd()
7265 rajveer 20908 
    oprot.writeFieldStop()
20909 
    oprot.writeStructEnd()
20910 
 
20911 
  def validate(self):
20912 
    return
20913 
 
20914 
 
20915 
  def __repr__(self):
20916 
    L = ['%s=%r' % (key, value)
20917 
      for key, value in self.__dict__.iteritems()]
20918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20919 
 
20920 
  def __eq__(self, other):
20921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20922 
 
20923 
  def __ne__(self, other):
20924 
    return not (self == other)
20925 
 
20926 
class updateStorePricing_result:
20927 
 
20928 
  thrift_spec = (
20929 
  )
20930 
 
20931 
  def read(self, iprot):
20932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20934 
      return
20935 
    iprot.readStructBegin()
20936 
    while True:
20937 
      (fname, ftype, fid) = iprot.readFieldBegin()
20938 
      if ftype == TType.STOP:
20939 
        break
20940 
      else:
20941 
        iprot.skip(ftype)
20942 
      iprot.readFieldEnd()
20943 
    iprot.readStructEnd()
20944 
 
20945 
  def write(self, oprot):
20946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20948 
      return
20949 
    oprot.writeStructBegin('updateStorePricing_result')
20950 
    oprot.writeFieldStop()
20951 
    oprot.writeStructEnd()
20952 
 
20953 
  def validate(self):
20954 
    return
20955 
 
20956 
 
20957 
  def __repr__(self):
20958 
    L = ['%s=%r' % (key, value)
20959 
      for key, value in self.__dict__.iteritems()]
20960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20961 
 
20962 
  def __eq__(self, other):
20963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20964 
 
20965 
  def __ne__(self, other):
20966 
    return not (self == other)
7281 kshitij.so 20967 
 
20968 
class getAllAmazonListedItems_args:
20969 
 
20970 
  thrift_spec = (
20971 
  )
20972 
 
20973 
  def read(self, iprot):
20974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20976 
      return
20977 
    iprot.readStructBegin()
20978 
    while True:
20979 
      (fname, ftype, fid) = iprot.readFieldBegin()
20980 
      if ftype == TType.STOP:
20981 
        break
20982 
      else:
20983 
        iprot.skip(ftype)
20984 
      iprot.readFieldEnd()
20985 
    iprot.readStructEnd()
20986 
 
20987 
  def write(self, oprot):
20988 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20989 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20990 
      return
20991 
    oprot.writeStructBegin('getAllAmazonListedItems_args')
20992 
    oprot.writeFieldStop()
20993 
    oprot.writeStructEnd()
20994 
 
20995 
  def validate(self):
20996 
    return
20997 
 
20998 
 
20999 
  def __repr__(self):
21000 
    L = ['%s=%r' % (key, value)
21001 
      for key, value in self.__dict__.iteritems()]
21002 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21003 
 
21004 
  def __eq__(self, other):
21005 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21006 
 
21007 
  def __ne__(self, other):
21008 
    return not (self == other)
21009 
 
21010 
class getAllAmazonListedItems_result:
21011 
  """
21012 
  Attributes:
21013 
   - success
21014 
  """
21015 
 
21016 
  thrift_spec = (
21017 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
21018 
  )
21019 
 
21020 
  def __init__(self, success=None,):
21021 
    self.success = success
21022 
 
21023 
  def read(self, iprot):
21024 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21025 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21026 
      return
21027 
    iprot.readStructBegin()
21028 
    while True:
21029 
      (fname, ftype, fid) = iprot.readFieldBegin()
21030 
      if ftype == TType.STOP:
21031 
        break
21032 
      if fid == 0:
21033 
        if ftype == TType.LIST:
21034 
          self.success = []
9155 kshitij.so 21035 
          (_etype414, _size411) = iprot.readListBegin()
21036 
          for _i415 in xrange(_size411):
21037 
            _elem416 = Amazonlisted()
21038 
            _elem416.read(iprot)
21039 
            self.success.append(_elem416)
7281 kshitij.so 21040 
          iprot.readListEnd()
21041 
        else:
21042 
          iprot.skip(ftype)
21043 
      else:
21044 
        iprot.skip(ftype)
21045 
      iprot.readFieldEnd()
21046 
    iprot.readStructEnd()
21047 
 
21048 
  def write(self, oprot):
21049 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21050 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21051 
      return
21052 
    oprot.writeStructBegin('getAllAmazonListedItems_result')
21053 
    if self.success is not None:
21054 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21055 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21056 
      for iter417 in self.success:
21057 
        iter417.write(oprot)
7281 kshitij.so 21058 
      oprot.writeListEnd()
21059 
      oprot.writeFieldEnd()
21060 
    oprot.writeFieldStop()
21061 
    oprot.writeStructEnd()
21062 
 
21063 
  def validate(self):
21064 
    return
21065 
 
21066 
 
21067 
  def __repr__(self):
21068 
    L = ['%s=%r' % (key, value)
21069 
      for key, value in self.__dict__.iteritems()]
21070 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21071 
 
21072 
  def __eq__(self, other):
21073 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21074 
 
21075 
  def __ne__(self, other):
21076 
    return not (self == other)
21077 
 
8619 kshitij.so 21078 
class searchAmazonItems_args:
21079 
  """
21080 
  Attributes:
21081 
   - searchTerm
21082 
   - offset
21083 
   - limit
21084 
  """
21085 
 
21086 
  thrift_spec = (
21087 
    None, # 0
21088 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
21089 
    (2, TType.I64, 'offset', None, None, ), # 2
21090 
    (3, TType.I64, 'limit', None, None, ), # 3
21091 
  )
21092 
 
21093 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
21094 
    self.searchTerm = searchTerm
21095 
    self.offset = offset
21096 
    self.limit = limit
21097 
 
21098 
  def read(self, iprot):
21099 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21100 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21101 
      return
21102 
    iprot.readStructBegin()
21103 
    while True:
21104 
      (fname, ftype, fid) = iprot.readFieldBegin()
21105 
      if ftype == TType.STOP:
21106 
        break
21107 
      if fid == 1:
21108 
        if ftype == TType.LIST:
21109 
          self.searchTerm = []
9155 kshitij.so 21110 
          (_etype421, _size418) = iprot.readListBegin()
21111 
          for _i422 in xrange(_size418):
21112 
            _elem423 = iprot.readString();
21113 
            self.searchTerm.append(_elem423)
8619 kshitij.so 21114 
          iprot.readListEnd()
21115 
        else:
21116 
          iprot.skip(ftype)
21117 
      elif fid == 2:
21118 
        if ftype == TType.I64:
21119 
          self.offset = iprot.readI64();
21120 
        else:
21121 
          iprot.skip(ftype)
21122 
      elif fid == 3:
21123 
        if ftype == TType.I64:
21124 
          self.limit = iprot.readI64();
21125 
        else:
21126 
          iprot.skip(ftype)
21127 
      else:
21128 
        iprot.skip(ftype)
21129 
      iprot.readFieldEnd()
21130 
    iprot.readStructEnd()
21131 
 
21132 
  def write(self, oprot):
21133 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21134 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21135 
      return
21136 
    oprot.writeStructBegin('searchAmazonItems_args')
21137 
    if self.searchTerm is not None:
21138 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
21139 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
9155 kshitij.so 21140 
      for iter424 in self.searchTerm:
21141 
        oprot.writeString(iter424)
8619 kshitij.so 21142 
      oprot.writeListEnd()
21143 
      oprot.writeFieldEnd()
21144 
    if self.offset is not None:
21145 
      oprot.writeFieldBegin('offset', TType.I64, 2)
21146 
      oprot.writeI64(self.offset)
21147 
      oprot.writeFieldEnd()
21148 
    if self.limit is not None:
21149 
      oprot.writeFieldBegin('limit', TType.I64, 3)
21150 
      oprot.writeI64(self.limit)
21151 
      oprot.writeFieldEnd()
21152 
    oprot.writeFieldStop()
21153 
    oprot.writeStructEnd()
21154 
 
21155 
  def validate(self):
21156 
    return
21157 
 
21158 
 
21159 
  def __repr__(self):
21160 
    L = ['%s=%r' % (key, value)
21161 
      for key, value in self.__dict__.iteritems()]
21162 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21163 
 
21164 
  def __eq__(self, other):
21165 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21166 
 
21167 
  def __ne__(self, other):
21168 
    return not (self == other)
21169 
 
21170 
class searchAmazonItems_result:
21171 
  """
21172 
  Attributes:
21173 
   - success
21174 
  """
21175 
 
21176 
  thrift_spec = (
21177 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
21178 
  )
21179 
 
21180 
  def __init__(self, success=None,):
21181 
    self.success = success
21182 
 
21183 
  def read(self, iprot):
21184 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21185 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21186 
      return
21187 
    iprot.readStructBegin()
21188 
    while True:
21189 
      (fname, ftype, fid) = iprot.readFieldBegin()
21190 
      if ftype == TType.STOP:
21191 
        break
21192 
      if fid == 0:
21193 
        if ftype == TType.LIST:
21194 
          self.success = []
9155 kshitij.so 21195 
          (_etype428, _size425) = iprot.readListBegin()
21196 
          for _i429 in xrange(_size425):
21197 
            _elem430 = Amazonlisted()
21198 
            _elem430.read(iprot)
21199 
            self.success.append(_elem430)
8619 kshitij.so 21200 
          iprot.readListEnd()
21201 
        else:
21202 
          iprot.skip(ftype)
21203 
      else:
21204 
        iprot.skip(ftype)
21205 
      iprot.readFieldEnd()
21206 
    iprot.readStructEnd()
21207 
 
21208 
  def write(self, oprot):
21209 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21210 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21211 
      return
21212 
    oprot.writeStructBegin('searchAmazonItems_result')
21213 
    if self.success is not None:
21214 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21215 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21216 
      for iter431 in self.success:
21217 
        iter431.write(oprot)
8619 kshitij.so 21218 
      oprot.writeListEnd()
21219 
      oprot.writeFieldEnd()
21220 
    oprot.writeFieldStop()
21221 
    oprot.writeStructEnd()
21222 
 
21223 
  def validate(self):
21224 
    return
21225 
 
21226 
 
21227 
  def __repr__(self):
21228 
    L = ['%s=%r' % (key, value)
21229 
      for key, value in self.__dict__.iteritems()]
21230 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21231 
 
21232 
  def __eq__(self, other):
21233 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21234 
 
21235 
  def __ne__(self, other):
21236 
    return not (self == other)
21237 
 
21238 
class getAmazonSearchResultCount_args:
21239 
  """
21240 
  Attributes:
21241 
   - searchTerm
21242 
  """
21243 
 
21244 
  thrift_spec = (
21245 
    None, # 0
21246 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
21247 
  )
21248 
 
21249 
  def __init__(self, searchTerm=None,):
21250 
    self.searchTerm = searchTerm
21251 
 
21252 
  def read(self, iprot):
21253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21255 
      return
21256 
    iprot.readStructBegin()
21257 
    while True:
21258 
      (fname, ftype, fid) = iprot.readFieldBegin()
21259 
      if ftype == TType.STOP:
21260 
        break
21261 
      if fid == 1:
21262 
        if ftype == TType.LIST:
21263 
          self.searchTerm = []
9155 kshitij.so 21264 
          (_etype435, _size432) = iprot.readListBegin()
21265 
          for _i436 in xrange(_size432):
21266 
            _elem437 = iprot.readString();
21267 
            self.searchTerm.append(_elem437)
8619 kshitij.so 21268 
          iprot.readListEnd()
21269 
        else:
21270 
          iprot.skip(ftype)
21271 
      else:
21272 
        iprot.skip(ftype)
21273 
      iprot.readFieldEnd()
21274 
    iprot.readStructEnd()
21275 
 
21276 
  def write(self, oprot):
21277 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21278 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21279 
      return
21280 
    oprot.writeStructBegin('getAmazonSearchResultCount_args')
21281 
    if self.searchTerm is not None:
21282 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
21283 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
9155 kshitij.so 21284 
      for iter438 in self.searchTerm:
21285 
        oprot.writeString(iter438)
8619 kshitij.so 21286 
      oprot.writeListEnd()
21287 
      oprot.writeFieldEnd()
21288 
    oprot.writeFieldStop()
21289 
    oprot.writeStructEnd()
21290 
 
21291 
  def validate(self):
21292 
    return
21293 
 
21294 
 
21295 
  def __repr__(self):
21296 
    L = ['%s=%r' % (key, value)
21297 
      for key, value in self.__dict__.iteritems()]
21298 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21299 
 
21300 
  def __eq__(self, other):
21301 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21302 
 
21303 
  def __ne__(self, other):
21304 
    return not (self == other)
21305 
 
21306 
class getAmazonSearchResultCount_result:
21307 
  """
21308 
  Attributes:
21309 
   - success
21310 
  """
21311 
 
21312 
  thrift_spec = (
21313 
    (0, TType.I64, 'success', None, None, ), # 0
21314 
  )
21315 
 
21316 
  def __init__(self, success=None,):
21317 
    self.success = success
21318 
 
21319 
  def read(self, iprot):
21320 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21321 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21322 
      return
21323 
    iprot.readStructBegin()
21324 
    while True:
21325 
      (fname, ftype, fid) = iprot.readFieldBegin()
21326 
      if ftype == TType.STOP:
21327 
        break
21328 
      if fid == 0:
21329 
        if ftype == TType.I64:
21330 
          self.success = iprot.readI64();
21331 
        else:
21332 
          iprot.skip(ftype)
21333 
      else:
21334 
        iprot.skip(ftype)
21335 
      iprot.readFieldEnd()
21336 
    iprot.readStructEnd()
21337 
 
21338 
  def write(self, oprot):
21339 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21340 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21341 
      return
21342 
    oprot.writeStructBegin('getAmazonSearchResultCount_result')
21343 
    if self.success is not None:
21344 
      oprot.writeFieldBegin('success', TType.I64, 0)
21345 
      oprot.writeI64(self.success)
21346 
      oprot.writeFieldEnd()
21347 
    oprot.writeFieldStop()
21348 
    oprot.writeStructEnd()
21349 
 
21350 
  def validate(self):
21351 
    return
21352 
 
21353 
 
21354 
  def __repr__(self):
21355 
    L = ['%s=%r' % (key, value)
21356 
      for key, value in self.__dict__.iteritems()]
21357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21358 
 
21359 
  def __eq__(self, other):
21360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21361 
 
21362 
  def __ne__(self, other):
21363 
    return not (self == other)
21364 
 
21365 
class getCountForAmazonlistedItems_args:
21366 
 
21367 
  thrift_spec = (
21368 
  )
21369 
 
21370 
  def read(self, iprot):
21371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21373 
      return
21374 
    iprot.readStructBegin()
21375 
    while True:
21376 
      (fname, ftype, fid) = iprot.readFieldBegin()
21377 
      if ftype == TType.STOP:
21378 
        break
21379 
      else:
21380 
        iprot.skip(ftype)
21381 
      iprot.readFieldEnd()
21382 
    iprot.readStructEnd()
21383 
 
21384 
  def write(self, oprot):
21385 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21386 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21387 
      return
21388 
    oprot.writeStructBegin('getCountForAmazonlistedItems_args')
21389 
    oprot.writeFieldStop()
21390 
    oprot.writeStructEnd()
21391 
 
21392 
  def validate(self):
21393 
    return
21394 
 
21395 
 
21396 
  def __repr__(self):
21397 
    L = ['%s=%r' % (key, value)
21398 
      for key, value in self.__dict__.iteritems()]
21399 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21400 
 
21401 
  def __eq__(self, other):
21402 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21403 
 
21404 
  def __ne__(self, other):
21405 
    return not (self == other)
21406 
 
21407 
class getCountForAmazonlistedItems_result:
21408 
  """
21409 
  Attributes:
21410 
   - success
21411 
  """
21412 
 
21413 
  thrift_spec = (
21414 
    (0, TType.I64, 'success', None, None, ), # 0
21415 
  )
21416 
 
21417 
  def __init__(self, success=None,):
21418 
    self.success = success
21419 
 
21420 
  def read(self, iprot):
21421 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21422 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21423 
      return
21424 
    iprot.readStructBegin()
21425 
    while True:
21426 
      (fname, ftype, fid) = iprot.readFieldBegin()
21427 
      if ftype == TType.STOP:
21428 
        break
21429 
      if fid == 0:
21430 
        if ftype == TType.I64:
21431 
          self.success = iprot.readI64();
21432 
        else:
21433 
          iprot.skip(ftype)
21434 
      else:
21435 
        iprot.skip(ftype)
21436 
      iprot.readFieldEnd()
21437 
    iprot.readStructEnd()
21438 
 
21439 
  def write(self, oprot):
21440 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21441 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21442 
      return
21443 
    oprot.writeStructBegin('getCountForAmazonlistedItems_result')
21444 
    if self.success is not None:
21445 
      oprot.writeFieldBegin('success', TType.I64, 0)
21446 
      oprot.writeI64(self.success)
21447 
      oprot.writeFieldEnd()
21448 
    oprot.writeFieldStop()
21449 
    oprot.writeStructEnd()
21450 
 
21451 
  def validate(self):
21452 
    return
21453 
 
21454 
 
21455 
  def __repr__(self):
21456 
    L = ['%s=%r' % (key, value)
21457 
      for key, value in self.__dict__.iteritems()]
21458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21459 
 
21460 
  def __eq__(self, other):
21461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21462 
 
21463 
  def __ne__(self, other):
21464 
    return not (self == other)
21465 
 
7281 kshitij.so 21466 
class getAmazonItemDetails_args:
21467 
  """
21468 
  Attributes:
21469 
   - itemId
21470 
  """
21471 
 
21472 
  thrift_spec = (
21473 
    None, # 0
21474 
    (1, TType.I64, 'itemId', None, None, ), # 1
21475 
  )
21476 
 
21477 
  def __init__(self, itemId=None,):
21478 
    self.itemId = itemId
21479 
 
21480 
  def read(self, iprot):
21481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21483 
      return
21484 
    iprot.readStructBegin()
21485 
    while True:
21486 
      (fname, ftype, fid) = iprot.readFieldBegin()
21487 
      if ftype == TType.STOP:
21488 
        break
21489 
      if fid == 1:
21490 
        if ftype == TType.I64:
21491 
          self.itemId = iprot.readI64();
21492 
        else:
21493 
          iprot.skip(ftype)
21494 
      else:
21495 
        iprot.skip(ftype)
21496 
      iprot.readFieldEnd()
21497 
    iprot.readStructEnd()
21498 
 
21499 
  def write(self, oprot):
21500 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21501 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21502 
      return
21503 
    oprot.writeStructBegin('getAmazonItemDetails_args')
21504 
    if self.itemId is not None:
21505 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
21506 
      oprot.writeI64(self.itemId)
21507 
      oprot.writeFieldEnd()
21508 
    oprot.writeFieldStop()
21509 
    oprot.writeStructEnd()
21510 
 
21511 
  def validate(self):
21512 
    return
21513 
 
21514 
 
21515 
  def __repr__(self):
21516 
    L = ['%s=%r' % (key, value)
21517 
      for key, value in self.__dict__.iteritems()]
21518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21519 
 
21520 
  def __eq__(self, other):
21521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21522 
 
21523 
  def __ne__(self, other):
21524 
    return not (self == other)
21525 
 
21526 
class getAmazonItemDetails_result:
21527 
  """
21528 
  Attributes:
21529 
   - success
21530 
  """
21531 
 
21532 
  thrift_spec = (
21533 
    (0, TType.STRUCT, 'success', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 0
21534 
  )
21535 
 
21536 
  def __init__(self, success=None,):
21537 
    self.success = success
21538 
 
21539 
  def read(self, iprot):
21540 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21541 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21542 
      return
21543 
    iprot.readStructBegin()
21544 
    while True:
21545 
      (fname, ftype, fid) = iprot.readFieldBegin()
21546 
      if ftype == TType.STOP:
21547 
        break
21548 
      if fid == 0:
21549 
        if ftype == TType.STRUCT:
21550 
          self.success = Amazonlisted()
21551 
          self.success.read(iprot)
21552 
        else:
21553 
          iprot.skip(ftype)
21554 
      else:
21555 
        iprot.skip(ftype)
21556 
      iprot.readFieldEnd()
21557 
    iprot.readStructEnd()
21558 
 
21559 
  def write(self, oprot):
21560 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21561 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21562 
      return
21563 
    oprot.writeStructBegin('getAmazonItemDetails_result')
21564 
    if self.success is not None:
21565 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21566 
      self.success.write(oprot)
21567 
      oprot.writeFieldEnd()
21568 
    oprot.writeFieldStop()
21569 
    oprot.writeStructEnd()
21570 
 
21571 
  def validate(self):
21572 
    return
21573 
 
21574 
 
21575 
  def __repr__(self):
21576 
    L = ['%s=%r' % (key, value)
21577 
      for key, value in self.__dict__.iteritems()]
21578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21579 
 
21580 
  def __eq__(self, other):
21581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21582 
 
21583 
  def __ne__(self, other):
21584 
    return not (self == other)
21585 
 
21586 
class updateAmazonItemDetails_args:
21587 
  """
21588 
  Attributes:
8168 kshitij.so 21589 
   - amazonlisted
7281 kshitij.so 21590 
  """
21591 
 
21592 
  thrift_spec = (
21593 
    None, # 0
8168 kshitij.so 21594 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
7281 kshitij.so 21595 
  )
21596 
 
8168 kshitij.so 21597 
  def __init__(self, amazonlisted=None,):
21598 
    self.amazonlisted = amazonlisted
7281 kshitij.so 21599 
 
21600 
  def read(self, iprot):
21601 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21602 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21603 
      return
21604 
    iprot.readStructBegin()
21605 
    while True:
21606 
      (fname, ftype, fid) = iprot.readFieldBegin()
21607 
      if ftype == TType.STOP:
21608 
        break
21609 
      if fid == 1:
8168 kshitij.so 21610 
        if ftype == TType.STRUCT:
21611 
          self.amazonlisted = Amazonlisted()
21612 
          self.amazonlisted.read(iprot)
7281 kshitij.so 21613 
        else:
21614 
          iprot.skip(ftype)
21615 
      else:
21616 
        iprot.skip(ftype)
21617 
      iprot.readFieldEnd()
21618 
    iprot.readStructEnd()
21619 
 
21620 
  def write(self, oprot):
21621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21623 
      return
21624 
    oprot.writeStructBegin('updateAmazonItemDetails_args')
8168 kshitij.so 21625 
    if self.amazonlisted is not None:
21626 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
21627 
      self.amazonlisted.write(oprot)
7281 kshitij.so 21628 
      oprot.writeFieldEnd()
21629 
    oprot.writeFieldStop()
21630 
    oprot.writeStructEnd()
21631 
 
21632 
  def validate(self):
21633 
    return
21634 
 
21635 
 
21636 
  def __repr__(self):
21637 
    L = ['%s=%r' % (key, value)
21638 
      for key, value in self.__dict__.iteritems()]
21639 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21640 
 
21641 
  def __eq__(self, other):
21642 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21643 
 
21644 
  def __ne__(self, other):
21645 
    return not (self == other)
21646 
 
21647 
class updateAmazonItemDetails_result:
21648 
 
21649 
  thrift_spec = (
21650 
  )
21651 
 
21652 
  def read(self, iprot):
21653 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21654 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21655 
      return
21656 
    iprot.readStructBegin()
21657 
    while True:
21658 
      (fname, ftype, fid) = iprot.readFieldBegin()
21659 
      if ftype == TType.STOP:
21660 
        break
21661 
      else:
21662 
        iprot.skip(ftype)
21663 
      iprot.readFieldEnd()
21664 
    iprot.readStructEnd()
21665 
 
21666 
  def write(self, oprot):
21667 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21668 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21669 
      return
21670 
    oprot.writeStructBegin('updateAmazonItemDetails_result')
21671 
    oprot.writeFieldStop()
21672 
    oprot.writeStructEnd()
21673 
 
21674 
  def validate(self):
21675 
    return
21676 
 
21677 
 
21678 
  def __repr__(self):
21679 
    L = ['%s=%r' % (key, value)
21680 
      for key, value in self.__dict__.iteritems()]
21681 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21682 
 
21683 
  def __eq__(self, other):
21684 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21685 
 
21686 
  def __ne__(self, other):
21687 
    return not (self == other)
21688 
 
21689 
class addAmazonItem_args:
21690 
  """
21691 
  Attributes:
21692 
   - amazonlisted
21693 
  """
21694 
 
21695 
  thrift_spec = (
21696 
    None, # 0
21697 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
21698 
  )
21699 
 
21700 
  def __init__(self, amazonlisted=None,):
21701 
    self.amazonlisted = amazonlisted
21702 
 
21703 
  def read(self, iprot):
21704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21706 
      return
21707 
    iprot.readStructBegin()
21708 
    while True:
21709 
      (fname, ftype, fid) = iprot.readFieldBegin()
21710 
      if ftype == TType.STOP:
21711 
        break
21712 
      if fid == 1:
21713 
        if ftype == TType.STRUCT:
21714 
          self.amazonlisted = Amazonlisted()
21715 
          self.amazonlisted.read(iprot)
21716 
        else:
21717 
          iprot.skip(ftype)
21718 
      else:
21719 
        iprot.skip(ftype)
21720 
      iprot.readFieldEnd()
21721 
    iprot.readStructEnd()
21722 
 
21723 
  def write(self, oprot):
21724 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21725 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21726 
      return
21727 
    oprot.writeStructBegin('addAmazonItem_args')
21728 
    if self.amazonlisted is not None:
21729 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
21730 
      self.amazonlisted.write(oprot)
21731 
      oprot.writeFieldEnd()
21732 
    oprot.writeFieldStop()
21733 
    oprot.writeStructEnd()
21734 
 
21735 
  def validate(self):
21736 
    return
21737 
 
21738 
 
21739 
  def __repr__(self):
21740 
    L = ['%s=%r' % (key, value)
21741 
      for key, value in self.__dict__.iteritems()]
21742 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21743 
 
21744 
  def __eq__(self, other):
21745 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21746 
 
21747 
  def __ne__(self, other):
21748 
    return not (self == other)
21749 
 
21750 
class addAmazonItem_result:
21751 
 
21752 
  thrift_spec = (
21753 
  )
21754 
 
21755 
  def read(self, iprot):
21756 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21757 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21758 
      return
21759 
    iprot.readStructBegin()
21760 
    while True:
21761 
      (fname, ftype, fid) = iprot.readFieldBegin()
21762 
      if ftype == TType.STOP:
21763 
        break
21764 
      else:
21765 
        iprot.skip(ftype)
21766 
      iprot.readFieldEnd()
21767 
    iprot.readStructEnd()
21768 
 
21769 
  def write(self, oprot):
21770 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21771 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21772 
      return
21773 
    oprot.writeStructBegin('addAmazonItem_result')
21774 
    oprot.writeFieldStop()
21775 
    oprot.writeStructEnd()
21776 
 
21777 
  def validate(self):
21778 
    return
21779 
 
21780 
 
21781 
  def __repr__(self):
21782 
    L = ['%s=%r' % (key, value)
21783 
      for key, value in self.__dict__.iteritems()]
21784 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21785 
 
21786 
  def __eq__(self, other):
21787 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21788 
 
21789 
  def __ne__(self, other):
21790 
    return not (self == other)
7291 vikram.rag 21791 
 
21792 
class getAsinItems_args:
21793 
 
21794 
  thrift_spec = (
21795 
  )
21796 
 
21797 
  def read(self, iprot):
21798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21800 
      return
21801 
    iprot.readStructBegin()
21802 
    while True:
21803 
      (fname, ftype, fid) = iprot.readFieldBegin()
21804 
      if ftype == TType.STOP:
21805 
        break
21806 
      else:
21807 
        iprot.skip(ftype)
21808 
      iprot.readFieldEnd()
21809 
    iprot.readStructEnd()
21810 
 
21811 
  def write(self, oprot):
21812 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21813 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21814 
      return
21815 
    oprot.writeStructBegin('getAsinItems_args')
21816 
    oprot.writeFieldStop()
21817 
    oprot.writeStructEnd()
21818 
 
21819 
  def validate(self):
21820 
    return
21821 
 
21822 
 
21823 
  def __repr__(self):
21824 
    L = ['%s=%r' % (key, value)
21825 
      for key, value in self.__dict__.iteritems()]
21826 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21827 
 
21828 
  def __eq__(self, other):
21829 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21830 
 
21831 
  def __ne__(self, other):
21832 
    return not (self == other)
21833 
 
21834 
class getAsinItems_result:
21835 
  """
21836 
  Attributes:
21837 
   - success
21838 
  """
21839 
 
21840 
  thrift_spec = (
21841 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
21842 
  )
21843 
 
21844 
  def __init__(self, success=None,):
21845 
    self.success = success
21846 
 
21847 
  def read(self, iprot):
21848 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21849 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21850 
      return
21851 
    iprot.readStructBegin()
21852 
    while True:
21853 
      (fname, ftype, fid) = iprot.readFieldBegin()
21854 
      if ftype == TType.STOP:
21855 
        break
21856 
      if fid == 0:
21857 
        if ftype == TType.LIST:
21858 
          self.success = []
9155 kshitij.so 21859 
          (_etype442, _size439) = iprot.readListBegin()
21860 
          for _i443 in xrange(_size439):
21861 
            _elem444 = Item()
21862 
            _elem444.read(iprot)
21863 
            self.success.append(_elem444)
7291 vikram.rag 21864 
          iprot.readListEnd()
21865 
        else:
21866 
          iprot.skip(ftype)
21867 
      else:
21868 
        iprot.skip(ftype)
21869 
      iprot.readFieldEnd()
21870 
    iprot.readStructEnd()
21871 
 
21872 
  def write(self, oprot):
21873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21875 
      return
21876 
    oprot.writeStructBegin('getAsinItems_result')
21877 
    if self.success is not None:
21878 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21879 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21880 
      for iter445 in self.success:
21881 
        iter445.write(oprot)
7291 vikram.rag 21882 
      oprot.writeListEnd()
21883 
      oprot.writeFieldEnd()
21884 
    oprot.writeFieldStop()
21885 
    oprot.writeStructEnd()
21886 
 
21887 
  def validate(self):
21888 
    return
21889 
 
21890 
 
21891 
  def __repr__(self):
21892 
    L = ['%s=%r' % (key, value)
21893 
      for key, value in self.__dict__.iteritems()]
21894 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21895 
 
21896 
  def __eq__(self, other):
21897 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21898 
 
21899 
  def __ne__(self, other):
21900 
    return not (self == other)
21901 
 
21902 
class getAllFbaListedItems_args:
21903 
 
21904 
  thrift_spec = (
21905 
  )
21906 
 
21907 
  def read(self, iprot):
21908 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21909 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21910 
      return
21911 
    iprot.readStructBegin()
21912 
    while True:
21913 
      (fname, ftype, fid) = iprot.readFieldBegin()
21914 
      if ftype == TType.STOP:
21915 
        break
21916 
      else:
21917 
        iprot.skip(ftype)
21918 
      iprot.readFieldEnd()
21919 
    iprot.readStructEnd()
21920 
 
21921 
  def write(self, oprot):
21922 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21923 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21924 
      return
21925 
    oprot.writeStructBegin('getAllFbaListedItems_args')
21926 
    oprot.writeFieldStop()
21927 
    oprot.writeStructEnd()
21928 
 
21929 
  def validate(self):
21930 
    return
21931 
 
21932 
 
21933 
  def __repr__(self):
21934 
    L = ['%s=%r' % (key, value)
21935 
      for key, value in self.__dict__.iteritems()]
21936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21937 
 
21938 
  def __eq__(self, other):
21939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21940 
 
21941 
  def __ne__(self, other):
21942 
    return not (self == other)
21943 
 
21944 
class getAllFbaListedItems_result:
21945 
  """
21946 
  Attributes:
21947 
   - success
21948 
  """
21949 
 
21950 
  thrift_spec = (
21951 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
21952 
  )
21953 
 
21954 
  def __init__(self, success=None,):
21955 
    self.success = success
21956 
 
21957 
  def read(self, iprot):
21958 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21959 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21960 
      return
21961 
    iprot.readStructBegin()
21962 
    while True:
21963 
      (fname, ftype, fid) = iprot.readFieldBegin()
21964 
      if ftype == TType.STOP:
21965 
        break
21966 
      if fid == 0:
21967 
        if ftype == TType.LIST:
21968 
          self.success = []
9155 kshitij.so 21969 
          (_etype449, _size446) = iprot.readListBegin()
21970 
          for _i450 in xrange(_size446):
21971 
            _elem451 = Amazonlisted()
21972 
            _elem451.read(iprot)
21973 
            self.success.append(_elem451)
7291 vikram.rag 21974 
          iprot.readListEnd()
21975 
        else:
21976 
          iprot.skip(ftype)
21977 
      else:
21978 
        iprot.skip(ftype)
21979 
      iprot.readFieldEnd()
21980 
    iprot.readStructEnd()
21981 
 
21982 
  def write(self, oprot):
21983 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21984 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21985 
      return
21986 
    oprot.writeStructBegin('getAllFbaListedItems_result')
21987 
    if self.success is not None:
21988 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21989 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21990 
      for iter452 in self.success:
21991 
        iter452.write(oprot)
7291 vikram.rag 21992 
      oprot.writeListEnd()
21993 
      oprot.writeFieldEnd()
21994 
    oprot.writeFieldStop()
21995 
    oprot.writeStructEnd()
21996 
 
21997 
  def validate(self):
21998 
    return
21999 
 
22000 
 
22001 
  def __repr__(self):
22002 
    L = ['%s=%r' % (key, value)
22003 
      for key, value in self.__dict__.iteritems()]
22004 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22005 
 
22006 
  def __eq__(self, other):
22007 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22008 
 
22009 
  def __ne__(self, other):
22010 
    return not (self == other)
22011 
 
22012 
class getAllNonFbaListedItems_args:
22013 
 
22014 
  thrift_spec = (
22015 
  )
22016 
 
22017 
  def read(self, iprot):
22018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22020 
      return
22021 
    iprot.readStructBegin()
22022 
    while True:
22023 
      (fname, ftype, fid) = iprot.readFieldBegin()
22024 
      if ftype == TType.STOP:
22025 
        break
22026 
      else:
22027 
        iprot.skip(ftype)
22028 
      iprot.readFieldEnd()
22029 
    iprot.readStructEnd()
22030 
 
22031 
  def write(self, oprot):
22032 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22033 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22034 
      return
22035 
    oprot.writeStructBegin('getAllNonFbaListedItems_args')
22036 
    oprot.writeFieldStop()
22037 
    oprot.writeStructEnd()
22038 
 
22039 
  def validate(self):
22040 
    return
22041 
 
22042 
 
22043 
  def __repr__(self):
22044 
    L = ['%s=%r' % (key, value)
22045 
      for key, value in self.__dict__.iteritems()]
22046 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22047 
 
22048 
  def __eq__(self, other):
22049 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22050 
 
22051 
  def __ne__(self, other):
22052 
    return not (self == other)
22053 
 
22054 
class getAllNonFbaListedItems_result:
22055 
  """
22056 
  Attributes:
22057 
   - success
22058 
  """
22059 
 
22060 
  thrift_spec = (
22061 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
22062 
  )
22063 
 
22064 
  def __init__(self, success=None,):
22065 
    self.success = success
22066 
 
22067 
  def read(self, iprot):
22068 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22069 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22070 
      return
22071 
    iprot.readStructBegin()
22072 
    while True:
22073 
      (fname, ftype, fid) = iprot.readFieldBegin()
22074 
      if ftype == TType.STOP:
22075 
        break
22076 
      if fid == 0:
22077 
        if ftype == TType.LIST:
22078 
          self.success = []
9155 kshitij.so 22079 
          (_etype456, _size453) = iprot.readListBegin()
22080 
          for _i457 in xrange(_size453):
22081 
            _elem458 = Amazonlisted()
22082 
            _elem458.read(iprot)
22083 
            self.success.append(_elem458)
7291 vikram.rag 22084 
          iprot.readListEnd()
22085 
        else:
22086 
          iprot.skip(ftype)
22087 
      else:
22088 
        iprot.skip(ftype)
22089 
      iprot.readFieldEnd()
22090 
    iprot.readStructEnd()
22091 
 
22092 
  def write(self, oprot):
22093 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22094 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22095 
      return
22096 
    oprot.writeStructBegin('getAllNonFbaListedItems_result')
22097 
    if self.success is not None:
22098 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22099 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22100 
      for iter459 in self.success:
22101 
        iter459.write(oprot)
7291 vikram.rag 22102 
      oprot.writeListEnd()
22103 
      oprot.writeFieldEnd()
22104 
    oprot.writeFieldStop()
22105 
    oprot.writeStructEnd()
22106 
 
22107 
  def validate(self):
22108 
    return
22109 
 
22110 
 
22111 
  def __repr__(self):
22112 
    L = ['%s=%r' % (key, value)
22113 
      for key, value in self.__dict__.iteritems()]
22114 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22115 
 
22116 
  def __eq__(self, other):
22117 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22118 
 
22119 
  def __ne__(self, other):
22120 
    return not (self == other)
7460 kshitij.so 22121 
 
22122 
class updateItemInventory_args:
22123 
  """
22124 
  Attributes:
22125 
   - itemId
22126 
   - holdInventory
22127 
   - defaultInventory
22128 
  """
22129 
 
22130 
  thrift_spec = (
22131 
    None, # 0
22132 
    (1, TType.I64, 'itemId', None, None, ), # 1
22133 
    (2, TType.I64, 'holdInventory', None, None, ), # 2
22134 
    (3, TType.I64, 'defaultInventory', None, None, ), # 3
22135 
  )
22136 
 
22137 
  def __init__(self, itemId=None, holdInventory=None, defaultInventory=None,):
22138 
    self.itemId = itemId
22139 
    self.holdInventory = holdInventory
22140 
    self.defaultInventory = defaultInventory
22141 
 
22142 
  def read(self, iprot):
22143 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22144 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22145 
      return
22146 
    iprot.readStructBegin()
22147 
    while True:
22148 
      (fname, ftype, fid) = iprot.readFieldBegin()
22149 
      if ftype == TType.STOP:
22150 
        break
22151 
      if fid == 1:
22152 
        if ftype == TType.I64:
22153 
          self.itemId = iprot.readI64();
22154 
        else:
22155 
          iprot.skip(ftype)
22156 
      elif fid == 2:
22157 
        if ftype == TType.I64:
22158 
          self.holdInventory = iprot.readI64();
22159 
        else:
22160 
          iprot.skip(ftype)
22161 
      elif fid == 3:
22162 
        if ftype == TType.I64:
22163 
          self.defaultInventory = iprot.readI64();
22164 
        else:
22165 
          iprot.skip(ftype)
22166 
      else:
22167 
        iprot.skip(ftype)
22168 
      iprot.readFieldEnd()
22169 
    iprot.readStructEnd()
22170 
 
22171 
  def write(self, oprot):
22172 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22173 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22174 
      return
22175 
    oprot.writeStructBegin('updateItemInventory_args')
22176 
    if self.itemId is not None:
22177 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
22178 
      oprot.writeI64(self.itemId)
22179 
      oprot.writeFieldEnd()
22180 
    if self.holdInventory is not None:
22181 
      oprot.writeFieldBegin('holdInventory', TType.I64, 2)
22182 
      oprot.writeI64(self.holdInventory)
22183 
      oprot.writeFieldEnd()
22184 
    if self.defaultInventory is not None:
22185 
      oprot.writeFieldBegin('defaultInventory', TType.I64, 3)
22186 
      oprot.writeI64(self.defaultInventory)
22187 
      oprot.writeFieldEnd()
22188 
    oprot.writeFieldStop()
22189 
    oprot.writeStructEnd()
22190 
 
22191 
  def validate(self):
22192 
    return
22193 
 
22194 
 
22195 
  def __repr__(self):
22196 
    L = ['%s=%r' % (key, value)
22197 
      for key, value in self.__dict__.iteritems()]
22198 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22199 
 
22200 
  def __eq__(self, other):
22201 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22202 
 
22203 
  def __ne__(self, other):
22204 
    return not (self == other)
22205 
 
22206 
class updateItemInventory_result:
22207 
  """
22208 
  Attributes:
22209 
   - success
22210 
  """
22211 
 
22212 
  thrift_spec = (
22213 
    (0, TType.BOOL, 'success', None, None, ), # 0
22214 
  )
22215 
 
22216 
  def __init__(self, success=None,):
22217 
    self.success = success
22218 
 
22219 
  def read(self, iprot):
22220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22222 
      return
22223 
    iprot.readStructBegin()
22224 
    while True:
22225 
      (fname, ftype, fid) = iprot.readFieldBegin()
22226 
      if ftype == TType.STOP:
22227 
        break
22228 
      if fid == 0:
22229 
        if ftype == TType.BOOL:
22230 
          self.success = iprot.readBool();
22231 
        else:
22232 
          iprot.skip(ftype)
22233 
      else:
22234 
        iprot.skip(ftype)
22235 
      iprot.readFieldEnd()
22236 
    iprot.readStructEnd()
22237 
 
22238 
  def write(self, oprot):
22239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22241 
      return
22242 
    oprot.writeStructBegin('updateItemInventory_result')
22243 
    if self.success is not None:
22244 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22245 
      oprot.writeBool(self.success)
22246 
      oprot.writeFieldEnd()
22247 
    oprot.writeFieldStop()
22248 
    oprot.writeStructEnd()
22249 
 
22250 
  def validate(self):
22251 
    return
22252 
 
22253 
 
22254 
  def __repr__(self):
22255 
    L = ['%s=%r' % (key, value)
22256 
      for key, value in self.__dict__.iteritems()]
22257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22258 
 
22259 
  def __eq__(self, other):
22260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22261 
 
22262 
  def __ne__(self, other):
22263 
    return not (self == other)
7770 kshitij.so 22264 
 
22265 
class updateTimestampForAmazonFeeds_args:
22266 
  """
22267 
  Attributes:
22268 
   - type
22269 
   - sku
22270 
   - timestamp
22271 
  """
22272 
 
22273 
  thrift_spec = (
22274 
    None, # 0
22275 
    (1, TType.STRING, 'type', None, None, ), # 1
22276 
    (2, TType.LIST, 'sku', (TType.I64,None), None, ), # 2
22277 
    (3, TType.I64, 'timestamp', None, None, ), # 3
22278 
  )
22279 
 
22280 
  def __init__(self, type=None, sku=None, timestamp=None,):
22281 
    self.type = type
22282 
    self.sku = sku
22283 
    self.timestamp = timestamp
22284 
 
22285 
  def read(self, iprot):
22286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22288 
      return
22289 
    iprot.readStructBegin()
22290 
    while True:
22291 
      (fname, ftype, fid) = iprot.readFieldBegin()
22292 
      if ftype == TType.STOP:
22293 
        break
22294 
      if fid == 1:
22295 
        if ftype == TType.STRING:
22296 
          self.type = iprot.readString();
22297 
        else:
22298 
          iprot.skip(ftype)
22299 
      elif fid == 2:
22300 
        if ftype == TType.LIST:
22301 
          self.sku = []
9155 kshitij.so 22302 
          (_etype463, _size460) = iprot.readListBegin()
22303 
          for _i464 in xrange(_size460):
22304 
            _elem465 = iprot.readI64();
22305 
            self.sku.append(_elem465)
7770 kshitij.so 22306 
          iprot.readListEnd()
22307 
        else:
22308 
          iprot.skip(ftype)
22309 
      elif fid == 3:
22310 
        if ftype == TType.I64:
22311 
          self.timestamp = iprot.readI64();
22312 
        else:
22313 
          iprot.skip(ftype)
22314 
      else:
22315 
        iprot.skip(ftype)
22316 
      iprot.readFieldEnd()
22317 
    iprot.readStructEnd()
22318 
 
22319 
  def write(self, oprot):
22320 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22321 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22322 
      return
22323 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_args')
22324 
    if self.type is not None:
22325 
      oprot.writeFieldBegin('type', TType.STRING, 1)
22326 
      oprot.writeString(self.type)
22327 
      oprot.writeFieldEnd()
22328 
    if self.sku is not None:
22329 
      oprot.writeFieldBegin('sku', TType.LIST, 2)
22330 
      oprot.writeListBegin(TType.I64, len(self.sku))
9155 kshitij.so 22331 
      for iter466 in self.sku:
22332 
        oprot.writeI64(iter466)
7770 kshitij.so 22333 
      oprot.writeListEnd()
22334 
      oprot.writeFieldEnd()
22335 
    if self.timestamp is not None:
22336 
      oprot.writeFieldBegin('timestamp', TType.I64, 3)
22337 
      oprot.writeI64(self.timestamp)
22338 
      oprot.writeFieldEnd()
22339 
    oprot.writeFieldStop()
22340 
    oprot.writeStructEnd()
22341 
 
22342 
  def validate(self):
22343 
    return
22344 
 
22345 
 
22346 
  def __repr__(self):
22347 
    L = ['%s=%r' % (key, value)
22348 
      for key, value in self.__dict__.iteritems()]
22349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22350 
 
22351 
  def __eq__(self, other):
22352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22353 
 
22354 
  def __ne__(self, other):
22355 
    return not (self == other)
22356 
 
22357 
class updateTimestampForAmazonFeeds_result:
22358 
  """
22359 
  Attributes:
22360 
   - success
22361 
  """
22362 
 
22363 
  thrift_spec = (
22364 
    (0, TType.BOOL, 'success', None, None, ), # 0
22365 
  )
22366 
 
22367 
  def __init__(self, success=None,):
22368 
    self.success = success
22369 
 
22370 
  def read(self, iprot):
22371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22373 
      return
22374 
    iprot.readStructBegin()
22375 
    while True:
22376 
      (fname, ftype, fid) = iprot.readFieldBegin()
22377 
      if ftype == TType.STOP:
22378 
        break
22379 
      if fid == 0:
22380 
        if ftype == TType.BOOL:
22381 
          self.success = iprot.readBool();
22382 
        else:
22383 
          iprot.skip(ftype)
22384 
      else:
22385 
        iprot.skip(ftype)
22386 
      iprot.readFieldEnd()
22387 
    iprot.readStructEnd()
22388 
 
22389 
  def write(self, oprot):
22390 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22391 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22392 
      return
22393 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_result')
22394 
    if self.success is not None:
22395 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22396 
      oprot.writeBool(self.success)
22397 
      oprot.writeFieldEnd()
22398 
    oprot.writeFieldStop()
22399 
    oprot.writeStructEnd()
22400 
 
22401 
  def validate(self):
22402 
    return
22403 
 
22404 
 
22405 
  def __repr__(self):
22406 
    L = ['%s=%r' % (key, value)
22407 
      for key, value in self.__dict__.iteritems()]
22408 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22409 
 
22410 
  def __eq__(self, other):
22411 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22412 
 
22413 
  def __ne__(self, other):
22414 
    return not (self == other)
7897 amar.kumar 22415 
 
22416 
class getAllParentCategories_args:
22417 
 
22418 
  thrift_spec = (
22419 
  )
22420 
 
22421 
  def read(self, iprot):
22422 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22423 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22424 
      return
22425 
    iprot.readStructBegin()
22426 
    while True:
22427 
      (fname, ftype, fid) = iprot.readFieldBegin()
22428 
      if ftype == TType.STOP:
22429 
        break
22430 
      else:
22431 
        iprot.skip(ftype)
22432 
      iprot.readFieldEnd()
22433 
    iprot.readStructEnd()
22434 
 
22435 
  def write(self, oprot):
22436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22438 
      return
22439 
    oprot.writeStructBegin('getAllParentCategories_args')
22440 
    oprot.writeFieldStop()
22441 
    oprot.writeStructEnd()
22442 
 
22443 
  def validate(self):
22444 
    return
22445 
 
22446 
 
22447 
  def __repr__(self):
22448 
    L = ['%s=%r' % (key, value)
22449 
      for key, value in self.__dict__.iteritems()]
22450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22451 
 
22452 
  def __eq__(self, other):
22453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22454 
 
22455 
  def __ne__(self, other):
22456 
    return not (self == other)
22457 
 
22458 
class getAllParentCategories_result:
22459 
  """
22460 
  Attributes:
22461 
   - success
22462 
  """
22463 
 
22464 
  thrift_spec = (
22465 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
22466 
  )
22467 
 
22468 
  def __init__(self, success=None,):
22469 
    self.success = success
22470 
 
22471 
  def read(self, iprot):
22472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22474 
      return
22475 
    iprot.readStructBegin()
22476 
    while True:
22477 
      (fname, ftype, fid) = iprot.readFieldBegin()
22478 
      if ftype == TType.STOP:
22479 
        break
22480 
      if fid == 0:
22481 
        if ftype == TType.LIST:
22482 
          self.success = []
9155 kshitij.so 22483 
          (_etype470, _size467) = iprot.readListBegin()
22484 
          for _i471 in xrange(_size467):
22485 
            _elem472 = Category()
22486 
            _elem472.read(iprot)
22487 
            self.success.append(_elem472)
7897 amar.kumar 22488 
          iprot.readListEnd()
22489 
        else:
22490 
          iprot.skip(ftype)
22491 
      else:
22492 
        iprot.skip(ftype)
22493 
      iprot.readFieldEnd()
22494 
    iprot.readStructEnd()
22495 
 
22496 
  def write(self, oprot):
22497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22499 
      return
22500 
    oprot.writeStructBegin('getAllParentCategories_result')
22501 
    if self.success is not None:
22502 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22503 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22504 
      for iter473 in self.success:
22505 
        iter473.write(oprot)
7897 amar.kumar 22506 
      oprot.writeListEnd()
22507 
      oprot.writeFieldEnd()
22508 
    oprot.writeFieldStop()
22509 
    oprot.writeStructEnd()
22510 
 
22511 
  def validate(self):
22512 
    return
22513 
 
22514 
 
22515 
  def __repr__(self):
22516 
    L = ['%s=%r' % (key, value)
22517 
      for key, value in self.__dict__.iteritems()]
22518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22519 
 
22520 
  def __eq__(self, other):
22521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22522 
 
22523 
  def __ne__(self, other):
22524 
    return not (self == other)
7977 kshitij.so 22525 
 
22526 
class addPageViewEvent_args:
22527 
  """
22528 
  Attributes:
22529 
   - pageViewEvents
22530 
  """
22531 
 
22532 
  thrift_spec = (
22533 
    None, # 0
22534 
    (1, TType.STRUCT, 'pageViewEvents', (PageViewEvents, PageViewEvents.thrift_spec), None, ), # 1
22535 
  )
22536 
 
22537 
  def __init__(self, pageViewEvents=None,):
22538 
    self.pageViewEvents = pageViewEvents
22539 
 
22540 
  def read(self, iprot):
22541 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22542 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22543 
      return
22544 
    iprot.readStructBegin()
22545 
    while True:
22546 
      (fname, ftype, fid) = iprot.readFieldBegin()
22547 
      if ftype == TType.STOP:
22548 
        break
22549 
      if fid == 1:
22550 
        if ftype == TType.STRUCT:
22551 
          self.pageViewEvents = PageViewEvents()
22552 
          self.pageViewEvents.read(iprot)
22553 
        else:
22554 
          iprot.skip(ftype)
22555 
      else:
22556 
        iprot.skip(ftype)
22557 
      iprot.readFieldEnd()
22558 
    iprot.readStructEnd()
22559 
 
22560 
  def write(self, oprot):
22561 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22562 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22563 
      return
22564 
    oprot.writeStructBegin('addPageViewEvent_args')
22565 
    if self.pageViewEvents is not None:
22566 
      oprot.writeFieldBegin('pageViewEvents', TType.STRUCT, 1)
22567 
      self.pageViewEvents.write(oprot)
22568 
      oprot.writeFieldEnd()
22569 
    oprot.writeFieldStop()
22570 
    oprot.writeStructEnd()
22571 
 
22572 
  def validate(self):
22573 
    return
22574 
 
22575 
 
22576 
  def __repr__(self):
22577 
    L = ['%s=%r' % (key, value)
22578 
      for key, value in self.__dict__.iteritems()]
22579 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22580 
 
22581 
  def __eq__(self, other):
22582 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22583 
 
22584 
  def __ne__(self, other):
22585 
    return not (self == other)
22586 
 
22587 
class addPageViewEvent_result:
22588 
 
22589 
  thrift_spec = (
22590 
  )
22591 
 
22592 
  def read(self, iprot):
22593 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22594 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22595 
      return
22596 
    iprot.readStructBegin()
22597 
    while True:
22598 
      (fname, ftype, fid) = iprot.readFieldBegin()
22599 
      if ftype == TType.STOP:
22600 
        break
22601 
      else:
22602 
        iprot.skip(ftype)
22603 
      iprot.readFieldEnd()
22604 
    iprot.readStructEnd()
22605 
 
22606 
  def write(self, oprot):
22607 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22608 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22609 
      return
22610 
    oprot.writeStructBegin('addPageViewEvent_result')
22611 
    oprot.writeFieldStop()
22612 
    oprot.writeStructEnd()
22613 
 
22614 
  def validate(self):
22615 
    return
22616 
 
22617 
 
22618 
  def __repr__(self):
22619 
    L = ['%s=%r' % (key, value)
22620 
      for key, value in self.__dict__.iteritems()]
22621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22622 
 
22623 
  def __eq__(self, other):
22624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22625 
 
22626 
  def __ne__(self, other):
22627 
    return not (self == other)
22628 
 
22629 
class addCartEvent_args:
22630 
  """
22631 
  Attributes:
22632 
   - cartEvents
22633 
  """
22634 
 
22635 
  thrift_spec = (
22636 
    None, # 0
22637 
    (1, TType.STRUCT, 'cartEvents', (CartEvents, CartEvents.thrift_spec), None, ), # 1
22638 
  )
22639 
 
22640 
  def __init__(self, cartEvents=None,):
22641 
    self.cartEvents = cartEvents
22642 
 
22643 
  def read(self, iprot):
22644 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22645 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22646 
      return
22647 
    iprot.readStructBegin()
22648 
    while True:
22649 
      (fname, ftype, fid) = iprot.readFieldBegin()
22650 
      if ftype == TType.STOP:
22651 
        break
22652 
      if fid == 1:
22653 
        if ftype == TType.STRUCT:
22654 
          self.cartEvents = CartEvents()
22655 
          self.cartEvents.read(iprot)
22656 
        else:
22657 
          iprot.skip(ftype)
22658 
      else:
22659 
        iprot.skip(ftype)
22660 
      iprot.readFieldEnd()
22661 
    iprot.readStructEnd()
22662 
 
22663 
  def write(self, oprot):
22664 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22665 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22666 
      return
22667 
    oprot.writeStructBegin('addCartEvent_args')
22668 
    if self.cartEvents is not None:
22669 
      oprot.writeFieldBegin('cartEvents', TType.STRUCT, 1)
22670 
      self.cartEvents.write(oprot)
22671 
      oprot.writeFieldEnd()
22672 
    oprot.writeFieldStop()
22673 
    oprot.writeStructEnd()
22674 
 
22675 
  def validate(self):
22676 
    return
22677 
 
22678 
 
22679 
  def __repr__(self):
22680 
    L = ['%s=%r' % (key, value)
22681 
      for key, value in self.__dict__.iteritems()]
22682 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22683 
 
22684 
  def __eq__(self, other):
22685 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22686 
 
22687 
  def __ne__(self, other):
22688 
    return not (self == other)
22689 
 
22690 
class addCartEvent_result:
22691 
 
22692 
  thrift_spec = (
22693 
  )
22694 
 
22695 
  def read(self, iprot):
22696 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22697 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22698 
      return
22699 
    iprot.readStructBegin()
22700 
    while True:
22701 
      (fname, ftype, fid) = iprot.readFieldBegin()
22702 
      if ftype == TType.STOP:
22703 
        break
22704 
      else:
22705 
        iprot.skip(ftype)
22706 
      iprot.readFieldEnd()
22707 
    iprot.readStructEnd()
22708 
 
22709 
  def write(self, oprot):
22710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22712 
      return
22713 
    oprot.writeStructBegin('addCartEvent_result')
22714 
    oprot.writeFieldStop()
22715 
    oprot.writeStructEnd()
22716 
 
22717 
  def validate(self):
22718 
    return
22719 
 
22720 
 
22721 
  def __repr__(self):
22722 
    L = ['%s=%r' % (key, value)
22723 
      for key, value in self.__dict__.iteritems()]
22724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22725 
 
22726 
  def __eq__(self, other):
22727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22728 
 
22729 
  def __ne__(self, other):
22730 
    return not (self == other)
8139 kshitij.so 22731 
 
8182 amar.kumar 22732 
class addEbayItem_args:
22733 
  """
22734 
  Attributes:
22735 
   - ebayItem
22736 
  """
22737 
 
22738 
  thrift_spec = (
22739 
    None, # 0
22740 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
22741 
  )
22742 
 
22743 
  def __init__(self, ebayItem=None,):
22744 
    self.ebayItem = ebayItem
22745 
 
22746 
  def read(self, iprot):
22747 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22748 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22749 
      return
22750 
    iprot.readStructBegin()
22751 
    while True:
22752 
      (fname, ftype, fid) = iprot.readFieldBegin()
22753 
      if ftype == TType.STOP:
22754 
        break
22755 
      if fid == 1:
22756 
        if ftype == TType.STRUCT:
22757 
          self.ebayItem = EbayItem()
22758 
          self.ebayItem.read(iprot)
22759 
        else:
22760 
          iprot.skip(ftype)
22761 
      else:
22762 
        iprot.skip(ftype)
22763 
      iprot.readFieldEnd()
22764 
    iprot.readStructEnd()
22765 
 
22766 
  def write(self, oprot):
22767 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22768 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22769 
      return
22770 
    oprot.writeStructBegin('addEbayItem_args')
22771 
    if self.ebayItem is not None:
22772 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
22773 
      self.ebayItem.write(oprot)
22774 
      oprot.writeFieldEnd()
22775 
    oprot.writeFieldStop()
22776 
    oprot.writeStructEnd()
22777 
 
22778 
  def validate(self):
22779 
    return
22780 
 
22781 
 
22782 
  def __repr__(self):
22783 
    L = ['%s=%r' % (key, value)
22784 
      for key, value in self.__dict__.iteritems()]
22785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22786 
 
22787 
  def __eq__(self, other):
22788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22789 
 
22790 
  def __ne__(self, other):
22791 
    return not (self == other)
22792 
 
22793 
class addEbayItem_result:
22794 
 
22795 
  thrift_spec = (
22796 
  )
22797 
 
22798 
  def read(self, iprot):
22799 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22800 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22801 
      return
22802 
    iprot.readStructBegin()
22803 
    while True:
22804 
      (fname, ftype, fid) = iprot.readFieldBegin()
22805 
      if ftype == TType.STOP:
22806 
        break
22807 
      else:
22808 
        iprot.skip(ftype)
22809 
      iprot.readFieldEnd()
22810 
    iprot.readStructEnd()
22811 
 
22812 
  def write(self, oprot):
22813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22815 
      return
22816 
    oprot.writeStructBegin('addEbayItem_result')
22817 
    oprot.writeFieldStop()
22818 
    oprot.writeStructEnd()
22819 
 
22820 
  def validate(self):
22821 
    return
22822 
 
22823 
 
22824 
  def __repr__(self):
22825 
    L = ['%s=%r' % (key, value)
22826 
      for key, value in self.__dict__.iteritems()]
22827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22828 
 
22829 
  def __eq__(self, other):
22830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22831 
 
22832 
  def __ne__(self, other):
22833 
    return not (self == other)
22834 
 
22835 
class getEbayItem_args:
22836 
  """
22837 
  Attributes:
22838 
   - listingId
22839 
  """
22840 
 
22841 
  thrift_spec = (
22842 
    None, # 0
22843 
    (1, TType.STRING, 'listingId', None, None, ), # 1
22844 
  )
22845 
 
22846 
  def __init__(self, listingId=None,):
22847 
    self.listingId = listingId
22848 
 
22849 
  def read(self, iprot):
22850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22852 
      return
22853 
    iprot.readStructBegin()
22854 
    while True:
22855 
      (fname, ftype, fid) = iprot.readFieldBegin()
22856 
      if ftype == TType.STOP:
22857 
        break
22858 
      if fid == 1:
22859 
        if ftype == TType.STRING:
22860 
          self.listingId = iprot.readString();
22861 
        else:
22862 
          iprot.skip(ftype)
22863 
      else:
22864 
        iprot.skip(ftype)
22865 
      iprot.readFieldEnd()
22866 
    iprot.readStructEnd()
22867 
 
22868 
  def write(self, oprot):
22869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22871 
      return
22872 
    oprot.writeStructBegin('getEbayItem_args')
22873 
    if self.listingId is not None:
22874 
      oprot.writeFieldBegin('listingId', TType.STRING, 1)
22875 
      oprot.writeString(self.listingId)
22876 
      oprot.writeFieldEnd()
22877 
    oprot.writeFieldStop()
22878 
    oprot.writeStructEnd()
22879 
 
22880 
  def validate(self):
22881 
    return
22882 
 
22883 
 
22884 
  def __repr__(self):
22885 
    L = ['%s=%r' % (key, value)
22886 
      for key, value in self.__dict__.iteritems()]
22887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22888 
 
22889 
  def __eq__(self, other):
22890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22891 
 
22892 
  def __ne__(self, other):
22893 
    return not (self == other)
22894 
 
22895 
class getEbayItem_result:
22896 
  """
22897 
  Attributes:
22898 
   - success
22899 
  """
22900 
 
22901 
  thrift_spec = (
22902 
    (0, TType.STRUCT, 'success', (EbayItem, EbayItem.thrift_spec), None, ), # 0
22903 
  )
22904 
 
22905 
  def __init__(self, success=None,):
22906 
    self.success = success
22907 
 
22908 
  def read(self, iprot):
22909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22911 
      return
22912 
    iprot.readStructBegin()
22913 
    while True:
22914 
      (fname, ftype, fid) = iprot.readFieldBegin()
22915 
      if ftype == TType.STOP:
22916 
        break
22917 
      if fid == 0:
22918 
        if ftype == TType.STRUCT:
22919 
          self.success = EbayItem()
22920 
          self.success.read(iprot)
22921 
        else:
22922 
          iprot.skip(ftype)
22923 
      else:
22924 
        iprot.skip(ftype)
22925 
      iprot.readFieldEnd()
22926 
    iprot.readStructEnd()
22927 
 
22928 
  def write(self, oprot):
22929 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22930 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22931 
      return
22932 
    oprot.writeStructBegin('getEbayItem_result')
22933 
    if self.success is not None:
22934 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22935 
      self.success.write(oprot)
22936 
      oprot.writeFieldEnd()
22937 
    oprot.writeFieldStop()
22938 
    oprot.writeStructEnd()
22939 
 
22940 
  def validate(self):
22941 
    return
22942 
 
22943 
 
22944 
  def __repr__(self):
22945 
    L = ['%s=%r' % (key, value)
22946 
      for key, value in self.__dict__.iteritems()]
22947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22948 
 
22949 
  def __eq__(self, other):
22950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22951 
 
22952 
  def __ne__(self, other):
22953 
    return not (self == other)
22954 
 
22955 
class updateEbayItem_args:
22956 
  """
22957 
  Attributes:
22958 
   - ebayItem
22959 
  """
22960 
 
22961 
  thrift_spec = (
22962 
    None, # 0
22963 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
22964 
  )
22965 
 
22966 
  def __init__(self, ebayItem=None,):
22967 
    self.ebayItem = ebayItem
22968 
 
22969 
  def read(self, iprot):
22970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22972 
      return
22973 
    iprot.readStructBegin()
22974 
    while True:
22975 
      (fname, ftype, fid) = iprot.readFieldBegin()
22976 
      if ftype == TType.STOP:
22977 
        break
22978 
      if fid == 1:
22979 
        if ftype == TType.STRUCT:
22980 
          self.ebayItem = EbayItem()
22981 
          self.ebayItem.read(iprot)
22982 
        else:
22983 
          iprot.skip(ftype)
22984 
      else:
22985 
        iprot.skip(ftype)
22986 
      iprot.readFieldEnd()
22987 
    iprot.readStructEnd()
22988 
 
22989 
  def write(self, oprot):
22990 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22991 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22992 
      return
22993 
    oprot.writeStructBegin('updateEbayItem_args')
22994 
    if self.ebayItem is not None:
22995 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
22996 
      self.ebayItem.write(oprot)
22997 
      oprot.writeFieldEnd()
22998 
    oprot.writeFieldStop()
22999 
    oprot.writeStructEnd()
23000 
 
23001 
  def validate(self):
23002 
    return
23003 
 
23004 
 
23005 
  def __repr__(self):
23006 
    L = ['%s=%r' % (key, value)
23007 
      for key, value in self.__dict__.iteritems()]
23008 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23009 
 
23010 
  def __eq__(self, other):
23011 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23012 
 
23013 
  def __ne__(self, other):
23014 
    return not (self == other)
23015 
 
23016 
class updateEbayItem_result:
23017 
 
23018 
  thrift_spec = (
23019 
  )
23020 
 
23021 
  def read(self, iprot):
23022 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23023 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23024 
      return
23025 
    iprot.readStructBegin()
23026 
    while True:
23027 
      (fname, ftype, fid) = iprot.readFieldBegin()
23028 
      if ftype == TType.STOP:
23029 
        break
23030 
      else:
23031 
        iprot.skip(ftype)
23032 
      iprot.readFieldEnd()
23033 
    iprot.readStructEnd()
23034 
 
23035 
  def write(self, oprot):
23036 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23037 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23038 
      return
23039 
    oprot.writeStructBegin('updateEbayItem_result')
23040 
    oprot.writeFieldStop()
23041 
    oprot.writeStructEnd()
23042 
 
23043 
  def validate(self):
23044 
    return
23045 
 
23046 
 
23047 
  def __repr__(self):
23048 
    L = ['%s=%r' % (key, value)
23049 
      for key, value in self.__dict__.iteritems()]
23050 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23051 
 
23052 
  def __eq__(self, other):
23053 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23054 
 
23055 
  def __ne__(self, other):
23056 
    return not (self == other)
23057 
 
8139 kshitij.so 23058 
class getAmazonListedItems_args:
23059 
  """
23060 
  Attributes:
23061 
   - offset
23062 
   - limit
23063 
  """
23064 
 
23065 
  thrift_spec = (
23066 
    None, # 0
23067 
    (1, TType.I64, 'offset', None, None, ), # 1
23068 
    (2, TType.I64, 'limit', None, None, ), # 2
23069 
  )
23070 
 
23071 
  def __init__(self, offset=None, limit=None,):
23072 
    self.offset = offset
23073 
    self.limit = limit
23074 
 
23075 
  def read(self, iprot):
23076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23078 
      return
23079 
    iprot.readStructBegin()
23080 
    while True:
23081 
      (fname, ftype, fid) = iprot.readFieldBegin()
23082 
      if ftype == TType.STOP:
23083 
        break
23084 
      if fid == 1:
23085 
        if ftype == TType.I64:
23086 
          self.offset = iprot.readI64();
23087 
        else:
23088 
          iprot.skip(ftype)
23089 
      elif fid == 2:
23090 
        if ftype == TType.I64:
23091 
          self.limit = iprot.readI64();
23092 
        else:
23093 
          iprot.skip(ftype)
23094 
      else:
23095 
        iprot.skip(ftype)
23096 
      iprot.readFieldEnd()
23097 
    iprot.readStructEnd()
23098 
 
23099 
  def write(self, oprot):
23100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23102 
      return
23103 
    oprot.writeStructBegin('getAmazonListedItems_args')
23104 
    if self.offset is not None:
23105 
      oprot.writeFieldBegin('offset', TType.I64, 1)
23106 
      oprot.writeI64(self.offset)
23107 
      oprot.writeFieldEnd()
23108 
    if self.limit is not None:
23109 
      oprot.writeFieldBegin('limit', TType.I64, 2)
23110 
      oprot.writeI64(self.limit)
23111 
      oprot.writeFieldEnd()
23112 
    oprot.writeFieldStop()
23113 
    oprot.writeStructEnd()
23114 
 
23115 
  def validate(self):
23116 
    return
23117 
 
23118 
 
23119 
  def __repr__(self):
23120 
    L = ['%s=%r' % (key, value)
23121 
      for key, value in self.__dict__.iteritems()]
23122 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23123 
 
23124 
  def __eq__(self, other):
23125 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23126 
 
23127 
  def __ne__(self, other):
23128 
    return not (self == other)
23129 
 
23130 
class getAmazonListedItems_result:
23131 
  """
23132 
  Attributes:
23133 
   - success
23134 
  """
23135 
 
23136 
  thrift_spec = (
23137 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
23138 
  )
23139 
 
23140 
  def __init__(self, success=None,):
23141 
    self.success = success
23142 
 
23143 
  def read(self, iprot):
23144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23146 
      return
23147 
    iprot.readStructBegin()
23148 
    while True:
23149 
      (fname, ftype, fid) = iprot.readFieldBegin()
23150 
      if ftype == TType.STOP:
23151 
        break
23152 
      if fid == 0:
23153 
        if ftype == TType.LIST:
23154 
          self.success = []
9155 kshitij.so 23155 
          (_etype477, _size474) = iprot.readListBegin()
23156 
          for _i478 in xrange(_size474):
23157 
            _elem479 = Amazonlisted()
23158 
            _elem479.read(iprot)
23159 
            self.success.append(_elem479)
8139 kshitij.so 23160 
          iprot.readListEnd()
23161 
        else:
23162 
          iprot.skip(ftype)
23163 
      else:
23164 
        iprot.skip(ftype)
23165 
      iprot.readFieldEnd()
23166 
    iprot.readStructEnd()
23167 
 
23168 
  def write(self, oprot):
23169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23171 
      return
23172 
    oprot.writeStructBegin('getAmazonListedItems_result')
23173 
    if self.success is not None:
23174 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23175 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 23176 
      for iter480 in self.success:
23177 
        iter480.write(oprot)
8139 kshitij.so 23178 
      oprot.writeListEnd()
23179 
      oprot.writeFieldEnd()
23180 
    oprot.writeFieldStop()
23181 
    oprot.writeStructEnd()
23182 
 
23183 
  def validate(self):
23184 
    return
23185 
 
23186 
 
23187 
  def __repr__(self):
23188 
    L = ['%s=%r' % (key, value)
23189 
      for key, value in self.__dict__.iteritems()]
23190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23191 
 
23192 
  def __eq__(self, other):
23193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23194 
 
23195 
  def __ne__(self, other):
23196 
    return not (self == other)
8168 kshitij.so 23197 
 
23198 
class updateAmazonAttributesInBulk_args:
23199 
  """
23200 
  Attributes:
23201 
   - amazonlisted
23202 
  """
23203 
 
23204 
  thrift_spec = (
23205 
    None, # 0
23206 
    (1, TType.MAP, 'amazonlisted', (TType.I64,None,TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 1
23207 
  )
23208 
 
23209 
  def __init__(self, amazonlisted=None,):
23210 
    self.amazonlisted = amazonlisted
23211 
 
23212 
  def read(self, iprot):
23213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23215 
      return
23216 
    iprot.readStructBegin()
23217 
    while True:
23218 
      (fname, ftype, fid) = iprot.readFieldBegin()
23219 
      if ftype == TType.STOP:
23220 
        break
23221 
      if fid == 1:
23222 
        if ftype == TType.MAP:
23223 
          self.amazonlisted = {}
9155 kshitij.so 23224 
          (_ktype482, _vtype483, _size481 ) = iprot.readMapBegin()
23225 
          for _i485 in xrange(_size481):
23226 
            _key486 = iprot.readI64();
23227 
            _val487 = Amazonlisted()
23228 
            _val487.read(iprot)
23229 
            self.amazonlisted[_key486] = _val487
8168 kshitij.so 23230 
          iprot.readMapEnd()
23231 
        else:
23232 
          iprot.skip(ftype)
23233 
      else:
23234 
        iprot.skip(ftype)
23235 
      iprot.readFieldEnd()
23236 
    iprot.readStructEnd()
23237 
 
23238 
  def write(self, oprot):
23239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23241 
      return
23242 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_args')
23243 
    if self.amazonlisted is not None:
23244 
      oprot.writeFieldBegin('amazonlisted', TType.MAP, 1)
23245 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.amazonlisted))
9155 kshitij.so 23246 
      for kiter488,viter489 in self.amazonlisted.items():
23247 
        oprot.writeI64(kiter488)
23248 
        viter489.write(oprot)
8168 kshitij.so 23249 
      oprot.writeMapEnd()
23250 
      oprot.writeFieldEnd()
23251 
    oprot.writeFieldStop()
23252 
    oprot.writeStructEnd()
23253 
 
23254 
  def validate(self):
23255 
    return
23256 
 
23257 
 
23258 
  def __repr__(self):
23259 
    L = ['%s=%r' % (key, value)
23260 
      for key, value in self.__dict__.iteritems()]
23261 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23262 
 
23263 
  def __eq__(self, other):
23264 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23265 
 
23266 
  def __ne__(self, other):
23267 
    return not (self == other)
23268 
 
23269 
class updateAmazonAttributesInBulk_result:
23270 
  """
23271 
  Attributes:
23272 
   - success
23273 
  """
23274 
 
23275 
  thrift_spec = (
23276 
    (0, TType.BOOL, 'success', None, None, ), # 0
23277 
  )
23278 
 
23279 
  def __init__(self, success=None,):
23280 
    self.success = success
23281 
 
23282 
  def read(self, iprot):
23283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23285 
      return
23286 
    iprot.readStructBegin()
23287 
    while True:
23288 
      (fname, ftype, fid) = iprot.readFieldBegin()
23289 
      if ftype == TType.STOP:
23290 
        break
23291 
      if fid == 0:
23292 
        if ftype == TType.BOOL:
23293 
          self.success = iprot.readBool();
23294 
        else:
23295 
          iprot.skip(ftype)
23296 
      else:
23297 
        iprot.skip(ftype)
23298 
      iprot.readFieldEnd()
23299 
    iprot.readStructEnd()
23300 
 
23301 
  def write(self, oprot):
23302 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23303 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23304 
      return
23305 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_result')
23306 
    if self.success is not None:
23307 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
23308 
      oprot.writeBool(self.success)
23309 
      oprot.writeFieldEnd()
23310 
    oprot.writeFieldStop()
23311 
    oprot.writeStructEnd()
23312 
 
23313 
  def validate(self):
23314 
    return
23315 
 
23316 
 
23317 
  def __repr__(self):
23318 
    L = ['%s=%r' % (key, value)
23319 
      for key, value in self.__dict__.iteritems()]
23320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23321 
 
23322 
  def __eq__(self, other):
23323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23324 
 
23325 
  def __ne__(self, other):
23326 
    return not (self == other)
8379 vikram.rag 23327 
 
23328 
class getAllItemstoListOnFba_args:
23329 
 
23330 
  thrift_spec = (
23331 
  )
23332 
 
23333 
  def read(self, iprot):
23334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23336 
      return
23337 
    iprot.readStructBegin()
23338 
    while True:
23339 
      (fname, ftype, fid) = iprot.readFieldBegin()
23340 
      if ftype == TType.STOP:
23341 
        break
23342 
      else:
23343 
        iprot.skip(ftype)
23344 
      iprot.readFieldEnd()
23345 
    iprot.readStructEnd()
23346 
 
23347 
  def write(self, oprot):
23348 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23349 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23350 
      return
23351 
    oprot.writeStructBegin('getAllItemstoListOnFba_args')
23352 
    oprot.writeFieldStop()
23353 
    oprot.writeStructEnd()
23354 
 
23355 
  def validate(self):
23356 
    return
23357 
 
23358 
 
23359 
  def __repr__(self):
23360 
    L = ['%s=%r' % (key, value)
23361 
      for key, value in self.__dict__.iteritems()]
23362 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23363 
 
23364 
  def __eq__(self, other):
23365 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23366 
 
23367 
  def __ne__(self, other):
23368 
    return not (self == other)
23369 
 
23370 
class getAllItemstoListOnFba_result:
23371 
  """
23372 
  Attributes:
23373 
   - success
23374 
  """
23375 
 
23376 
  thrift_spec = (
23377 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
23378 
  )
23379 
 
23380 
  def __init__(self, success=None,):
23381 
    self.success = success
23382 
 
23383 
  def read(self, iprot):
23384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23386 
      return
23387 
    iprot.readStructBegin()
23388 
    while True:
23389 
      (fname, ftype, fid) = iprot.readFieldBegin()
23390 
      if ftype == TType.STOP:
23391 
        break
23392 
      if fid == 0:
23393 
        if ftype == TType.LIST:
23394 
          self.success = []
9155 kshitij.so 23395 
          (_etype493, _size490) = iprot.readListBegin()
23396 
          for _i494 in xrange(_size490):
23397 
            _elem495 = Amazonlisted()
23398 
            _elem495.read(iprot)
23399 
            self.success.append(_elem495)
8379 vikram.rag 23400 
          iprot.readListEnd()
23401 
        else:
23402 
          iprot.skip(ftype)
23403 
      else:
23404 
        iprot.skip(ftype)
23405 
      iprot.readFieldEnd()
23406 
    iprot.readStructEnd()
23407 
 
23408 
  def write(self, oprot):
23409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23411 
      return
23412 
    oprot.writeStructBegin('getAllItemstoListOnFba_result')
23413 
    if self.success is not None:
23414 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23415 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 23416 
      for iter496 in self.success:
23417 
        iter496.write(oprot)
8379 vikram.rag 23418 
      oprot.writeListEnd()
23419 
      oprot.writeFieldEnd()
23420 
    oprot.writeFieldStop()
23421 
    oprot.writeStructEnd()
23422 
 
23423 
  def validate(self):
23424 
    return
23425 
 
23426 
 
23427 
  def __repr__(self):
23428 
    L = ['%s=%r' % (key, value)
23429 
      for key, value in self.__dict__.iteritems()]
23430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23431 
 
23432 
  def __eq__(self, other):
23433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23434 
 
23435 
  def __ne__(self, other):
23436 
    return not (self == other)
23437 
 
23438 
class getAllItemstoListOnNonFba_args:
23439 
 
23440 
  thrift_spec = (
23441 
  )
23442 
 
23443 
  def read(self, iprot):
23444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23446 
      return
23447 
    iprot.readStructBegin()
23448 
    while True:
23449 
      (fname, ftype, fid) = iprot.readFieldBegin()
23450 
      if ftype == TType.STOP:
23451 
        break
23452 
      else:
23453 
        iprot.skip(ftype)
23454 
      iprot.readFieldEnd()
23455 
    iprot.readStructEnd()
23456 
 
23457 
  def write(self, oprot):
23458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23460 
      return
23461 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_args')
23462 
    oprot.writeFieldStop()
23463 
    oprot.writeStructEnd()
23464 
 
23465 
  def validate(self):
23466 
    return
23467 
 
23468 
 
23469 
  def __repr__(self):
23470 
    L = ['%s=%r' % (key, value)
23471 
      for key, value in self.__dict__.iteritems()]
23472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23473 
 
23474 
  def __eq__(self, other):
23475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23476 
 
23477 
  def __ne__(self, other):
23478 
    return not (self == other)
23479 
 
23480 
class getAllItemstoListOnNonFba_result:
23481 
  """
23482 
  Attributes:
23483 
   - success
23484 
  """
23485 
 
23486 
  thrift_spec = (
23487 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
23488 
  )
23489 
 
23490 
  def __init__(self, success=None,):
23491 
    self.success = success
23492 
 
23493 
  def read(self, iprot):
23494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23496 
      return
23497 
    iprot.readStructBegin()
23498 
    while True:
23499 
      (fname, ftype, fid) = iprot.readFieldBegin()
23500 
      if ftype == TType.STOP:
23501 
        break
23502 
      if fid == 0:
23503 
        if ftype == TType.LIST:
23504 
          self.success = []
9155 kshitij.so 23505 
          (_etype500, _size497) = iprot.readListBegin()
23506 
          for _i501 in xrange(_size497):
23507 
            _elem502 = Amazonlisted()
23508 
            _elem502.read(iprot)
23509 
            self.success.append(_elem502)
8379 vikram.rag 23510 
          iprot.readListEnd()
23511 
        else:
23512 
          iprot.skip(ftype)
23513 
      else:
23514 
        iprot.skip(ftype)
23515 
      iprot.readFieldEnd()
23516 
    iprot.readStructEnd()
23517 
 
23518 
  def write(self, oprot):
23519 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23520 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23521 
      return
23522 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_result')
23523 
    if self.success is not None:
23524 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23525 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 23526 
      for iter503 in self.success:
23527 
        iter503.write(oprot)
8379 vikram.rag 23528 
      oprot.writeListEnd()
23529 
      oprot.writeFieldEnd()
23530 
    oprot.writeFieldStop()
23531 
    oprot.writeStructEnd()
23532 
 
23533 
  def validate(self):
23534 
    return
23535 
 
23536 
 
23537 
  def __repr__(self):
23538 
    L = ['%s=%r' % (key, value)
23539 
      for key, value in self.__dict__.iteritems()]
23540 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23541 
 
23542 
  def __eq__(self, other):
23543 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23544 
 
23545 
  def __ne__(self, other):
23546 
    return not (self == other)
8616 vikram.rag 23547 
 
9242 kshitij.so 23548 
class updateAsin_args:
23549 
  """
23550 
  Attributes:
23551 
   - item
23552 
  """
8616 vikram.rag 23553 
 
23554 
  thrift_spec = (
9242 kshitij.so 23555 
    None, # 0
23556 
    (1, TType.MAP, 'item', (TType.I64,None,TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 1
8616 vikram.rag 23557 
  )
23558 
 
9242 kshitij.so 23559 
  def __init__(self, item=None,):
23560 
    self.item = item
23561 
 
8616 vikram.rag 23562 
  def read(self, iprot):
23563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23565 
      return
23566 
    iprot.readStructBegin()
23567 
    while True:
23568 
      (fname, ftype, fid) = iprot.readFieldBegin()
23569 
      if ftype == TType.STOP:
23570 
        break
9242 kshitij.so 23571 
      if fid == 1:
23572 
        if ftype == TType.MAP:
23573 
          self.item = {}
23574 
          (_ktype505, _vtype506, _size504 ) = iprot.readMapBegin()
23575 
          for _i508 in xrange(_size504):
23576 
            _key509 = iprot.readI64();
23577 
            _val510 = Item()
23578 
            _val510.read(iprot)
23579 
            self.item[_key509] = _val510
23580 
          iprot.readMapEnd()
23581 
        else:
23582 
          iprot.skip(ftype)
8616 vikram.rag 23583 
      else:
23584 
        iprot.skip(ftype)
23585 
      iprot.readFieldEnd()
23586 
    iprot.readStructEnd()
23587 
 
23588 
  def write(self, oprot):
23589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23591 
      return
9242 kshitij.so 23592 
    oprot.writeStructBegin('updateAsin_args')
23593 
    if self.item is not None:
23594 
      oprot.writeFieldBegin('item', TType.MAP, 1)
23595 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.item))
23596 
      for kiter511,viter512 in self.item.items():
23597 
        oprot.writeI64(kiter511)
23598 
        viter512.write(oprot)
23599 
      oprot.writeMapEnd()
23600 
      oprot.writeFieldEnd()
8616 vikram.rag 23601 
    oprot.writeFieldStop()
23602 
    oprot.writeStructEnd()
23603 
 
23604 
  def validate(self):
23605 
    return
23606 
 
23607 
 
23608 
  def __repr__(self):
23609 
    L = ['%s=%r' % (key, value)
23610 
      for key, value in self.__dict__.iteritems()]
23611 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23612 
 
23613 
  def __eq__(self, other):
23614 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23615 
 
23616 
  def __ne__(self, other):
23617 
    return not (self == other)
23618 
 
9242 kshitij.so 23619 
class updateAsin_result:
8616 vikram.rag 23620 
 
23621 
  thrift_spec = (
23622 
  )
23623 
 
23624 
  def read(self, iprot):
23625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23627 
      return
23628 
    iprot.readStructBegin()
23629 
    while True:
23630 
      (fname, ftype, fid) = iprot.readFieldBegin()
23631 
      if ftype == TType.STOP:
23632 
        break
23633 
      else:
23634 
        iprot.skip(ftype)
23635 
      iprot.readFieldEnd()
23636 
    iprot.readStructEnd()
23637 
 
23638 
  def write(self, oprot):
23639 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23640 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23641 
      return
9242 kshitij.so 23642 
    oprot.writeStructBegin('updateAsin_result')
8616 vikram.rag 23643 
    oprot.writeFieldStop()
23644 
    oprot.writeStructEnd()
23645 
 
23646 
  def validate(self):
23647 
    return
23648 
 
23649 
 
23650 
  def __repr__(self):
23651 
    L = ['%s=%r' % (key, value)
23652 
      for key, value in self.__dict__.iteritems()]
23653 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23654 
 
23655 
  def __eq__(self, other):
23656 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23657 
 
23658 
  def __ne__(self, other):
23659 
    return not (self == other)
8619 kshitij.so 23660 
 
9242 kshitij.so 23661 
class addOrUpdateSnapdealItem_args:
8619 kshitij.so 23662 
  """
23663 
  Attributes:
9242 kshitij.so 23664 
   - snapdealitem
8619 kshitij.so 23665 
  """
23666 
 
9242 kshitij.so 23667 
  thrift_spec = None
23668 
  def __init__(self, snapdealitem=None,):
23669 
    self.snapdealitem = snapdealitem
8619 kshitij.so 23670 
 
23671 
  def read(self, iprot):
23672 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23673 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23674 
      return
23675 
    iprot.readStructBegin()
23676 
    while True:
23677 
      (fname, ftype, fid) = iprot.readFieldBegin()
23678 
      if ftype == TType.STOP:
23679 
        break
9242 kshitij.so 23680 
      if fid == -1:
23681 
        if ftype == TType.STRUCT:
23682 
          self.snapdealitem = SnapdealItem()
23683 
          self.snapdealitem.read(iprot)
8619 kshitij.so 23684 
        else:
23685 
          iprot.skip(ftype)
23686 
      else:
23687 
        iprot.skip(ftype)
23688 
      iprot.readFieldEnd()
23689 
    iprot.readStructEnd()
23690 
 
23691 
  def write(self, oprot):
23692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23694 
      return
9242 kshitij.so 23695 
    oprot.writeStructBegin('addOrUpdateSnapdealItem_args')
23696 
    if self.snapdealitem is not None:
23697 
      oprot.writeFieldBegin('snapdealitem', TType.STRUCT, -1)
23698 
      self.snapdealitem.write(oprot)
8619 kshitij.so 23699 
      oprot.writeFieldEnd()
23700 
    oprot.writeFieldStop()
23701 
    oprot.writeStructEnd()
23702 
 
23703 
  def validate(self):
23704 
    return
23705 
 
23706 
 
23707 
  def __repr__(self):
23708 
    L = ['%s=%r' % (key, value)
23709 
      for key, value in self.__dict__.iteritems()]
23710 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23711 
 
23712 
  def __eq__(self, other):
23713 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23714 
 
23715 
  def __ne__(self, other):
23716 
    return not (self == other)
23717 
 
9242 kshitij.so 23718 
class addOrUpdateSnapdealItem_result:
23719 
  """
23720 
  Attributes:
23721 
   - success
23722 
  """
8619 kshitij.so 23723 
 
23724 
  thrift_spec = (
9242 kshitij.so 23725 
    (0, TType.BOOL, 'success', None, None, ), # 0
8619 kshitij.so 23726 
  )
23727 
 
9242 kshitij.so 23728 
  def __init__(self, success=None,):
23729 
    self.success = success
23730 
 
8619 kshitij.so 23731 
  def read(self, iprot):
23732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23734 
      return
23735 
    iprot.readStructBegin()
23736 
    while True:
23737 
      (fname, ftype, fid) = iprot.readFieldBegin()
23738 
      if ftype == TType.STOP:
23739 
        break
9242 kshitij.so 23740 
      if fid == 0:
23741 
        if ftype == TType.BOOL:
23742 
          self.success = iprot.readBool();
23743 
        else:
23744 
          iprot.skip(ftype)
8619 kshitij.so 23745 
      else:
23746 
        iprot.skip(ftype)
23747 
      iprot.readFieldEnd()
23748 
    iprot.readStructEnd()
23749 
 
23750 
  def write(self, oprot):
23751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23753 
      return
9242 kshitij.so 23754 
    oprot.writeStructBegin('addOrUpdateSnapdealItem_result')
23755 
    if self.success is not None:
23756 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
23757 
      oprot.writeBool(self.success)
23758 
      oprot.writeFieldEnd()
8619 kshitij.so 23759 
    oprot.writeFieldStop()
23760 
    oprot.writeStructEnd()
23761 
 
23762 
  def validate(self):
23763 
    return
23764 
 
23765 
 
23766 
  def __repr__(self):
23767 
    L = ['%s=%r' % (key, value)
23768 
      for key, value in self.__dict__.iteritems()]
23769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23770 
 
23771 
  def __eq__(self, other):
23772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23773 
 
23774 
  def __ne__(self, other):
23775 
    return not (self == other)
8739 vikram.rag 23776 
 
9242 kshitij.so 23777 
class getSnapdealItem_args:
8739 vikram.rag 23778 
  """
23779 
  Attributes:
9242 kshitij.so 23780 
   - item_id
8739 vikram.rag 23781 
  """
23782 
 
9242 kshitij.so 23783 
  thrift_spec = (
23784 
    None, # 0
23785 
    (1, TType.I64, 'item_id', None, None, ), # 1
23786 
  )
8739 vikram.rag 23787 
 
9242 kshitij.so 23788 
  def __init__(self, item_id=None,):
23789 
    self.item_id = item_id
23790 
 
8739 vikram.rag 23791 
  def read(self, iprot):
23792 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23793 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23794 
      return
23795 
    iprot.readStructBegin()
23796 
    while True:
23797 
      (fname, ftype, fid) = iprot.readFieldBegin()
23798 
      if ftype == TType.STOP:
23799 
        break
9242 kshitij.so 23800 
      if fid == 1:
23801 
        if ftype == TType.I64:
23802 
          self.item_id = iprot.readI64();
8739 vikram.rag 23803 
        else:
23804 
          iprot.skip(ftype)
23805 
      else:
23806 
        iprot.skip(ftype)
23807 
      iprot.readFieldEnd()
23808 
    iprot.readStructEnd()
23809 
 
23810 
  def write(self, oprot):
23811 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23812 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23813 
      return
9242 kshitij.so 23814 
    oprot.writeStructBegin('getSnapdealItem_args')
23815 
    if self.item_id is not None:
23816 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
23817 
      oprot.writeI64(self.item_id)
8739 vikram.rag 23818 
      oprot.writeFieldEnd()
23819 
    oprot.writeFieldStop()
23820 
    oprot.writeStructEnd()
23821 
 
23822 
  def validate(self):
23823 
    return
23824 
 
23825 
 
23826 
  def __repr__(self):
23827 
    L = ['%s=%r' % (key, value)
23828 
      for key, value in self.__dict__.iteritems()]
23829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23830 
 
23831 
  def __eq__(self, other):
23832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23833 
 
23834 
  def __ne__(self, other):
23835 
    return not (self == other)
23836 
 
9242 kshitij.so 23837 
class getSnapdealItem_result:
8739 vikram.rag 23838 
  """
23839 
  Attributes:
23840 
   - success
23841 
  """
23842 
 
23843 
  thrift_spec = (
9242 kshitij.so 23844 
    (0, TType.STRUCT, 'success', (SnapdealItem, SnapdealItem.thrift_spec), None, ), # 0
8739 vikram.rag 23845 
  )
23846 
 
23847 
  def __init__(self, success=None,):
23848 
    self.success = success
23849 
 
23850 
  def read(self, iprot):
23851 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23852 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23853 
      return
23854 
    iprot.readStructBegin()
23855 
    while True:
23856 
      (fname, ftype, fid) = iprot.readFieldBegin()
23857 
      if ftype == TType.STOP:
23858 
        break
23859 
      if fid == 0:
9242 kshitij.so 23860 
        if ftype == TType.STRUCT:
23861 
          self.success = SnapdealItem()
23862 
          self.success.read(iprot)
8739 vikram.rag 23863 
        else:
23864 
          iprot.skip(ftype)
23865 
      else:
23866 
        iprot.skip(ftype)
23867 
      iprot.readFieldEnd()
23868 
    iprot.readStructEnd()
23869 
 
23870 
  def write(self, oprot):
23871 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23872 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23873 
      return
9242 kshitij.so 23874 
    oprot.writeStructBegin('getSnapdealItem_result')
8739 vikram.rag 23875 
    if self.success is not None:
9242 kshitij.so 23876 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23877 
      self.success.write(oprot)
8739 vikram.rag 23878 
      oprot.writeFieldEnd()
23879 
    oprot.writeFieldStop()
23880 
    oprot.writeStructEnd()
23881 
 
23882 
  def validate(self):
23883 
    return
23884 
 
23885 
 
23886 
  def __repr__(self):
23887 
    L = ['%s=%r' % (key, value)
23888 
      for key, value in self.__dict__.iteritems()]
23889 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23890 
 
23891 
  def __eq__(self, other):
23892 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23893 
 
23894 
  def __ne__(self, other):
23895 
    return not (self == other)
23896 
 
9242 kshitij.so 23897 
class getSnapdealItemDetails_args:
8739 vikram.rag 23898 
  """
23899 
  Attributes:
23900 
   - item_id
23901 
  """
23902 
 
23903 
  thrift_spec = (
23904 
    None, # 0
23905 
    (1, TType.I64, 'item_id', None, None, ), # 1
23906 
  )
23907 
 
23908 
  def __init__(self, item_id=None,):
23909 
    self.item_id = item_id
23910 
 
23911 
  def read(self, iprot):
23912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23914 
      return
23915 
    iprot.readStructBegin()
23916 
    while True:
23917 
      (fname, ftype, fid) = iprot.readFieldBegin()
23918 
      if ftype == TType.STOP:
23919 
        break
23920 
      if fid == 1:
23921 
        if ftype == TType.I64:
23922 
          self.item_id = iprot.readI64();
23923 
        else:
23924 
          iprot.skip(ftype)
23925 
      else:
23926 
        iprot.skip(ftype)
23927 
      iprot.readFieldEnd()
23928 
    iprot.readStructEnd()
23929 
 
23930 
  def write(self, oprot):
23931 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23932 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23933 
      return
9242 kshitij.so 23934 
    oprot.writeStructBegin('getSnapdealItemDetails_args')
8739 vikram.rag 23935 
    if self.item_id is not None:
23936 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
23937 
      oprot.writeI64(self.item_id)
23938 
      oprot.writeFieldEnd()
23939 
    oprot.writeFieldStop()
23940 
    oprot.writeStructEnd()
23941 
 
23942 
  def validate(self):
23943 
    return
23944 
 
23945 
 
23946 
  def __repr__(self):
23947 
    L = ['%s=%r' % (key, value)
23948 
      for key, value in self.__dict__.iteritems()]
23949 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23950 
 
23951 
  def __eq__(self, other):
23952 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23953 
 
23954 
  def __ne__(self, other):
23955 
    return not (self == other)
23956 
 
9242 kshitij.so 23957 
class getSnapdealItemDetails_result:
8739 vikram.rag 23958 
  """
23959 
  Attributes:
23960 
   - success
23961 
  """
23962 
 
23963 
  thrift_spec = (
9242 kshitij.so 23964 
    (0, TType.STRUCT, 'success', (SnapdealItemDetails, SnapdealItemDetails.thrift_spec), None, ), # 0
8739 vikram.rag 23965 
  )
23966 
 
23967 
  def __init__(self, success=None,):
23968 
    self.success = success
23969 
 
23970 
  def read(self, iprot):
23971 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23972 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23973 
      return
23974 
    iprot.readStructBegin()
23975 
    while True:
23976 
      (fname, ftype, fid) = iprot.readFieldBegin()
23977 
      if ftype == TType.STOP:
23978 
        break
23979 
      if fid == 0:
23980 
        if ftype == TType.STRUCT:
9242 kshitij.so 23981 
          self.success = SnapdealItemDetails()
8739 vikram.rag 23982 
          self.success.read(iprot)
23983 
        else:
23984 
          iprot.skip(ftype)
23985 
      else:
23986 
        iprot.skip(ftype)
23987 
      iprot.readFieldEnd()
23988 
    iprot.readStructEnd()
23989 
 
23990 
  def write(self, oprot):
23991 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23992 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23993 
      return
9242 kshitij.so 23994 
    oprot.writeStructBegin('getSnapdealItemDetails_result')
8739 vikram.rag 23995 
    if self.success is not None:
23996 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23997 
      self.success.write(oprot)
23998 
      oprot.writeFieldEnd()
23999 
    oprot.writeFieldStop()
24000 
    oprot.writeStructEnd()
24001 
 
24002 
  def validate(self):
24003 
    return
24004 
 
24005 
 
24006 
  def __repr__(self):
24007 
    L = ['%s=%r' % (key, value)
24008 
      for key, value in self.__dict__.iteritems()]
24009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24010 
 
24011 
  def __eq__(self, other):
24012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24013 
 
24014 
  def __ne__(self, other):
24015 
    return not (self == other)
24016 
 
24017 
class getAllSnapdealItems_args:
24018 
 
24019 
  thrift_spec = (
24020 
  )
24021 
 
24022 
  def read(self, iprot):
24023 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24024 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24025 
      return
24026 
    iprot.readStructBegin()
24027 
    while True:
24028 
      (fname, ftype, fid) = iprot.readFieldBegin()
24029 
      if ftype == TType.STOP:
24030 
        break
24031 
      else:
24032 
        iprot.skip(ftype)
24033 
      iprot.readFieldEnd()
24034 
    iprot.readStructEnd()
24035 
 
24036 
  def write(self, oprot):
24037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24039 
      return
24040 
    oprot.writeStructBegin('getAllSnapdealItems_args')
24041 
    oprot.writeFieldStop()
24042 
    oprot.writeStructEnd()
24043 
 
24044 
  def validate(self):
24045 
    return
24046 
 
24047 
 
24048 
  def __repr__(self):
24049 
    L = ['%s=%r' % (key, value)
24050 
      for key, value in self.__dict__.iteritems()]
24051 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24052 
 
24053 
  def __eq__(self, other):
24054 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24055 
 
24056 
  def __ne__(self, other):
24057 
    return not (self == other)
24058 
 
24059 
class getAllSnapdealItems_result:
24060 
  """
24061 
  Attributes:
24062 
   - success
24063 
  """
24064 
 
24065 
  thrift_spec = (
9242 kshitij.so 24066 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
8739 vikram.rag 24067 
  )
24068 
 
24069 
  def __init__(self, success=None,):
24070 
    self.success = success
24071 
 
24072 
  def read(self, iprot):
24073 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24074 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24075 
      return
24076 
    iprot.readStructBegin()
24077 
    while True:
24078 
      (fname, ftype, fid) = iprot.readFieldBegin()
24079 
      if ftype == TType.STOP:
24080 
        break
24081 
      if fid == 0:
24082 
        if ftype == TType.LIST:
24083 
          self.success = []
9242 kshitij.so 24084 
          (_etype516, _size513) = iprot.readListBegin()
24085 
          for _i517 in xrange(_size513):
24086 
            _elem518 = SnapdealItemDetails()
24087 
            _elem518.read(iprot)
24088 
            self.success.append(_elem518)
24089 
          iprot.readListEnd()
24090 
        else:
24091 
          iprot.skip(ftype)
24092 
      else:
24093 
        iprot.skip(ftype)
24094 
      iprot.readFieldEnd()
24095 
    iprot.readStructEnd()
24096 
 
24097 
  def write(self, oprot):
24098 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24099 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24100 
      return
24101 
    oprot.writeStructBegin('getAllSnapdealItems_result')
24102 
    if self.success is not None:
24103 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24104 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
24105 
      for iter519 in self.success:
24106 
        iter519.write(oprot)
24107 
      oprot.writeListEnd()
24108 
      oprot.writeFieldEnd()
24109 
    oprot.writeFieldStop()
24110 
    oprot.writeStructEnd()
24111 
 
24112 
  def validate(self):
24113 
    return
24114 
 
24115 
 
24116 
  def __repr__(self):
24117 
    L = ['%s=%r' % (key, value)
24118 
      for key, value in self.__dict__.iteritems()]
24119 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24120 
 
24121 
  def __eq__(self, other):
24122 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24123 
 
24124 
  def __ne__(self, other):
24125 
    return not (self == other)
24126 
 
24127 
class getSnapdealItems_args:
24128 
  """
24129 
  Attributes:
24130 
   - offset
24131 
   - limit
24132 
  """
24133 
 
24134 
  thrift_spec = (
24135 
    None, # 0
24136 
    (1, TType.I64, 'offset', None, None, ), # 1
24137 
    (2, TType.I64, 'limit', None, None, ), # 2
24138 
  )
24139 
 
24140 
  def __init__(self, offset=None, limit=None,):
24141 
    self.offset = offset
24142 
    self.limit = limit
24143 
 
24144 
  def read(self, iprot):
24145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24147 
      return
24148 
    iprot.readStructBegin()
24149 
    while True:
24150 
      (fname, ftype, fid) = iprot.readFieldBegin()
24151 
      if ftype == TType.STOP:
24152 
        break
24153 
      if fid == 1:
24154 
        if ftype == TType.I64:
24155 
          self.offset = iprot.readI64();
24156 
        else:
24157 
          iprot.skip(ftype)
24158 
      elif fid == 2:
24159 
        if ftype == TType.I64:
24160 
          self.limit = iprot.readI64();
24161 
        else:
24162 
          iprot.skip(ftype)
24163 
      else:
24164 
        iprot.skip(ftype)
24165 
      iprot.readFieldEnd()
24166 
    iprot.readStructEnd()
24167 
 
24168 
  def write(self, oprot):
24169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24171 
      return
24172 
    oprot.writeStructBegin('getSnapdealItems_args')
24173 
    if self.offset is not None:
24174 
      oprot.writeFieldBegin('offset', TType.I64, 1)
24175 
      oprot.writeI64(self.offset)
24176 
      oprot.writeFieldEnd()
24177 
    if self.limit is not None:
24178 
      oprot.writeFieldBegin('limit', TType.I64, 2)
24179 
      oprot.writeI64(self.limit)
24180 
      oprot.writeFieldEnd()
24181 
    oprot.writeFieldStop()
24182 
    oprot.writeStructEnd()
24183 
 
24184 
  def validate(self):
24185 
    return
24186 
 
24187 
 
24188 
  def __repr__(self):
24189 
    L = ['%s=%r' % (key, value)
24190 
      for key, value in self.__dict__.iteritems()]
24191 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24192 
 
24193 
  def __eq__(self, other):
24194 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24195 
 
24196 
  def __ne__(self, other):
24197 
    return not (self == other)
24198 
 
24199 
class getSnapdealItems_result:
24200 
  """
24201 
  Attributes:
24202 
   - success
24203 
  """
24204 
 
24205 
  thrift_spec = (
24206 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
24207 
  )
24208 
 
24209 
  def __init__(self, success=None,):
24210 
    self.success = success
24211 
 
24212 
  def read(self, iprot):
24213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24215 
      return
24216 
    iprot.readStructBegin()
24217 
    while True:
24218 
      (fname, ftype, fid) = iprot.readFieldBegin()
24219 
      if ftype == TType.STOP:
24220 
        break
24221 
      if fid == 0:
24222 
        if ftype == TType.LIST:
24223 
          self.success = []
9155 kshitij.so 24224 
          (_etype523, _size520) = iprot.readListBegin()
24225 
          for _i524 in xrange(_size520):
9242 kshitij.so 24226 
            _elem525 = SnapdealItemDetails()
9155 kshitij.so 24227 
            _elem525.read(iprot)
24228 
            self.success.append(_elem525)
8739 vikram.rag 24229 
          iprot.readListEnd()
24230 
        else:
24231 
          iprot.skip(ftype)
24232 
      else:
24233 
        iprot.skip(ftype)
24234 
      iprot.readFieldEnd()
24235 
    iprot.readStructEnd()
24236 
 
24237 
  def write(self, oprot):
24238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24240 
      return
9242 kshitij.so 24241 
    oprot.writeStructBegin('getSnapdealItems_result')
8739 vikram.rag 24242 
    if self.success is not None:
24243 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24244 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 24245 
      for iter526 in self.success:
24246 
        iter526.write(oprot)
8739 vikram.rag 24247 
      oprot.writeListEnd()
24248 
      oprot.writeFieldEnd()
24249 
    oprot.writeFieldStop()
24250 
    oprot.writeStructEnd()
24251 
 
24252 
  def validate(self):
24253 
    return
24254 
 
24255 
 
24256 
  def __repr__(self):
24257 
    L = ['%s=%r' % (key, value)
24258 
      for key, value in self.__dict__.iteritems()]
24259 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24260 
 
24261 
  def __eq__(self, other):
24262 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24263 
 
24264 
  def __ne__(self, other):
24265 
    return not (self == other)
9242 kshitij.so 24266 
 
24267 
class searchSnapdealItems_args:
24268 
  """
24269 
  Attributes:
24270 
   - searchTerm
24271 
   - offset
24272 
   - limit
24273 
  """
24274 
 
24275 
  thrift_spec = (
24276 
    None, # 0
24277 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
24278 
    (2, TType.I64, 'offset', None, None, ), # 2
24279 
    (3, TType.I64, 'limit', None, None, ), # 3
24280 
  )
24281 
 
24282 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
24283 
    self.searchTerm = searchTerm
24284 
    self.offset = offset
24285 
    self.limit = limit
24286 
 
24287 
  def read(self, iprot):
24288 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24289 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24290 
      return
24291 
    iprot.readStructBegin()
24292 
    while True:
24293 
      (fname, ftype, fid) = iprot.readFieldBegin()
24294 
      if ftype == TType.STOP:
24295 
        break
24296 
      if fid == 1:
24297 
        if ftype == TType.LIST:
24298 
          self.searchTerm = []
24299 
          (_etype530, _size527) = iprot.readListBegin()
24300 
          for _i531 in xrange(_size527):
24301 
            _elem532 = iprot.readString();
24302 
            self.searchTerm.append(_elem532)
24303 
          iprot.readListEnd()
24304 
        else:
24305 
          iprot.skip(ftype)
24306 
      elif fid == 2:
24307 
        if ftype == TType.I64:
24308 
          self.offset = iprot.readI64();
24309 
        else:
24310 
          iprot.skip(ftype)
24311 
      elif fid == 3:
24312 
        if ftype == TType.I64:
24313 
          self.limit = iprot.readI64();
24314 
        else:
24315 
          iprot.skip(ftype)
24316 
      else:
24317 
        iprot.skip(ftype)
24318 
      iprot.readFieldEnd()
24319 
    iprot.readStructEnd()
24320 
 
24321 
  def write(self, oprot):
24322 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24323 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24324 
      return
24325 
    oprot.writeStructBegin('searchSnapdealItems_args')
24326 
    if self.searchTerm is not None:
24327 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
24328 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
24329 
      for iter533 in self.searchTerm:
24330 
        oprot.writeString(iter533)
24331 
      oprot.writeListEnd()
24332 
      oprot.writeFieldEnd()
24333 
    if self.offset is not None:
24334 
      oprot.writeFieldBegin('offset', TType.I64, 2)
24335 
      oprot.writeI64(self.offset)
24336 
      oprot.writeFieldEnd()
24337 
    if self.limit is not None:
24338 
      oprot.writeFieldBegin('limit', TType.I64, 3)
24339 
      oprot.writeI64(self.limit)
24340 
      oprot.writeFieldEnd()
24341 
    oprot.writeFieldStop()
24342 
    oprot.writeStructEnd()
24343 
 
24344 
  def validate(self):
24345 
    return
24346 
 
24347 
 
24348 
  def __repr__(self):
24349 
    L = ['%s=%r' % (key, value)
24350 
      for key, value in self.__dict__.iteritems()]
24351 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24352 
 
24353 
  def __eq__(self, other):
24354 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24355 
 
24356 
  def __ne__(self, other):
24357 
    return not (self == other)
24358 
 
24359 
class searchSnapdealItems_result:
24360 
  """
24361 
  Attributes:
24362 
   - success
24363 
  """
24364 
 
24365 
  thrift_spec = (
24366 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
24367 
  )
24368 
 
24369 
  def __init__(self, success=None,):
24370 
    self.success = success
24371 
 
24372 
  def read(self, iprot):
24373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24375 
      return
24376 
    iprot.readStructBegin()
24377 
    while True:
24378 
      (fname, ftype, fid) = iprot.readFieldBegin()
24379 
      if ftype == TType.STOP:
24380 
        break
24381 
      if fid == 0:
24382 
        if ftype == TType.LIST:
24383 
          self.success = []
24384 
          (_etype537, _size534) = iprot.readListBegin()
24385 
          for _i538 in xrange(_size534):
24386 
            _elem539 = SnapdealItemDetails()
24387 
            _elem539.read(iprot)
24388 
            self.success.append(_elem539)
24389 
          iprot.readListEnd()
24390 
        else:
24391 
          iprot.skip(ftype)
24392 
      else:
24393 
        iprot.skip(ftype)
24394 
      iprot.readFieldEnd()
24395 
    iprot.readStructEnd()
24396 
 
24397 
  def write(self, oprot):
24398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24400 
      return
24401 
    oprot.writeStructBegin('searchSnapdealItems_result')
24402 
    if self.success is not None:
24403 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24404 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
24405 
      for iter540 in self.success:
24406 
        iter540.write(oprot)
24407 
      oprot.writeListEnd()
24408 
      oprot.writeFieldEnd()
24409 
    oprot.writeFieldStop()
24410 
    oprot.writeStructEnd()
24411 
 
24412 
  def validate(self):
24413 
    return
24414 
 
24415 
 
24416 
  def __repr__(self):
24417 
    L = ['%s=%r' % (key, value)
24418 
      for key, value in self.__dict__.iteritems()]
24419 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24420 
 
24421 
  def __eq__(self, other):
24422 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24423 
 
24424 
  def __ne__(self, other):
24425 
    return not (self == other)
24426 
 
24427 
class getCountForSnapdealItems_args:
24428 
 
24429 
  thrift_spec = (
24430 
  )
24431 
 
24432 
  def read(self, iprot):
24433 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24434 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24435 
      return
24436 
    iprot.readStructBegin()
24437 
    while True:
24438 
      (fname, ftype, fid) = iprot.readFieldBegin()
24439 
      if ftype == TType.STOP:
24440 
        break
24441 
      else:
24442 
        iprot.skip(ftype)
24443 
      iprot.readFieldEnd()
24444 
    iprot.readStructEnd()
24445 
 
24446 
  def write(self, oprot):
24447 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24448 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24449 
      return
24450 
    oprot.writeStructBegin('getCountForSnapdealItems_args')
24451 
    oprot.writeFieldStop()
24452 
    oprot.writeStructEnd()
24453 
 
24454 
  def validate(self):
24455 
    return
24456 
 
24457 
 
24458 
  def __repr__(self):
24459 
    L = ['%s=%r' % (key, value)
24460 
      for key, value in self.__dict__.iteritems()]
24461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24462 
 
24463 
  def __eq__(self, other):
24464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24465 
 
24466 
  def __ne__(self, other):
24467 
    return not (self == other)
24468 
 
24469 
class getCountForSnapdealItems_result:
24470 
  """
24471 
  Attributes:
24472 
   - success
24473 
  """
24474 
 
24475 
  thrift_spec = (
24476 
    (0, TType.I64, 'success', None, None, ), # 0
24477 
  )
24478 
 
24479 
  def __init__(self, success=None,):
24480 
    self.success = success
24481 
 
24482 
  def read(self, iprot):
24483 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24484 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24485 
      return
24486 
    iprot.readStructBegin()
24487 
    while True:
24488 
      (fname, ftype, fid) = iprot.readFieldBegin()
24489 
      if ftype == TType.STOP:
24490 
        break
24491 
      if fid == 0:
24492 
        if ftype == TType.I64:
24493 
          self.success = iprot.readI64();
24494 
        else:
24495 
          iprot.skip(ftype)
24496 
      else:
24497 
        iprot.skip(ftype)
24498 
      iprot.readFieldEnd()
24499 
    iprot.readStructEnd()
24500 
 
24501 
  def write(self, oprot):
24502 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24503 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24504 
      return
24505 
    oprot.writeStructBegin('getCountForSnapdealItems_result')
24506 
    if self.success is not None:
24507 
      oprot.writeFieldBegin('success', TType.I64, 0)
24508 
      oprot.writeI64(self.success)
24509 
      oprot.writeFieldEnd()
24510 
    oprot.writeFieldStop()
24511 
    oprot.writeStructEnd()
24512 
 
24513 
  def validate(self):
24514 
    return
24515 
 
24516 
 
24517 
  def __repr__(self):
24518 
    L = ['%s=%r' % (key, value)
24519 
      for key, value in self.__dict__.iteritems()]
24520 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24521 
 
24522 
  def __eq__(self, other):
24523 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24524 
 
24525 
  def __ne__(self, other):
24526 
    return not (self == other)
24527 
 
24528 
class getSnapdealSearchResultCount_args:
24529 
  """
24530 
  Attributes:
24531 
   - searchTerm
24532 
  """
24533 
 
24534 
  thrift_spec = (
24535 
    None, # 0
24536 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
24537 
  )
24538 
 
24539 
  def __init__(self, searchTerm=None,):
24540 
    self.searchTerm = searchTerm
24541 
 
24542 
  def read(self, iprot):
24543 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24544 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24545 
      return
24546 
    iprot.readStructBegin()
24547 
    while True:
24548 
      (fname, ftype, fid) = iprot.readFieldBegin()
24549 
      if ftype == TType.STOP:
24550 
        break
24551 
      if fid == 1:
24552 
        if ftype == TType.LIST:
24553 
          self.searchTerm = []
24554 
          (_etype544, _size541) = iprot.readListBegin()
24555 
          for _i545 in xrange(_size541):
24556 
            _elem546 = iprot.readString();
24557 
            self.searchTerm.append(_elem546)
24558 
          iprot.readListEnd()
24559 
        else:
24560 
          iprot.skip(ftype)
24561 
      else:
24562 
        iprot.skip(ftype)
24563 
      iprot.readFieldEnd()
24564 
    iprot.readStructEnd()
24565 
 
24566 
  def write(self, oprot):
24567 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24568 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24569 
      return
24570 
    oprot.writeStructBegin('getSnapdealSearchResultCount_args')
24571 
    if self.searchTerm is not None:
24572 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
24573 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
24574 
      for iter547 in self.searchTerm:
24575 
        oprot.writeString(iter547)
24576 
      oprot.writeListEnd()
24577 
      oprot.writeFieldEnd()
24578 
    oprot.writeFieldStop()
24579 
    oprot.writeStructEnd()
24580 
 
24581 
  def validate(self):
24582 
    return
24583 
 
24584 
 
24585 
  def __repr__(self):
24586 
    L = ['%s=%r' % (key, value)
24587 
      for key, value in self.__dict__.iteritems()]
24588 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24589 
 
24590 
  def __eq__(self, other):
24591 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24592 
 
24593 
  def __ne__(self, other):
24594 
    return not (self == other)
24595 
 
24596 
class getSnapdealSearchResultCount_result:
24597 
  """
24598 
  Attributes:
24599 
   - success
24600 
  """
24601 
 
24602 
  thrift_spec = (
24603 
    (0, TType.I64, 'success', None, None, ), # 0
24604 
  )
24605 
 
24606 
  def __init__(self, success=None,):
24607 
    self.success = success
24608 
 
24609 
  def read(self, iprot):
24610 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24611 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24612 
      return
24613 
    iprot.readStructBegin()
24614 
    while True:
24615 
      (fname, ftype, fid) = iprot.readFieldBegin()
24616 
      if ftype == TType.STOP:
24617 
        break
24618 
      if fid == 0:
24619 
        if ftype == TType.I64:
24620 
          self.success = iprot.readI64();
24621 
        else:
24622 
          iprot.skip(ftype)
24623 
      else:
24624 
        iprot.skip(ftype)
24625 
      iprot.readFieldEnd()
24626 
    iprot.readStructEnd()
24627 
 
24628 
  def write(self, oprot):
24629 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24630 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24631 
      return
24632 
    oprot.writeStructBegin('getSnapdealSearchResultCount_result')
24633 
    if self.success is not None:
24634 
      oprot.writeFieldBegin('success', TType.I64, 0)
24635 
      oprot.writeI64(self.success)
24636 
      oprot.writeFieldEnd()
24637 
    oprot.writeFieldStop()
24638 
    oprot.writeStructEnd()
24639 
 
24640 
  def validate(self):
24641 
    return
24642 
 
24643 
 
24644 
  def __repr__(self):
24645 
    L = ['%s=%r' % (key, value)
24646 
      for key, value in self.__dict__.iteritems()]
24647 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24648 
 
24649 
  def __eq__(self, other):
24650 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24651 
 
24652 
  def __ne__(self, other):
24653 
    return not (self == other)
9299 kshitij.so 24654 
 
24655 
class getPrefferedInsurerForItem_args:
24656 
  """
24657 
  Attributes:
24658 
   - itemId
24659 
   - insurerType
24660 
  """
24661 
 
24662 
  thrift_spec = (
24663 
    None, # 0
24664 
    (1, TType.I64, 'itemId', None, None, ), # 1
24665 
    (2, TType.I32, 'insurerType', None, None, ), # 2
24666 
  )
24667 
 
24668 
  def __init__(self, itemId=None, insurerType=None,):
24669 
    self.itemId = itemId
24670 
    self.insurerType = insurerType
24671 
 
24672 
  def read(self, iprot):
24673 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24674 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24675 
      return
24676 
    iprot.readStructBegin()
24677 
    while True:
24678 
      (fname, ftype, fid) = iprot.readFieldBegin()
24679 
      if ftype == TType.STOP:
24680 
        break
24681 
      if fid == 1:
24682 
        if ftype == TType.I64:
24683 
          self.itemId = iprot.readI64();
24684 
        else:
24685 
          iprot.skip(ftype)
24686 
      elif fid == 2:
24687 
        if ftype == TType.I32:
24688 
          self.insurerType = iprot.readI32();
24689 
        else:
24690 
          iprot.skip(ftype)
24691 
      else:
24692 
        iprot.skip(ftype)
24693 
      iprot.readFieldEnd()
24694 
    iprot.readStructEnd()
24695 
 
24696 
  def write(self, oprot):
24697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24699 
      return
24700 
    oprot.writeStructBegin('getPrefferedInsurerForItem_args')
24701 
    if self.itemId is not None:
24702 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
24703 
      oprot.writeI64(self.itemId)
24704 
      oprot.writeFieldEnd()
24705 
    if self.insurerType is not None:
24706 
      oprot.writeFieldBegin('insurerType', TType.I32, 2)
24707 
      oprot.writeI32(self.insurerType)
24708 
      oprot.writeFieldEnd()
24709 
    oprot.writeFieldStop()
24710 
    oprot.writeStructEnd()
24711 
 
24712 
  def validate(self):
24713 
    return
24714 
 
24715 
 
24716 
  def __repr__(self):
24717 
    L = ['%s=%r' % (key, value)
24718 
      for key, value in self.__dict__.iteritems()]
24719 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24720 
 
24721 
  def __eq__(self, other):
24722 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24723 
 
24724 
  def __ne__(self, other):
24725 
    return not (self == other)
24726 
 
24727 
class getPrefferedInsurerForItem_result:
24728 
  """
24729 
  Attributes:
24730 
   - success
24731 
  """
24732 
 
24733 
  thrift_spec = (
24734 
    (0, TType.I64, 'success', None, None, ), # 0
24735 
  )
24736 
 
24737 
  def __init__(self, success=None,):
24738 
    self.success = success
24739 
 
24740 
  def read(self, iprot):
24741 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24742 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24743 
      return
24744 
    iprot.readStructBegin()
24745 
    while True:
24746 
      (fname, ftype, fid) = iprot.readFieldBegin()
24747 
      if ftype == TType.STOP:
24748 
        break
24749 
      if fid == 0:
24750 
        if ftype == TType.I64:
24751 
          self.success = iprot.readI64();
24752 
        else:
24753 
          iprot.skip(ftype)
24754 
      else:
24755 
        iprot.skip(ftype)
24756 
      iprot.readFieldEnd()
24757 
    iprot.readStructEnd()
24758 
 
24759 
  def write(self, oprot):
24760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24762 
      return
24763 
    oprot.writeStructBegin('getPrefferedInsurerForItem_result')
24764 
    if self.success is not None:
24765 
      oprot.writeFieldBegin('success', TType.I64, 0)
24766 
      oprot.writeI64(self.success)
24767 
      oprot.writeFieldEnd()
24768 
    oprot.writeFieldStop()
24769 
    oprot.writeStructEnd()
24770 
 
24771 
  def validate(self):
24772 
    return
24773 
 
24774 
 
24775 
  def __repr__(self):
24776 
    L = ['%s=%r' % (key, value)
24777 
      for key, value in self.__dict__.iteritems()]
24778 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24779 
 
24780 
  def __eq__(self, other):
24781 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24782 
 
24783 
  def __ne__(self, other):
24784 
    return not (self == other)
9456 vikram.rag 24785 
 
24786 
class getSnapdealItembySkuAtSnapdeal_args:
24787 
  """
24788 
  Attributes:
24789 
   - skuAtSnapdeal
24790 
  """
24791 
 
24792 
  thrift_spec = None
24793 
  def __init__(self, skuAtSnapdeal=None,):
24794 
    self.skuAtSnapdeal = skuAtSnapdeal
24795 
 
24796 
  def read(self, iprot):
24797 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24798 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24799 
      return
24800 
    iprot.readStructBegin()
24801 
    while True:
24802 
      (fname, ftype, fid) = iprot.readFieldBegin()
24803 
      if ftype == TType.STOP:
24804 
        break
24805 
      if fid == -1:
24806 
        if ftype == TType.STRING:
24807 
          self.skuAtSnapdeal = iprot.readString();
24808 
        else:
24809 
          iprot.skip(ftype)
24810 
      else:
24811 
        iprot.skip(ftype)
24812 
      iprot.readFieldEnd()
24813 
    iprot.readStructEnd()
24814 
 
24815 
  def write(self, oprot):
24816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24818 
      return
24819 
    oprot.writeStructBegin('getSnapdealItembySkuAtSnapdeal_args')
24820 
    if self.skuAtSnapdeal is not None:
24821 
      oprot.writeFieldBegin('skuAtSnapdeal', TType.STRING, -1)
24822 
      oprot.writeString(self.skuAtSnapdeal)
24823 
      oprot.writeFieldEnd()
24824 
    oprot.writeFieldStop()
24825 
    oprot.writeStructEnd()
24826 
 
24827 
  def validate(self):
24828 
    return
24829 
 
24830 
 
24831 
  def __repr__(self):
24832 
    L = ['%s=%r' % (key, value)
24833 
      for key, value in self.__dict__.iteritems()]
24834 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24835 
 
24836 
  def __eq__(self, other):
24837 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24838 
 
24839 
  def __ne__(self, other):
24840 
    return not (self == other)
24841 
 
24842 
class getSnapdealItembySkuAtSnapdeal_result:
24843 
  """
24844 
  Attributes:
24845 
   - success
24846 
  """
24847 
 
24848 
  thrift_spec = (
24849 
    (0, TType.STRUCT, 'success', (SnapdealItem, SnapdealItem.thrift_spec), None, ), # 0
24850 
  )
24851 
 
24852 
  def __init__(self, success=None,):
24853 
    self.success = success
24854 
 
24855 
  def read(self, iprot):
24856 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24857 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24858 
      return
24859 
    iprot.readStructBegin()
24860 
    while True:
24861 
      (fname, ftype, fid) = iprot.readFieldBegin()
24862 
      if ftype == TType.STOP:
24863 
        break
24864 
      if fid == 0:
24865 
        if ftype == TType.STRUCT:
24866 
          self.success = SnapdealItem()
24867 
          self.success.read(iprot)
24868 
        else:
24869 
          iprot.skip(ftype)
24870 
      else:
24871 
        iprot.skip(ftype)
24872 
      iprot.readFieldEnd()
24873 
    iprot.readStructEnd()
24874 
 
24875 
  def write(self, oprot):
24876 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24877 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24878 
      return
24879 
    oprot.writeStructBegin('getSnapdealItembySkuAtSnapdeal_result')
24880 
    if self.success is not None:
24881 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24882 
      self.success.write(oprot)
24883 
      oprot.writeFieldEnd()
24884 
    oprot.writeFieldStop()
24885 
    oprot.writeStructEnd()
24886 
 
24887 
  def validate(self):
24888 
    return
24889 
 
24890 
 
24891 
  def __repr__(self):
24892 
    L = ['%s=%r' % (key, value)
24893 
      for key, value in self.__dict__.iteritems()]
24894 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24895 
 
24896 
  def __eq__(self, other):
24897 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24898 
 
24899 
  def __ne__(self, other):
24900 
    return not (self == other)
9621 manish.sha 24901 
 
24902 
class getProductFeedSubmit_args:
24903 
  """
24904 
  Attributes:
24905 
   - catalogItemId
24906 
  """
24907 
 
24908 
  thrift_spec = (
24909 
    None, # 0
24910 
    (1, TType.I64, 'catalogItemId', None, None, ), # 1
24911 
  )
24912 
 
24913 
  def __init__(self, catalogItemId=None,):
24914 
    self.catalogItemId = catalogItemId
24915 
 
24916 
  def read(self, iprot):
24917 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24918 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24919 
      return
24920 
    iprot.readStructBegin()
24921 
    while True:
24922 
      (fname, ftype, fid) = iprot.readFieldBegin()
24923 
      if ftype == TType.STOP:
24924 
        break
24925 
      if fid == 1:
24926 
        if ftype == TType.I64:
24927 
          self.catalogItemId = iprot.readI64();
24928 
        else:
24929 
          iprot.skip(ftype)
24930 
      else:
24931 
        iprot.skip(ftype)
24932 
      iprot.readFieldEnd()
24933 
    iprot.readStructEnd()
24934 
 
24935 
  def write(self, oprot):
24936 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24937 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24938 
      return
24939 
    oprot.writeStructBegin('getProductFeedSubmit_args')
24940 
    if self.catalogItemId is not None:
24941 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 1)
24942 
      oprot.writeI64(self.catalogItemId)
24943 
      oprot.writeFieldEnd()
24944 
    oprot.writeFieldStop()
24945 
    oprot.writeStructEnd()
24946 
 
24947 
  def validate(self):
24948 
    return
24949 
 
24950 
 
24951 
  def __repr__(self):
24952 
    L = ['%s=%r' % (key, value)
24953 
      for key, value in self.__dict__.iteritems()]
24954 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24955 
 
24956 
  def __eq__(self, other):
24957 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24958 
 
24959 
  def __ne__(self, other):
24960 
    return not (self == other)
24961 
 
24962 
class getProductFeedSubmit_result:
24963 
  """
24964 
  Attributes:
24965 
   - success
24966 
   - cex
24967 
  """
24968 
 
24969 
  thrift_spec = (
24970 
    (0, TType.STRUCT, 'success', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 0
24971 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
24972 
  )
24973 
 
24974 
  def __init__(self, success=None, cex=None,):
24975 
    self.success = success
24976 
    self.cex = cex
24977 
 
24978 
  def read(self, iprot):
24979 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24980 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24981 
      return
24982 
    iprot.readStructBegin()
24983 
    while True:
24984 
      (fname, ftype, fid) = iprot.readFieldBegin()
24985 
      if ftype == TType.STOP:
24986 
        break
24987 
      if fid == 0:
24988 
        if ftype == TType.STRUCT:
24989 
          self.success = ProductFeedSubmit()
24990 
          self.success.read(iprot)
24991 
        else:
24992 
          iprot.skip(ftype)
24993 
      elif fid == 1:
24994 
        if ftype == TType.STRUCT:
24995 
          self.cex = CatalogServiceException()
24996 
          self.cex.read(iprot)
24997 
        else:
24998 
          iprot.skip(ftype)
24999 
      else:
25000 
        iprot.skip(ftype)
25001 
      iprot.readFieldEnd()
25002 
    iprot.readStructEnd()
25003 
 
25004 
  def write(self, oprot):
25005 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25006 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25007 
      return
25008 
    oprot.writeStructBegin('getProductFeedSubmit_result')
25009 
    if self.success is not None:
25010 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
25011 
      self.success.write(oprot)
25012 
      oprot.writeFieldEnd()
25013 
    if self.cex is not None:
25014 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
25015 
      self.cex.write(oprot)
25016 
      oprot.writeFieldEnd()
25017 
    oprot.writeFieldStop()
25018 
    oprot.writeStructEnd()
25019 
 
25020 
  def validate(self):
25021 
    return
25022 
 
25023 
 
25024 
  def __repr__(self):
25025 
    L = ['%s=%r' % (key, value)
25026 
      for key, value in self.__dict__.iteritems()]
25027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25028 
 
25029 
  def __eq__(self, other):
25030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25031 
 
25032 
  def __ne__(self, other):
25033 
    return not (self == other)
25034 
 
25035 
class addProductFeedSubmit_args:
25036 
  """
25037 
  Attributes:
25038 
   - productFeedSubmit
25039 
  """
25040 
 
25041 
  thrift_spec = (
25042 
    None, # 0
25043 
    (1, TType.STRUCT, 'productFeedSubmit', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 1
25044 
  )
25045 
 
25046 
  def __init__(self, productFeedSubmit=None,):
25047 
    self.productFeedSubmit = productFeedSubmit
25048 
 
25049 
  def read(self, iprot):
25050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25052 
      return
25053 
    iprot.readStructBegin()
25054 
    while True:
25055 
      (fname, ftype, fid) = iprot.readFieldBegin()
25056 
      if ftype == TType.STOP:
25057 
        break
25058 
      if fid == 1:
25059 
        if ftype == TType.STRUCT:
25060 
          self.productFeedSubmit = ProductFeedSubmit()
25061 
          self.productFeedSubmit.read(iprot)
25062 
        else:
25063 
          iprot.skip(ftype)
25064 
      else:
25065 
        iprot.skip(ftype)
25066 
      iprot.readFieldEnd()
25067 
    iprot.readStructEnd()
25068 
 
25069 
  def write(self, oprot):
25070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25072 
      return
25073 
    oprot.writeStructBegin('addProductFeedSubmit_args')
25074 
    if self.productFeedSubmit is not None:
25075 
      oprot.writeFieldBegin('productFeedSubmit', TType.STRUCT, 1)
25076 
      self.productFeedSubmit.write(oprot)
25077 
      oprot.writeFieldEnd()
25078 
    oprot.writeFieldStop()
25079 
    oprot.writeStructEnd()
25080 
 
25081 
  def validate(self):
25082 
    return
25083 
 
25084 
 
25085 
  def __repr__(self):
25086 
    L = ['%s=%r' % (key, value)
25087 
      for key, value in self.__dict__.iteritems()]
25088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25089 
 
25090 
  def __eq__(self, other):
25091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25092 
 
25093 
  def __ne__(self, other):
25094 
    return not (self == other)
25095 
 
25096 
class addProductFeedSubmit_result:
25097 
  """
25098 
  Attributes:
25099 
   - success
25100 
   - cex
25101 
  """
25102 
 
25103 
  thrift_spec = (
25104 
    (0, TType.BOOL, 'success', None, None, ), # 0
25105 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
25106 
  )
25107 
 
25108 
  def __init__(self, success=None, cex=None,):
25109 
    self.success = success
25110 
    self.cex = cex
25111 
 
25112 
  def read(self, iprot):
25113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25115 
      return
25116 
    iprot.readStructBegin()
25117 
    while True:
25118 
      (fname, ftype, fid) = iprot.readFieldBegin()
25119 
      if ftype == TType.STOP:
25120 
        break
25121 
      if fid == 0:
25122 
        if ftype == TType.BOOL:
25123 
          self.success = iprot.readBool();
25124 
        else:
25125 
          iprot.skip(ftype)
25126 
      elif fid == 1:
25127 
        if ftype == TType.STRUCT:
25128 
          self.cex = CatalogServiceException()
25129 
          self.cex.read(iprot)
25130 
        else:
25131 
          iprot.skip(ftype)
25132 
      else:
25133 
        iprot.skip(ftype)
25134 
      iprot.readFieldEnd()
25135 
    iprot.readStructEnd()
25136 
 
25137 
  def write(self, oprot):
25138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25140 
      return
25141 
    oprot.writeStructBegin('addProductFeedSubmit_result')
25142 
    if self.success is not None:
25143 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
25144 
      oprot.writeBool(self.success)
25145 
      oprot.writeFieldEnd()
25146 
    if self.cex is not None:
25147 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
25148 
      self.cex.write(oprot)
25149 
      oprot.writeFieldEnd()
25150 
    oprot.writeFieldStop()
25151 
    oprot.writeStructEnd()
25152 
 
25153 
  def validate(self):
25154 
    return
25155 
 
25156 
 
25157 
  def __repr__(self):
25158 
    L = ['%s=%r' % (key, value)
25159 
      for key, value in self.__dict__.iteritems()]
25160 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25161 
 
25162 
  def __eq__(self, other):
25163 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25164 
 
25165 
  def __ne__(self, other):
25166 
    return not (self == other)
25167 
 
25168 
class updateProductFeedSubmit_args:
25169 
  """
25170 
  Attributes:
25171 
   - productFeedSubmit
25172 
  """
25173 
 
25174 
  thrift_spec = (
25175 
    None, # 0
25176 
    (1, TType.STRUCT, 'productFeedSubmit', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 1
25177 
  )
25178 
 
25179 
  def __init__(self, productFeedSubmit=None,):
25180 
    self.productFeedSubmit = productFeedSubmit
25181 
 
25182 
  def read(self, iprot):
25183 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25184 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25185 
      return
25186 
    iprot.readStructBegin()
25187 
    while True:
25188 
      (fname, ftype, fid) = iprot.readFieldBegin()
25189 
      if ftype == TType.STOP:
25190 
        break
25191 
      if fid == 1:
25192 
        if ftype == TType.STRUCT:
25193 
          self.productFeedSubmit = ProductFeedSubmit()
25194 
          self.productFeedSubmit.read(iprot)
25195 
        else:
25196 
          iprot.skip(ftype)
25197 
      else:
25198 
        iprot.skip(ftype)
25199 
      iprot.readFieldEnd()
25200 
    iprot.readStructEnd()
25201 
 
25202 
  def write(self, oprot):
25203 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25204 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25205 
      return
25206 
    oprot.writeStructBegin('updateProductFeedSubmit_args')
25207 
    if self.productFeedSubmit is not None:
25208 
      oprot.writeFieldBegin('productFeedSubmit', TType.STRUCT, 1)
25209 
      self.productFeedSubmit.write(oprot)
25210 
      oprot.writeFieldEnd()
25211 
    oprot.writeFieldStop()
25212 
    oprot.writeStructEnd()
25213 
 
25214 
  def validate(self):
25215 
    return
25216 
 
25217 
 
25218 
  def __repr__(self):
25219 
    L = ['%s=%r' % (key, value)
25220 
      for key, value in self.__dict__.iteritems()]
25221 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25222 
 
25223 
  def __eq__(self, other):
25224 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25225 
 
25226 
  def __ne__(self, other):
25227 
    return not (self == other)
25228 
 
25229 
class updateProductFeedSubmit_result:
25230 
  """
25231 
  Attributes:
25232 
   - success
25233 
   - cex
25234 
  """
25235 
 
25236 
  thrift_spec = (
25237 
    (0, TType.BOOL, 'success', None, None, ), # 0
25238 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
25239 
  )
25240 
 
25241 
  def __init__(self, success=None, cex=None,):
25242 
    self.success = success
25243 
    self.cex = cex
25244 
 
25245 
  def read(self, iprot):
25246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25248 
      return
25249 
    iprot.readStructBegin()
25250 
    while True:
25251 
      (fname, ftype, fid) = iprot.readFieldBegin()
25252 
      if ftype == TType.STOP:
25253 
        break
25254 
      if fid == 0:
25255 
        if ftype == TType.BOOL:
25256 
          self.success = iprot.readBool();
25257 
        else:
25258 
          iprot.skip(ftype)
25259 
      elif fid == 1:
25260 
        if ftype == TType.STRUCT:
25261 
          self.cex = CatalogServiceException()
25262 
          self.cex.read(iprot)
25263 
        else:
25264 
          iprot.skip(ftype)
25265 
      else:
25266 
        iprot.skip(ftype)
25267 
      iprot.readFieldEnd()
25268 
    iprot.readStructEnd()
25269 
 
25270 
  def write(self, oprot):
25271 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25272 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25273 
      return
25274 
    oprot.writeStructBegin('updateProductFeedSubmit_result')
25275 
    if self.success is not None:
25276 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
25277 
      oprot.writeBool(self.success)
25278 
      oprot.writeFieldEnd()
25279 
    if self.cex is not None:
25280 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
25281 
      self.cex.write(oprot)
25282 
      oprot.writeFieldEnd()
25283 
    oprot.writeFieldStop()
25284 
    oprot.writeStructEnd()
25285 
 
25286 
  def validate(self):
25287 
    return
25288 
 
25289 
 
25290 
  def __repr__(self):
25291 
    L = ['%s=%r' % (key, value)
25292 
      for key, value in self.__dict__.iteritems()]
25293 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25294 
 
25295 
  def __eq__(self, other):
25296 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25297 
 
25298 
  def __ne__(self, other):
25299 
    return not (self == other)
25300 
 
25301 
class deleteProductFeedSubmit_args:
25302 
  """
25303 
  Attributes:
25304 
   - catalogItemId
25305 
  """
25306 
 
25307 
  thrift_spec = (
25308 
    None, # 0
25309 
    (1, TType.I64, 'catalogItemId', None, None, ), # 1
25310 
  )
25311 
 
25312 
  def __init__(self, catalogItemId=None,):
25313 
    self.catalogItemId = catalogItemId
25314 
 
25315 
  def read(self, iprot):
25316 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25317 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25318 
      return
25319 
    iprot.readStructBegin()
25320 
    while True:
25321 
      (fname, ftype, fid) = iprot.readFieldBegin()
25322 
      if ftype == TType.STOP:
25323 
        break
25324 
      if fid == 1:
25325 
        if ftype == TType.I64:
25326 
          self.catalogItemId = iprot.readI64();
25327 
        else:
25328 
          iprot.skip(ftype)
25329 
      else:
25330 
        iprot.skip(ftype)
25331 
      iprot.readFieldEnd()
25332 
    iprot.readStructEnd()
25333 
 
25334 
  def write(self, oprot):
25335 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25336 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25337 
      return
25338 
    oprot.writeStructBegin('deleteProductFeedSubmit_args')
25339 
    if self.catalogItemId is not None:
25340 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 1)
25341 
      oprot.writeI64(self.catalogItemId)
25342 
      oprot.writeFieldEnd()
25343 
    oprot.writeFieldStop()
25344 
    oprot.writeStructEnd()
25345 
 
25346 
  def validate(self):
25347 
    return
25348 
 
25349 
 
25350 
  def __repr__(self):
25351 
    L = ['%s=%r' % (key, value)
25352 
      for key, value in self.__dict__.iteritems()]
25353 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25354 
 
25355 
  def __eq__(self, other):
25356 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25357 
 
25358 
  def __ne__(self, other):
25359 
    return not (self == other)
25360 
 
25361 
class deleteProductFeedSubmit_result:
25362 
  """
25363 
  Attributes:
25364 
   - success
25365 
   - cex
25366 
  """
25367 
 
25368 
  thrift_spec = (
25369 
    (0, TType.BOOL, 'success', None, None, ), # 0
25370 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
25371 
  )
25372 
 
25373 
  def __init__(self, success=None, cex=None,):
25374 
    self.success = success
25375 
    self.cex = cex
25376 
 
25377 
  def read(self, iprot):
25378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25380 
      return
25381 
    iprot.readStructBegin()
25382 
    while True:
25383 
      (fname, ftype, fid) = iprot.readFieldBegin()
25384 
      if ftype == TType.STOP:
25385 
        break
25386 
      if fid == 0:
25387 
        if ftype == TType.BOOL:
25388 
          self.success = iprot.readBool();
25389 
        else:
25390 
          iprot.skip(ftype)
25391 
      elif fid == 1:
25392 
        if ftype == TType.STRUCT:
25393 
          self.cex = CatalogServiceException()
25394 
          self.cex.read(iprot)
25395 
        else:
25396 
          iprot.skip(ftype)
25397 
      else:
25398 
        iprot.skip(ftype)
25399 
      iprot.readFieldEnd()
25400 
    iprot.readStructEnd()
25401 
 
25402 
  def write(self, oprot):
25403 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25404 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25405 
      return
25406 
    oprot.writeStructBegin('deleteProductFeedSubmit_result')
25407 
    if self.success is not None:
25408 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
25409 
      oprot.writeBool(self.success)
25410 
      oprot.writeFieldEnd()
25411 
    if self.cex is not None:
25412 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
25413 
      self.cex.write(oprot)
25414 
      oprot.writeFieldEnd()
25415 
    oprot.writeFieldStop()
25416 
    oprot.writeStructEnd()
25417 
 
25418 
  def validate(self):
25419 
    return
25420 
 
25421 
 
25422 
  def __repr__(self):
25423 
    L = ['%s=%r' % (key, value)
25424 
      for key, value in self.__dict__.iteritems()]
25425 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25426 
 
25427 
  def __eq__(self, other):
25428 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25429 
 
25430 
  def __ne__(self, other):
25431 
    return not (self == other)
25432 
 
25433 
class getAllProductFeedSubmit_args:
25434 
 
25435 
  thrift_spec = (
25436 
  )
25437 
 
25438 
  def read(self, iprot):
25439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25441 
      return
25442 
    iprot.readStructBegin()
25443 
    while True:
25444 
      (fname, ftype, fid) = iprot.readFieldBegin()
25445 
      if ftype == TType.STOP:
25446 
        break
25447 
      else:
25448 
        iprot.skip(ftype)
25449 
      iprot.readFieldEnd()
25450 
    iprot.readStructEnd()
25451 
 
25452 
  def write(self, oprot):
25453 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25454 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25455 
      return
25456 
    oprot.writeStructBegin('getAllProductFeedSubmit_args')
25457 
    oprot.writeFieldStop()
25458 
    oprot.writeStructEnd()
25459 
 
25460 
  def validate(self):
25461 
    return
25462 
 
25463 
 
25464 
  def __repr__(self):
25465 
    L = ['%s=%r' % (key, value)
25466 
      for key, value in self.__dict__.iteritems()]
25467 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25468 
 
25469 
  def __eq__(self, other):
25470 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25471 
 
25472 
  def __ne__(self, other):
25473 
    return not (self == other)
25474 
 
25475 
class getAllProductFeedSubmit_result:
25476 
  """
25477 
  Attributes:
25478 
   - success
25479 
   - cex
25480 
  """
25481 
 
25482 
  thrift_spec = (
25483 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductFeedSubmit, ProductFeedSubmit.thrift_spec)), None, ), # 0
25484 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
25485 
  )
25486 
 
25487 
  def __init__(self, success=None, cex=None,):
25488 
    self.success = success
25489 
    self.cex = cex
25490 
 
25491 
  def read(self, iprot):
25492 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25493 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25494 
      return
25495 
    iprot.readStructBegin()
25496 
    while True:
25497 
      (fname, ftype, fid) = iprot.readFieldBegin()
25498 
      if ftype == TType.STOP:
25499 
        break
25500 
      if fid == 0:
25501 
        if ftype == TType.LIST:
25502 
          self.success = []
25503 
          (_etype551, _size548) = iprot.readListBegin()
25504 
          for _i552 in xrange(_size548):
25505 
            _elem553 = ProductFeedSubmit()
25506 
            _elem553.read(iprot)
25507 
            self.success.append(_elem553)
25508 
          iprot.readListEnd()
25509 
        else:
25510 
          iprot.skip(ftype)
25511 
      elif fid == 1:
25512 
        if ftype == TType.STRUCT:
25513 
          self.cex = CatalogServiceException()
25514 
          self.cex.read(iprot)
25515 
        else:
25516 
          iprot.skip(ftype)
25517 
      else:
25518 
        iprot.skip(ftype)
25519 
      iprot.readFieldEnd()
25520 
    iprot.readStructEnd()
25521 
 
25522 
  def write(self, oprot):
25523 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25524 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25525 
      return
25526 
    oprot.writeStructBegin('getAllProductFeedSubmit_result')
25527 
    if self.success is not None:
25528 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25529 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
25530 
      for iter554 in self.success:
25531 
        iter554.write(oprot)
25532 
      oprot.writeListEnd()
25533 
      oprot.writeFieldEnd()
25534 
    if self.cex is not None:
25535 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
25536 
      self.cex.write(oprot)
25537 
      oprot.writeFieldEnd()
25538 
    oprot.writeFieldStop()
25539 
    oprot.writeStructEnd()
25540 
 
25541 
  def validate(self):
25542 
    return
25543 
 
25544 
 
25545 
  def __repr__(self):
25546 
    L = ['%s=%r' % (key, value)
25547 
      for key, value in self.__dict__.iteritems()]
25548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25549 
 
25550 
  def __eq__(self, other):
25551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25552 
 
25553 
  def __ne__(self, other):
25554 
    return not (self == other)
9724 kshitij.so 25555 
 
25556 
class getMarketplacedetailsForItem_args:
25557 
  """
25558 
  Attributes:
25559 
   - itemId
25560 
   - sourceId
25561 
  """
25562 
 
25563 
  thrift_spec = (
25564 
    None, # 0
25565 
    (1, TType.I64, 'itemId', None, None, ), # 1
25566 
    (2, TType.I64, 'sourceId', None, None, ), # 2
25567 
  )
25568 
 
25569 
  def __init__(self, itemId=None, sourceId=None,):
25570 
    self.itemId = itemId
25571 
    self.sourceId = sourceId
25572 
 
25573 
  def read(self, iprot):
25574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25576 
      return
25577 
    iprot.readStructBegin()
25578 
    while True:
25579 
      (fname, ftype, fid) = iprot.readFieldBegin()
25580 
      if ftype == TType.STOP:
25581 
        break
25582 
      if fid == 1:
25583 
        if ftype == TType.I64:
25584 
          self.itemId = iprot.readI64();
25585 
        else:
25586 
          iprot.skip(ftype)
25587 
      elif fid == 2:
25588 
        if ftype == TType.I64:
25589 
          self.sourceId = iprot.readI64();
25590 
        else:
25591 
          iprot.skip(ftype)
25592 
      else:
25593 
        iprot.skip(ftype)
25594 
      iprot.readFieldEnd()
25595 
    iprot.readStructEnd()
25596 
 
25597 
  def write(self, oprot):
25598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25600 
      return
25601 
    oprot.writeStructBegin('getMarketplacedetailsForItem_args')
25602 
    if self.itemId is not None:
25603 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
25604 
      oprot.writeI64(self.itemId)
25605 
      oprot.writeFieldEnd()
25606 
    if self.sourceId is not None:
25607 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
25608 
      oprot.writeI64(self.sourceId)
25609 
      oprot.writeFieldEnd()
25610 
    oprot.writeFieldStop()
25611 
    oprot.writeStructEnd()
25612 
 
25613 
  def validate(self):
25614 
    return
25615 
 
25616 
 
25617 
  def __repr__(self):
25618 
    L = ['%s=%r' % (key, value)
25619 
      for key, value in self.__dict__.iteritems()]
25620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25621 
 
25622 
  def __eq__(self, other):
25623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25624 
 
25625 
  def __ne__(self, other):
25626 
    return not (self == other)
25627 
 
25628 
class getMarketplacedetailsForItem_result:
25629 
  """
25630 
  Attributes:
25631 
   - success
25632 
  """
25633 
 
25634 
  thrift_spec = (
25635 
    (0, TType.STRUCT, 'success', (MarketplaceItems, MarketplaceItems.thrift_spec), None, ), # 0
25636 
  )
25637 
 
25638 
  def __init__(self, success=None,):
25639 
    self.success = success
25640 
 
25641 
  def read(self, iprot):
25642 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25643 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25644 
      return
25645 
    iprot.readStructBegin()
25646 
    while True:
25647 
      (fname, ftype, fid) = iprot.readFieldBegin()
25648 
      if ftype == TType.STOP:
25649 
        break
25650 
      if fid == 0:
25651 
        if ftype == TType.STRUCT:
25652 
          self.success = MarketplaceItems()
25653 
          self.success.read(iprot)
25654 
        else:
25655 
          iprot.skip(ftype)
25656 
      else:
25657 
        iprot.skip(ftype)
25658 
      iprot.readFieldEnd()
25659 
    iprot.readStructEnd()
25660 
 
25661 
  def write(self, oprot):
25662 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25663 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25664 
      return
25665 
    oprot.writeStructBegin('getMarketplacedetailsForItem_result')
25666 
    if self.success is not None:
25667 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
25668 
      self.success.write(oprot)
25669 
      oprot.writeFieldEnd()
25670 
    oprot.writeFieldStop()
25671 
    oprot.writeStructEnd()
25672 
 
25673 
  def validate(self):
25674 
    return
25675 
 
25676 
 
25677 
  def __repr__(self):
25678 
    L = ['%s=%r' % (key, value)
25679 
      for key, value in self.__dict__.iteritems()]
25680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25681 
 
25682 
  def __eq__(self, other):
25683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25684 
 
25685 
  def __ne__(self, other):
25686 
    return not (self == other)
25687 
 
25688 
class updateMarketplaceAttributesForItem_args:
25689 
  """
25690 
  Attributes:
25691 
   - marketPlaceItem
25692 
  """
25693 
 
25694 
  thrift_spec = (
25695 
    None, # 0
25696 
    (1, TType.STRUCT, 'marketPlaceItem', (MarketplaceItems, MarketplaceItems.thrift_spec), None, ), # 1
25697 
  )
25698 
 
25699 
  def __init__(self, marketPlaceItem=None,):
25700 
    self.marketPlaceItem = marketPlaceItem
25701 
 
25702 
  def read(self, iprot):
25703 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25704 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25705 
      return
25706 
    iprot.readStructBegin()
25707 
    while True:
25708 
      (fname, ftype, fid) = iprot.readFieldBegin()
25709 
      if ftype == TType.STOP:
25710 
        break
25711 
      if fid == 1:
25712 
        if ftype == TType.STRUCT:
25713 
          self.marketPlaceItem = MarketplaceItems()
25714 
          self.marketPlaceItem.read(iprot)
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('updateMarketplaceAttributesForItem_args')
25727 
    if self.marketPlaceItem is not None:
25728 
      oprot.writeFieldBegin('marketPlaceItem', TType.STRUCT, 1)
25729 
      self.marketPlaceItem.write(oprot)
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 updateMarketplaceAttributesForItem_result:
25750 
  """
25751 
  Attributes:
25752 
   - success
25753 
  """
25754 
 
25755 
  thrift_spec = (
25756 
    (0, TType.BOOL, 'success', None, 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.BOOL:
25773 
          self.success = iprot.readBool();
25774 
        else:
25775 
          iprot.skip(ftype)
25776 
      else:
25777 
        iprot.skip(ftype)
25778 
      iprot.readFieldEnd()
25779 
    iprot.readStructEnd()
25780 
 
25781 
  def write(self, oprot):
25782 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25783 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25784 
      return
25785 
    oprot.writeStructBegin('updateMarketplaceAttributesForItem_result')
25786 
    if self.success is not None:
25787 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
25788 
      oprot.writeBool(self.success)
25789 
      oprot.writeFieldEnd()
25790 
    oprot.writeFieldStop()
25791 
    oprot.writeStructEnd()
25792 
 
25793 
  def validate(self):
25794 
    return
25795 
 
25796 
 
25797 
  def __repr__(self):
25798 
    L = ['%s=%r' % (key, value)
25799 
      for key, value in self.__dict__.iteritems()]
25800 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25801 
 
25802 
  def __eq__(self, other):
25803 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25804 
 
25805 
  def __ne__(self, other):
25806 
    return not (self == other)
9776 vikram.rag 25807 
 
9779 kshitij.so 25808 
class getCostingForMarketplace_args:
25809 
  """
25810 
  Attributes:
25811 
   - source
25812 
   - item_id
25813 
  """
25814 
 
25815 
  thrift_spec = (
25816 
    None, # 0
25817 
    (1, TType.I64, 'source', None, None, ), # 1
25818 
    (2, TType.I64, 'item_id', None, None, ), # 2
25819 
  )
25820 
 
25821 
  def __init__(self, source=None, item_id=None,):
25822 
    self.source = source
25823 
    self.item_id = item_id
25824 
 
25825 
  def read(self, iprot):
25826 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25827 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25828 
      return
25829 
    iprot.readStructBegin()
25830 
    while True:
25831 
      (fname, ftype, fid) = iprot.readFieldBegin()
25832 
      if ftype == TType.STOP:
25833 
        break
25834 
      if fid == 1:
25835 
        if ftype == TType.I64:
25836 
          self.source = iprot.readI64();
25837 
        else:
25838 
          iprot.skip(ftype)
25839 
      elif fid == 2:
25840 
        if ftype == TType.I64:
25841 
          self.item_id = iprot.readI64();
25842 
        else:
25843 
          iprot.skip(ftype)
25844 
      else:
25845 
        iprot.skip(ftype)
25846 
      iprot.readFieldEnd()
25847 
    iprot.readStructEnd()
25848 
 
25849 
  def write(self, oprot):
25850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25852 
      return
25853 
    oprot.writeStructBegin('getCostingForMarketplace_args')
25854 
    if self.source is not None:
25855 
      oprot.writeFieldBegin('source', TType.I64, 1)
25856 
      oprot.writeI64(self.source)
25857 
      oprot.writeFieldEnd()
25858 
    if self.item_id is not None:
25859 
      oprot.writeFieldBegin('item_id', TType.I64, 2)
25860 
      oprot.writeI64(self.item_id)
25861 
      oprot.writeFieldEnd()
25862 
    oprot.writeFieldStop()
25863 
    oprot.writeStructEnd()
25864 
 
25865 
  def validate(self):
25866 
    return
25867 
 
25868 
 
25869 
  def __repr__(self):
25870 
    L = ['%s=%r' % (key, value)
25871 
      for key, value in self.__dict__.iteritems()]
25872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25873 
 
25874 
  def __eq__(self, other):
25875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25876 
 
25877 
  def __ne__(self, other):
25878 
    return not (self == other)
25879 
 
25880 
class getCostingForMarketplace_result:
25881 
  """
25882 
  Attributes:
25883 
   - success
25884 
  """
25885 
 
25886 
  thrift_spec = (
25887 
    (0, TType.STRUCT, 'success', (MarketplacePercentage, MarketplacePercentage.thrift_spec), None, ), # 0
25888 
  )
25889 
 
25890 
  def __init__(self, success=None,):
25891 
    self.success = success
25892 
 
25893 
  def read(self, iprot):
25894 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25895 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25896 
      return
25897 
    iprot.readStructBegin()
25898 
    while True:
25899 
      (fname, ftype, fid) = iprot.readFieldBegin()
25900 
      if ftype == TType.STOP:
25901 
        break
25902 
      if fid == 0:
25903 
        if ftype == TType.STRUCT:
25904 
          self.success = MarketplacePercentage()
25905 
          self.success.read(iprot)
25906 
        else:
25907 
          iprot.skip(ftype)
25908 
      else:
25909 
        iprot.skip(ftype)
25910 
      iprot.readFieldEnd()
25911 
    iprot.readStructEnd()
25912 
 
25913 
  def write(self, oprot):
25914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25916 
      return
25917 
    oprot.writeStructBegin('getCostingForMarketplace_result')
25918 
    if self.success is not None:
25919 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
25920 
      self.success.write(oprot)
25921 
      oprot.writeFieldEnd()
25922 
    oprot.writeFieldStop()
25923 
    oprot.writeStructEnd()
25924 
 
25925 
  def validate(self):
25926 
    return
25927 
 
25928 
 
25929 
  def __repr__(self):
25930 
    L = ['%s=%r' % (key, value)
25931 
      for key, value in self.__dict__.iteritems()]
25932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25933 
 
25934 
  def __eq__(self, other):
25935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25936 
 
25937 
  def __ne__(self, other):
25938 
    return not (self == other)
25939 
 
9776 vikram.rag 25940 
class getMarketPlaceItemsForPriceUpdate_args:
25941 
  """
25942 
  Attributes:
25943 
   - source
25944 
  """
25945 
 
25946 
  thrift_spec = (
25947 
    None, # 0
25948 
    (1, TType.I64, 'source', None, None, ), # 1
25949 
  )
25950 
 
25951 
  def __init__(self, source=None,):
25952 
    self.source = source
25953 
 
25954 
  def read(self, iprot):
25955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25957 
      return
25958 
    iprot.readStructBegin()
25959 
    while True:
25960 
      (fname, ftype, fid) = iprot.readFieldBegin()
25961 
      if ftype == TType.STOP:
25962 
        break
25963 
      if fid == 1:
25964 
        if ftype == TType.I64:
25965 
          self.source = iprot.readI64();
25966 
        else:
25967 
          iprot.skip(ftype)
25968 
      else:
25969 
        iprot.skip(ftype)
25970 
      iprot.readFieldEnd()
25971 
    iprot.readStructEnd()
25972 
 
25973 
  def write(self, oprot):
25974 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25975 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25976 
      return
25977 
    oprot.writeStructBegin('getMarketPlaceItemsForPriceUpdate_args')
25978 
    if self.source is not None:
25979 
      oprot.writeFieldBegin('source', TType.I64, 1)
25980 
      oprot.writeI64(self.source)
25981 
      oprot.writeFieldEnd()
25982 
    oprot.writeFieldStop()
25983 
    oprot.writeStructEnd()
25984 
 
25985 
  def validate(self):
25986 
    return
25987 
 
25988 
 
25989 
  def __repr__(self):
25990 
    L = ['%s=%r' % (key, value)
25991 
      for key, value in self.__dict__.iteritems()]
25992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25993 
 
25994 
  def __eq__(self, other):
25995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25996 
 
25997 
  def __ne__(self, other):
25998 
    return not (self == other)
25999 
 
26000 
class getMarketPlaceItemsForPriceUpdate_result:
26001 
  """
26002 
  Attributes:
26003 
   - success
26004 
  """
26005 
 
26006 
  thrift_spec = (
26007 
    (0, TType.LIST, 'success', (TType.STRUCT,(MarketPlaceItemPrice, MarketPlaceItemPrice.thrift_spec)), None, ), # 0
26008 
  )
26009 
 
26010 
  def __init__(self, success=None,):
26011 
    self.success = success
26012 
 
26013 
  def read(self, iprot):
26014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26016 
      return
26017 
    iprot.readStructBegin()
26018 
    while True:
26019 
      (fname, ftype, fid) = iprot.readFieldBegin()
26020 
      if ftype == TType.STOP:
26021 
        break
26022 
      if fid == 0:
26023 
        if ftype == TType.LIST:
26024 
          self.success = []
26025 
          (_etype558, _size555) = iprot.readListBegin()
26026 
          for _i559 in xrange(_size555):
26027 
            _elem560 = MarketPlaceItemPrice()
26028 
            _elem560.read(iprot)
26029 
            self.success.append(_elem560)
26030 
          iprot.readListEnd()
26031 
        else:
26032 
          iprot.skip(ftype)
26033 
      else:
26034 
        iprot.skip(ftype)
26035 
      iprot.readFieldEnd()
26036 
    iprot.readStructEnd()
26037 
 
26038 
  def write(self, oprot):
26039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26041 
      return
26042 
    oprot.writeStructBegin('getMarketPlaceItemsForPriceUpdate_result')
26043 
    if self.success is not None:
26044 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26045 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
26046 
      for iter561 in self.success:
26047 
        iter561.write(oprot)
26048 
      oprot.writeListEnd()
26049 
      oprot.writeFieldEnd()
26050 
    oprot.writeFieldStop()
26051 
    oprot.writeStructEnd()
26052 
 
26053 
  def validate(self):
26054 
    return
26055 
 
26056 
 
26057 
  def __repr__(self):
26058 
    L = ['%s=%r' % (key, value)
26059 
      for key, value in self.__dict__.iteritems()]
26060 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26061 
 
26062 
  def __eq__(self, other):
26063 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26064 
 
26065 
  def __ne__(self, other):
26066 
    return not (self == other)
26067 
 
26068 
class updateMarketPlacePriceUpdateStatus_args:
26069 
  """
26070 
  Attributes:
26071 
   - skulist
26072 
   - timestamp
9816 kshitij.so 26073 
   - source
9776 vikram.rag 26074 
  """
26075 
 
26076 
  thrift_spec = (
26077 
    None, # 0
26078 
    (1, TType.LIST, 'skulist', (TType.I64,None), None, ), # 1
26079 
    (2, TType.I64, 'timestamp', None, None, ), # 2
9816 kshitij.so 26080 
    (3, TType.I64, 'source', None, None, ), # 3
9776 vikram.rag 26081 
  )
26082 
 
9816 kshitij.so 26083 
  def __init__(self, skulist=None, timestamp=None, source=None,):
9776 vikram.rag 26084 
    self.skulist = skulist
26085 
    self.timestamp = timestamp
9816 kshitij.so 26086 
    self.source = source
9776 vikram.rag 26087 
 
26088 
  def read(self, iprot):
26089 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26090 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26091 
      return
26092 
    iprot.readStructBegin()
26093 
    while True:
26094 
      (fname, ftype, fid) = iprot.readFieldBegin()
26095 
      if ftype == TType.STOP:
26096 
        break
26097 
      if fid == 1:
26098 
        if ftype == TType.LIST:
26099 
          self.skulist = []
26100 
          (_etype565, _size562) = iprot.readListBegin()
26101 
          for _i566 in xrange(_size562):
26102 
            _elem567 = iprot.readI64();
26103 
            self.skulist.append(_elem567)
26104 
          iprot.readListEnd()
26105 
        else:
26106 
          iprot.skip(ftype)
26107 
      elif fid == 2:
26108 
        if ftype == TType.I64:
26109 
          self.timestamp = iprot.readI64();
26110 
        else:
26111 
          iprot.skip(ftype)
9816 kshitij.so 26112 
      elif fid == 3:
26113 
        if ftype == TType.I64:
26114 
          self.source = iprot.readI64();
26115 
        else:
26116 
          iprot.skip(ftype)
9776 vikram.rag 26117 
      else:
26118 
        iprot.skip(ftype)
26119 
      iprot.readFieldEnd()
26120 
    iprot.readStructEnd()
26121 
 
26122 
  def write(self, oprot):
26123 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26124 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26125 
      return
26126 
    oprot.writeStructBegin('updateMarketPlacePriceUpdateStatus_args')
26127 
    if self.skulist is not None:
26128 
      oprot.writeFieldBegin('skulist', TType.LIST, 1)
26129 
      oprot.writeListBegin(TType.I64, len(self.skulist))
26130 
      for iter568 in self.skulist:
26131 
        oprot.writeI64(iter568)
26132 
      oprot.writeListEnd()
26133 
      oprot.writeFieldEnd()
26134 
    if self.timestamp is not None:
26135 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
26136 
      oprot.writeI64(self.timestamp)
26137 
      oprot.writeFieldEnd()
9816 kshitij.so 26138 
    if self.source is not None:
26139 
      oprot.writeFieldBegin('source', TType.I64, 3)
26140 
      oprot.writeI64(self.source)
26141 
      oprot.writeFieldEnd()
9776 vikram.rag 26142 
    oprot.writeFieldStop()
26143 
    oprot.writeStructEnd()
26144 
 
26145 
  def validate(self):
26146 
    return
26147 
 
26148 
 
26149 
  def __repr__(self):
26150 
    L = ['%s=%r' % (key, value)
26151 
      for key, value in self.__dict__.iteritems()]
26152 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26153 
 
26154 
  def __eq__(self, other):
26155 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26156 
 
26157 
  def __ne__(self, other):
26158 
    return not (self == other)
26159 
 
26160 
class updateMarketPlacePriceUpdateStatus_result:
26161 
 
26162 
  thrift_spec = (
26163 
  )
26164 
 
26165 
  def read(self, iprot):
26166 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26167 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26168 
      return
26169 
    iprot.readStructBegin()
26170 
    while True:
26171 
      (fname, ftype, fid) = iprot.readFieldBegin()
26172 
      if ftype == TType.STOP:
26173 
        break
26174 
      else:
26175 
        iprot.skip(ftype)
26176 
      iprot.readFieldEnd()
26177 
    iprot.readStructEnd()
26178 
 
26179 
  def write(self, oprot):
26180 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26181 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26182 
      return
26183 
    oprot.writeStructBegin('updateMarketPlacePriceUpdateStatus_result')
26184 
    oprot.writeFieldStop()
26185 
    oprot.writeStructEnd()
26186 
 
26187 
  def validate(self):
26188 
    return
26189 
 
26190 
 
26191 
  def __repr__(self):
26192 
    L = ['%s=%r' % (key, value)
26193 
      for key, value in self.__dict__.iteritems()]
26194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26195 
 
26196 
  def __eq__(self, other):
26197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26198 
 
26199 
  def __ne__(self, other):
26200 
    return not (self == other)
9861 rajveer 26201 
 
26202 
class updateItemHoldInventory_args:
26203 
  """
26204 
  Attributes:
26205 
   - itemHoldMap
26206 
  """
26207 
 
26208 
  thrift_spec = (
26209 
    None, # 0
26210 
    (1, TType.MAP, 'itemHoldMap', (TType.I64,None,TType.I64,None), None, ), # 1
26211 
  )
26212 
 
26213 
  def __init__(self, itemHoldMap=None,):
26214 
    self.itemHoldMap = itemHoldMap
26215 
 
26216 
  def read(self, iprot):
26217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26219 
      return
26220 
    iprot.readStructBegin()
26221 
    while True:
26222 
      (fname, ftype, fid) = iprot.readFieldBegin()
26223 
      if ftype == TType.STOP:
26224 
        break
26225 
      if fid == 1:
26226 
        if ftype == TType.MAP:
26227 
          self.itemHoldMap = {}
26228 
          (_ktype570, _vtype571, _size569 ) = iprot.readMapBegin()
26229 
          for _i573 in xrange(_size569):
26230 
            _key574 = iprot.readI64();
26231 
            _val575 = iprot.readI64();
26232 
            self.itemHoldMap[_key574] = _val575
26233 
          iprot.readMapEnd()
26234 
        else:
26235 
          iprot.skip(ftype)
26236 
      else:
26237 
        iprot.skip(ftype)
26238 
      iprot.readFieldEnd()
26239 
    iprot.readStructEnd()
26240 
 
26241 
  def write(self, oprot):
26242 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26243 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26244 
      return
26245 
    oprot.writeStructBegin('updateItemHoldInventory_args')
26246 
    if self.itemHoldMap is not None:
26247 
      oprot.writeFieldBegin('itemHoldMap', TType.MAP, 1)
26248 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.itemHoldMap))
26249 
      for kiter576,viter577 in self.itemHoldMap.items():
26250 
        oprot.writeI64(kiter576)
26251 
        oprot.writeI64(viter577)
26252 
      oprot.writeMapEnd()
26253 
      oprot.writeFieldEnd()
26254 
    oprot.writeFieldStop()
26255 
    oprot.writeStructEnd()
26256 
 
26257 
  def validate(self):
26258 
    return
26259 
 
26260 
 
26261 
  def __repr__(self):
26262 
    L = ['%s=%r' % (key, value)
26263 
      for key, value in self.__dict__.iteritems()]
26264 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26265 
 
26266 
  def __eq__(self, other):
26267 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26268 
 
26269 
  def __ne__(self, other):
26270 
    return not (self == other)
26271 
 
26272 
class updateItemHoldInventory_result:
26273 
 
26274 
  thrift_spec = (
26275 
  )
26276 
 
26277 
  def read(self, iprot):
26278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26280 
      return
26281 
    iprot.readStructBegin()
26282 
    while True:
26283 
      (fname, ftype, fid) = iprot.readFieldBegin()
26284 
      if ftype == TType.STOP:
26285 
        break
26286 
      else:
26287 
        iprot.skip(ftype)
26288 
      iprot.readFieldEnd()
26289 
    iprot.readStructEnd()
26290 
 
26291 
  def write(self, oprot):
26292 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26293 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26294 
      return
26295 
    oprot.writeStructBegin('updateItemHoldInventory_result')
26296 
    oprot.writeFieldStop()
26297 
    oprot.writeStructEnd()
26298 
 
26299 
  def validate(self):
26300 
    return
26301 
 
26302 
 
26303 
  def __repr__(self):
26304 
    L = ['%s=%r' % (key, value)
26305 
      for key, value in self.__dict__.iteritems()]
26306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26307 
 
26308 
  def __eq__(self, other):
26309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26310 
 
26311 
  def __ne__(self, other):
26312 
    return not (self == other)
9895 vikram.rag 26313 
 
26314 
class updateNlcAtMarketplaces_args:
26315 
  """
26316 
  Attributes:
26317 
   - item_id
26318 
   - vendor_id
26319 
   - nlc
26320 
  """
26321 
 
26322 
  thrift_spec = None
26323 
  def __init__(self, item_id=None, vendor_id=None, nlc=None,):
26324 
    self.item_id = item_id
26325 
    self.vendor_id = vendor_id
26326 
    self.nlc = nlc
26327 
 
26328 
  def read(self, iprot):
26329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26331 
      return
26332 
    iprot.readStructBegin()
26333 
    while True:
26334 
      (fname, ftype, fid) = iprot.readFieldBegin()
26335 
      if ftype == TType.STOP:
26336 
        break
26337 
      if fid == 1:
26338 
        if ftype == TType.I64:
26339 
          self.item_id = iprot.readI64();
26340 
        else:
26341 
          iprot.skip(ftype)
26342 
      elif fid == 2:
26343 
        if ftype == TType.I64:
26344 
          self.vendor_id = iprot.readI64();
26345 
        else:
26346 
          iprot.skip(ftype)
26347 
      elif fid == -1:
26348 
        if ftype == TType.DOUBLE:
26349 
          self.nlc = iprot.readDouble();
26350 
        else:
26351 
          iprot.skip(ftype)
26352 
      else:
26353 
        iprot.skip(ftype)
26354 
      iprot.readFieldEnd()
26355 
    iprot.readStructEnd()
26356 
 
26357 
  def write(self, oprot):
26358 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26359 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26360 
      return
26361 
    oprot.writeStructBegin('updateNlcAtMarketplaces_args')
26362 
    if self.nlc is not None:
26363 
      oprot.writeFieldBegin('nlc', TType.DOUBLE, -1)
26364 
      oprot.writeDouble(self.nlc)
26365 
      oprot.writeFieldEnd()
26366 
    if self.item_id is not None:
26367 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
26368 
      oprot.writeI64(self.item_id)
26369 
      oprot.writeFieldEnd()
26370 
    if self.vendor_id is not None:
26371 
      oprot.writeFieldBegin('vendor_id', TType.I64, 2)
26372 
      oprot.writeI64(self.vendor_id)
26373 
      oprot.writeFieldEnd()
26374 
    oprot.writeFieldStop()
26375 
    oprot.writeStructEnd()
26376 
 
26377 
  def validate(self):
26378 
    return
26379 
 
26380 
 
26381 
  def __repr__(self):
26382 
    L = ['%s=%r' % (key, value)
26383 
      for key, value in self.__dict__.iteritems()]
26384 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26385 
 
26386 
  def __eq__(self, other):
26387 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26388 
 
26389 
  def __ne__(self, other):
26390 
    return not (self == other)
26391 
 
26392 
class updateNlcAtMarketplaces_result:
26393 
 
26394 
  thrift_spec = (
26395 
  )
26396 
 
26397 
  def read(self, iprot):
26398 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26399 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26400 
      return
26401 
    iprot.readStructBegin()
26402 
    while True:
26403 
      (fname, ftype, fid) = iprot.readFieldBegin()
26404 
      if ftype == TType.STOP:
26405 
        break
26406 
      else:
26407 
        iprot.skip(ftype)
26408 
      iprot.readFieldEnd()
26409 
    iprot.readStructEnd()
26410 
 
26411 
  def write(self, oprot):
26412 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26413 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26414 
      return
26415 
    oprot.writeStructBegin('updateNlcAtMarketplaces_result')
26416 
    oprot.writeFieldStop()
26417 
    oprot.writeStructEnd()
26418 
 
26419 
  def validate(self):
26420 
    return
26421 
 
26422 
 
26423 
  def __repr__(self):
26424 
    L = ['%s=%r' % (key, value)
26425 
      for key, value in self.__dict__.iteritems()]
26426 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26427 
 
26428 
  def __eq__(self, other):
26429 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26430 
 
26431 
  def __ne__(self, other):
26432 
    return not (self == other)
9945 vikram.rag 26433 
 
26434 
class getAllFlipkartItems_args:
26435 
 
26436 
  thrift_spec = (
26437 
  )
26438 
 
26439 
  def read(self, iprot):
26440 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26441 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26442 
      return
26443 
    iprot.readStructBegin()
26444 
    while True:
26445 
      (fname, ftype, fid) = iprot.readFieldBegin()
26446 
      if ftype == TType.STOP:
26447 
        break
26448 
      else:
26449 
        iprot.skip(ftype)
26450 
      iprot.readFieldEnd()
26451 
    iprot.readStructEnd()
26452 
 
26453 
  def write(self, oprot):
26454 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26455 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26456 
      return
26457 
    oprot.writeStructBegin('getAllFlipkartItems_args')
26458 
    oprot.writeFieldStop()
26459 
    oprot.writeStructEnd()
26460 
 
26461 
  def validate(self):
26462 
    return
26463 
 
26464 
 
26465 
  def __repr__(self):
26466 
    L = ['%s=%r' % (key, value)
26467 
      for key, value in self.__dict__.iteritems()]
26468 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26469 
 
26470 
  def __eq__(self, other):
26471 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26472 
 
26473 
  def __ne__(self, other):
26474 
    return not (self == other)
26475 
 
26476 
class getAllFlipkartItems_result:
26477 
  """
26478 
  Attributes:
26479 
   - success
26480 
  """
26481 
 
26482 
  thrift_spec = (
26483 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartItem, FlipkartItem.thrift_spec)), None, ), # 0
26484 
  )
26485 
 
26486 
  def __init__(self, success=None,):
26487 
    self.success = success
26488 
 
26489 
  def read(self, iprot):
26490 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26491 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26492 
      return
26493 
    iprot.readStructBegin()
26494 
    while True:
26495 
      (fname, ftype, fid) = iprot.readFieldBegin()
26496 
      if ftype == TType.STOP:
26497 
        break
26498 
      if fid == 0:
26499 
        if ftype == TType.LIST:
26500 
          self.success = []
26501 
          (_etype581, _size578) = iprot.readListBegin()
26502 
          for _i582 in xrange(_size578):
26503 
            _elem583 = FlipkartItem()
26504 
            _elem583.read(iprot)
26505 
            self.success.append(_elem583)
26506 
          iprot.readListEnd()
26507 
        else:
26508 
          iprot.skip(ftype)
26509 
      else:
26510 
        iprot.skip(ftype)
26511 
      iprot.readFieldEnd()
26512 
    iprot.readStructEnd()
26513 
 
26514 
  def write(self, oprot):
26515 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26516 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26517 
      return
26518 
    oprot.writeStructBegin('getAllFlipkartItems_result')
26519 
    if self.success is not None:
26520 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26521 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
26522 
      for iter584 in self.success:
26523 
        iter584.write(oprot)
26524 
      oprot.writeListEnd()
26525 
      oprot.writeFieldEnd()
26526 
    oprot.writeFieldStop()
26527 
    oprot.writeStructEnd()
26528 
 
26529 
  def validate(self):
26530 
    return
26531 
 
26532 
 
26533 
  def __repr__(self):
26534 
    L = ['%s=%r' % (key, value)
26535 
      for key, value in self.__dict__.iteritems()]
26536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26537 
 
26538 
  def __eq__(self, other):
26539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26540 
 
26541 
  def __ne__(self, other):
26542 
    return not (self == other)
10097 kshitij.so 26543 
 
26544 
class addOrUpdateFlipkartItem_args:
26545 
  """
26546 
  Attributes:
26547 
   - flipkartitem
26548 
  """
26549 
 
26550 
  thrift_spec = None
26551 
  def __init__(self, flipkartitem=None,):
26552 
    self.flipkartitem = flipkartitem
26553 
 
26554 
  def read(self, iprot):
26555 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26556 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26557 
      return
26558 
    iprot.readStructBegin()
26559 
    while True:
26560 
      (fname, ftype, fid) = iprot.readFieldBegin()
26561 
      if ftype == TType.STOP:
26562 
        break
26563 
      if fid == -1:
26564 
        if ftype == TType.STRUCT:
26565 
          self.flipkartitem = FlipkartItem()
26566 
          self.flipkartitem.read(iprot)
26567 
        else:
26568 
          iprot.skip(ftype)
26569 
      else:
26570 
        iprot.skip(ftype)
26571 
      iprot.readFieldEnd()
26572 
    iprot.readStructEnd()
26573 
 
26574 
  def write(self, oprot):
26575 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26576 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26577 
      return
26578 
    oprot.writeStructBegin('addOrUpdateFlipkartItem_args')
26579 
    if self.flipkartitem is not None:
26580 
      oprot.writeFieldBegin('flipkartitem', TType.STRUCT, -1)
26581 
      self.flipkartitem.write(oprot)
26582 
      oprot.writeFieldEnd()
26583 
    oprot.writeFieldStop()
26584 
    oprot.writeStructEnd()
26585 
 
26586 
  def validate(self):
26587 
    return
26588 
 
26589 
 
26590 
  def __repr__(self):
26591 
    L = ['%s=%r' % (key, value)
26592 
      for key, value in self.__dict__.iteritems()]
26593 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26594 
 
26595 
  def __eq__(self, other):
26596 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26597 
 
26598 
  def __ne__(self, other):
26599 
    return not (self == other)
26600 
 
26601 
class addOrUpdateFlipkartItem_result:
26602 
  """
26603 
  Attributes:
26604 
   - success
26605 
  """
26606 
 
26607 
  thrift_spec = (
26608 
    (0, TType.BOOL, 'success', None, None, ), # 0
26609 
  )
26610 
 
26611 
  def __init__(self, success=None,):
26612 
    self.success = success
26613 
 
26614 
  def read(self, iprot):
26615 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26616 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26617 
      return
26618 
    iprot.readStructBegin()
26619 
    while True:
26620 
      (fname, ftype, fid) = iprot.readFieldBegin()
26621 
      if ftype == TType.STOP:
26622 
        break
26623 
      if fid == 0:
26624 
        if ftype == TType.BOOL:
26625 
          self.success = iprot.readBool();
26626 
        else:
26627 
          iprot.skip(ftype)
26628 
      else:
26629 
        iprot.skip(ftype)
26630 
      iprot.readFieldEnd()
26631 
    iprot.readStructEnd()
26632 
 
26633 
  def write(self, oprot):
26634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26636 
      return
26637 
    oprot.writeStructBegin('addOrUpdateFlipkartItem_result')
26638 
    if self.success is not None:
26639 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26640 
      oprot.writeBool(self.success)
26641 
      oprot.writeFieldEnd()
26642 
    oprot.writeFieldStop()
26643 
    oprot.writeStructEnd()
26644 
 
26645 
  def validate(self):
26646 
    return
26647 
 
26648 
 
26649 
  def __repr__(self):
26650 
    L = ['%s=%r' % (key, value)
26651 
      for key, value in self.__dict__.iteritems()]
26652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26653 
 
26654 
  def __eq__(self, other):
26655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26656 
 
26657 
  def __ne__(self, other):
26658 
    return not (self == other)
26659 
 
26660 
class getFlipkartItem_args:
26661 
  """
26662 
  Attributes:
26663 
   - item_id
26664 
  """
26665 
 
26666 
  thrift_spec = (
26667 
    None, # 0
26668 
    (1, TType.I64, 'item_id', None, None, ), # 1
26669 
  )
26670 
 
26671 
  def __init__(self, item_id=None,):
26672 
    self.item_id = item_id
26673 
 
26674 
  def read(self, iprot):
26675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26677 
      return
26678 
    iprot.readStructBegin()
26679 
    while True:
26680 
      (fname, ftype, fid) = iprot.readFieldBegin()
26681 
      if ftype == TType.STOP:
26682 
        break
26683 
      if fid == 1:
26684 
        if ftype == TType.I64:
26685 
          self.item_id = iprot.readI64();
26686 
        else:
26687 
          iprot.skip(ftype)
26688 
      else:
26689 
        iprot.skip(ftype)
26690 
      iprot.readFieldEnd()
26691 
    iprot.readStructEnd()
26692 
 
26693 
  def write(self, oprot):
26694 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26695 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26696 
      return
26697 
    oprot.writeStructBegin('getFlipkartItem_args')
26698 
    if self.item_id is not None:
26699 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
26700 
      oprot.writeI64(self.item_id)
26701 
      oprot.writeFieldEnd()
26702 
    oprot.writeFieldStop()
26703 
    oprot.writeStructEnd()
26704 
 
26705 
  def validate(self):
26706 
    return
26707 
 
26708 
 
26709 
  def __repr__(self):
26710 
    L = ['%s=%r' % (key, value)
26711 
      for key, value in self.__dict__.iteritems()]
26712 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26713 
 
26714 
  def __eq__(self, other):
26715 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26716 
 
26717 
  def __ne__(self, other):
26718 
    return not (self == other)
26719 
 
26720 
class getFlipkartItem_result:
26721 
  """
26722 
  Attributes:
26723 
   - success
26724 
  """
26725 
 
26726 
  thrift_spec = (
26727 
    (0, TType.STRUCT, 'success', (FlipkartItem, FlipkartItem.thrift_spec), None, ), # 0
26728 
  )
26729 
 
26730 
  def __init__(self, success=None,):
26731 
    self.success = success
26732 
 
26733 
  def read(self, iprot):
26734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26736 
      return
26737 
    iprot.readStructBegin()
26738 
    while True:
26739 
      (fname, ftype, fid) = iprot.readFieldBegin()
26740 
      if ftype == TType.STOP:
26741 
        break
26742 
      if fid == 0:
26743 
        if ftype == TType.STRUCT:
26744 
          self.success = FlipkartItem()
26745 
          self.success.read(iprot)
26746 
        else:
26747 
          iprot.skip(ftype)
26748 
      else:
26749 
        iprot.skip(ftype)
26750 
      iprot.readFieldEnd()
26751 
    iprot.readStructEnd()
26752 
 
26753 
  def write(self, oprot):
26754 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26755 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26756 
      return
26757 
    oprot.writeStructBegin('getFlipkartItem_result')
26758 
    if self.success is not None:
26759 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26760 
      self.success.write(oprot)
26761 
      oprot.writeFieldEnd()
26762 
    oprot.writeFieldStop()
26763 
    oprot.writeStructEnd()
26764 
 
26765 
  def validate(self):
26766 
    return
26767 
 
26768 
 
26769 
  def __repr__(self):
26770 
    L = ['%s=%r' % (key, value)
26771 
      for key, value in self.__dict__.iteritems()]
26772 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26773 
 
26774 
  def __eq__(self, other):
26775 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26776 
 
26777 
  def __ne__(self, other):
26778 
    return not (self == other)
26779 
 
26780 
class getFlipkartItemDetails_args:
26781 
  """
26782 
  Attributes:
26783 
   - item_id
26784 
  """
26785 
 
26786 
  thrift_spec = (
26787 
    None, # 0
26788 
    (1, TType.I64, 'item_id', None, None, ), # 1
26789 
  )
26790 
 
26791 
  def __init__(self, item_id=None,):
26792 
    self.item_id = item_id
26793 
 
26794 
  def read(self, iprot):
26795 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26796 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26797 
      return
26798 
    iprot.readStructBegin()
26799 
    while True:
26800 
      (fname, ftype, fid) = iprot.readFieldBegin()
26801 
      if ftype == TType.STOP:
26802 
        break
26803 
      if fid == 1:
26804 
        if ftype == TType.I64:
26805 
          self.item_id = iprot.readI64();
26806 
        else:
26807 
          iprot.skip(ftype)
26808 
      else:
26809 
        iprot.skip(ftype)
26810 
      iprot.readFieldEnd()
26811 
    iprot.readStructEnd()
26812 
 
26813 
  def write(self, oprot):
26814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26816 
      return
26817 
    oprot.writeStructBegin('getFlipkartItemDetails_args')
26818 
    if self.item_id is not None:
26819 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
26820 
      oprot.writeI64(self.item_id)
26821 
      oprot.writeFieldEnd()
26822 
    oprot.writeFieldStop()
26823 
    oprot.writeStructEnd()
26824 
 
26825 
  def validate(self):
26826 
    return
26827 
 
26828 
 
26829 
  def __repr__(self):
26830 
    L = ['%s=%r' % (key, value)
26831 
      for key, value in self.__dict__.iteritems()]
26832 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26833 
 
26834 
  def __eq__(self, other):
26835 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26836 
 
26837 
  def __ne__(self, other):
26838 
    return not (self == other)
26839 
 
26840 
class getFlipkartItemDetails_result:
26841 
  """
26842 
  Attributes:
26843 
   - success
26844 
  """
26845 
 
26846 
  thrift_spec = (
26847 
    (0, TType.STRUCT, 'success', (FlipkartItemDetails, FlipkartItemDetails.thrift_spec), None, ), # 0
26848 
  )
26849 
 
26850 
  def __init__(self, success=None,):
26851 
    self.success = success
26852 
 
26853 
  def read(self, iprot):
26854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26856 
      return
26857 
    iprot.readStructBegin()
26858 
    while True:
26859 
      (fname, ftype, fid) = iprot.readFieldBegin()
26860 
      if ftype == TType.STOP:
26861 
        break
26862 
      if fid == 0:
26863 
        if ftype == TType.STRUCT:
26864 
          self.success = FlipkartItemDetails()
26865 
          self.success.read(iprot)
26866 
        else:
26867 
          iprot.skip(ftype)
26868 
      else:
26869 
        iprot.skip(ftype)
26870 
      iprot.readFieldEnd()
26871 
    iprot.readStructEnd()
26872 
 
26873 
  def write(self, oprot):
26874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26876 
      return
26877 
    oprot.writeStructBegin('getFlipkartItemDetails_result')
26878 
    if self.success is not None:
26879 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26880 
      self.success.write(oprot)
26881 
      oprot.writeFieldEnd()
26882 
    oprot.writeFieldStop()
26883 
    oprot.writeStructEnd()
26884 
 
26885 
  def validate(self):
26886 
    return
26887 
 
26888 
 
26889 
  def __repr__(self):
26890 
    L = ['%s=%r' % (key, value)
26891 
      for key, value in self.__dict__.iteritems()]
26892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26893 
 
26894 
  def __eq__(self, other):
26895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26896 
 
26897 
  def __ne__(self, other):
26898 
    return not (self == other)
26899 
 
26900 
class getFlipkartItems_args:
26901 
  """
26902 
  Attributes:
26903 
   - offset
26904 
   - limit
26905 
  """
26906 
 
26907 
  thrift_spec = (
26908 
    None, # 0
26909 
    (1, TType.I64, 'offset', None, None, ), # 1
26910 
    (2, TType.I64, 'limit', None, None, ), # 2
26911 
  )
26912 
 
26913 
  def __init__(self, offset=None, limit=None,):
26914 
    self.offset = offset
26915 
    self.limit = limit
26916 
 
26917 
  def read(self, iprot):
26918 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26919 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26920 
      return
26921 
    iprot.readStructBegin()
26922 
    while True:
26923 
      (fname, ftype, fid) = iprot.readFieldBegin()
26924 
      if ftype == TType.STOP:
26925 
        break
26926 
      if fid == 1:
26927 
        if ftype == TType.I64:
26928 
          self.offset = iprot.readI64();
26929 
        else:
26930 
          iprot.skip(ftype)
26931 
      elif fid == 2:
26932 
        if ftype == TType.I64:
26933 
          self.limit = iprot.readI64();
26934 
        else:
26935 
          iprot.skip(ftype)
26936 
      else:
26937 
        iprot.skip(ftype)
26938 
      iprot.readFieldEnd()
26939 
    iprot.readStructEnd()
26940 
 
26941 
  def write(self, oprot):
26942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26944 
      return
26945 
    oprot.writeStructBegin('getFlipkartItems_args')
26946 
    if self.offset is not None:
26947 
      oprot.writeFieldBegin('offset', TType.I64, 1)
26948 
      oprot.writeI64(self.offset)
26949 
      oprot.writeFieldEnd()
26950 
    if self.limit is not None:
26951 
      oprot.writeFieldBegin('limit', TType.I64, 2)
26952 
      oprot.writeI64(self.limit)
26953 
      oprot.writeFieldEnd()
26954 
    oprot.writeFieldStop()
26955 
    oprot.writeStructEnd()
26956 
 
26957 
  def validate(self):
26958 
    return
26959 
 
26960 
 
26961 
  def __repr__(self):
26962 
    L = ['%s=%r' % (key, value)
26963 
      for key, value in self.__dict__.iteritems()]
26964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26965 
 
26966 
  def __eq__(self, other):
26967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26968 
 
26969 
  def __ne__(self, other):
26970 
    return not (self == other)
26971 
 
26972 
class getFlipkartItems_result:
26973 
  """
26974 
  Attributes:
26975 
   - success
26976 
  """
26977 
 
26978 
  thrift_spec = (
26979 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartItemDetails, FlipkartItemDetails.thrift_spec)), None, ), # 0
26980 
  )
26981 
 
26982 
  def __init__(self, success=None,):
26983 
    self.success = success
26984 
 
26985 
  def read(self, iprot):
26986 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26987 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26988 
      return
26989 
    iprot.readStructBegin()
26990 
    while True:
26991 
      (fname, ftype, fid) = iprot.readFieldBegin()
26992 
      if ftype == TType.STOP:
26993 
        break
26994 
      if fid == 0:
26995 
        if ftype == TType.LIST:
26996 
          self.success = []
26997 
          (_etype588, _size585) = iprot.readListBegin()
26998 
          for _i589 in xrange(_size585):
26999 
            _elem590 = FlipkartItemDetails()
27000 
            _elem590.read(iprot)
27001 
            self.success.append(_elem590)
27002 
          iprot.readListEnd()
27003 
        else:
27004 
          iprot.skip(ftype)
27005 
      else:
27006 
        iprot.skip(ftype)
27007 
      iprot.readFieldEnd()
27008 
    iprot.readStructEnd()
27009 
 
27010 
  def write(self, oprot):
27011 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27012 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27013 
      return
27014 
    oprot.writeStructBegin('getFlipkartItems_result')
27015 
    if self.success is not None:
27016 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27017 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
27018 
      for iter591 in self.success:
27019 
        iter591.write(oprot)
27020 
      oprot.writeListEnd()
27021 
      oprot.writeFieldEnd()
27022 
    oprot.writeFieldStop()
27023 
    oprot.writeStructEnd()
27024 
 
27025 
  def validate(self):
27026 
    return
27027 
 
27028 
 
27029 
  def __repr__(self):
27030 
    L = ['%s=%r' % (key, value)
27031 
      for key, value in self.__dict__.iteritems()]
27032 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27033 
 
27034 
  def __eq__(self, other):
27035 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27036 
 
27037 
  def __ne__(self, other):
27038 
    return not (self == other)
27039 
 
27040 
class searchFlipkartItems_args:
27041 
  """
27042 
  Attributes:
27043 
   - searchTerm
27044 
   - offset
27045 
   - limit
27046 
  """
27047 
 
27048 
  thrift_spec = (
27049 
    None, # 0
27050 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
27051 
    (2, TType.I64, 'offset', None, None, ), # 2
27052 
    (3, TType.I64, 'limit', None, None, ), # 3
27053 
  )
27054 
 
27055 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
27056 
    self.searchTerm = searchTerm
27057 
    self.offset = offset
27058 
    self.limit = limit
27059 
 
27060 
  def read(self, iprot):
27061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27063 
      return
27064 
    iprot.readStructBegin()
27065 
    while True:
27066 
      (fname, ftype, fid) = iprot.readFieldBegin()
27067 
      if ftype == TType.STOP:
27068 
        break
27069 
      if fid == 1:
27070 
        if ftype == TType.LIST:
27071 
          self.searchTerm = []
27072 
          (_etype595, _size592) = iprot.readListBegin()
27073 
          for _i596 in xrange(_size592):
27074 
            _elem597 = iprot.readString();
27075 
            self.searchTerm.append(_elem597)
27076 
          iprot.readListEnd()
27077 
        else:
27078 
          iprot.skip(ftype)
27079 
      elif fid == 2:
27080 
        if ftype == TType.I64:
27081 
          self.offset = iprot.readI64();
27082 
        else:
27083 
          iprot.skip(ftype)
27084 
      elif fid == 3:
27085 
        if ftype == TType.I64:
27086 
          self.limit = iprot.readI64();
27087 
        else:
27088 
          iprot.skip(ftype)
27089 
      else:
27090 
        iprot.skip(ftype)
27091 
      iprot.readFieldEnd()
27092 
    iprot.readStructEnd()
27093 
 
27094 
  def write(self, oprot):
27095 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27096 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27097 
      return
27098 
    oprot.writeStructBegin('searchFlipkartItems_args')
27099 
    if self.searchTerm is not None:
27100 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
27101 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
27102 
      for iter598 in self.searchTerm:
27103 
        oprot.writeString(iter598)
27104 
      oprot.writeListEnd()
27105 
      oprot.writeFieldEnd()
27106 
    if self.offset is not None:
27107 
      oprot.writeFieldBegin('offset', TType.I64, 2)
27108 
      oprot.writeI64(self.offset)
27109 
      oprot.writeFieldEnd()
27110 
    if self.limit is not None:
27111 
      oprot.writeFieldBegin('limit', TType.I64, 3)
27112 
      oprot.writeI64(self.limit)
27113 
      oprot.writeFieldEnd()
27114 
    oprot.writeFieldStop()
27115 
    oprot.writeStructEnd()
27116 
 
27117 
  def validate(self):
27118 
    return
27119 
 
27120 
 
27121 
  def __repr__(self):
27122 
    L = ['%s=%r' % (key, value)
27123 
      for key, value in self.__dict__.iteritems()]
27124 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27125 
 
27126 
  def __eq__(self, other):
27127 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27128 
 
27129 
  def __ne__(self, other):
27130 
    return not (self == other)
27131 
 
27132 
class searchFlipkartItems_result:
27133 
  """
27134 
  Attributes:
27135 
   - success
27136 
  """
27137 
 
27138 
  thrift_spec = (
27139 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartItemDetails, FlipkartItemDetails.thrift_spec)), None, ), # 0
27140 
  )
27141 
 
27142 
  def __init__(self, success=None,):
27143 
    self.success = success
27144 
 
27145 
  def read(self, iprot):
27146 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27147 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27148 
      return
27149 
    iprot.readStructBegin()
27150 
    while True:
27151 
      (fname, ftype, fid) = iprot.readFieldBegin()
27152 
      if ftype == TType.STOP:
27153 
        break
27154 
      if fid == 0:
27155 
        if ftype == TType.LIST:
27156 
          self.success = []
27157 
          (_etype602, _size599) = iprot.readListBegin()
27158 
          for _i603 in xrange(_size599):
27159 
            _elem604 = FlipkartItemDetails()
27160 
            _elem604.read(iprot)
27161 
            self.success.append(_elem604)
27162 
          iprot.readListEnd()
27163 
        else:
27164 
          iprot.skip(ftype)
27165 
      else:
27166 
        iprot.skip(ftype)
27167 
      iprot.readFieldEnd()
27168 
    iprot.readStructEnd()
27169 
 
27170 
  def write(self, oprot):
27171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27173 
      return
27174 
    oprot.writeStructBegin('searchFlipkartItems_result')
27175 
    if self.success is not None:
27176 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27177 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
27178 
      for iter605 in self.success:
27179 
        iter605.write(oprot)
27180 
      oprot.writeListEnd()
27181 
      oprot.writeFieldEnd()
27182 
    oprot.writeFieldStop()
27183 
    oprot.writeStructEnd()
27184 
 
27185 
  def validate(self):
27186 
    return
27187 
 
27188 
 
27189 
  def __repr__(self):
27190 
    L = ['%s=%r' % (key, value)
27191 
      for key, value in self.__dict__.iteritems()]
27192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27193 
 
27194 
  def __eq__(self, other):
27195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27196 
 
27197 
  def __ne__(self, other):
27198 
    return not (self == other)
27199 
 
27200 
class getCountForFlipkartItems_args:
27201 
 
27202 
  thrift_spec = (
27203 
  )
27204 
 
27205 
  def read(self, iprot):
27206 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27207 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27208 
      return
27209 
    iprot.readStructBegin()
27210 
    while True:
27211 
      (fname, ftype, fid) = iprot.readFieldBegin()
27212 
      if ftype == TType.STOP:
27213 
        break
27214 
      else:
27215 
        iprot.skip(ftype)
27216 
      iprot.readFieldEnd()
27217 
    iprot.readStructEnd()
27218 
 
27219 
  def write(self, oprot):
27220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27222 
      return
27223 
    oprot.writeStructBegin('getCountForFlipkartItems_args')
27224 
    oprot.writeFieldStop()
27225 
    oprot.writeStructEnd()
27226 
 
27227 
  def validate(self):
27228 
    return
27229 
 
27230 
 
27231 
  def __repr__(self):
27232 
    L = ['%s=%r' % (key, value)
27233 
      for key, value in self.__dict__.iteritems()]
27234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27235 
 
27236 
  def __eq__(self, other):
27237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27238 
 
27239 
  def __ne__(self, other):
27240 
    return not (self == other)
27241 
 
27242 
class getCountForFlipkartItems_result:
27243 
  """
27244 
  Attributes:
27245 
   - success
27246 
  """
27247 
 
27248 
  thrift_spec = (
27249 
    (0, TType.I64, 'success', None, None, ), # 0
27250 
  )
27251 
 
27252 
  def __init__(self, success=None,):
27253 
    self.success = success
27254 
 
27255 
  def read(self, iprot):
27256 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27257 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27258 
      return
27259 
    iprot.readStructBegin()
27260 
    while True:
27261 
      (fname, ftype, fid) = iprot.readFieldBegin()
27262 
      if ftype == TType.STOP:
27263 
        break
27264 
      if fid == 0:
27265 
        if ftype == TType.I64:
27266 
          self.success = iprot.readI64();
27267 
        else:
27268 
          iprot.skip(ftype)
27269 
      else:
27270 
        iprot.skip(ftype)
27271 
      iprot.readFieldEnd()
27272 
    iprot.readStructEnd()
27273 
 
27274 
  def write(self, oprot):
27275 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27276 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27277 
      return
27278 
    oprot.writeStructBegin('getCountForFlipkartItems_result')
27279 
    if self.success is not None:
27280 
      oprot.writeFieldBegin('success', TType.I64, 0)
27281 
      oprot.writeI64(self.success)
27282 
      oprot.writeFieldEnd()
27283 
    oprot.writeFieldStop()
27284 
    oprot.writeStructEnd()
27285 
 
27286 
  def validate(self):
27287 
    return
27288 
 
27289 
 
27290 
  def __repr__(self):
27291 
    L = ['%s=%r' % (key, value)
27292 
      for key, value in self.__dict__.iteritems()]
27293 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27294 
 
27295 
  def __eq__(self, other):
27296 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27297 
 
27298 
  def __ne__(self, other):
27299 
    return not (self == other)
27300 
 
27301 
class getFlipkartSearchResultCount_args:
27302 
  """
27303 
  Attributes:
27304 
   - searchTerm
27305 
  """
27306 
 
27307 
  thrift_spec = (
27308 
    None, # 0
27309 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
27310 
  )
27311 
 
27312 
  def __init__(self, searchTerm=None,):
27313 
    self.searchTerm = searchTerm
27314 
 
27315 
  def read(self, iprot):
27316 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27317 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27318 
      return
27319 
    iprot.readStructBegin()
27320 
    while True:
27321 
      (fname, ftype, fid) = iprot.readFieldBegin()
27322 
      if ftype == TType.STOP:
27323 
        break
27324 
      if fid == 1:
27325 
        if ftype == TType.LIST:
27326 
          self.searchTerm = []
27327 
          (_etype609, _size606) = iprot.readListBegin()
27328 
          for _i610 in xrange(_size606):
27329 
            _elem611 = iprot.readString();
27330 
            self.searchTerm.append(_elem611)
27331 
          iprot.readListEnd()
27332 
        else:
27333 
          iprot.skip(ftype)
27334 
      else:
27335 
        iprot.skip(ftype)
27336 
      iprot.readFieldEnd()
27337 
    iprot.readStructEnd()
27338 
 
27339 
  def write(self, oprot):
27340 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27341 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27342 
      return
27343 
    oprot.writeStructBegin('getFlipkartSearchResultCount_args')
27344 
    if self.searchTerm is not None:
27345 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
27346 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
27347 
      for iter612 in self.searchTerm:
27348 
        oprot.writeString(iter612)
27349 
      oprot.writeListEnd()
27350 
      oprot.writeFieldEnd()
27351 
    oprot.writeFieldStop()
27352 
    oprot.writeStructEnd()
27353 
 
27354 
  def validate(self):
27355 
    return
27356 
 
27357 
 
27358 
  def __repr__(self):
27359 
    L = ['%s=%r' % (key, value)
27360 
      for key, value in self.__dict__.iteritems()]
27361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27362 
 
27363 
  def __eq__(self, other):
27364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27365 
 
27366 
  def __ne__(self, other):
27367 
    return not (self == other)
27368 
 
27369 
class getFlipkartSearchResultCount_result:
27370 
  """
27371 
  Attributes:
27372 
   - success
27373 
  """
27374 
 
27375 
  thrift_spec = (
27376 
    (0, TType.I64, 'success', None, None, ), # 0
27377 
  )
27378 
 
27379 
  def __init__(self, success=None,):
27380 
    self.success = success
27381 
 
27382 
  def read(self, iprot):
27383 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27384 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27385 
      return
27386 
    iprot.readStructBegin()
27387 
    while True:
27388 
      (fname, ftype, fid) = iprot.readFieldBegin()
27389 
      if ftype == TType.STOP:
27390 
        break
27391 
      if fid == 0:
27392 
        if ftype == TType.I64:
27393 
          self.success = iprot.readI64();
27394 
        else:
27395 
          iprot.skip(ftype)
27396 
      else:
27397 
        iprot.skip(ftype)
27398 
      iprot.readFieldEnd()
27399 
    iprot.readStructEnd()
27400 
 
27401 
  def write(self, oprot):
27402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27404 
      return
27405 
    oprot.writeStructBegin('getFlipkartSearchResultCount_result')
27406 
    if self.success is not None:
27407 
      oprot.writeFieldBegin('success', TType.I64, 0)
27408 
      oprot.writeI64(self.success)
27409 
      oprot.writeFieldEnd()
27410 
    oprot.writeFieldStop()
27411 
    oprot.writeStructEnd()
27412 
 
27413 
  def validate(self):
27414 
    return
27415 
 
27416 
 
27417 
  def __repr__(self):
27418 
    L = ['%s=%r' % (key, value)
27419 
      for key, value in self.__dict__.iteritems()]
27420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27421 
 
27422 
  def __eq__(self, other):
27423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27424 
 
27425 
  def __ne__(self, other):
27426 
    return not (self == other)
27427 
 
27428 
class getAllFkItems_args:
27429 
 
27430 
  thrift_spec = (
27431 
  )
27432 
 
27433 
  def read(self, iprot):
27434 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27435 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27436 
      return
27437 
    iprot.readStructBegin()
27438 
    while True:
27439 
      (fname, ftype, fid) = iprot.readFieldBegin()
27440 
      if ftype == TType.STOP:
27441 
        break
27442 
      else:
27443 
        iprot.skip(ftype)
27444 
      iprot.readFieldEnd()
27445 
    iprot.readStructEnd()
27446 
 
27447 
  def write(self, oprot):
27448 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27449 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27450 
      return
27451 
    oprot.writeStructBegin('getAllFkItems_args')
27452 
    oprot.writeFieldStop()
27453 
    oprot.writeStructEnd()
27454 
 
27455 
  def validate(self):
27456 
    return
27457 
 
27458 
 
27459 
  def __repr__(self):
27460 
    L = ['%s=%r' % (key, value)
27461 
      for key, value in self.__dict__.iteritems()]
27462 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27463 
 
27464 
  def __eq__(self, other):
27465 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27466 
 
27467 
  def __ne__(self, other):
27468 
    return not (self == other)
27469 
 
27470 
class getAllFkItems_result:
27471 
  """
27472 
  Attributes:
27473 
   - success
27474 
  """
27475 
 
27476 
  thrift_spec = (
27477 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartItemDetails, FlipkartItemDetails.thrift_spec)), None, ), # 0
27478 
  )
27479 
 
27480 
  def __init__(self, success=None,):
27481 
    self.success = success
27482 
 
27483 
  def read(self, iprot):
27484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27486 
      return
27487 
    iprot.readStructBegin()
27488 
    while True:
27489 
      (fname, ftype, fid) = iprot.readFieldBegin()
27490 
      if ftype == TType.STOP:
27491 
        break
27492 
      if fid == 0:
27493 
        if ftype == TType.LIST:
27494 
          self.success = []
27495 
          (_etype616, _size613) = iprot.readListBegin()
27496 
          for _i617 in xrange(_size613):
27497 
            _elem618 = FlipkartItemDetails()
27498 
            _elem618.read(iprot)
27499 
            self.success.append(_elem618)
27500 
          iprot.readListEnd()
27501 
        else:
27502 
          iprot.skip(ftype)
27503 
      else:
27504 
        iprot.skip(ftype)
27505 
      iprot.readFieldEnd()
27506 
    iprot.readStructEnd()
27507 
 
27508 
  def write(self, oprot):
27509 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27510 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27511 
      return
27512 
    oprot.writeStructBegin('getAllFkItems_result')
27513 
    if self.success is not None:
27514 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27515 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
27516 
      for iter619 in self.success:
27517 
        iter619.write(oprot)
27518 
      oprot.writeListEnd()
27519 
      oprot.writeFieldEnd()
27520 
    oprot.writeFieldStop()
27521 
    oprot.writeStructEnd()
27522 
 
27523 
  def validate(self):
27524 
    return
27525 
 
27526 
 
27527 
  def __repr__(self):
27528 
    L = ['%s=%r' % (key, value)
27529 
      for key, value in self.__dict__.iteritems()]
27530 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27531 
 
27532 
  def __eq__(self, other):
27533 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27534 
 
27535 
  def __ne__(self, other):
27536 
    return not (self == other)
10140 vikram.rag 27537 
 
27538 
class getFlipkartItemBySkyAtFlipkart_args:
27539 
  """
27540 
  Attributes:
27541 
   - sku
27542 
  """
27543 
 
11015 kshitij.so 27544 
  thrift_spec = (
27545 
    None, # 0
27546 
    (1, TType.STRING, 'sku', None, None, ), # 1
27547 
  )
27548 
 
10140 vikram.rag 27549 
  def __init__(self, sku=None,):
27550 
    self.sku = sku
27551 
 
27552 
  def read(self, iprot):
27553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27555 
      return
27556 
    iprot.readStructBegin()
27557 
    while True:
27558 
      (fname, ftype, fid) = iprot.readFieldBegin()
27559 
      if ftype == TType.STOP:
27560 
        break
11015 kshitij.so 27561 
      if fid == 1:
10140 vikram.rag 27562 
        if ftype == TType.STRING:
27563 
          self.sku = iprot.readString();
27564 
        else:
27565 
          iprot.skip(ftype)
27566 
      else:
27567 
        iprot.skip(ftype)
27568 
      iprot.readFieldEnd()
27569 
    iprot.readStructEnd()
27570 
 
27571 
  def write(self, oprot):
27572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27574 
      return
27575 
    oprot.writeStructBegin('getFlipkartItemBySkyAtFlipkart_args')
27576 
    if self.sku is not None:
11015 kshitij.so 27577 
      oprot.writeFieldBegin('sku', TType.STRING, 1)
10140 vikram.rag 27578 
      oprot.writeString(self.sku)
27579 
      oprot.writeFieldEnd()
27580 
    oprot.writeFieldStop()
27581 
    oprot.writeStructEnd()
27582 
 
27583 
  def validate(self):
27584 
    return
27585 
 
27586 
 
27587 
  def __repr__(self):
27588 
    L = ['%s=%r' % (key, value)
27589 
      for key, value in self.__dict__.iteritems()]
27590 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27591 
 
27592 
  def __eq__(self, other):
27593 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27594 
 
27595 
  def __ne__(self, other):
27596 
    return not (self == other)
27597 
 
27598 
class getFlipkartItemBySkyAtFlipkart_result:
27599 
  """
27600 
  Attributes:
27601 
   - success
27602 
  """
27603 
 
27604 
  thrift_spec = (
27605 
    (0, TType.STRUCT, 'success', (FlipkartItem, FlipkartItem.thrift_spec), None, ), # 0
27606 
  )
27607 
 
27608 
  def __init__(self, success=None,):
27609 
    self.success = success
27610 
 
27611 
  def read(self, iprot):
27612 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27613 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27614 
      return
27615 
    iprot.readStructBegin()
27616 
    while True:
27617 
      (fname, ftype, fid) = iprot.readFieldBegin()
27618 
      if ftype == TType.STOP:
27619 
        break
27620 
      if fid == 0:
27621 
        if ftype == TType.STRUCT:
27622 
          self.success = FlipkartItem()
27623 
          self.success.read(iprot)
27624 
        else:
27625 
          iprot.skip(ftype)
27626 
      else:
27627 
        iprot.skip(ftype)
27628 
      iprot.readFieldEnd()
27629 
    iprot.readStructEnd()
27630 
 
27631 
  def write(self, oprot):
27632 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27633 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27634 
      return
27635 
    oprot.writeStructBegin('getFlipkartItemBySkyAtFlipkart_result')
27636 
    if self.success is not None:
27637 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27638 
      self.success.write(oprot)
27639 
      oprot.writeFieldEnd()
27640 
    oprot.writeFieldStop()
27641 
    oprot.writeStructEnd()
27642 
 
27643 
  def validate(self):
27644 
    return
27645 
 
27646 
 
27647 
  def __repr__(self):
27648 
    L = ['%s=%r' % (key, value)
27649 
      for key, value in self.__dict__.iteritems()]
27650 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27651 
 
27652 
  def __eq__(self, other):
27653 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27654 
 
27655 
  def __ne__(self, other):
27656 
    return not (self == other)
10909 vikram.rag 27657 
 
11015 kshitij.so 27658 
class getMarketplaceHistory_args:
27659 
  """
27660 
  Attributes:
27661 
   - source
27662 
   - offset
27663 
   - itemId
27664 
  """
10909 vikram.rag 27665 
 
27666 
  thrift_spec = (
11015 kshitij.so 27667 
    None, # 0
27668 
    (1, TType.I64, 'source', None, None, ), # 1
27669 
    (2, TType.I64, 'offset', None, None, ), # 2
27670 
    (3, TType.I64, 'itemId', None, None, ), # 3
10909 vikram.rag 27671 
  )
27672 
 
11015 kshitij.so 27673 
  def __init__(self, source=None, offset=None, itemId=None,):
27674 
    self.source = source
27675 
    self.offset = offset
27676 
    self.itemId = itemId
27677 
 
10909 vikram.rag 27678 
  def read(self, iprot):
27679 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27680 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27681 
      return
27682 
    iprot.readStructBegin()
27683 
    while True:
27684 
      (fname, ftype, fid) = iprot.readFieldBegin()
27685 
      if ftype == TType.STOP:
27686 
        break
11015 kshitij.so 27687 
      if fid == 1:
27688 
        if ftype == TType.I64:
27689 
          self.source = iprot.readI64();
27690 
        else:
27691 
          iprot.skip(ftype)
27692 
      elif fid == 2:
27693 
        if ftype == TType.I64:
27694 
          self.offset = iprot.readI64();
27695 
        else:
27696 
          iprot.skip(ftype)
27697 
      elif fid == 3:
27698 
        if ftype == TType.I64:
27699 
          self.itemId = iprot.readI64();
27700 
        else:
27701 
          iprot.skip(ftype)
10909 vikram.rag 27702 
      else:
27703 
        iprot.skip(ftype)
27704 
      iprot.readFieldEnd()
27705 
    iprot.readStructEnd()
27706 
 
27707 
  def write(self, oprot):
27708 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27709 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27710 
      return
11015 kshitij.so 27711 
    oprot.writeStructBegin('getMarketplaceHistory_args')
27712 
    if self.source is not None:
27713 
      oprot.writeFieldBegin('source', TType.I64, 1)
27714 
      oprot.writeI64(self.source)
27715 
      oprot.writeFieldEnd()
27716 
    if self.offset is not None:
27717 
      oprot.writeFieldBegin('offset', TType.I64, 2)
27718 
      oprot.writeI64(self.offset)
27719 
      oprot.writeFieldEnd()
27720 
    if self.itemId is not None:
27721 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
27722 
      oprot.writeI64(self.itemId)
27723 
      oprot.writeFieldEnd()
10909 vikram.rag 27724 
    oprot.writeFieldStop()
27725 
    oprot.writeStructEnd()
27726 
 
27727 
  def validate(self):
27728 
    return
27729 
 
27730 
 
27731 
  def __repr__(self):
27732 
    L = ['%s=%r' % (key, value)
27733 
      for key, value in self.__dict__.iteritems()]
27734 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27735 
 
27736 
  def __eq__(self, other):
27737 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27738 
 
27739 
  def __ne__(self, other):
27740 
    return not (self == other)
27741 
 
11015 kshitij.so 27742 
class getMarketplaceHistory_result:
10909 vikram.rag 27743 
  """
27744 
  Attributes:
27745 
   - success
27746 
  """
27747 
 
27748 
  thrift_spec = (
11015 kshitij.so 27749 
    (0, TType.LIST, 'success', (TType.STRUCT,(MarketplaceHistory, MarketplaceHistory.thrift_spec)), None, ), # 0
10909 vikram.rag 27750 
  )
27751 
 
27752 
  def __init__(self, success=None,):
27753 
    self.success = success
27754 
 
27755 
  def read(self, iprot):
27756 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27757 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27758 
      return
27759 
    iprot.readStructBegin()
27760 
    while True:
27761 
      (fname, ftype, fid) = iprot.readFieldBegin()
27762 
      if ftype == TType.STOP:
27763 
        break
27764 
      if fid == 0:
27765 
        if ftype == TType.LIST:
27766 
          self.success = []
27767 
          (_etype623, _size620) = iprot.readListBegin()
27768 
          for _i624 in xrange(_size620):
11015 kshitij.so 27769 
            _elem625 = MarketplaceHistory()
10909 vikram.rag 27770 
            _elem625.read(iprot)
27771 
            self.success.append(_elem625)
27772 
          iprot.readListEnd()
27773 
        else:
27774 
          iprot.skip(ftype)
27775 
      else:
27776 
        iprot.skip(ftype)
27777 
      iprot.readFieldEnd()
27778 
    iprot.readStructEnd()
27779 
 
27780 
  def write(self, oprot):
27781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27783 
      return
11015 kshitij.so 27784 
    oprot.writeStructBegin('getMarketplaceHistory_result')
10909 vikram.rag 27785 
    if self.success is not None:
27786 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27787 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
27788 
      for iter626 in self.success:
27789 
        iter626.write(oprot)
27790 
      oprot.writeListEnd()
27791 
      oprot.writeFieldEnd()
27792 
    oprot.writeFieldStop()
27793 
    oprot.writeStructEnd()
27794 
 
27795 
  def validate(self):
27796 
    return
27797 
 
27798 
 
27799 
  def __repr__(self):
27800 
    L = ['%s=%r' % (key, value)
27801 
      for key, value in self.__dict__.iteritems()]
27802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27803 
 
27804 
  def __eq__(self, other):
27805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27806 
 
27807 
  def __ne__(self, other):
27808 
    return not (self == other)
10924 vikram.rag 27809 
 
11015 kshitij.so 27810 
class getAllFbbListedItems_args:
10924 vikram.rag 27811 
 
27812 
  thrift_spec = (
27813 
  )
27814 
 
27815 
  def read(self, iprot):
27816 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27817 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27818 
      return
27819 
    iprot.readStructBegin()
27820 
    while True:
27821 
      (fname, ftype, fid) = iprot.readFieldBegin()
27822 
      if ftype == TType.STOP:
27823 
        break
27824 
      else:
27825 
        iprot.skip(ftype)
27826 
      iprot.readFieldEnd()
27827 
    iprot.readStructEnd()
27828 
 
27829 
  def write(self, oprot):
27830 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27831 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27832 
      return
11015 kshitij.so 27833 
    oprot.writeStructBegin('getAllFbbListedItems_args')
10924 vikram.rag 27834 
    oprot.writeFieldStop()
27835 
    oprot.writeStructEnd()
27836 
 
27837 
  def validate(self):
27838 
    return
27839 
 
27840 
 
27841 
  def __repr__(self):
27842 
    L = ['%s=%r' % (key, value)
27843 
      for key, value in self.__dict__.iteritems()]
27844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27845 
 
27846 
  def __eq__(self, other):
27847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27848 
 
27849 
  def __ne__(self, other):
27850 
    return not (self == other)
27851 
 
11015 kshitij.so 27852 
class getAllFbbListedItems_result:
10924 vikram.rag 27853 
  """
27854 
  Attributes:
27855 
   - success
27856 
  """
27857 
 
27858 
  thrift_spec = (
27859 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
27860 
  )
27861 
 
27862 
  def __init__(self, success=None,):
27863 
    self.success = success
27864 
 
27865 
  def read(self, iprot):
27866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27868 
      return
27869 
    iprot.readStructBegin()
27870 
    while True:
27871 
      (fname, ftype, fid) = iprot.readFieldBegin()
27872 
      if ftype == TType.STOP:
27873 
        break
27874 
      if fid == 0:
27875 
        if ftype == TType.LIST:
27876 
          self.success = []
27877 
          (_etype630, _size627) = iprot.readListBegin()
27878 
          for _i631 in xrange(_size627):
27879 
            _elem632 = Amazonlisted()
27880 
            _elem632.read(iprot)
27881 
            self.success.append(_elem632)
27882 
          iprot.readListEnd()
27883 
        else:
27884 
          iprot.skip(ftype)
27885 
      else:
27886 
        iprot.skip(ftype)
27887 
      iprot.readFieldEnd()
27888 
    iprot.readStructEnd()
27889 
 
27890 
  def write(self, oprot):
27891 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27892 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27893 
      return
11015 kshitij.so 27894 
    oprot.writeStructBegin('getAllFbbListedItems_result')
10924 vikram.rag 27895 
    if self.success is not None:
27896 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27897 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
27898 
      for iter633 in self.success:
27899 
        iter633.write(oprot)
27900 
      oprot.writeListEnd()
27901 
      oprot.writeFieldEnd()
27902 
    oprot.writeFieldStop()
27903 
    oprot.writeStructEnd()
27904 
 
27905 
  def validate(self):
27906 
    return
27907 
 
27908 
 
27909 
  def __repr__(self):
27910 
    L = ['%s=%r' % (key, value)
27911 
      for key, value in self.__dict__.iteritems()]
27912 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27913 
 
27914 
  def __eq__(self, other):
27915 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27916 
 
27917 
  def __ne__(self, other):
27918 
    return not (self == other)
11015 kshitij.so 27919 
 
27920 
class getAllFbbPricingItems_args:
27921 
 
27922 
  thrift_spec = (
27923 
  )
27924 
 
27925 
  def read(self, iprot):
27926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27928 
      return
27929 
    iprot.readStructBegin()
27930 
    while True:
27931 
      (fname, ftype, fid) = iprot.readFieldBegin()
27932 
      if ftype == TType.STOP:
27933 
        break
27934 
      else:
27935 
        iprot.skip(ftype)
27936 
      iprot.readFieldEnd()
27937 
    iprot.readStructEnd()
27938 
 
27939 
  def write(self, oprot):
27940 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27941 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27942 
      return
27943 
    oprot.writeStructBegin('getAllFbbPricingItems_args')
27944 
    oprot.writeFieldStop()
27945 
    oprot.writeStructEnd()
27946 
 
27947 
  def validate(self):
27948 
    return
27949 
 
27950 
 
27951 
  def __repr__(self):
27952 
    L = ['%s=%r' % (key, value)
27953 
      for key, value in self.__dict__.iteritems()]
27954 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27955 
 
27956 
  def __eq__(self, other):
27957 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27958 
 
27959 
  def __ne__(self, other):
27960 
    return not (self == other)
27961 
 
27962 
class getAllFbbPricingItems_result:
27963 
  """
27964 
  Attributes:
27965 
   - success
27966 
  """
27967 
 
27968 
  thrift_spec = (
27969 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
27970 
  )
27971 
 
27972 
  def __init__(self, success=None,):
27973 
    self.success = success
27974 
 
27975 
  def read(self, iprot):
27976 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27977 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27978 
      return
27979 
    iprot.readStructBegin()
27980 
    while True:
27981 
      (fname, ftype, fid) = iprot.readFieldBegin()
27982 
      if ftype == TType.STOP:
27983 
        break
27984 
      if fid == 0:
27985 
        if ftype == TType.LIST:
27986 
          self.success = []
27987 
          (_etype637, _size634) = iprot.readListBegin()
27988 
          for _i638 in xrange(_size634):
27989 
            _elem639 = Amazonlisted()
27990 
            _elem639.read(iprot)
27991 
            self.success.append(_elem639)
27992 
          iprot.readListEnd()
27993 
        else:
27994 
          iprot.skip(ftype)
27995 
      else:
27996 
        iprot.skip(ftype)
27997 
      iprot.readFieldEnd()
27998 
    iprot.readStructEnd()
27999 
 
28000 
  def write(self, oprot):
28001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28003 
      return
28004 
    oprot.writeStructBegin('getAllFbbPricingItems_result')
28005 
    if self.success is not None:
28006 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28007 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
28008 
      for iter640 in self.success:
28009 
        iter640.write(oprot)
28010 
      oprot.writeListEnd()
28011 
      oprot.writeFieldEnd()
28012 
    oprot.writeFieldStop()
28013 
    oprot.writeStructEnd()
28014 
 
28015 
  def validate(self):
28016 
    return
28017 
 
28018 
 
28019 
  def __repr__(self):
28020 
    L = ['%s=%r' % (key, value)
28021 
      for key, value in self.__dict__.iteritems()]
28022 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28023 
 
28024 
  def __eq__(self, other):
28025 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28026 
 
28027 
  def __ne__(self, other):
28028 
    return not (self == other)
28029 
 
28030 
class getCountForMarketplaceHistory_args:
28031 
  """
28032 
  Attributes:
28033 
   - source
28034 
   - itemId
28035 
  """
28036 
 
28037 
  thrift_spec = (
28038 
    None, # 0
28039 
    (1, TType.I64, 'source', None, None, ), # 1
28040 
    (2, TType.I64, 'itemId', None, None, ), # 2
28041 
  )
28042 
 
28043 
  def __init__(self, source=None, itemId=None,):
28044 
    self.source = source
28045 
    self.itemId = itemId
28046 
 
28047 
  def read(self, iprot):
28048 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28049 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28050 
      return
28051 
    iprot.readStructBegin()
28052 
    while True:
28053 
      (fname, ftype, fid) = iprot.readFieldBegin()
28054 
      if ftype == TType.STOP:
28055 
        break
28056 
      if fid == 1:
28057 
        if ftype == TType.I64:
28058 
          self.source = iprot.readI64();
28059 
        else:
28060 
          iprot.skip(ftype)
28061 
      elif fid == 2:
28062 
        if ftype == TType.I64:
28063 
          self.itemId = iprot.readI64();
28064 
        else:
28065 
          iprot.skip(ftype)
28066 
      else:
28067 
        iprot.skip(ftype)
28068 
      iprot.readFieldEnd()
28069 
    iprot.readStructEnd()
28070 
 
28071 
  def write(self, oprot):
28072 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28073 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28074 
      return
28075 
    oprot.writeStructBegin('getCountForMarketplaceHistory_args')
28076 
    if self.source is not None:
28077 
      oprot.writeFieldBegin('source', TType.I64, 1)
28078 
      oprot.writeI64(self.source)
28079 
      oprot.writeFieldEnd()
28080 
    if self.itemId is not None:
28081 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
28082 
      oprot.writeI64(self.itemId)
28083 
      oprot.writeFieldEnd()
28084 
    oprot.writeFieldStop()
28085 
    oprot.writeStructEnd()
28086 
 
28087 
  def validate(self):
28088 
    return
28089 
 
28090 
 
28091 
  def __repr__(self):
28092 
    L = ['%s=%r' % (key, value)
28093 
      for key, value in self.__dict__.iteritems()]
28094 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28095 
 
28096 
  def __eq__(self, other):
28097 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28098 
 
28099 
  def __ne__(self, other):
28100 
    return not (self == other)
28101 
 
28102 
class getCountForMarketplaceHistory_result:
28103 
  """
28104 
  Attributes:
28105 
   - success
28106 
  """
28107 
 
28108 
  thrift_spec = (
28109 
    (0, TType.I64, 'success', None, None, ), # 0
28110 
  )
28111 
 
28112 
  def __init__(self, success=None,):
28113 
    self.success = success
28114 
 
28115 
  def read(self, iprot):
28116 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28117 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28118 
      return
28119 
    iprot.readStructBegin()
28120 
    while True:
28121 
      (fname, ftype, fid) = iprot.readFieldBegin()
28122 
      if ftype == TType.STOP:
28123 
        break
28124 
      if fid == 0:
28125 
        if ftype == TType.I64:
28126 
          self.success = iprot.readI64();
28127 
        else:
28128 
          iprot.skip(ftype)
28129 
      else:
28130 
        iprot.skip(ftype)
28131 
      iprot.readFieldEnd()
28132 
    iprot.readStructEnd()
28133 
 
28134 
  def write(self, oprot):
28135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28137 
      return
28138 
    oprot.writeStructBegin('getCountForMarketplaceHistory_result')
28139 
    if self.success is not None:
28140 
      oprot.writeFieldBegin('success', TType.I64, 0)
28141 
      oprot.writeI64(self.success)
28142 
      oprot.writeFieldEnd()
28143 
    oprot.writeFieldStop()
28144 
    oprot.writeStructEnd()
28145 
 
28146 
  def validate(self):
28147 
    return
28148 
 
28149 
 
28150 
  def __repr__(self):
28151 
    L = ['%s=%r' % (key, value)
28152 
      for key, value in self.__dict__.iteritems()]
28153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28154 
 
28155 
  def __eq__(self, other):
28156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28157 
 
28158 
  def __ne__(self, other):
28159 
    return not (self == other)
28160 
 
28161 
class getMarketplaceHistoryByDate_args:
28162 
  """
28163 
  Attributes:
28164 
   - source
28165 
   - startDate
28166 
   - endDate
28167 
   - offset
28168 
   - limit
28169 
   - itemId
28170 
  """
28171 
 
28172 
  thrift_spec = (
28173 
    None, # 0
28174 
    (1, TType.I64, 'source', None, None, ), # 1
28175 
    (2, TType.I64, 'startDate', None, None, ), # 2
28176 
    (3, TType.I64, 'endDate', None, None, ), # 3
28177 
    (4, TType.I64, 'offset', None, None, ), # 4
28178 
    (5, TType.I64, 'limit', None, None, ), # 5
28179 
    (6, TType.I64, 'itemId', None, None, ), # 6
28180 
  )
28181 
 
28182 
  def __init__(self, source=None, startDate=None, endDate=None, offset=None, limit=None, itemId=None,):
28183 
    self.source = source
28184 
    self.startDate = startDate
28185 
    self.endDate = endDate
28186 
    self.offset = offset
28187 
    self.limit = limit
28188 
    self.itemId = itemId
28189 
 
28190 
  def read(self, iprot):
28191 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28192 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28193 
      return
28194 
    iprot.readStructBegin()
28195 
    while True:
28196 
      (fname, ftype, fid) = iprot.readFieldBegin()
28197 
      if ftype == TType.STOP:
28198 
        break
28199 
      if fid == 1:
28200 
        if ftype == TType.I64:
28201 
          self.source = iprot.readI64();
28202 
        else:
28203 
          iprot.skip(ftype)
28204 
      elif fid == 2:
28205 
        if ftype == TType.I64:
28206 
          self.startDate = iprot.readI64();
28207 
        else:
28208 
          iprot.skip(ftype)
28209 
      elif fid == 3:
28210 
        if ftype == TType.I64:
28211 
          self.endDate = iprot.readI64();
28212 
        else:
28213 
          iprot.skip(ftype)
28214 
      elif fid == 4:
28215 
        if ftype == TType.I64:
28216 
          self.offset = iprot.readI64();
28217 
        else:
28218 
          iprot.skip(ftype)
28219 
      elif fid == 5:
28220 
        if ftype == TType.I64:
28221 
          self.limit = iprot.readI64();
28222 
        else:
28223 
          iprot.skip(ftype)
28224 
      elif fid == 6:
28225 
        if ftype == TType.I64:
28226 
          self.itemId = iprot.readI64();
28227 
        else:
28228 
          iprot.skip(ftype)
28229 
      else:
28230 
        iprot.skip(ftype)
28231 
      iprot.readFieldEnd()
28232 
    iprot.readStructEnd()
28233 
 
28234 
  def write(self, oprot):
28235 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28236 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28237 
      return
28238 
    oprot.writeStructBegin('getMarketplaceHistoryByDate_args')
28239 
    if self.source is not None:
28240 
      oprot.writeFieldBegin('source', TType.I64, 1)
28241 
      oprot.writeI64(self.source)
28242 
      oprot.writeFieldEnd()
28243 
    if self.startDate is not None:
28244 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
28245 
      oprot.writeI64(self.startDate)
28246 
      oprot.writeFieldEnd()
28247 
    if self.endDate is not None:
28248 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
28249 
      oprot.writeI64(self.endDate)
28250 
      oprot.writeFieldEnd()
28251 
    if self.offset is not None:
28252 
      oprot.writeFieldBegin('offset', TType.I64, 4)
28253 
      oprot.writeI64(self.offset)
28254 
      oprot.writeFieldEnd()
28255 
    if self.limit is not None:
28256 
      oprot.writeFieldBegin('limit', TType.I64, 5)
28257 
      oprot.writeI64(self.limit)
28258 
      oprot.writeFieldEnd()
28259 
    if self.itemId is not None:
28260 
      oprot.writeFieldBegin('itemId', TType.I64, 6)
28261 
      oprot.writeI64(self.itemId)
28262 
      oprot.writeFieldEnd()
28263 
    oprot.writeFieldStop()
28264 
    oprot.writeStructEnd()
28265 
 
28266 
  def validate(self):
28267 
    return
28268 
 
28269 
 
28270 
  def __repr__(self):
28271 
    L = ['%s=%r' % (key, value)
28272 
      for key, value in self.__dict__.iteritems()]
28273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28274 
 
28275 
  def __eq__(self, other):
28276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28277 
 
28278 
  def __ne__(self, other):
28279 
    return not (self == other)
28280 
 
28281 
class getMarketplaceHistoryByDate_result:
28282 
  """
28283 
  Attributes:
28284 
   - success
28285 
  """
28286 
 
28287 
  thrift_spec = (
28288 
    (0, TType.LIST, 'success', (TType.STRUCT,(MarketplaceHistory, MarketplaceHistory.thrift_spec)), None, ), # 0
28289 
  )
28290 
 
28291 
  def __init__(self, success=None,):
28292 
    self.success = success
28293 
 
28294 
  def read(self, iprot):
28295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28297 
      return
28298 
    iprot.readStructBegin()
28299 
    while True:
28300 
      (fname, ftype, fid) = iprot.readFieldBegin()
28301 
      if ftype == TType.STOP:
28302 
        break
28303 
      if fid == 0:
28304 
        if ftype == TType.LIST:
28305 
          self.success = []
28306 
          (_etype644, _size641) = iprot.readListBegin()
28307 
          for _i645 in xrange(_size641):
28308 
            _elem646 = MarketplaceHistory()
28309 
            _elem646.read(iprot)
28310 
            self.success.append(_elem646)
28311 
          iprot.readListEnd()
28312 
        else:
28313 
          iprot.skip(ftype)
28314 
      else:
28315 
        iprot.skip(ftype)
28316 
      iprot.readFieldEnd()
28317 
    iprot.readStructEnd()
28318 
 
28319 
  def write(self, oprot):
28320 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28321 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28322 
      return
28323 
    oprot.writeStructBegin('getMarketplaceHistoryByDate_result')
28324 
    if self.success is not None:
28325 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28326 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
28327 
      for iter647 in self.success:
28328 
        iter647.write(oprot)
28329 
      oprot.writeListEnd()
28330 
      oprot.writeFieldEnd()
28331 
    oprot.writeFieldStop()
28332 
    oprot.writeStructEnd()
28333 
 
28334 
  def validate(self):
28335 
    return
28336 
 
28337 
 
28338 
  def __repr__(self):
28339 
    L = ['%s=%r' % (key, value)
28340 
      for key, value in self.__dict__.iteritems()]
28341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28342 
 
28343 
  def __eq__(self, other):
28344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28345 
 
28346 
  def __ne__(self, other):
28347 
    return not (self == other)