Subversion Repositories SmartDukaan

Rev

Rev 10909 | Rev 11015 | 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 
 
10909 vikram.rag 1114 
  def getAllFbbListedItems(self, ):
1115 
    pass
10140 vikram.rag 1116 
 
10924 vikram.rag 1117 
  def getAllFbbPricingItems(self, ):
1118 
    pass
10909 vikram.rag 1119 
 
10924 vikram.rag 1120 
 
5944 mandeep.dh 1121 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
1122 
  def __init__(self, iprot, oprot=None):
1123 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
1124 
 
1125 
  def addItem(self, item):
1126 
    """
1127 
    Availability and inventory attributes
1128 
 
1129 
    Parameters:
1130 
     - item
1131 
    """
1132 
    self.send_addItem(item)
1133 
    return self.recv_addItem()
1134 
 
1135 
  def send_addItem(self, item):
1136 
    self._oprot.writeMessageBegin('addItem', TMessageType.CALL, self._seqid)
1137 
    args = addItem_args()
1138 
    args.item = item
1139 
    args.write(self._oprot)
1140 
    self._oprot.writeMessageEnd()
1141 
    self._oprot.trans.flush()
1142 
 
1143 
  def recv_addItem(self, ):
1144 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1145 
    if mtype == TMessageType.EXCEPTION:
1146 
      x = TApplicationException()
1147 
      x.read(self._iprot)
1148 
      self._iprot.readMessageEnd()
1149 
      raise x
1150 
    result = addItem_result()
1151 
    result.read(self._iprot)
1152 
    self._iprot.readMessageEnd()
1153 
    if result.success is not None:
1154 
      return result.success
1155 
    if result.cex is not None:
1156 
      raise result.cex
1157 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItem failed: unknown result");
1158 
 
1159 
  def updateItem(self, item):
1160 
    """
1161 
    Parameters:
1162 
     - item
1163 
    """
1164 
    self.send_updateItem(item)
1165 
    return self.recv_updateItem()
1166 
 
1167 
  def send_updateItem(self, item):
1168 
    self._oprot.writeMessageBegin('updateItem', TMessageType.CALL, self._seqid)
1169 
    args = updateItem_args()
1170 
    args.item = item
1171 
    args.write(self._oprot)
1172 
    self._oprot.writeMessageEnd()
1173 
    self._oprot.trans.flush()
1174 
 
1175 
  def recv_updateItem(self, ):
1176 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1177 
    if mtype == TMessageType.EXCEPTION:
1178 
      x = TApplicationException()
1179 
      x.read(self._iprot)
1180 
      self._iprot.readMessageEnd()
1181 
      raise x
1182 
    result = updateItem_result()
1183 
    result.read(self._iprot)
1184 
    self._iprot.readMessageEnd()
1185 
    if result.success is not None:
1186 
      return result.success
1187 
    if result.cex is not None:
1188 
      raise result.cex
1189 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItem failed: unknown result");
1190 
 
1191 
  def isActive(self, itemId):
1192 
    """
1193 
    Checks if the item given to the corresponding itemId is active. If it's active,
1194 
    whether it's risky and if it's risky, its inventory position.
1195 
 
1196 
    Parameters:
1197 
     - itemId
1198 
    """
1199 
    self.send_isActive(itemId)
1200 
    return self.recv_isActive()
1201 
 
1202 
  def send_isActive(self, itemId):
1203 
    self._oprot.writeMessageBegin('isActive', TMessageType.CALL, self._seqid)
1204 
    args = isActive_args()
1205 
    args.itemId = itemId
1206 
    args.write(self._oprot)
1207 
    self._oprot.writeMessageEnd()
1208 
    self._oprot.trans.flush()
1209 
 
1210 
  def recv_isActive(self, ):
1211 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1212 
    if mtype == TMessageType.EXCEPTION:
1213 
      x = TApplicationException()
1214 
      x.read(self._iprot)
1215 
      self._iprot.readMessageEnd()
1216 
      raise x
1217 
    result = isActive_result()
1218 
    result.read(self._iprot)
1219 
    self._iprot.readMessageEnd()
1220 
    if result.success is not None:
1221 
      return result.success
1222 
    if result.isex is not None:
1223 
      raise result.isex
1224 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isActive failed: unknown result");
1225 
 
7438 amit.gupta 1226 
  def getItemsStatus(self, itemIds):
1227 
    """
1228 
    Parameters:
1229 
     - itemIds
1230 
    """
1231 
    self.send_getItemsStatus(itemIds)
1232 
    return self.recv_getItemsStatus()
1233 
 
1234 
  def send_getItemsStatus(self, itemIds):
1235 
    self._oprot.writeMessageBegin('getItemsStatus', TMessageType.CALL, self._seqid)
1236 
    args = getItemsStatus_args()
1237 
    args.itemIds = itemIds
1238 
    args.write(self._oprot)
1239 
    self._oprot.writeMessageEnd()
1240 
    self._oprot.trans.flush()
1241 
 
1242 
  def recv_getItemsStatus(self, ):
1243 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1244 
    if mtype == TMessageType.EXCEPTION:
1245 
      x = TApplicationException()
1246 
      x.read(self._iprot)
1247 
      self._iprot.readMessageEnd()
1248 
      raise x
1249 
    result = getItemsStatus_result()
1250 
    result.read(self._iprot)
1251 
    self._iprot.readMessageEnd()
1252 
    if result.success is not None:
1253 
      return result.success
1254 
    if result.isex is not None:
1255 
      raise result.isex
1256 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsStatus failed: unknown result");
1257 
 
5944 mandeep.dh 1258 
  def getItemStatusDescription(self, itemId):
1259 
    """
1260 
    Parameters:
1261 
     - itemId
1262 
    """
1263 
    self.send_getItemStatusDescription(itemId)
1264 
    return self.recv_getItemStatusDescription()
1265 
 
1266 
  def send_getItemStatusDescription(self, itemId):
1267 
    self._oprot.writeMessageBegin('getItemStatusDescription', TMessageType.CALL, self._seqid)
1268 
    args = getItemStatusDescription_args()
1269 
    args.itemId = itemId
1270 
    args.write(self._oprot)
1271 
    self._oprot.writeMessageEnd()
1272 
    self._oprot.trans.flush()
1273 
 
1274 
  def recv_getItemStatusDescription(self, ):
1275 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1276 
    if mtype == TMessageType.EXCEPTION:
1277 
      x = TApplicationException()
1278 
      x.read(self._iprot)
1279 
      self._iprot.readMessageEnd()
1280 
      raise x
1281 
    result = getItemStatusDescription_result()
1282 
    result.read(self._iprot)
1283 
    self._iprot.readMessageEnd()
1284 
    if result.success is not None:
1285 
      return result.success
1286 
    if result.isex is not None:
1287 
      raise result.isex
1288 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStatusDescription failed: unknown result");
1289 
 
1290 
  def startItemOn(self, item_id, timestamp):
1291 
    """
1292 
    Parameters:
1293 
     - item_id
1294 
     - timestamp
1295 
    """
1296 
    self.send_startItemOn(item_id, timestamp)
1297 
    self.recv_startItemOn()
1298 
 
1299 
  def send_startItemOn(self, item_id, timestamp):
1300 
    self._oprot.writeMessageBegin('startItemOn', TMessageType.CALL, self._seqid)
1301 
    args = startItemOn_args()
1302 
    args.item_id = item_id
1303 
    args.timestamp = timestamp
1304 
    args.write(self._oprot)
1305 
    self._oprot.writeMessageEnd()
1306 
    self._oprot.trans.flush()
1307 
 
1308 
  def recv_startItemOn(self, ):
1309 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1310 
    if mtype == TMessageType.EXCEPTION:
1311 
      x = TApplicationException()
1312 
      x.read(self._iprot)
1313 
      self._iprot.readMessageEnd()
1314 
      raise x
1315 
    result = startItemOn_result()
1316 
    result.read(self._iprot)
1317 
    self._iprot.readMessageEnd()
1318 
    if result.cex is not None:
1319 
      raise result.cex
1320 
    return
1321 
 
1322 
  def retireItemOn(self, item_id, timestamp):
1323 
    """
1324 
    Parameters:
1325 
     - item_id
1326 
     - timestamp
1327 
    """
1328 
    self.send_retireItemOn(item_id, timestamp)
1329 
    self.recv_retireItemOn()
1330 
 
1331 
  def send_retireItemOn(self, item_id, timestamp):
1332 
    self._oprot.writeMessageBegin('retireItemOn', TMessageType.CALL, self._seqid)
1333 
    args = retireItemOn_args()
1334 
    args.item_id = item_id
1335 
    args.timestamp = timestamp
1336 
    args.write(self._oprot)
1337 
    self._oprot.writeMessageEnd()
1338 
    self._oprot.trans.flush()
1339 
 
1340 
  def recv_retireItemOn(self, ):
1341 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1342 
    if mtype == TMessageType.EXCEPTION:
1343 
      x = TApplicationException()
1344 
      x.read(self._iprot)
1345 
      self._iprot.readMessageEnd()
1346 
      raise x
1347 
    result = retireItemOn_result()
1348 
    result.read(self._iprot)
1349 
    self._iprot.readMessageEnd()
1350 
    if result.cex is not None:
1351 
      raise result.cex
1352 
    return
1353 
 
1354 
  def changeItemStatus(self, item_id, timestamp, newstatus):
1355 
    """
1356 
    Parameters:
1357 
     - item_id
1358 
     - timestamp
1359 
     - newstatus
1360 
    """
1361 
    self.send_changeItemStatus(item_id, timestamp, newstatus)
1362 
    self.recv_changeItemStatus()
1363 
 
1364 
  def send_changeItemStatus(self, item_id, timestamp, newstatus):
1365 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
1366 
    args = changeItemStatus_args()
1367 
    args.item_id = item_id
1368 
    args.timestamp = timestamp
1369 
    args.newstatus = newstatus
1370 
    args.write(self._oprot)
1371 
    self._oprot.writeMessageEnd()
1372 
    self._oprot.trans.flush()
1373 
 
1374 
  def recv_changeItemStatus(self, ):
1375 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1376 
    if mtype == TMessageType.EXCEPTION:
1377 
      x = TApplicationException()
1378 
      x.read(self._iprot)
1379 
      self._iprot.readMessageEnd()
1380 
      raise x
1381 
    result = changeItemStatus_result()
1382 
    result.read(self._iprot)
1383 
    self._iprot.readMessageEnd()
1384 
    if result.cex is not None:
1385 
      raise result.cex
1386 
    return
1387 
 
1388 
  def getItem(self, item_id):
1389 
    """
1390 
    Parameters:
1391 
     - item_id
1392 
    """
1393 
    self.send_getItem(item_id)
1394 
    return self.recv_getItem()
1395 
 
1396 
  def send_getItem(self, item_id):
1397 
    self._oprot.writeMessageBegin('getItem', TMessageType.CALL, self._seqid)
1398 
    args = getItem_args()
1399 
    args.item_id = item_id
1400 
    args.write(self._oprot)
1401 
    self._oprot.writeMessageEnd()
1402 
    self._oprot.trans.flush()
1403 
 
1404 
  def recv_getItem(self, ):
1405 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1406 
    if mtype == TMessageType.EXCEPTION:
1407 
      x = TApplicationException()
1408 
      x.read(self._iprot)
1409 
      self._iprot.readMessageEnd()
1410 
      raise x
1411 
    result = getItem_result()
1412 
    result.read(self._iprot)
1413 
    self._iprot.readMessageEnd()
1414 
    if result.success is not None:
1415 
      return result.success
1416 
    if result.cex is not None:
1417 
      raise result.cex
1418 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItem failed: unknown result");
1419 
 
1420 
  def getItemsByCatalogId(self, catalog_item_id):
1421 
    """
1422 
    Parameters:
1423 
     - catalog_item_id
1424 
    """
1425 
    self.send_getItemsByCatalogId(catalog_item_id)
1426 
    return self.recv_getItemsByCatalogId()
1427 
 
1428 
  def send_getItemsByCatalogId(self, catalog_item_id):
1429 
    self._oprot.writeMessageBegin('getItemsByCatalogId', TMessageType.CALL, self._seqid)
1430 
    args = getItemsByCatalogId_args()
1431 
    args.catalog_item_id = catalog_item_id
1432 
    args.write(self._oprot)
1433 
    self._oprot.writeMessageEnd()
1434 
    self._oprot.trans.flush()
1435 
 
1436 
  def recv_getItemsByCatalogId(self, ):
1437 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1438 
    if mtype == TMessageType.EXCEPTION:
1439 
      x = TApplicationException()
1440 
      x.read(self._iprot)
1441 
      self._iprot.readMessageEnd()
1442 
      raise x
1443 
    result = getItemsByCatalogId_result()
1444 
    result.read(self._iprot)
1445 
    self._iprot.readMessageEnd()
1446 
    if result.success is not None:
1447 
      return result.success
1448 
    if result.cex is not None:
1449 
      raise result.cex
1450 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByCatalogId failed: unknown result");
1451 
 
1452 
  def getValidItemsByCatalogId(self, catalog_item_id):
1453 
    """
1454 
    Parameters:
1455 
     - catalog_item_id
1456 
    """
1457 
    self.send_getValidItemsByCatalogId(catalog_item_id)
1458 
    return self.recv_getValidItemsByCatalogId()
1459 
 
1460 
  def send_getValidItemsByCatalogId(self, catalog_item_id):
1461 
    self._oprot.writeMessageBegin('getValidItemsByCatalogId', TMessageType.CALL, self._seqid)
1462 
    args = getValidItemsByCatalogId_args()
1463 
    args.catalog_item_id = catalog_item_id
1464 
    args.write(self._oprot)
1465 
    self._oprot.writeMessageEnd()
1466 
    self._oprot.trans.flush()
1467 
 
1468 
  def recv_getValidItemsByCatalogId(self, ):
1469 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1470 
    if mtype == TMessageType.EXCEPTION:
1471 
      x = TApplicationException()
1472 
      x.read(self._iprot)
1473 
      self._iprot.readMessageEnd()
1474 
      raise x
1475 
    result = getValidItemsByCatalogId_result()
1476 
    result.read(self._iprot)
1477 
    self._iprot.readMessageEnd()
1478 
    if result.success is not None:
1479 
      return result.success
1480 
    if result.cex is not None:
1481 
      raise result.cex
1482 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidItemsByCatalogId failed: unknown result");
1483 
 
1484 
  def getAllItems(self, isActive):
1485 
    """
1486 
    Parameters:
1487 
     - isActive
1488 
    """
1489 
    self.send_getAllItems(isActive)
1490 
    return self.recv_getAllItems()
1491 
 
1492 
  def send_getAllItems(self, isActive):
1493 
    self._oprot.writeMessageBegin('getAllItems', TMessageType.CALL, self._seqid)
1494 
    args = getAllItems_args()
1495 
    args.isActive = isActive
1496 
    args.write(self._oprot)
1497 
    self._oprot.writeMessageEnd()
1498 
    self._oprot.trans.flush()
1499 
 
1500 
  def recv_getAllItems(self, ):
1501 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1502 
    if mtype == TMessageType.EXCEPTION:
1503 
      x = TApplicationException()
1504 
      x.read(self._iprot)
1505 
      self._iprot.readMessageEnd()
1506 
      raise x
1507 
    result = getAllItems_result()
1508 
    result.read(self._iprot)
1509 
    self._iprot.readMessageEnd()
1510 
    if result.success is not None:
1511 
      return result.success
1512 
    if result.cex is not None:
1513 
      raise result.cex
1514 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItems failed: unknown result");
1515 
 
1516 
  def getAllItemsByStatus(self, itemStatus):
1517 
    """
1518 
    Parameters:
1519 
     - itemStatus
1520 
    """
1521 
    self.send_getAllItemsByStatus(itemStatus)
1522 
    return self.recv_getAllItemsByStatus()
1523 
 
1524 
  def send_getAllItemsByStatus(self, itemStatus):
1525 
    self._oprot.writeMessageBegin('getAllItemsByStatus', TMessageType.CALL, self._seqid)
1526 
    args = getAllItemsByStatus_args()
1527 
    args.itemStatus = itemStatus
1528 
    args.write(self._oprot)
1529 
    self._oprot.writeMessageEnd()
1530 
    self._oprot.trans.flush()
1531 
 
1532 
  def recv_getAllItemsByStatus(self, ):
1533 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1534 
    if mtype == TMessageType.EXCEPTION:
1535 
      x = TApplicationException()
1536 
      x.read(self._iprot)
1537 
      self._iprot.readMessageEnd()
1538 
      raise x
1539 
    result = getAllItemsByStatus_result()
1540 
    result.read(self._iprot)
1541 
    self._iprot.readMessageEnd()
1542 
    if result.success is not None:
1543 
      return result.success
1544 
    if result.cex is not None:
1545 
      raise result.cex
1546 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatus failed: unknown result");
1547 
 
9253 rajveer 1548 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber, isAndroid):
5944 mandeep.dh 1549 
    """
1550 
    Parameters:
1551 
     - entityId
1552 
     - category
1553 
     - brand
1554 
     - modelName
1555 
     - modelNumber
9253 rajveer 1556 
     - isAndroid
5944 mandeep.dh 1557 
    """
9253 rajveer 1558 
    self.send_markItemAsContentComplete(entityId, category, brand, modelName, modelNumber, isAndroid)
5944 mandeep.dh 1559 
    return self.recv_markItemAsContentComplete()
1560 
 
9253 rajveer 1561 
  def send_markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber, isAndroid):
5944 mandeep.dh 1562 
    self._oprot.writeMessageBegin('markItemAsContentComplete', TMessageType.CALL, self._seqid)
1563 
    args = markItemAsContentComplete_args()
1564 
    args.entityId = entityId
1565 
    args.category = category
1566 
    args.brand = brand
1567 
    args.modelName = modelName
1568 
    args.modelNumber = modelNumber
9253 rajveer 1569 
    args.isAndroid = isAndroid
5944 mandeep.dh 1570 
    args.write(self._oprot)
1571 
    self._oprot.writeMessageEnd()
1572 
    self._oprot.trans.flush()
1573 
 
1574 
  def recv_markItemAsContentComplete(self, ):
1575 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1576 
    if mtype == TMessageType.EXCEPTION:
1577 
      x = TApplicationException()
1578 
      x.read(self._iprot)
1579 
      self._iprot.readMessageEnd()
1580 
      raise x
1581 
    result = markItemAsContentComplete_result()
1582 
    result.read(self._iprot)
1583 
    self._iprot.readMessageEnd()
1584 
    if result.success is not None:
1585 
      return result.success
1586 
    if result.cex is not None:
1587 
      raise result.cex
1588 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markItemAsContentComplete failed: unknown result");
1589 
 
1590 
  def getAllItemsInRange(self, offset, limit):
1591 
    """
1592 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
1593 
 
1594 
    Parameters:
1595 
     - offset
1596 
     - limit
1597 
    """
1598 
    self.send_getAllItemsInRange(offset, limit)
1599 
    return self.recv_getAllItemsInRange()
1600 
 
1601 
  def send_getAllItemsInRange(self, offset, limit):
1602 
    self._oprot.writeMessageBegin('getAllItemsInRange', TMessageType.CALL, self._seqid)
1603 
    args = getAllItemsInRange_args()
1604 
    args.offset = offset
1605 
    args.limit = limit
1606 
    args.write(self._oprot)
1607 
    self._oprot.writeMessageEnd()
1608 
    self._oprot.trans.flush()
1609 
 
1610 
  def recv_getAllItemsInRange(self, ):
1611 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1612 
    if mtype == TMessageType.EXCEPTION:
1613 
      x = TApplicationException()
1614 
      x.read(self._iprot)
1615 
      self._iprot.readMessageEnd()
1616 
      raise x
1617 
    result = getAllItemsInRange_result()
1618 
    result.read(self._iprot)
1619 
    self._iprot.readMessageEnd()
1620 
    if result.success is not None:
1621 
      return result.success
1622 
    if result.cex is not None:
1623 
      raise result.cex
1624 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsInRange failed: unknown result");
1625 
 
1626 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1627 
    """
1628 
    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.
1629 
 
1630 
    Parameters:
1631 
     - itemStatus
1632 
     - offset
1633 
     - limit
1634 
    """
1635 
    self.send_getAllItemsByStatusInRange(itemStatus, offset, limit)
1636 
    return self.recv_getAllItemsByStatusInRange()
1637 
 
1638 
  def send_getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1639 
    self._oprot.writeMessageBegin('getAllItemsByStatusInRange', TMessageType.CALL, self._seqid)
1640 
    args = getAllItemsByStatusInRange_args()
1641 
    args.itemStatus = itemStatus
1642 
    args.offset = offset
1643 
    args.limit = limit
1644 
    args.write(self._oprot)
1645 
    self._oprot.writeMessageEnd()
1646 
    self._oprot.trans.flush()
1647 
 
1648 
  def recv_getAllItemsByStatusInRange(self, ):
1649 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1650 
    if mtype == TMessageType.EXCEPTION:
1651 
      x = TApplicationException()
1652 
      x.read(self._iprot)
1653 
      self._iprot.readMessageEnd()
1654 
      raise x
1655 
    result = getAllItemsByStatusInRange_result()
1656 
    result.read(self._iprot)
1657 
    self._iprot.readMessageEnd()
1658 
    if result.success is not None:
1659 
      return result.success
1660 
    if result.cex is not None:
1661 
      raise result.cex
1662 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatusInRange failed: unknown result");
1663 
 
1664 
  def getItemCountByStatus(self, useStatus, itemStatus):
1665 
    """
1666 
    Gets a count of all items by status
1667 
 
1668 
    Parameters:
1669 
     - useStatus
1670 
     - itemStatus
1671 
    """
1672 
    self.send_getItemCountByStatus(useStatus, itemStatus)
1673 
    return self.recv_getItemCountByStatus()
1674 
 
1675 
  def send_getItemCountByStatus(self, useStatus, itemStatus):
1676 
    self._oprot.writeMessageBegin('getItemCountByStatus', TMessageType.CALL, self._seqid)
1677 
    args = getItemCountByStatus_args()
1678 
    args.useStatus = useStatus
1679 
    args.itemStatus = itemStatus
1680 
    args.write(self._oprot)
1681 
    self._oprot.writeMessageEnd()
1682 
    self._oprot.trans.flush()
1683 
 
1684 
  def recv_getItemCountByStatus(self, ):
1685 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1686 
    if mtype == TMessageType.EXCEPTION:
1687 
      x = TApplicationException()
1688 
      x.read(self._iprot)
1689 
      self._iprot.readMessageEnd()
1690 
      raise x
1691 
    result = getItemCountByStatus_result()
1692 
    result.read(self._iprot)
1693 
    self._iprot.readMessageEnd()
1694 
    if result.success is not None:
1695 
      return result.success
1696 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemCountByStatus failed: unknown result");
1697 
 
1698 
  def getBestSellers(self, ):
1699 
    self.send_getBestSellers()
1700 
    return self.recv_getBestSellers()
1701 
 
1702 
  def send_getBestSellers(self, ):
1703 
    self._oprot.writeMessageBegin('getBestSellers', TMessageType.CALL, self._seqid)
1704 
    args = getBestSellers_args()
1705 
    args.write(self._oprot)
1706 
    self._oprot.writeMessageEnd()
1707 
    self._oprot.trans.flush()
1708 
 
1709 
  def recv_getBestSellers(self, ):
1710 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1711 
    if mtype == TMessageType.EXCEPTION:
1712 
      x = TApplicationException()
1713 
      x.read(self._iprot)
1714 
      self._iprot.readMessageEnd()
1715 
      raise x
1716 
    result = getBestSellers_result()
1717 
    result.read(self._iprot)
1718 
    self._iprot.readMessageEnd()
1719 
    if result.success is not None:
1720 
      return result.success
1721 
    if result.isex is not None:
1722 
      raise result.isex
1723 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellers failed: unknown result");
1724 
 
1725 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1726 
    """
1727 
    Parameters:
1728 
     - beginIndex
1729 
     - totalItems
1730 
     - brand
1731 
     - category
1732 
    """
1733 
    self.send_getBestSellersCatalogIds(beginIndex, totalItems, brand, category)
1734 
    return self.recv_getBestSellersCatalogIds()
1735 
 
1736 
  def send_getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1737 
    self._oprot.writeMessageBegin('getBestSellersCatalogIds', TMessageType.CALL, self._seqid)
1738 
    args = getBestSellersCatalogIds_args()
1739 
    args.beginIndex = beginIndex
1740 
    args.totalItems = totalItems
1741 
    args.brand = brand
1742 
    args.category = category
1743 
    args.write(self._oprot)
1744 
    self._oprot.writeMessageEnd()
1745 
    self._oprot.trans.flush()
1746 
 
1747 
  def recv_getBestSellersCatalogIds(self, ):
1748 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1749 
    if mtype == TMessageType.EXCEPTION:
1750 
      x = TApplicationException()
1751 
      x.read(self._iprot)
1752 
      self._iprot.readMessageEnd()
1753 
      raise x
1754 
    result = getBestSellersCatalogIds_result()
1755 
    result.read(self._iprot)
1756 
    self._iprot.readMessageEnd()
1757 
    if result.success is not None:
1758 
      return result.success
1759 
    if result.cex is not None:
1760 
      raise result.cex
1761 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCatalogIds failed: unknown result");
1762 
 
1763 
  def getBestSellersCount(self, ):
1764 
    self.send_getBestSellersCount()
1765 
    return self.recv_getBestSellersCount()
1766 
 
1767 
  def send_getBestSellersCount(self, ):
1768 
    self._oprot.writeMessageBegin('getBestSellersCount', TMessageType.CALL, self._seqid)
1769 
    args = getBestSellersCount_args()
1770 
    args.write(self._oprot)
1771 
    self._oprot.writeMessageEnd()
1772 
    self._oprot.trans.flush()
1773 
 
1774 
  def recv_getBestSellersCount(self, ):
1775 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1776 
    if mtype == TMessageType.EXCEPTION:
1777 
      x = TApplicationException()
1778 
      x.read(self._iprot)
1779 
      self._iprot.readMessageEnd()
1780 
      raise x
1781 
    result = getBestSellersCount_result()
1782 
    result.read(self._iprot)
1783 
    self._iprot.readMessageEnd()
1784 
    if result.success is not None:
1785 
      return result.success
1786 
    if result.cex is not None:
1787 
      raise result.cex
1788 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCount failed: unknown result");
1789 
 
1790 
  def getBestDeals(self, ):
1791 
    self.send_getBestDeals()
1792 
    return self.recv_getBestDeals()
1793 
 
1794 
  def send_getBestDeals(self, ):
1795 
    self._oprot.writeMessageBegin('getBestDeals', TMessageType.CALL, self._seqid)
1796 
    args = getBestDeals_args()
1797 
    args.write(self._oprot)
1798 
    self._oprot.writeMessageEnd()
1799 
    self._oprot.trans.flush()
1800 
 
1801 
  def recv_getBestDeals(self, ):
1802 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1803 
    if mtype == TMessageType.EXCEPTION:
1804 
      x = TApplicationException()
1805 
      x.read(self._iprot)
1806 
      self._iprot.readMessageEnd()
1807 
      raise x
1808 
    result = getBestDeals_result()
1809 
    result.read(self._iprot)
1810 
    self._iprot.readMessageEnd()
1811 
    if result.success is not None:
1812 
      return result.success
1813 
    if result.isex is not None:
1814 
      raise result.isex
1815 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDeals failed: unknown result");
1816 
 
1817 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1818 
    """
1819 
    Parameters:
1820 
     - beginIndex
1821 
     - totalItems
1822 
     - brand
1823 
     - category
1824 
    """
1825 
    self.send_getBestDealsCatalogIds(beginIndex, totalItems, brand, category)
1826 
    return self.recv_getBestDealsCatalogIds()
1827 
 
1828 
  def send_getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1829 
    self._oprot.writeMessageBegin('getBestDealsCatalogIds', TMessageType.CALL, self._seqid)
1830 
    args = getBestDealsCatalogIds_args()
1831 
    args.beginIndex = beginIndex
1832 
    args.totalItems = totalItems
1833 
    args.brand = brand
1834 
    args.category = category
1835 
    args.write(self._oprot)
1836 
    self._oprot.writeMessageEnd()
1837 
    self._oprot.trans.flush()
1838 
 
1839 
  def recv_getBestDealsCatalogIds(self, ):
1840 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1841 
    if mtype == TMessageType.EXCEPTION:
1842 
      x = TApplicationException()
1843 
      x.read(self._iprot)
1844 
      self._iprot.readMessageEnd()
1845 
      raise x
1846 
    result = getBestDealsCatalogIds_result()
1847 
    result.read(self._iprot)
1848 
    self._iprot.readMessageEnd()
1849 
    if result.success is not None:
1850 
      return result.success
1851 
    if result.cex is not None:
1852 
      raise result.cex
1853 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCatalogIds failed: unknown result");
1854 
 
1855 
  def getBestDealsCount(self, ):
1856 
    self.send_getBestDealsCount()
1857 
    return self.recv_getBestDealsCount()
1858 
 
1859 
  def send_getBestDealsCount(self, ):
1860 
    self._oprot.writeMessageBegin('getBestDealsCount', TMessageType.CALL, self._seqid)
1861 
    args = getBestDealsCount_args()
1862 
    args.write(self._oprot)
1863 
    self._oprot.writeMessageEnd()
1864 
    self._oprot.trans.flush()
1865 
 
1866 
  def recv_getBestDealsCount(self, ):
1867 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1868 
    if mtype == TMessageType.EXCEPTION:
1869 
      x = TApplicationException()
1870 
      x.read(self._iprot)
1871 
      self._iprot.readMessageEnd()
1872 
      raise x
1873 
    result = getBestDealsCount_result()
1874 
    result.read(self._iprot)
1875 
    self._iprot.readMessageEnd()
1876 
    if result.success is not None:
1877 
      return result.success
1878 
    if result.cex is not None:
1879 
      raise result.cex
1880 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCount failed: unknown result");
1881 
 
1882 
  def getComingSoon(self, ):
1883 
    self.send_getComingSoon()
1884 
    return self.recv_getComingSoon()
1885 
 
1886 
  def send_getComingSoon(self, ):
1887 
    self._oprot.writeMessageBegin('getComingSoon', TMessageType.CALL, self._seqid)
1888 
    args = getComingSoon_args()
1889 
    args.write(self._oprot)
1890 
    self._oprot.writeMessageEnd()
1891 
    self._oprot.trans.flush()
1892 
 
1893 
  def recv_getComingSoon(self, ):
1894 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1895 
    if mtype == TMessageType.EXCEPTION:
1896 
      x = TApplicationException()
1897 
      x.read(self._iprot)
1898 
      self._iprot.readMessageEnd()
1899 
      raise x
1900 
    result = getComingSoon_result()
1901 
    result.read(self._iprot)
1902 
    self._iprot.readMessageEnd()
1903 
    if result.success is not None:
1904 
      return result.success
1905 
    if result.isex is not None:
1906 
      raise result.isex
1907 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoon failed: unknown result");
1908 
 
1909 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1910 
    """
1911 
    Parameters:
1912 
     - beginIndex
1913 
     - totalItems
1914 
     - brand
1915 
     - category
1916 
    """
1917 
    self.send_getComingSoonCatalogIds(beginIndex, totalItems, brand, category)
1918 
    return self.recv_getComingSoonCatalogIds()
1919 
 
1920 
  def send_getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1921 
    self._oprot.writeMessageBegin('getComingSoonCatalogIds', TMessageType.CALL, self._seqid)
1922 
    args = getComingSoonCatalogIds_args()
1923 
    args.beginIndex = beginIndex
1924 
    args.totalItems = totalItems
1925 
    args.brand = brand
1926 
    args.category = category
1927 
    args.write(self._oprot)
1928 
    self._oprot.writeMessageEnd()
1929 
    self._oprot.trans.flush()
1930 
 
1931 
  def recv_getComingSoonCatalogIds(self, ):
1932 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1933 
    if mtype == TMessageType.EXCEPTION:
1934 
      x = TApplicationException()
1935 
      x.read(self._iprot)
1936 
      self._iprot.readMessageEnd()
1937 
      raise x
1938 
    result = getComingSoonCatalogIds_result()
1939 
    result.read(self._iprot)
1940 
    self._iprot.readMessageEnd()
1941 
    if result.success is not None:
1942 
      return result.success
1943 
    if result.cex is not None:
1944 
      raise result.cex
1945 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCatalogIds failed: unknown result");
1946 
 
1947 
  def getComingSoonCount(self, ):
1948 
    self.send_getComingSoonCount()
1949 
    return self.recv_getComingSoonCount()
1950 
 
1951 
  def send_getComingSoonCount(self, ):
1952 
    self._oprot.writeMessageBegin('getComingSoonCount', TMessageType.CALL, self._seqid)
1953 
    args = getComingSoonCount_args()
1954 
    args.write(self._oprot)
1955 
    self._oprot.writeMessageEnd()
1956 
    self._oprot.trans.flush()
1957 
 
1958 
  def recv_getComingSoonCount(self, ):
1959 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1960 
    if mtype == TMessageType.EXCEPTION:
1961 
      x = TApplicationException()
1962 
      x.read(self._iprot)
1963 
      self._iprot.readMessageEnd()
1964 
      raise x
1965 
    result = getComingSoonCount_result()
1966 
    result.read(self._iprot)
1967 
    self._iprot.readMessageEnd()
1968 
    if result.success is not None:
1969 
      return result.success
1970 
    if result.cex is not None:
1971 
      raise result.cex
1972 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCount failed: unknown result");
1973 
 
1974 
  def getLatestArrivals(self, ):
1975 
    """
1976 
    Returns a list of items sorted in the descending order by start date.
1977 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
1978 
    """
1979 
    self.send_getLatestArrivals()
1980 
    return self.recv_getLatestArrivals()
1981 
 
1982 
  def send_getLatestArrivals(self, ):
1983 
    self._oprot.writeMessageBegin('getLatestArrivals', TMessageType.CALL, self._seqid)
1984 
    args = getLatestArrivals_args()
1985 
    args.write(self._oprot)
1986 
    self._oprot.writeMessageEnd()
1987 
    self._oprot.trans.flush()
1988 
 
1989 
  def recv_getLatestArrivals(self, ):
1990 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1991 
    if mtype == TMessageType.EXCEPTION:
1992 
      x = TApplicationException()
1993 
      x.read(self._iprot)
1994 
      self._iprot.readMessageEnd()
1995 
      raise x
1996 
    result = getLatestArrivals_result()
1997 
    result.read(self._iprot)
1998 
    self._iprot.readMessageEnd()
1999 
    if result.success is not None:
2000 
      return result.success
2001 
    if result.isex is not None:
2002 
      raise result.isex
2003 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivals failed: unknown result");
2004 
 
2005 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
2006 
    """
2007 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
2008 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
2009 
 
2010 
    Parameters:
2011 
     - beginIndex
2012 
     - totalItems
2013 
     - brand
2014 
     - categories
2015 
    """
2016 
    self.send_getLatestArrivalsCatalogIds(beginIndex, totalItems, brand, categories)
2017 
    return self.recv_getLatestArrivalsCatalogIds()
2018 
 
2019 
  def send_getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
2020 
    self._oprot.writeMessageBegin('getLatestArrivalsCatalogIds', TMessageType.CALL, self._seqid)
2021 
    args = getLatestArrivalsCatalogIds_args()
2022 
    args.beginIndex = beginIndex
2023 
    args.totalItems = totalItems
2024 
    args.brand = brand
2025 
    args.categories = categories
2026 
    args.write(self._oprot)
2027 
    self._oprot.writeMessageEnd()
2028 
    self._oprot.trans.flush()
2029 
 
2030 
  def recv_getLatestArrivalsCatalogIds(self, ):
2031 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2032 
    if mtype == TMessageType.EXCEPTION:
2033 
      x = TApplicationException()
2034 
      x.read(self._iprot)
2035 
      self._iprot.readMessageEnd()
2036 
      raise x
2037 
    result = getLatestArrivalsCatalogIds_result()
2038 
    result.read(self._iprot)
2039 
    self._iprot.readMessageEnd()
2040 
    if result.success is not None:
2041 
      return result.success
2042 
    if result.cex is not None:
2043 
      raise result.cex
2044 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCatalogIds failed: unknown result");
2045 
 
2046 
  def getLatestArrivalsCount(self, ):
2047 
    """
2048 
    Get the total number of latest arrivals we are willing to show.
2049 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
2050 
    """
2051 
    self.send_getLatestArrivalsCount()
2052 
    return self.recv_getLatestArrivalsCount()
2053 
 
2054 
  def send_getLatestArrivalsCount(self, ):
2055 
    self._oprot.writeMessageBegin('getLatestArrivalsCount', TMessageType.CALL, self._seqid)
2056 
    args = getLatestArrivalsCount_args()
2057 
    args.write(self._oprot)
2058 
    self._oprot.writeMessageEnd()
2059 
    self._oprot.trans.flush()
2060 
 
2061 
  def recv_getLatestArrivalsCount(self, ):
2062 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2063 
    if mtype == TMessageType.EXCEPTION:
2064 
      x = TApplicationException()
2065 
      x.read(self._iprot)
2066 
      self._iprot.readMessageEnd()
2067 
      raise x
2068 
    result = getLatestArrivalsCount_result()
2069 
    result.read(self._iprot)
2070 
    self._iprot.readMessageEnd()
2071 
    if result.success is not None:
2072 
      return result.success
2073 
    if result.cex is not None:
2074 
      raise result.cex
2075 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCount failed: unknown result");
2076 
 
2077 
  def generateNewEntityID(self, ):
2078 
    self.send_generateNewEntityID()
2079 
    return self.recv_generateNewEntityID()
2080 
 
2081 
  def send_generateNewEntityID(self, ):
2082 
    self._oprot.writeMessageBegin('generateNewEntityID', TMessageType.CALL, self._seqid)
2083 
    args = generateNewEntityID_args()
2084 
    args.write(self._oprot)
2085 
    self._oprot.writeMessageEnd()
2086 
    self._oprot.trans.flush()
2087 
 
2088 
  def recv_generateNewEntityID(self, ):
2089 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2090 
    if mtype == TMessageType.EXCEPTION:
2091 
      x = TApplicationException()
2092 
      x.read(self._iprot)
2093 
      self._iprot.readMessageEnd()
2094 
      raise x
2095 
    result = generateNewEntityID_result()
2096 
    result.read(self._iprot)
2097 
    self._iprot.readMessageEnd()
2098 
    if result.success is not None:
2099 
      return result.success
2100 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateNewEntityID failed: unknown result");
2101 
 
2102 
  def addCategory(self, category):
2103 
    """
2104 
    All category related functions
2105 
 
2106 
    Parameters:
2107 
     - category
2108 
    """
2109 
    self.send_addCategory(category)
2110 
    return self.recv_addCategory()
2111 
 
2112 
  def send_addCategory(self, category):
2113 
    self._oprot.writeMessageBegin('addCategory', TMessageType.CALL, self._seqid)
2114 
    args = addCategory_args()
2115 
    args.category = category
2116 
    args.write(self._oprot)
2117 
    self._oprot.writeMessageEnd()
2118 
    self._oprot.trans.flush()
2119 
 
2120 
  def recv_addCategory(self, ):
2121 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2122 
    if mtype == TMessageType.EXCEPTION:
2123 
      x = TApplicationException()
2124 
      x.read(self._iprot)
2125 
      self._iprot.readMessageEnd()
2126 
      raise x
2127 
    result = addCategory_result()
2128 
    result.read(self._iprot)
2129 
    self._iprot.readMessageEnd()
2130 
    if result.success is not None:
2131 
      return result.success
2132 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addCategory failed: unknown result");
2133 
 
2134 
  def getCategory(self, id):
2135 
    """
2136 
    Parameters:
2137 
     - id
2138 
    """
2139 
    self.send_getCategory(id)
2140 
    return self.recv_getCategory()
2141 
 
2142 
  def send_getCategory(self, id):
2143 
    self._oprot.writeMessageBegin('getCategory', TMessageType.CALL, self._seqid)
2144 
    args = getCategory_args()
2145 
    args.id = id
2146 
    args.write(self._oprot)
2147 
    self._oprot.writeMessageEnd()
2148 
    self._oprot.trans.flush()
2149 
 
2150 
  def recv_getCategory(self, ):
2151 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2152 
    if mtype == TMessageType.EXCEPTION:
2153 
      x = TApplicationException()
2154 
      x.read(self._iprot)
2155 
      self._iprot.readMessageEnd()
2156 
      raise x
2157 
    result = getCategory_result()
2158 
    result.read(self._iprot)
2159 
    self._iprot.readMessageEnd()
2160 
    if result.success is not None:
2161 
      return result.success
2162 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCategory failed: unknown result");
2163 
 
2164 
  def getAllCategories(self, ):
2165 
    self.send_getAllCategories()
2166 
    return self.recv_getAllCategories()
2167 
 
2168 
  def send_getAllCategories(self, ):
2169 
    self._oprot.writeMessageBegin('getAllCategories', TMessageType.CALL, self._seqid)
2170 
    args = getAllCategories_args()
2171 
    args.write(self._oprot)
2172 
    self._oprot.writeMessageEnd()
2173 
    self._oprot.trans.flush()
2174 
 
2175 
  def recv_getAllCategories(self, ):
2176 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2177 
    if mtype == TMessageType.EXCEPTION:
2178 
      x = TApplicationException()
2179 
      x.read(self._iprot)
2180 
      self._iprot.readMessageEnd()
2181 
      raise x
2182 
    result = getAllCategories_result()
2183 
    result.read(self._iprot)
2184 
    self._iprot.readMessageEnd()
2185 
    if result.success is not None:
2186 
      return result.success
2187 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCategories failed: unknown result");
2188 
 
2189 
  def getAllSimilarItems(self, itemId):
2190 
    """
2191 
    Returns the list of similar items.
2192 
 
2193 
    Parameters:
2194 
     - itemId
2195 
    """
2196 
    self.send_getAllSimilarItems(itemId)
2197 
    return self.recv_getAllSimilarItems()
2198 
 
2199 
  def send_getAllSimilarItems(self, itemId):
2200 
    self._oprot.writeMessageBegin('getAllSimilarItems', TMessageType.CALL, self._seqid)
2201 
    args = getAllSimilarItems_args()
2202 
    args.itemId = itemId
2203 
    args.write(self._oprot)
2204 
    self._oprot.writeMessageEnd()
2205 
    self._oprot.trans.flush()
2206 
 
2207 
  def recv_getAllSimilarItems(self, ):
2208 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2209 
    if mtype == TMessageType.EXCEPTION:
2210 
      x = TApplicationException()
2211 
      x.read(self._iprot)
2212 
      self._iprot.readMessageEnd()
2213 
      raise x
2214 
    result = getAllSimilarItems_result()
2215 
    result.read(self._iprot)
2216 
    self._iprot.readMessageEnd()
2217 
    if result.success is not None:
2218 
      return result.success
2219 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSimilarItems failed: unknown result");
2220 
 
2221 
  def addSimilarItem(self, itemId, catalogItemId):
2222 
    """
2223 
    Adds similar item.
2224 
 
2225 
    Parameters:
2226 
     - itemId
2227 
     - catalogItemId
2228 
    """
2229 
    self.send_addSimilarItem(itemId, catalogItemId)
2230 
    return self.recv_addSimilarItem()
2231 
 
2232 
  def send_addSimilarItem(self, itemId, catalogItemId):
2233 
    self._oprot.writeMessageBegin('addSimilarItem', TMessageType.CALL, self._seqid)
2234 
    args = addSimilarItem_args()
2235 
    args.itemId = itemId
2236 
    args.catalogItemId = catalogItemId
2237 
    args.write(self._oprot)
2238 
    self._oprot.writeMessageEnd()
2239 
    self._oprot.trans.flush()
2240 
 
2241 
  def recv_addSimilarItem(self, ):
2242 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2243 
    if mtype == TMessageType.EXCEPTION:
2244 
      x = TApplicationException()
2245 
      x.read(self._iprot)
2246 
      self._iprot.readMessageEnd()
2247 
      raise x
2248 
    result = addSimilarItem_result()
2249 
    result.read(self._iprot)
2250 
    self._iprot.readMessageEnd()
2251 
    if result.success is not None:
2252 
      return result.success
2253 
    if result.cex is not None:
2254 
      raise result.cex
2255 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSimilarItem failed: unknown result");
2256 
 
6512 kshitij.so 2257 
  def addTag(self, displayName, itemId):
2258 
    """
2259 
    Tag Related
2260 
 
2261 
    Parameters:
2262 
     - displayName
2263 
     - itemId
2264 
    """
2265 
    self.send_addTag(displayName, itemId)
2266 
    return self.recv_addTag()
2267 
 
2268 
  def send_addTag(self, displayName, itemId):
2269 
    self._oprot.writeMessageBegin('addTag', TMessageType.CALL, self._seqid)
2270 
    args = addTag_args()
2271 
    args.displayName = displayName
2272 
    args.itemId = itemId
2273 
    args.write(self._oprot)
2274 
    self._oprot.writeMessageEnd()
2275 
    self._oprot.trans.flush()
2276 
 
2277 
  def recv_addTag(self, ):
2278 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2279 
    if mtype == TMessageType.EXCEPTION:
2280 
      x = TApplicationException()
2281 
      x.read(self._iprot)
2282 
      self._iprot.readMessageEnd()
2283 
      raise x
2284 
    result = addTag_result()
2285 
    result.read(self._iprot)
2286 
    self._iprot.readMessageEnd()
2287 
    if result.success is not None:
2288 
      return result.success
2289 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTag failed: unknown result");
2290 
 
2291 
  def deleteEntityTag(self, displayName, itemId):
2292 
    """
2293 
    Parameters:
2294 
     - displayName
2295 
     - itemId
2296 
    """
2297 
    self.send_deleteEntityTag(displayName, itemId)
2298 
    return self.recv_deleteEntityTag()
2299 
 
2300 
  def send_deleteEntityTag(self, displayName, itemId):
2301 
    self._oprot.writeMessageBegin('deleteEntityTag', TMessageType.CALL, self._seqid)
2302 
    args = deleteEntityTag_args()
2303 
    args.displayName = displayName
2304 
    args.itemId = itemId
2305 
    args.write(self._oprot)
2306 
    self._oprot.writeMessageEnd()
2307 
    self._oprot.trans.flush()
2308 
 
2309 
  def recv_deleteEntityTag(self, ):
2310 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2311 
    if mtype == TMessageType.EXCEPTION:
2312 
      x = TApplicationException()
2313 
      x.read(self._iprot)
2314 
      self._iprot.readMessageEnd()
2315 
      raise x
2316 
    result = deleteEntityTag_result()
2317 
    result.read(self._iprot)
2318 
    self._iprot.readMessageEnd()
2319 
    if result.success is not None:
2320 
      return result.success
2321 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteEntityTag failed: unknown result");
2322 
 
2323 
  def deleteTag(self, displayName):
2324 
    """
2325 
    Parameters:
2326 
     - displayName
2327 
    """
2328 
    self.send_deleteTag(displayName)
2329 
    return self.recv_deleteTag()
2330 
 
2331 
  def send_deleteTag(self, displayName):
2332 
    self._oprot.writeMessageBegin('deleteTag', TMessageType.CALL, self._seqid)
2333 
    args = deleteTag_args()
2334 
    args.displayName = displayName
2335 
    args.write(self._oprot)
2336 
    self._oprot.writeMessageEnd()
2337 
    self._oprot.trans.flush()
2338 
 
2339 
  def recv_deleteTag(self, ):
2340 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2341 
    if mtype == TMessageType.EXCEPTION:
2342 
      x = TApplicationException()
2343 
      x.read(self._iprot)
2344 
      self._iprot.readMessageEnd()
2345 
      raise x
2346 
    result = deleteTag_result()
2347 
    result.read(self._iprot)
2348 
    self._iprot.readMessageEnd()
2349 
    if result.success is not None:
2350 
      return result.success
2351 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteTag failed: unknown result");
2352 
 
2353 
  def getAllTags(self, ):
2354 
    self.send_getAllTags()
2355 
    return self.recv_getAllTags()
2356 
 
2357 
  def send_getAllTags(self, ):
2358 
    self._oprot.writeMessageBegin('getAllTags', TMessageType.CALL, self._seqid)
2359 
    args = getAllTags_args()
2360 
    args.write(self._oprot)
2361 
    self._oprot.writeMessageEnd()
2362 
    self._oprot.trans.flush()
2363 
 
2364 
  def recv_getAllTags(self, ):
2365 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2366 
    if mtype == TMessageType.EXCEPTION:
2367 
      x = TApplicationException()
2368 
      x.read(self._iprot)
2369 
      self._iprot.readMessageEnd()
2370 
      raise x
2371 
    result = getAllTags_result()
2372 
    result.read(self._iprot)
2373 
    self._iprot.readMessageEnd()
2374 
    if result.success is not None:
2375 
      return result.success
2376 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllTags failed: unknown result");
2377 
 
2378 
  def getAllEntitiesByTagName(self, displayName):
2379 
    """
2380 
    Parameters:
2381 
     - displayName
2382 
    """
2383 
    self.send_getAllEntitiesByTagName(displayName)
2384 
    return self.recv_getAllEntitiesByTagName()
2385 
 
2386 
  def send_getAllEntitiesByTagName(self, displayName):
2387 
    self._oprot.writeMessageBegin('getAllEntitiesByTagName', TMessageType.CALL, self._seqid)
2388 
    args = getAllEntitiesByTagName_args()
2389 
    args.displayName = displayName
2390 
    args.write(self._oprot)
2391 
    self._oprot.writeMessageEnd()
2392 
    self._oprot.trans.flush()
2393 
 
2394 
  def recv_getAllEntitiesByTagName(self, ):
2395 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2396 
    if mtype == TMessageType.EXCEPTION:
2397 
      x = TApplicationException()
2398 
      x.read(self._iprot)
2399 
      self._iprot.readMessageEnd()
2400 
      raise x
2401 
    result = getAllEntitiesByTagName_result()
2402 
    result.read(self._iprot)
2403 
    self._iprot.readMessageEnd()
2404 
    if result.success is not None:
2405 
      return result.success
2406 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntitiesByTagName failed: unknown result");
2407 
 
6845 amit.gupta 2408 
  def getAllEntityTags(self, ):
2409 
    self.send_getAllEntityTags()
2410 
    return self.recv_getAllEntityTags()
2411 
 
2412 
  def send_getAllEntityTags(self, ):
2413 
    self._oprot.writeMessageBegin('getAllEntityTags', TMessageType.CALL, self._seqid)
2414 
    args = getAllEntityTags_args()
2415 
    args.write(self._oprot)
2416 
    self._oprot.writeMessageEnd()
2417 
    self._oprot.trans.flush()
2418 
 
2419 
  def recv_getAllEntityTags(self, ):
2420 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2421 
    if mtype == TMessageType.EXCEPTION:
2422 
      x = TApplicationException()
2423 
      x.read(self._iprot)
2424 
      self._iprot.readMessageEnd()
2425 
      raise x
2426 
    result = getAllEntityTags_result()
2427 
    result.read(self._iprot)
2428 
    self._iprot.readMessageEnd()
2429 
    if result.success is not None:
2430 
      return result.success
2431 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntityTags failed: unknown result");
2432 
 
8590 kshitij.so 2433 
  def addBanner(self, bannerCongregate):
6850 kshitij.so 2434 
    """
8579 kshitij.so 2435 
    Banner Related
2436 
 
6850 kshitij.so 2437 
    Parameters:
8590 kshitij.so 2438 
     - bannerCongregate
6850 kshitij.so 2439 
    """
8590 kshitij.so 2440 
    self.send_addBanner(bannerCongregate)
10097 kshitij.so 2441 
    return self.recv_addBanner()
6850 kshitij.so 2442 
 
8590 kshitij.so 2443 
  def send_addBanner(self, bannerCongregate):
6850 kshitij.so 2444 
    self._oprot.writeMessageBegin('addBanner', TMessageType.CALL, self._seqid)
2445 
    args = addBanner_args()
8590 kshitij.so 2446 
    args.bannerCongregate = bannerCongregate
6850 kshitij.so 2447 
    args.write(self._oprot)
2448 
    self._oprot.writeMessageEnd()
2449 
    self._oprot.trans.flush()
2450 
 
2451 
  def recv_addBanner(self, ):
2452 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2453 
    if mtype == TMessageType.EXCEPTION:
2454 
      x = TApplicationException()
2455 
      x.read(self._iprot)
2456 
      self._iprot.readMessageEnd()
2457 
      raise x
2458 
    result = addBanner_result()
2459 
    result.read(self._iprot)
2460 
    self._iprot.readMessageEnd()
10097 kshitij.so 2461 
    if result.success is not None:
2462 
      return result.success
2463 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBanner failed: unknown result");
6850 kshitij.so 2464 
 
8579 kshitij.so 2465 
  def updateBanner(self, banner):
2466 
    """
2467 
    Parameters:
2468 
     - banner
2469 
    """
2470 
    self.send_updateBanner(banner)
2471 
    return self.recv_updateBanner()
2472 
 
2473 
  def send_updateBanner(self, banner):
2474 
    self._oprot.writeMessageBegin('updateBanner', TMessageType.CALL, self._seqid)
2475 
    args = updateBanner_args()
2476 
    args.banner = banner
2477 
    args.write(self._oprot)
2478 
    self._oprot.writeMessageEnd()
2479 
    self._oprot.trans.flush()
2480 
 
2481 
  def recv_updateBanner(self, ):
2482 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2483 
    if mtype == TMessageType.EXCEPTION:
2484 
      x = TApplicationException()
2485 
      x.read(self._iprot)
2486 
      self._iprot.readMessageEnd()
2487 
      raise x
2488 
    result = updateBanner_result()
2489 
    result.read(self._iprot)
2490 
    self._iprot.readMessageEnd()
2491 
    if result.success is not None:
2492 
      return result.success
2493 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBanner failed: unknown result");
2494 
 
6850 kshitij.so 2495 
  def getAllBanners(self, ):
2496 
    self.send_getAllBanners()
2497 
    return self.recv_getAllBanners()
2498 
 
2499 
  def send_getAllBanners(self, ):
2500 
    self._oprot.writeMessageBegin('getAllBanners', TMessageType.CALL, self._seqid)
2501 
    args = getAllBanners_args()
2502 
    args.write(self._oprot)
2503 
    self._oprot.writeMessageEnd()
2504 
    self._oprot.trans.flush()
2505 
 
2506 
  def recv_getAllBanners(self, ):
2507 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2508 
    if mtype == TMessageType.EXCEPTION:
2509 
      x = TApplicationException()
2510 
      x.read(self._iprot)
2511 
      self._iprot.readMessageEnd()
2512 
      raise x
2513 
    result = getAllBanners_result()
2514 
    result.read(self._iprot)
2515 
    self._iprot.readMessageEnd()
2516 
    if result.success is not None:
2517 
      return result.success
2518 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBanners failed: unknown result");
2519 
 
9155 kshitij.so 2520 
  def deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 2521 
    """
2522 
    Parameters:
2523 
     - bannerName
9155 kshitij.so 2524 
     - bannerType
6850 kshitij.so 2525 
    """
9155 kshitij.so 2526 
    self.send_deleteBanner(bannerName, bannerType)
6850 kshitij.so 2527 
    return self.recv_deleteBanner()
2528 
 
9155 kshitij.so 2529 
  def send_deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 2530 
    self._oprot.writeMessageBegin('deleteBanner', TMessageType.CALL, self._seqid)
2531 
    args = deleteBanner_args()
2532 
    args.bannerName = bannerName
9155 kshitij.so 2533 
    args.bannerType = bannerType
6850 kshitij.so 2534 
    args.write(self._oprot)
2535 
    self._oprot.writeMessageEnd()
2536 
    self._oprot.trans.flush()
2537 
 
2538 
  def recv_deleteBanner(self, ):
2539 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2540 
    if mtype == TMessageType.EXCEPTION:
2541 
      x = TApplicationException()
2542 
      x.read(self._iprot)
2543 
      self._iprot.readMessageEnd()
2544 
      raise x
2545 
    result = deleteBanner_result()
2546 
    result.read(self._iprot)
2547 
    self._iprot.readMessageEnd()
2548 
    if result.success is not None:
2549 
      return result.success
2550 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBanner failed: unknown result");
2551 
 
9155 kshitij.so 2552 
  def getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 2553 
    """
2554 
    Parameters:
2555 
     - bannerName
9155 kshitij.so 2556 
     - bannerType
6850 kshitij.so 2557 
    """
9155 kshitij.so 2558 
    self.send_getBannerDetails(bannerName, bannerType)
6850 kshitij.so 2559 
    return self.recv_getBannerDetails()
2560 
 
9155 kshitij.so 2561 
  def send_getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 2562 
    self._oprot.writeMessageBegin('getBannerDetails', TMessageType.CALL, self._seqid)
2563 
    args = getBannerDetails_args()
2564 
    args.bannerName = bannerName
9155 kshitij.so 2565 
    args.bannerType = bannerType
6850 kshitij.so 2566 
    args.write(self._oprot)
2567 
    self._oprot.writeMessageEnd()
2568 
    self._oprot.trans.flush()
2569 
 
2570 
  def recv_getBannerDetails(self, ):
2571 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2572 
    if mtype == TMessageType.EXCEPTION:
2573 
      x = TApplicationException()
2574 
      x.read(self._iprot)
2575 
      self._iprot.readMessageEnd()
2576 
      raise x
2577 
    result = getBannerDetails_result()
2578 
    result.read(self._iprot)
2579 
    self._iprot.readMessageEnd()
2580 
    if result.success is not None:
2581 
      return result.success
2582 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerDetails failed: unknown result");
2583 
 
2584 
  def getActiveBanners(self, ):
2585 
    self.send_getActiveBanners()
2586 
    return self.recv_getActiveBanners()
2587 
 
2588 
  def send_getActiveBanners(self, ):
2589 
    self._oprot.writeMessageBegin('getActiveBanners', TMessageType.CALL, self._seqid)
2590 
    args = getActiveBanners_args()
2591 
    args.write(self._oprot)
2592 
    self._oprot.writeMessageEnd()
2593 
    self._oprot.trans.flush()
2594 
 
2595 
  def recv_getActiveBanners(self, ):
2596 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2597 
    if mtype == TMessageType.EXCEPTION:
2598 
      x = TApplicationException()
2599 
      x.read(self._iprot)
2600 
      self._iprot.readMessageEnd()
2601 
      raise x
2602 
    result = getActiveBanners_result()
2603 
    result.read(self._iprot)
2604 
    self._iprot.readMessageEnd()
2605 
    if result.success is not None:
2606 
      return result.success
2607 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBanners failed: unknown result");
2608 
 
8579 kshitij.so 2609 
  def addBannerMap(self, bannerMaps):
6849 kshitij.so 2610 
    """
2611 
    Parameters:
8579 kshitij.so 2612 
     - bannerMaps
6849 kshitij.so 2613 
    """
8579 kshitij.so 2614 
    self.send_addBannerMap(bannerMaps)
6849 kshitij.so 2615 
    return self.recv_addBannerMap()
2616 
 
8579 kshitij.so 2617 
  def send_addBannerMap(self, bannerMaps):
6849 kshitij.so 2618 
    self._oprot.writeMessageBegin('addBannerMap', TMessageType.CALL, self._seqid)
2619 
    args = addBannerMap_args()
8579 kshitij.so 2620 
    args.bannerMaps = bannerMaps
6849 kshitij.so 2621 
    args.write(self._oprot)
2622 
    self._oprot.writeMessageEnd()
2623 
    self._oprot.trans.flush()
2624 
 
2625 
  def recv_addBannerMap(self, ):
2626 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2627 
    if mtype == TMessageType.EXCEPTION:
2628 
      x = TApplicationException()
2629 
      x.read(self._iprot)
2630 
      self._iprot.readMessageEnd()
2631 
      raise x
2632 
    result = addBannerMap_result()
2633 
    result.read(self._iprot)
2634 
    self._iprot.readMessageEnd()
2635 
    if result.success is not None:
2636 
      return result.success
2637 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBannerMap failed: unknown result");
2638 
 
8579 kshitij.so 2639 
  def updateBannerMap(self, bannerMap):
2640 
    """
2641 
    Parameters:
2642 
     - bannerMap
2643 
    """
2644 
    self.send_updateBannerMap(bannerMap)
2645 
    return self.recv_updateBannerMap()
2646 
 
2647 
  def send_updateBannerMap(self, bannerMap):
2648 
    self._oprot.writeMessageBegin('updateBannerMap', TMessageType.CALL, self._seqid)
2649 
    args = updateBannerMap_args()
2650 
    args.bannerMap = bannerMap
2651 
    args.write(self._oprot)
2652 
    self._oprot.writeMessageEnd()
2653 
    self._oprot.trans.flush()
2654 
 
2655 
  def recv_updateBannerMap(self, ):
2656 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2657 
    if mtype == TMessageType.EXCEPTION:
2658 
      x = TApplicationException()
2659 
      x.read(self._iprot)
2660 
      self._iprot.readMessageEnd()
2661 
      raise x
2662 
    result = updateBannerMap_result()
2663 
    result.read(self._iprot)
2664 
    self._iprot.readMessageEnd()
2665 
    if result.success is not None:
2666 
      return result.success
2667 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBannerMap failed: unknown result");
2668 
 
6849 kshitij.so 2669 
  def deleteBannerMap(self, bannerName):
2670 
    """
2671 
    Parameters:
2672 
     - bannerName
2673 
    """
2674 
    self.send_deleteBannerMap(bannerName)
2675 
    return self.recv_deleteBannerMap()
2676 
 
2677 
  def send_deleteBannerMap(self, bannerName):
2678 
    self._oprot.writeMessageBegin('deleteBannerMap', TMessageType.CALL, self._seqid)
2679 
    args = deleteBannerMap_args()
2680 
    args.bannerName = bannerName
2681 
    args.write(self._oprot)
2682 
    self._oprot.writeMessageEnd()
2683 
    self._oprot.trans.flush()
2684 
 
2685 
  def recv_deleteBannerMap(self, ):
2686 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2687 
    if mtype == TMessageType.EXCEPTION:
2688 
      x = TApplicationException()
2689 
      x.read(self._iprot)
2690 
      self._iprot.readMessageEnd()
2691 
      raise x
2692 
    result = deleteBannerMap_result()
2693 
    result.read(self._iprot)
2694 
    self._iprot.readMessageEnd()
2695 
    if result.success is not None:
2696 
      return result.success
2697 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBannerMap failed: unknown result");
2698 
 
9155 kshitij.so 2699 
  def getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 2700 
    """
2701 
    Parameters:
2702 
     - bannerName
9155 kshitij.so 2703 
     - bannerType
6849 kshitij.so 2704 
    """
9155 kshitij.so 2705 
    self.send_getBannerMapDetails(bannerName, bannerType)
6849 kshitij.so 2706 
    return self.recv_getBannerMapDetails()
2707 
 
9155 kshitij.so 2708 
  def send_getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 2709 
    self._oprot.writeMessageBegin('getBannerMapDetails', TMessageType.CALL, self._seqid)
2710 
    args = getBannerMapDetails_args()
2711 
    args.bannerName = bannerName
9155 kshitij.so 2712 
    args.bannerType = bannerType
6849 kshitij.so 2713 
    args.write(self._oprot)
2714 
    self._oprot.writeMessageEnd()
2715 
    self._oprot.trans.flush()
2716 
 
2717 
  def recv_getBannerMapDetails(self, ):
2718 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2719 
    if mtype == TMessageType.EXCEPTION:
2720 
      x = TApplicationException()
2721 
      x.read(self._iprot)
2722 
      self._iprot.readMessageEnd()
2723 
      raise x
2724 
    result = getBannerMapDetails_result()
2725 
    result.read(self._iprot)
2726 
    self._iprot.readMessageEnd()
2727 
    if result.success is not None:
2728 
      return result.success
2729 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerMapDetails failed: unknown result");
2730 
 
8579 kshitij.so 2731 
  def addBannerUri(self, bannerUriMappings):
2732 
    """
2733 
    Parameters:
2734 
     - bannerUriMappings
2735 
    """
2736 
    self.send_addBannerUri(bannerUriMappings)
2737 
    self.recv_addBannerUri()
2738 
 
2739 
  def send_addBannerUri(self, bannerUriMappings):
2740 
    self._oprot.writeMessageBegin('addBannerUri', TMessageType.CALL, self._seqid)
2741 
    args = addBannerUri_args()
2742 
    args.bannerUriMappings = bannerUriMappings
2743 
    args.write(self._oprot)
2744 
    self._oprot.writeMessageEnd()
2745 
    self._oprot.trans.flush()
2746 
 
2747 
  def recv_addBannerUri(self, ):
2748 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2749 
    if mtype == TMessageType.EXCEPTION:
2750 
      x = TApplicationException()
2751 
      x.read(self._iprot)
2752 
      self._iprot.readMessageEnd()
2753 
      raise x
2754 
    result = addBannerUri_result()
2755 
    result.read(self._iprot)
2756 
    self._iprot.readMessageEnd()
2757 
    return
2758 
 
9155 kshitij.so 2759 
  def getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 2760 
    """
2761 
    Parameters:
2762 
     - bannerName
9155 kshitij.so 2763 
     - bannerType
8579 kshitij.so 2764 
    """
9155 kshitij.so 2765 
    self.send_getUriMapping(bannerName, bannerType)
8579 kshitij.so 2766 
    return self.recv_getUriMapping()
2767 
 
9155 kshitij.so 2768 
  def send_getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 2769 
    self._oprot.writeMessageBegin('getUriMapping', TMessageType.CALL, self._seqid)
2770 
    args = getUriMapping_args()
2771 
    args.bannerName = bannerName
9155 kshitij.so 2772 
    args.bannerType = bannerType
8579 kshitij.so 2773 
    args.write(self._oprot)
2774 
    self._oprot.writeMessageEnd()
2775 
    self._oprot.trans.flush()
2776 
 
2777 
  def recv_getUriMapping(self, ):
2778 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2779 
    if mtype == TMessageType.EXCEPTION:
2780 
      x = TApplicationException()
2781 
      x.read(self._iprot)
2782 
      self._iprot.readMessageEnd()
2783 
      raise x
2784 
    result = getUriMapping_result()
2785 
    result.read(self._iprot)
2786 
    self._iprot.readMessageEnd()
2787 
    if result.success is not None:
2788 
      return result.success
2789 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUriMapping failed: unknown result");
2790 
 
2791 
  def addCampaign(self, campaign):
2792 
    """
2793 
    Parameters:
2794 
     - campaign
2795 
    """
2796 
    self.send_addCampaign(campaign)
2797 
    self.recv_addCampaign()
2798 
 
2799 
  def send_addCampaign(self, campaign):
2800 
    self._oprot.writeMessageBegin('addCampaign', TMessageType.CALL, self._seqid)
2801 
    args = addCampaign_args()
2802 
    args.campaign = campaign
2803 
    args.write(self._oprot)
2804 
    self._oprot.writeMessageEnd()
2805 
    self._oprot.trans.flush()
2806 
 
2807 
  def recv_addCampaign(self, ):
2808 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2809 
    if mtype == TMessageType.EXCEPTION:
2810 
      x = TApplicationException()
2811 
      x.read(self._iprot)
2812 
      self._iprot.readMessageEnd()
2813 
      raise x
2814 
    result = addCampaign_result()
2815 
    result.read(self._iprot)
2816 
    self._iprot.readMessageEnd()
2817 
    return
2818 
 
2819 
  def getCampaigns(self, campaignName):
2820 
    """
2821 
    Parameters:
2822 
     - campaignName
2823 
    """
2824 
    self.send_getCampaigns(campaignName)
2825 
    return self.recv_getCampaigns()
2826 
 
2827 
  def send_getCampaigns(self, campaignName):
2828 
    self._oprot.writeMessageBegin('getCampaigns', TMessageType.CALL, self._seqid)
2829 
    args = getCampaigns_args()
2830 
    args.campaignName = campaignName
2831 
    args.write(self._oprot)
2832 
    self._oprot.writeMessageEnd()
2833 
    self._oprot.trans.flush()
2834 
 
2835 
  def recv_getCampaigns(self, ):
2836 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2837 
    if mtype == TMessageType.EXCEPTION:
2838 
      x = TApplicationException()
2839 
      x.read(self._iprot)
2840 
      self._iprot.readMessageEnd()
2841 
      raise x
2842 
    result = getCampaigns_result()
2843 
    result.read(self._iprot)
2844 
    self._iprot.readMessageEnd()
2845 
    if result.success is not None:
2846 
      return result.success
2847 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCampaigns failed: unknown result");
2848 
 
2849 
  def deleteCampaign(self, campaignId):
2850 
    """
2851 
    Parameters:
2852 
     - campaignId
2853 
    """
2854 
    self.send_deleteCampaign(campaignId)
2855 
    self.recv_deleteCampaign()
2856 
 
2857 
  def send_deleteCampaign(self, campaignId):
2858 
    self._oprot.writeMessageBegin('deleteCampaign', TMessageType.CALL, self._seqid)
2859 
    args = deleteCampaign_args()
2860 
    args.campaignId = campaignId
2861 
    args.write(self._oprot)
2862 
    self._oprot.writeMessageEnd()
2863 
    self._oprot.trans.flush()
2864 
 
2865 
  def recv_deleteCampaign(self, ):
2866 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2867 
    if mtype == TMessageType.EXCEPTION:
2868 
      x = TApplicationException()
2869 
      x.read(self._iprot)
2870 
      self._iprot.readMessageEnd()
2871 
      raise x
2872 
    result = deleteCampaign_result()
2873 
    result.read(self._iprot)
2874 
    self._iprot.readMessageEnd()
2875 
    return
2876 
 
2877 
  def getAllCampaigns(self, ):
2878 
    self.send_getAllCampaigns()
2879 
    return self.recv_getAllCampaigns()
2880 
 
2881 
  def send_getAllCampaigns(self, ):
2882 
    self._oprot.writeMessageBegin('getAllCampaigns', TMessageType.CALL, self._seqid)
2883 
    args = getAllCampaigns_args()
2884 
    args.write(self._oprot)
2885 
    self._oprot.writeMessageEnd()
2886 
    self._oprot.trans.flush()
2887 
 
2888 
  def recv_getAllCampaigns(self, ):
2889 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2890 
    if mtype == TMessageType.EXCEPTION:
2891 
      x = TApplicationException()
2892 
      x.read(self._iprot)
2893 
      self._iprot.readMessageEnd()
2894 
      raise x
2895 
    result = getAllCampaigns_result()
2896 
    result.read(self._iprot)
2897 
    self._iprot.readMessageEnd()
2898 
    if result.success is not None:
2899 
      return result.success
2900 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCampaigns failed: unknown result");
2901 
 
9155 kshitij.so 2902 
  def getActiveBannersForMobileSite(self, ):
2903 
    self.send_getActiveBannersForMobileSite()
2904 
    return self.recv_getActiveBannersForMobileSite()
2905 
 
2906 
  def send_getActiveBannersForMobileSite(self, ):
2907 
    self._oprot.writeMessageBegin('getActiveBannersForMobileSite', TMessageType.CALL, self._seqid)
2908 
    args = getActiveBannersForMobileSite_args()
2909 
    args.write(self._oprot)
2910 
    self._oprot.writeMessageEnd()
2911 
    self._oprot.trans.flush()
2912 
 
2913 
  def recv_getActiveBannersForMobileSite(self, ):
2914 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2915 
    if mtype == TMessageType.EXCEPTION:
2916 
      x = TApplicationException()
2917 
      x.read(self._iprot)
2918 
      self._iprot.readMessageEnd()
2919 
      raise x
2920 
    result = getActiveBannersForMobileSite_result()
2921 
    result.read(self._iprot)
2922 
    self._iprot.readMessageEnd()
2923 
    if result.success is not None:
2924 
      return result.success
2925 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBannersForMobileSite failed: unknown result");
2926 
 
5944 mandeep.dh 2927 
  def deleteSimilarItem(self, itemId, catalogItemId):
2928 
    """
2929 
    Delete similar item.
2930 
 
2931 
    Parameters:
2932 
     - itemId
2933 
     - catalogItemId
2934 
    """
2935 
    self.send_deleteSimilarItem(itemId, catalogItemId)
2936 
    return self.recv_deleteSimilarItem()
2937 
 
2938 
  def send_deleteSimilarItem(self, itemId, catalogItemId):
2939 
    self._oprot.writeMessageBegin('deleteSimilarItem', TMessageType.CALL, self._seqid)
2940 
    args = deleteSimilarItem_args()
2941 
    args.itemId = itemId
2942 
    args.catalogItemId = catalogItemId
2943 
    args.write(self._oprot)
2944 
    self._oprot.writeMessageEnd()
2945 
    self._oprot.trans.flush()
2946 
 
2947 
  def recv_deleteSimilarItem(self, ):
2948 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2949 
    if mtype == TMessageType.EXCEPTION:
2950 
      x = TApplicationException()
2951 
      x.read(self._iprot)
2952 
      self._iprot.readMessageEnd()
2953 
      raise x
2954 
    result = deleteSimilarItem_result()
2955 
    result.read(self._iprot)
2956 
    self._iprot.readMessageEnd()
2957 
    if result.success is not None:
2958 
      return result.success
2959 
    if result.cex is not None:
2960 
      raise result.cex
2961 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteSimilarItem failed: unknown result");
2962 
 
2963 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
2964 
    """
2965 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
2966 
    If yes, returns the itemId else returns 0
2967 
 
2968 
    Parameters:
2969 
     - brand
2970 
     - modelNumber
2971 
     - modelName
2972 
     - color
2973 
    """
2974 
    self.send_checkSimilarItem(brand, modelNumber, modelName, color)
2975 
    return self.recv_checkSimilarItem()
2976 
 
2977 
  def send_checkSimilarItem(self, brand, modelNumber, modelName, color):
2978 
    self._oprot.writeMessageBegin('checkSimilarItem', TMessageType.CALL, self._seqid)
2979 
    args = checkSimilarItem_args()
2980 
    args.brand = brand
2981 
    args.modelNumber = modelNumber
2982 
    args.modelName = modelName
2983 
    args.color = color
2984 
    args.write(self._oprot)
2985 
    self._oprot.writeMessageEnd()
2986 
    self._oprot.trans.flush()
2987 
 
2988 
  def recv_checkSimilarItem(self, ):
2989 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2990 
    if mtype == TMessageType.EXCEPTION:
2991 
      x = TApplicationException()
2992 
      x.read(self._iprot)
2993 
      self._iprot.readMessageEnd()
2994 
      raise x
2995 
    result = checkSimilarItem_result()
2996 
    result.read(self._iprot)
2997 
    self._iprot.readMessageEnd()
2998 
    if result.success is not None:
2999 
      return result.success
3000 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkSimilarItem failed: unknown result");
3001 
 
3002 
  def validateRiskyStatus(self, itemId):
3003 
    """
3004 
    Check wether item is risky and change status if inventory is not available for risky items
3005 
 
3006 
    Parameters:
3007 
     - itemId
3008 
    """
3009 
    self.send_validateRiskyStatus(itemId)
3010 
    self.recv_validateRiskyStatus()
3011 
 
3012 
  def send_validateRiskyStatus(self, itemId):
3013 
    self._oprot.writeMessageBegin('validateRiskyStatus', TMessageType.CALL, self._seqid)
3014 
    args = validateRiskyStatus_args()
3015 
    args.itemId = itemId
3016 
    args.write(self._oprot)
3017 
    self._oprot.writeMessageEnd()
3018 
    self._oprot.trans.flush()
3019 
 
3020 
  def recv_validateRiskyStatus(self, ):
3021 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3022 
    if mtype == TMessageType.EXCEPTION:
3023 
      x = TApplicationException()
3024 
      x.read(self._iprot)
3025 
      self._iprot.readMessageEnd()
3026 
      raise x
3027 
    result = validateRiskyStatus_result()
3028 
    result.read(self._iprot)
3029 
    self._iprot.readMessageEnd()
3030 
    return
3031 
 
3032 
  def changeItemRiskyFlag(self, itemId, risky):
3033 
    """
3034 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
3035 
 
3036 
    Parameters:
3037 
     - itemId
3038 
     - risky
3039 
    """
3040 
    self.send_changeItemRiskyFlag(itemId, risky)
3041 
    self.recv_changeItemRiskyFlag()
3042 
 
3043 
  def send_changeItemRiskyFlag(self, itemId, risky):
3044 
    self._oprot.writeMessageBegin('changeItemRiskyFlag', TMessageType.CALL, self._seqid)
3045 
    args = changeItemRiskyFlag_args()
3046 
    args.itemId = itemId
3047 
    args.risky = risky
3048 
    args.write(self._oprot)
3049 
    self._oprot.writeMessageEnd()
3050 
    self._oprot.trans.flush()
3051 
 
3052 
  def recv_changeItemRiskyFlag(self, ):
3053 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3054 
    if mtype == TMessageType.EXCEPTION:
3055 
      x = TApplicationException()
3056 
      x.read(self._iprot)
3057 
      self._iprot.readMessageEnd()
3058 
      raise x
3059 
    result = changeItemRiskyFlag_result()
3060 
    result.read(self._iprot)
3061 
    self._iprot.readMessageEnd()
3062 
    return
3063 
 
3064 
  def getItemsByRiskyFlag(self, ):
3065 
    """
3066 
    Returns list of items marked as risky.
3067 
    """
3068 
    self.send_getItemsByRiskyFlag()
3069 
    return self.recv_getItemsByRiskyFlag()
3070 
 
3071 
  def send_getItemsByRiskyFlag(self, ):
3072 
    self._oprot.writeMessageBegin('getItemsByRiskyFlag', TMessageType.CALL, self._seqid)
3073 
    args = getItemsByRiskyFlag_args()
3074 
    args.write(self._oprot)
3075 
    self._oprot.writeMessageEnd()
3076 
    self._oprot.trans.flush()
3077 
 
3078 
  def recv_getItemsByRiskyFlag(self, ):
3079 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3080 
    if mtype == TMessageType.EXCEPTION:
3081 
      x = TApplicationException()
3082 
      x.read(self._iprot)
3083 
      self._iprot.readMessageEnd()
3084 
      raise x
3085 
    result = getItemsByRiskyFlag_result()
3086 
    result.read(self._iprot)
3087 
    self._iprot.readMessageEnd()
3088 
    if result.success is not None:
3089 
      return result.success
3090 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByRiskyFlag failed: unknown result");
3091 
 
3092 
  def getItemsForMasterSheet(self, category, brand):
3093 
    """
3094 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
3095 
 
3096 
    Parameters:
3097 
     - category
3098 
     - brand
3099 
    """
3100 
    self.send_getItemsForMasterSheet(category, brand)
3101 
    return self.recv_getItemsForMasterSheet()
3102 
 
3103 
  def send_getItemsForMasterSheet(self, category, brand):
3104 
    self._oprot.writeMessageBegin('getItemsForMasterSheet', TMessageType.CALL, self._seqid)
3105 
    args = getItemsForMasterSheet_args()
3106 
    args.category = category
3107 
    args.brand = brand
3108 
    args.write(self._oprot)
3109 
    self._oprot.writeMessageEnd()
3110 
    self._oprot.trans.flush()
3111 
 
3112 
  def recv_getItemsForMasterSheet(self, ):
3113 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3114 
    if mtype == TMessageType.EXCEPTION:
3115 
      x = TApplicationException()
3116 
      x.read(self._iprot)
3117 
      self._iprot.readMessageEnd()
3118 
      raise x
3119 
    result = getItemsForMasterSheet_result()
3120 
    result.read(self._iprot)
3121 
    self._iprot.readMessageEnd()
3122 
    if result.success is not None:
3123 
      return result.success
3124 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsForMasterSheet failed: unknown result");
3125 
 
3126 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
3127 
    """
3128 
    Returns list of catalog ids of items with same similarity index as of the given itemId
3129 
 
3130 
    Parameters:
3131 
     - beginIndex
3132 
     - totalItems
3133 
     - itemId
3134 
    """
3135 
    self.send_getSimilarItemsCatalogIds(beginIndex, totalItems, itemId)
3136 
    return self.recv_getSimilarItemsCatalogIds()
3137 
 
3138 
  def send_getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
3139 
    self._oprot.writeMessageBegin('getSimilarItemsCatalogIds', TMessageType.CALL, self._seqid)
3140 
    args = getSimilarItemsCatalogIds_args()
3141 
    args.beginIndex = beginIndex
3142 
    args.totalItems = totalItems
3143 
    args.itemId = itemId
3144 
    args.write(self._oprot)
3145 
    self._oprot.writeMessageEnd()
3146 
    self._oprot.trans.flush()
3147 
 
3148 
  def recv_getSimilarItemsCatalogIds(self, ):
3149 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3150 
    if mtype == TMessageType.EXCEPTION:
3151 
      x = TApplicationException()
3152 
      x.read(self._iprot)
3153 
      self._iprot.readMessageEnd()
3154 
      raise x
3155 
    result = getSimilarItemsCatalogIds_result()
3156 
    result.read(self._iprot)
3157 
    self._iprot.readMessageEnd()
3158 
    if result.success is not None:
3159 
      return result.success
3160 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSimilarItemsCatalogIds failed: unknown result");
3161 
 
3162 
  def addProductNotification(self, itemId, email):
3163 
    """
3164 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
3165 
 
3166 
    Parameters:
3167 
     - itemId
3168 
     - email
3169 
    """
3170 
    self.send_addProductNotification(itemId, email)
3171 
    return self.recv_addProductNotification()
3172 
 
3173 
  def send_addProductNotification(self, itemId, email):
3174 
    self._oprot.writeMessageBegin('addProductNotification', TMessageType.CALL, self._seqid)
3175 
    args = addProductNotification_args()
3176 
    args.itemId = itemId
3177 
    args.email = email
3178 
    args.write(self._oprot)
3179 
    self._oprot.writeMessageEnd()
3180 
    self._oprot.trans.flush()
3181 
 
3182 
  def recv_addProductNotification(self, ):
3183 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3184 
    if mtype == TMessageType.EXCEPTION:
3185 
      x = TApplicationException()
3186 
      x.read(self._iprot)
3187 
      self._iprot.readMessageEnd()
3188 
      raise x
3189 
    result = addProductNotification_result()
3190 
    result.read(self._iprot)
3191 
    self._iprot.readMessageEnd()
3192 
    if result.success is not None:
3193 
      return result.success
3194 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductNotification failed: unknown result");
3195 
 
3196 
  def sendProductNotifications(self, ):
3197 
    """
3198 
    Send the product notifications to the users for items which has stock.
3199 
    """
3200 
    self.send_sendProductNotifications()
3201 
    return self.recv_sendProductNotifications()
3202 
 
3203 
  def send_sendProductNotifications(self, ):
3204 
    self._oprot.writeMessageBegin('sendProductNotifications', TMessageType.CALL, self._seqid)
3205 
    args = sendProductNotifications_args()
3206 
    args.write(self._oprot)
3207 
    self._oprot.writeMessageEnd()
3208 
    self._oprot.trans.flush()
3209 
 
3210 
  def recv_sendProductNotifications(self, ):
3211 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3212 
    if mtype == TMessageType.EXCEPTION:
3213 
      x = TApplicationException()
3214 
      x.read(self._iprot)
3215 
      self._iprot.readMessageEnd()
3216 
      raise x
3217 
    result = sendProductNotifications_result()
3218 
    result.read(self._iprot)
3219 
    self._iprot.readMessageEnd()
3220 
    if result.success is not None:
3221 
      return result.success
3222 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendProductNotifications failed: unknown result");
3223 
 
3224 
  def getAllBrandsByCategory(self, categoryId):
3225 
    """
3226 
    Returns list of brand names for a given category Id
3227 
 
3228 
    Parameters:
3229 
     - categoryId
3230 
    """
3231 
    self.send_getAllBrandsByCategory(categoryId)
3232 
    return self.recv_getAllBrandsByCategory()
3233 
 
3234 
  def send_getAllBrandsByCategory(self, categoryId):
3235 
    self._oprot.writeMessageBegin('getAllBrandsByCategory', TMessageType.CALL, self._seqid)
3236 
    args = getAllBrandsByCategory_args()
3237 
    args.categoryId = categoryId
3238 
    args.write(self._oprot)
3239 
    self._oprot.writeMessageEnd()
3240 
    self._oprot.trans.flush()
3241 
 
3242 
  def recv_getAllBrandsByCategory(self, ):
3243 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3244 
    if mtype == TMessageType.EXCEPTION:
3245 
      x = TApplicationException()
3246 
      x.read(self._iprot)
3247 
      self._iprot.readMessageEnd()
3248 
      raise x
3249 
    result = getAllBrandsByCategory_result()
3250 
    result.read(self._iprot)
3251 
    self._iprot.readMessageEnd()
3252 
    if result.success is not None:
3253 
      return result.success
3254 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrandsByCategory failed: unknown result");
3255 
 
3256 
  def getAllBrands(self, ):
3257 
    """
3258 
    Returns list of brand names
3259 
    """
3260 
    self.send_getAllBrands()
3261 
    return self.recv_getAllBrands()
3262 
 
3263 
  def send_getAllBrands(self, ):
3264 
    self._oprot.writeMessageBegin('getAllBrands', TMessageType.CALL, self._seqid)
3265 
    args = getAllBrands_args()
3266 
    args.write(self._oprot)
3267 
    self._oprot.writeMessageEnd()
3268 
    self._oprot.trans.flush()
3269 
 
3270 
  def recv_getAllBrands(self, ):
3271 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3272 
    if mtype == TMessageType.EXCEPTION:
3273 
      x = TApplicationException()
3274 
      x.read(self._iprot)
3275 
      self._iprot.readMessageEnd()
3276 
      raise x
3277 
    result = getAllBrands_result()
3278 
    result.read(self._iprot)
3279 
    self._iprot.readMessageEnd()
3280 
    if result.success is not None:
3281 
      return result.success
3282 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrands failed: unknown result");
3283 
 
3284 
  def getAllSources(self, ):
3285 
    """
3286 
    Return list of all sources
3287 
    """
3288 
    self.send_getAllSources()
3289 
    return self.recv_getAllSources()
3290 
 
3291 
  def send_getAllSources(self, ):
3292 
    self._oprot.writeMessageBegin('getAllSources', TMessageType.CALL, self._seqid)
3293 
    args = getAllSources_args()
3294 
    args.write(self._oprot)
3295 
    self._oprot.writeMessageEnd()
3296 
    self._oprot.trans.flush()
3297 
 
3298 
  def recv_getAllSources(self, ):
3299 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3300 
    if mtype == TMessageType.EXCEPTION:
3301 
      x = TApplicationException()
3302 
      x.read(self._iprot)
3303 
      self._iprot.readMessageEnd()
3304 
      raise x
3305 
    result = getAllSources_result()
3306 
    result.read(self._iprot)
3307 
    self._iprot.readMessageEnd()
3308 
    if result.success is not None:
3309 
      return result.success
3310 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSources failed: unknown result");
3311 
 
3312 
  def getItemPricingBySource(self, itemId, sourceId):
3313 
    """
3314 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
3315 
 
3316 
    Parameters:
3317 
     - itemId
3318 
     - sourceId
3319 
    """
3320 
    self.send_getItemPricingBySource(itemId, sourceId)
3321 
    return self.recv_getItemPricingBySource()
3322 
 
3323 
  def send_getItemPricingBySource(self, itemId, sourceId):
3324 
    self._oprot.writeMessageBegin('getItemPricingBySource', TMessageType.CALL, self._seqid)
3325 
    args = getItemPricingBySource_args()
3326 
    args.itemId = itemId
3327 
    args.sourceId = sourceId
3328 
    args.write(self._oprot)
3329 
    self._oprot.writeMessageEnd()
3330 
    self._oprot.trans.flush()
3331 
 
3332 
  def recv_getItemPricingBySource(self, ):
3333 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3334 
    if mtype == TMessageType.EXCEPTION:
3335 
      x = TApplicationException()
3336 
      x.read(self._iprot)
3337 
      self._iprot.readMessageEnd()
3338 
      raise x
3339 
    result = getItemPricingBySource_result()
3340 
    result.read(self._iprot)
3341 
    self._iprot.readMessageEnd()
3342 
    if result.success is not None:
3343 
      return result.success
3344 
    if result.cex is not None:
3345 
      raise result.cex
3346 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricingBySource failed: unknown result");
3347 
 
3348 
  def addSourceItemPricing(self, sourceItemPricing):
3349 
    """
3350 
    Adds prices to be displayed corresponding to the item if user comes from a source.
3351 
    If item is not found or source is not found, it will throw exception.
3352 
 
3353 
    Parameters:
3354 
     - sourceItemPricing
3355 
    """
3356 
    self.send_addSourceItemPricing(sourceItemPricing)
3357 
    self.recv_addSourceItemPricing()
3358 
 
3359 
  def send_addSourceItemPricing(self, sourceItemPricing):
3360 
    self._oprot.writeMessageBegin('addSourceItemPricing', TMessageType.CALL, self._seqid)
3361 
    args = addSourceItemPricing_args()
3362 
    args.sourceItemPricing = sourceItemPricing
3363 
    args.write(self._oprot)
3364 
    self._oprot.writeMessageEnd()
3365 
    self._oprot.trans.flush()
3366 
 
3367 
  def recv_addSourceItemPricing(self, ):
3368 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3369 
    if mtype == TMessageType.EXCEPTION:
3370 
      x = TApplicationException()
3371 
      x.read(self._iprot)
3372 
      self._iprot.readMessageEnd()
3373 
      raise x
3374 
    result = addSourceItemPricing_result()
3375 
    result.read(self._iprot)
3376 
    self._iprot.readMessageEnd()
3377 
    if result.cex is not None:
3378 
      raise result.cex
3379 
    return
3380 
 
3381 
  def getAllSourcePricing(self, itemId):
3382 
    """
3383 
    Returns the list of source pricing information of an item.
3384 
    Raises an exception if item not found corresponding to itemId
3385 
 
3386 
    Parameters:
3387 
     - itemId
3388 
    """
3389 
    self.send_getAllSourcePricing(itemId)
3390 
    return self.recv_getAllSourcePricing()
3391 
 
3392 
  def send_getAllSourcePricing(self, itemId):
3393 
    self._oprot.writeMessageBegin('getAllSourcePricing', TMessageType.CALL, self._seqid)
3394 
    args = getAllSourcePricing_args()
3395 
    args.itemId = itemId
3396 
    args.write(self._oprot)
3397 
    self._oprot.writeMessageEnd()
3398 
    self._oprot.trans.flush()
3399 
 
3400 
  def recv_getAllSourcePricing(self, ):
3401 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3402 
    if mtype == TMessageType.EXCEPTION:
3403 
      x = TApplicationException()
3404 
      x.read(self._iprot)
3405 
      self._iprot.readMessageEnd()
3406 
      raise x
3407 
    result = getAllSourcePricing_result()
3408 
    result.read(self._iprot)
3409 
    self._iprot.readMessageEnd()
3410 
    if result.success is not None:
3411 
      return result.success
3412 
    if result.cex is not None:
3413 
      raise result.cex
3414 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSourcePricing failed: unknown result");
3415 
 
3416 
  def getItemForSource(self, item_id, sourceId):
3417 
    """
3418 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
3419 
 
3420 
    Parameters:
3421 
     - item_id
3422 
     - sourceId
3423 
    """
3424 
    self.send_getItemForSource(item_id, sourceId)
3425 
    return self.recv_getItemForSource()
3426 
 
3427 
  def send_getItemForSource(self, item_id, sourceId):
3428 
    self._oprot.writeMessageBegin('getItemForSource', TMessageType.CALL, self._seqid)
3429 
    args = getItemForSource_args()
3430 
    args.item_id = item_id
3431 
    args.sourceId = sourceId
3432 
    args.write(self._oprot)
3433 
    self._oprot.writeMessageEnd()
3434 
    self._oprot.trans.flush()
3435 
 
3436 
  def recv_getItemForSource(self, ):
3437 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3438 
    if mtype == TMessageType.EXCEPTION:
3439 
      x = TApplicationException()
3440 
      x.read(self._iprot)
3441 
      self._iprot.readMessageEnd()
3442 
      raise x
3443 
    result = getItemForSource_result()
3444 
    result.read(self._iprot)
3445 
    self._iprot.readMessageEnd()
3446 
    if result.success is not None:
3447 
      return result.success
3448 
    if result.cex is not None:
3449 
      raise result.cex
3450 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemForSource failed: unknown result");
3451 
 
3452 
  def searchItemsInRange(self, searchTerms, offset, limit):
3453 
    """
3454 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
3455 
 
3456 
    Parameters:
3457 
     - searchTerms
3458 
     - offset
3459 
     - limit
3460 
    """
3461 
    self.send_searchItemsInRange(searchTerms, offset, limit)
3462 
    return self.recv_searchItemsInRange()
3463 
 
3464 
  def send_searchItemsInRange(self, searchTerms, offset, limit):
3465 
    self._oprot.writeMessageBegin('searchItemsInRange', TMessageType.CALL, self._seqid)
3466 
    args = searchItemsInRange_args()
3467 
    args.searchTerms = searchTerms
3468 
    args.offset = offset
3469 
    args.limit = limit
3470 
    args.write(self._oprot)
3471 
    self._oprot.writeMessageEnd()
3472 
    self._oprot.trans.flush()
3473 
 
3474 
  def recv_searchItemsInRange(self, ):
3475 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3476 
    if mtype == TMessageType.EXCEPTION:
3477 
      x = TApplicationException()
3478 
      x.read(self._iprot)
3479 
      self._iprot.readMessageEnd()
3480 
      raise x
3481 
    result = searchItemsInRange_result()
3482 
    result.read(self._iprot)
3483 
    self._iprot.readMessageEnd()
3484 
    if result.success is not None:
3485 
      return result.success
3486 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchItemsInRange failed: unknown result");
3487 
 
3488 
  def getSearchResultCount(self, searchTerms):
3489 
    """
3490 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
3491 
 
3492 
    Parameters:
3493 
     - searchTerms
3494 
    """
3495 
    self.send_getSearchResultCount(searchTerms)
3496 
    return self.recv_getSearchResultCount()
3497 
 
3498 
  def send_getSearchResultCount(self, searchTerms):
3499 
    self._oprot.writeMessageBegin('getSearchResultCount', TMessageType.CALL, self._seqid)
3500 
    args = getSearchResultCount_args()
3501 
    args.searchTerms = searchTerms
3502 
    args.write(self._oprot)
3503 
    self._oprot.writeMessageEnd()
3504 
    self._oprot.trans.flush()
3505 
 
3506 
  def recv_getSearchResultCount(self, ):
3507 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3508 
    if mtype == TMessageType.EXCEPTION:
3509 
      x = TApplicationException()
3510 
      x.read(self._iprot)
3511 
      self._iprot.readMessageEnd()
3512 
      raise x
3513 
    result = getSearchResultCount_result()
3514 
    result.read(self._iprot)
3515 
    self._iprot.readMessageEnd()
3516 
    if result.success is not None:
3517 
      return result.success
3518 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSearchResultCount failed: unknown result");
3519 
 
3520 
  def getProductNotifications(self, startDateTime):
3521 
    """
3522 
    Returns a list of product notifications added after a supplied datetime
3523 
 
3524 
    Parameters:
3525 
     - startDateTime
3526 
    """
3527 
    self.send_getProductNotifications(startDateTime)
3528 
    return self.recv_getProductNotifications()
3529 
 
3530 
  def send_getProductNotifications(self, startDateTime):
3531 
    self._oprot.writeMessageBegin('getProductNotifications', TMessageType.CALL, self._seqid)
3532 
    args = getProductNotifications_args()
3533 
    args.startDateTime = startDateTime
3534 
    args.write(self._oprot)
3535 
    self._oprot.writeMessageEnd()
3536 
    self._oprot.trans.flush()
3537 
 
3538 
  def recv_getProductNotifications(self, ):
3539 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3540 
    if mtype == TMessageType.EXCEPTION:
3541 
      x = TApplicationException()
3542 
      x.read(self._iprot)
3543 
      self._iprot.readMessageEnd()
3544 
      raise x
3545 
    result = getProductNotifications_result()
3546 
    result.read(self._iprot)
3547 
    self._iprot.readMessageEnd()
3548 
    if result.success is not None:
3549 
      return result.success
3550 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotifications failed: unknown result");
3551 
 
7897 amar.kumar 3552 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3553 
    """
3554 
    Returns a list of count of requests for product notification against each item
3555 
 
3556 
    Parameters:
3557 
     - startDateTime
7897 amar.kumar 3558 
     - categoryId
5944 mandeep.dh 3559 
    """
7897 amar.kumar 3560 
    self.send_getProductNotificationRequestCount(startDateTime, categoryId)
5944 mandeep.dh 3561 
    return self.recv_getProductNotificationRequestCount()
3562 
 
7897 amar.kumar 3563 
  def send_getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3564 
    self._oprot.writeMessageBegin('getProductNotificationRequestCount', TMessageType.CALL, self._seqid)
3565 
    args = getProductNotificationRequestCount_args()
3566 
    args.startDateTime = startDateTime
7897 amar.kumar 3567 
    args.categoryId = categoryId
5944 mandeep.dh 3568 
    args.write(self._oprot)
3569 
    self._oprot.writeMessageEnd()
3570 
    self._oprot.trans.flush()
3571 
 
3572 
  def recv_getProductNotificationRequestCount(self, ):
3573 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3574 
    if mtype == TMessageType.EXCEPTION:
3575 
      x = TApplicationException()
3576 
      x.read(self._iprot)
3577 
      self._iprot.readMessageEnd()
3578 
      raise x
3579 
    result = getProductNotificationRequestCount_result()
3580 
    result.read(self._iprot)
3581 
    self._iprot.readMessageEnd()
3582 
    if result.success is not None:
3583 
      return result.success
3584 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotificationRequestCount failed: unknown result");
3585 
 
3586 
  def addAuthorizationLog(self, itemId, username, reason):
3587 
    """
3588 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
3589 
 
3590 
    Parameters:
3591 
     - itemId
3592 
     - username
3593 
     - reason
3594 
    """
3595 
    self.send_addAuthorizationLog(itemId, username, reason)
3596 
    return self.recv_addAuthorizationLog()
3597 
 
3598 
  def send_addAuthorizationLog(self, itemId, username, reason):
3599 
    self._oprot.writeMessageBegin('addAuthorizationLog', TMessageType.CALL, self._seqid)
3600 
    args = addAuthorizationLog_args()
3601 
    args.itemId = itemId
3602 
    args.username = username
3603 
    args.reason = reason
3604 
    args.write(self._oprot)
3605 
    self._oprot.writeMessageEnd()
3606 
    self._oprot.trans.flush()
3607 
 
3608 
  def recv_addAuthorizationLog(self, ):
3609 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3610 
    if mtype == TMessageType.EXCEPTION:
3611 
      x = TApplicationException()
3612 
      x.read(self._iprot)
3613 
      self._iprot.readMessageEnd()
3614 
      raise x
3615 
    result = addAuthorizationLog_result()
3616 
    result.read(self._iprot)
3617 
    self._iprot.readMessageEnd()
3618 
    if result.success is not None:
3619 
      return result.success
3620 
    if result.cex is not None:
3621 
      raise result.cex
3622 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAuthorizationLog failed: unknown result");
3623 
 
3624 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3625 
    """
3626 
    Parameters:
3627 
     - catalog_item_id
3628 
     - voucherType
3629 
     - voucherAmount
3630 
    """
3631 
    self.send_addupdateVoucherForItem(catalog_item_id, voucherType, voucherAmount)
3632 
    return self.recv_addupdateVoucherForItem()
3633 
 
3634 
  def send_addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3635 
    self._oprot.writeMessageBegin('addupdateVoucherForItem', TMessageType.CALL, self._seqid)
3636 
    args = addupdateVoucherForItem_args()
3637 
    args.catalog_item_id = catalog_item_id
3638 
    args.voucherType = voucherType
3639 
    args.voucherAmount = voucherAmount
3640 
    args.write(self._oprot)
3641 
    self._oprot.writeMessageEnd()
3642 
    self._oprot.trans.flush()
3643 
 
3644 
  def recv_addupdateVoucherForItem(self, ):
3645 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3646 
    if mtype == TMessageType.EXCEPTION:
3647 
      x = TApplicationException()
3648 
      x.read(self._iprot)
3649 
      self._iprot.readMessageEnd()
3650 
      raise x
3651 
    result = addupdateVoucherForItem_result()
3652 
    result.read(self._iprot)
3653 
    self._iprot.readMessageEnd()
3654 
    if result.success is not None:
3655 
      return result.success
3656 
    if result.cex is not None:
3657 
      raise result.cex
3658 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addupdateVoucherForItem failed: unknown result");
3659 
 
3660 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
3661 
    """
3662 
    Parameters:
3663 
     - catalog_item_id
3664 
     - voucherType
3665 
    """
3666 
    self.send_deleteVoucherForItem(catalog_item_id, voucherType)
3667 
    return self.recv_deleteVoucherForItem()
3668 
 
3669 
  def send_deleteVoucherForItem(self, catalog_item_id, voucherType):
3670 
    self._oprot.writeMessageBegin('deleteVoucherForItem', TMessageType.CALL, self._seqid)
3671 
    args = deleteVoucherForItem_args()
3672 
    args.catalog_item_id = catalog_item_id
3673 
    args.voucherType = voucherType
3674 
    args.write(self._oprot)
3675 
    self._oprot.writeMessageEnd()
3676 
    self._oprot.trans.flush()
3677 
 
3678 
  def recv_deleteVoucherForItem(self, ):
3679 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3680 
    if mtype == TMessageType.EXCEPTION:
3681 
      x = TApplicationException()
3682 
      x.read(self._iprot)
3683 
      self._iprot.readMessageEnd()
3684 
      raise x
3685 
    result = deleteVoucherForItem_result()
3686 
    result.read(self._iprot)
3687 
    self._iprot.readMessageEnd()
3688 
    if result.success is not None:
3689 
      return result.success
3690 
    if result.cex is not None:
3691 
      raise result.cex
3692 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteVoucherForItem failed: unknown result");
3693 
 
3694 
  def getVoucherAmount(self, itemId, voucherType):
3695 
    """
3696 
    Parameters:
3697 
     - itemId
3698 
     - voucherType
3699 
    """
3700 
    self.send_getVoucherAmount(itemId, voucherType)
3701 
    return self.recv_getVoucherAmount()
3702 
 
3703 
  def send_getVoucherAmount(self, itemId, voucherType):
3704 
    self._oprot.writeMessageBegin('getVoucherAmount', TMessageType.CALL, self._seqid)
3705 
    args = getVoucherAmount_args()
3706 
    args.itemId = itemId
3707 
    args.voucherType = voucherType
3708 
    args.write(self._oprot)
3709 
    self._oprot.writeMessageEnd()
3710 
    self._oprot.trans.flush()
3711 
 
3712 
  def recv_getVoucherAmount(self, ):
3713 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3714 
    if mtype == TMessageType.EXCEPTION:
3715 
      x = TApplicationException()
3716 
      x.read(self._iprot)
3717 
      self._iprot.readMessageEnd()
3718 
      raise x
3719 
    result = getVoucherAmount_result()
3720 
    result.read(self._iprot)
3721 
    self._iprot.readMessageEnd()
3722 
    if result.success is not None:
3723 
      return result.success
3724 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVoucherAmount failed: unknown result");
3725 
 
3726 
  def getAllItemVouchers(self, itemId):
3727 
    """
3728 
    Parameters:
3729 
     - itemId
3730 
    """
3731 
    self.send_getAllItemVouchers(itemId)
3732 
    return self.recv_getAllItemVouchers()
3733 
 
3734 
  def send_getAllItemVouchers(self, itemId):
3735 
    self._oprot.writeMessageBegin('getAllItemVouchers', TMessageType.CALL, self._seqid)
3736 
    args = getAllItemVouchers_args()
3737 
    args.itemId = itemId
3738 
    args.write(self._oprot)
3739 
    self._oprot.writeMessageEnd()
3740 
    self._oprot.trans.flush()
3741 
 
3742 
  def recv_getAllItemVouchers(self, ):
3743 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3744 
    if mtype == TMessageType.EXCEPTION:
3745 
      x = TApplicationException()
3746 
      x.read(self._iprot)
3747 
      self._iprot.readMessageEnd()
3748 
      raise x
3749 
    result = getAllItemVouchers_result()
3750 
    result.read(self._iprot)
3751 
    self._iprot.readMessageEnd()
3752 
    if result.success is not None:
3753 
      return result.success
3754 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemVouchers failed: unknown result");
3755 
 
3756 
  def isValidCatalogItemId(self, catalog_item_id):
3757 
    """
3758 
    Parameters:
3759 
     - catalog_item_id
3760 
    """
3761 
    self.send_isValidCatalogItemId(catalog_item_id)
3762 
    return self.recv_isValidCatalogItemId()
3763 
 
3764 
  def send_isValidCatalogItemId(self, catalog_item_id):
3765 
    self._oprot.writeMessageBegin('isValidCatalogItemId', TMessageType.CALL, self._seqid)
3766 
    args = isValidCatalogItemId_args()
3767 
    args.catalog_item_id = catalog_item_id
3768 
    args.write(self._oprot)
3769 
    self._oprot.writeMessageEnd()
3770 
    self._oprot.trans.flush()
3771 
 
3772 
  def recv_isValidCatalogItemId(self, ):
3773 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3774 
    if mtype == TMessageType.EXCEPTION:
3775 
      x = TApplicationException()
3776 
      x.read(self._iprot)
3777 
      self._iprot.readMessageEnd()
3778 
      raise x
3779 
    result = isValidCatalogItemId_result()
3780 
    result.read(self._iprot)
3781 
    self._iprot.readMessageEnd()
3782 
    if result.success is not None:
3783 
      return result.success
3784 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isValidCatalogItemId failed: unknown result");
3785 
 
7330 amit.gupta 3786 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3787 
    """
3788 
    Parameters:
3789 
     - itemId
7330 amit.gupta 3790 
     - stateId
6039 amit.gupta 3791 
     - price
3792 
    """
7330 amit.gupta 3793 
    self.send_getVatPercentageForItem(itemId, stateId, price)
6039 amit.gupta 3794 
    return self.recv_getVatPercentageForItem()
5944 mandeep.dh 3795 
 
7330 amit.gupta 3796 
  def send_getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3797 
    self._oprot.writeMessageBegin('getVatPercentageForItem', TMessageType.CALL, self._seqid)
3798 
    args = getVatPercentageForItem_args()
3799 
    args.itemId = itemId
7330 amit.gupta 3800 
    args.stateId = stateId
6039 amit.gupta 3801 
    args.price = price
3802 
    args.write(self._oprot)
3803 
    self._oprot.writeMessageEnd()
3804 
    self._oprot.trans.flush()
3805 
 
3806 
  def recv_getVatPercentageForItem(self, ):
3807 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3808 
    if mtype == TMessageType.EXCEPTION:
3809 
      x = TApplicationException()
3810 
      x.read(self._iprot)
3811 
      self._iprot.readMessageEnd()
3812 
      raise x
3813 
    result = getVatPercentageForItem_result()
3814 
    result.read(self._iprot)
3815 
    self._iprot.readMessageEnd()
3816 
    if result.success is not None:
3817 
      return result.success
7340 amit.gupta 3818 
    if result.cex is not None:
3819 
      raise result.cex
6039 amit.gupta 3820 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatPercentageForItem failed: unknown result");
3821 
 
3822 
  def getVatAmountForItem(self, itemId, price):
3823 
    """
3824 
    Parameters:
3825 
     - itemId
3826 
     - price
3827 
    """
3828 
    self.send_getVatAmountForItem(itemId, price)
3829 
    return self.recv_getVatAmountForItem()
3830 
 
3831 
  def send_getVatAmountForItem(self, itemId, price):
3832 
    self._oprot.writeMessageBegin('getVatAmountForItem', TMessageType.CALL, self._seqid)
3833 
    args = getVatAmountForItem_args()
3834 
    args.itemId = itemId
3835 
    args.price = price
3836 
    args.write(self._oprot)
3837 
    self._oprot.writeMessageEnd()
3838 
    self._oprot.trans.flush()
3839 
 
3840 
  def recv_getVatAmountForItem(self, ):
3841 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3842 
    if mtype == TMessageType.EXCEPTION:
3843 
      x = TApplicationException()
3844 
      x.read(self._iprot)
3845 
      self._iprot.readMessageEnd()
3846 
      raise x
3847 
    result = getVatAmountForItem_result()
3848 
    result.read(self._iprot)
3849 
    self._iprot.readMessageEnd()
3850 
    if result.success is not None:
3851 
      return result.success
3852 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatAmountForItem failed: unknown result");
3853 
 
6531 vikram.rag 3854 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3855 
    """
3856 
    Parameters:
3857 
     - offset
3858 
     - limit
3859 
    """
3860 
    self.send_getAllIgnoredInventoryUpdateItemsList(offset, limit)
3861 
    return self.recv_getAllIgnoredInventoryUpdateItemsList()
6039 amit.gupta 3862 
 
6531 vikram.rag 3863 
  def send_getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3864 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryUpdateItemsList', TMessageType.CALL, self._seqid)
3865 
    args = getAllIgnoredInventoryUpdateItemsList_args()
3866 
    args.offset = offset
3867 
    args.limit = limit
3868 
    args.write(self._oprot)
3869 
    self._oprot.writeMessageEnd()
3870 
    self._oprot.trans.flush()
3871 
 
3872 
  def recv_getAllIgnoredInventoryUpdateItemsList(self, ):
3873 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3874 
    if mtype == TMessageType.EXCEPTION:
3875 
      x = TApplicationException()
3876 
      x.read(self._iprot)
3877 
      self._iprot.readMessageEnd()
3878 
      raise x
3879 
    result = getAllIgnoredInventoryUpdateItemsList_result()
3880 
    result.read(self._iprot)
3881 
    self._iprot.readMessageEnd()
3882 
    if result.success is not None:
3883 
      return result.success
3884 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryUpdateItemsList failed: unknown result");
3885 
 
6821 amar.kumar 3886 
  def getAllAliveItems(self, ):
3887 
    self.send_getAllAliveItems()
3888 
    return self.recv_getAllAliveItems()
3889 
 
3890 
  def send_getAllAliveItems(self, ):
3891 
    self._oprot.writeMessageBegin('getAllAliveItems', TMessageType.CALL, self._seqid)
3892 
    args = getAllAliveItems_args()
3893 
    args.write(self._oprot)
3894 
    self._oprot.writeMessageEnd()
3895 
    self._oprot.trans.flush()
3896 
 
3897 
  def recv_getAllAliveItems(self, ):
3898 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3899 
    if mtype == TMessageType.EXCEPTION:
3900 
      x = TApplicationException()
3901 
      x.read(self._iprot)
3902 
      self._iprot.readMessageEnd()
3903 
      raise x
3904 
    result = getAllAliveItems_result()
3905 
    result.read(self._iprot)
3906 
    self._iprot.readMessageEnd()
3907 
    if result.success is not None:
3908 
      return result.success
3909 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAliveItems failed: unknown result");
3910 
 
6921 anupam.sin 3911 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3912 
    """
3913 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 3914 
 
6805 anupam.sin 3915 
    Parameters:
3916 
     - itemId
6921 anupam.sin 3917 
     - price
6805 anupam.sin 3918 
     - insurerId
3919 
     - quantity
3920 
    """
6921 anupam.sin 3921 
    self.send_getInsuranceAmount(itemId, price, insurerId, quantity)
6805 anupam.sin 3922 
    return self.recv_getInsuranceAmount()
3923 
 
6921 anupam.sin 3924 
  def send_getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3925 
    self._oprot.writeMessageBegin('getInsuranceAmount', TMessageType.CALL, self._seqid)
3926 
    args = getInsuranceAmount_args()
3927 
    args.itemId = itemId
6921 anupam.sin 3928 
    args.price = price
6805 anupam.sin 3929 
    args.insurerId = insurerId
3930 
    args.quantity = quantity
3931 
    args.write(self._oprot)
3932 
    self._oprot.writeMessageEnd()
3933 
    self._oprot.trans.flush()
3934 
 
3935 
  def recv_getInsuranceAmount(self, ):
3936 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3937 
    if mtype == TMessageType.EXCEPTION:
3938 
      x = TApplicationException()
3939 
      x.read(self._iprot)
3940 
      self._iprot.readMessageEnd()
3941 
      raise x
3942 
    result = getInsuranceAmount_result()
3943 
    result.read(self._iprot)
3944 
    self._iprot.readMessageEnd()
3945 
    if result.success is not None:
3946 
      return result.success
3947 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsuranceAmount failed: unknown result");
3948 
 
3949 
  def getInsurer(self, insurerId):
3950 
    """
3951 
    Parameters:
3952 
     - insurerId
3953 
    """
3954 
    self.send_getInsurer(insurerId)
3955 
    return self.recv_getInsurer()
3956 
 
3957 
  def send_getInsurer(self, insurerId):
3958 
    self._oprot.writeMessageBegin('getInsurer', TMessageType.CALL, self._seqid)
3959 
    args = getInsurer_args()
3960 
    args.insurerId = insurerId
3961 
    args.write(self._oprot)
3962 
    self._oprot.writeMessageEnd()
3963 
    self._oprot.trans.flush()
3964 
 
3965 
  def recv_getInsurer(self, ):
3966 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3967 
    if mtype == TMessageType.EXCEPTION:
3968 
      x = TApplicationException()
3969 
      x.read(self._iprot)
3970 
      self._iprot.readMessageEnd()
3971 
      raise x
3972 
    result = getInsurer_result()
3973 
    result.read(self._iprot)
3974 
    self._iprot.readMessageEnd()
3975 
    if result.success is not None:
3976 
      return result.success
3977 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsurer failed: unknown result");
3978 
 
6838 vikram.rag 3979 
  def getAllInsurers(self, ):
3980 
    self.send_getAllInsurers()
3981 
    return self.recv_getAllInsurers()
6805 anupam.sin 3982 
 
6838 vikram.rag 3983 
  def send_getAllInsurers(self, ):
3984 
    self._oprot.writeMessageBegin('getAllInsurers', TMessageType.CALL, self._seqid)
3985 
    args = getAllInsurers_args()
3986 
    args.write(self._oprot)
3987 
    self._oprot.writeMessageEnd()
3988 
    self._oprot.trans.flush()
3989 
 
3990 
  def recv_getAllInsurers(self, ):
3991 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3992 
    if mtype == TMessageType.EXCEPTION:
3993 
      x = TApplicationException()
3994 
      x.read(self._iprot)
3995 
      self._iprot.readMessageEnd()
3996 
      raise x
3997 
    result = getAllInsurers_result()
3998 
    result.read(self._iprot)
3999 
    self._iprot.readMessageEnd()
4000 
    if result.success is not None:
4001 
      return result.success
4002 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllInsurers failed: unknown result");
4003 
 
6962 rajveer 4004 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
4005 
    """
4006 
    Parameters:
4007 
     - insurerId
4008 
     - amount
4009 
    """
4010 
    self.send_updateInsuranceDeclaredAmount(insurerId, amount)
4011 
    self.recv_updateInsuranceDeclaredAmount()
6838 vikram.rag 4012 
 
6962 rajveer 4013 
  def send_updateInsuranceDeclaredAmount(self, insurerId, amount):
4014 
    self._oprot.writeMessageBegin('updateInsuranceDeclaredAmount', TMessageType.CALL, self._seqid)
4015 
    args = updateInsuranceDeclaredAmount_args()
4016 
    args.insurerId = insurerId
4017 
    args.amount = amount
4018 
    args.write(self._oprot)
4019 
    self._oprot.writeMessageEnd()
4020 
    self._oprot.trans.flush()
4021 
 
4022 
  def recv_updateInsuranceDeclaredAmount(self, ):
4023 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4024 
    if mtype == TMessageType.EXCEPTION:
4025 
      x = TApplicationException()
4026 
      x.read(self._iprot)
4027 
      self._iprot.readMessageEnd()
4028 
      raise x
4029 
    result = updateInsuranceDeclaredAmount_result()
4030 
    result.read(self._iprot)
4031 
    self._iprot.readMessageEnd()
4032 
    return
4033 
 
7190 amar.kumar 4034 
  def getFreebieForItem(self, itemId):
4035 
    """
4036 
    Parameters:
4037 
     - itemId
4038 
    """
4039 
    self.send_getFreebieForItem(itemId)
4040 
    return self.recv_getFreebieForItem()
6962 rajveer 4041 
 
7190 amar.kumar 4042 
  def send_getFreebieForItem(self, itemId):
4043 
    self._oprot.writeMessageBegin('getFreebieForItem', TMessageType.CALL, self._seqid)
4044 
    args = getFreebieForItem_args()
4045 
    args.itemId = itemId
4046 
    args.write(self._oprot)
4047 
    self._oprot.writeMessageEnd()
4048 
    self._oprot.trans.flush()
4049 
 
4050 
  def recv_getFreebieForItem(self, ):
4051 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4052 
    if mtype == TMessageType.EXCEPTION:
4053 
      x = TApplicationException()
4054 
      x.read(self._iprot)
4055 
      self._iprot.readMessageEnd()
4056 
      raise x
4057 
    result = getFreebieForItem_result()
4058 
    result.read(self._iprot)
4059 
    self._iprot.readMessageEnd()
4060 
    if result.success is not None:
4061 
      return result.success
4062 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFreebieForItem failed: unknown result");
4063 
 
4064 
  def addOrUpdateFreebieForItem(self, freebieItem):
4065 
    """
4066 
    Parameters:
4067 
     - freebieItem
4068 
    """
4069 
    self.send_addOrUpdateFreebieForItem(freebieItem)
4070 
    self.recv_addOrUpdateFreebieForItem()
4071 
 
4072 
  def send_addOrUpdateFreebieForItem(self, freebieItem):
4073 
    self._oprot.writeMessageBegin('addOrUpdateFreebieForItem', TMessageType.CALL, self._seqid)
4074 
    args = addOrUpdateFreebieForItem_args()
4075 
    args.freebieItem = freebieItem
4076 
    args.write(self._oprot)
4077 
    self._oprot.writeMessageEnd()
4078 
    self._oprot.trans.flush()
4079 
 
4080 
  def recv_addOrUpdateFreebieForItem(self, ):
4081 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4082 
    if mtype == TMessageType.EXCEPTION:
4083 
      x = TApplicationException()
4084 
      x.read(self._iprot)
4085 
      self._iprot.readMessageEnd()
4086 
      raise x
4087 
    result = addOrUpdateFreebieForItem_result()
4088 
    result.read(self._iprot)
4089 
    self._iprot.readMessageEnd()
4090 
    return
4091 
 
7272 amit.gupta 4092 
  def addOrUpdateBrandInfo(self, brandInfo):
4093 
    """
4094 
    Parameters:
4095 
     - brandInfo
4096 
    """
4097 
    self.send_addOrUpdateBrandInfo(brandInfo)
4098 
    self.recv_addOrUpdateBrandInfo()
4099 
 
4100 
  def send_addOrUpdateBrandInfo(self, brandInfo):
4101 
    self._oprot.writeMessageBegin('addOrUpdateBrandInfo', TMessageType.CALL, self._seqid)
4102 
    args = addOrUpdateBrandInfo_args()
4103 
    args.brandInfo = brandInfo
4104 
    args.write(self._oprot)
4105 
    self._oprot.writeMessageEnd()
4106 
    self._oprot.trans.flush()
4107 
 
4108 
  def recv_addOrUpdateBrandInfo(self, ):
4109 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4110 
    if mtype == TMessageType.EXCEPTION:
4111 
      x = TApplicationException()
4112 
      x.read(self._iprot)
4113 
      self._iprot.readMessageEnd()
4114 
      raise x
4115 
    result = addOrUpdateBrandInfo_result()
4116 
    result.read(self._iprot)
4117 
    self._iprot.readMessageEnd()
4118 
    return
4119 
 
4120 
  def getBrandInfo(self, ):
4121 
    self.send_getBrandInfo()
4122 
    return self.recv_getBrandInfo()
4123 
 
4124 
  def send_getBrandInfo(self, ):
4125 
    self._oprot.writeMessageBegin('getBrandInfo', TMessageType.CALL, self._seqid)
4126 
    args = getBrandInfo_args()
4127 
    args.write(self._oprot)
4128 
    self._oprot.writeMessageEnd()
4129 
    self._oprot.trans.flush()
4130 
 
4131 
  def recv_getBrandInfo(self, ):
4132 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4133 
    if mtype == TMessageType.EXCEPTION:
4134 
      x = TApplicationException()
4135 
      x.read(self._iprot)
4136 
      self._iprot.readMessageEnd()
4137 
      raise x
4138 
    result = getBrandInfo_result()
4139 
    result.read(self._iprot)
4140 
    self._iprot.readMessageEnd()
4141 
    if result.success is not None:
4142 
      return result.success
4143 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrandInfo failed: unknown result");
4144 
 
7256 rajveer 4145 
  def getStorePricing(self, itemId):
4146 
    """
4147 
    Parameters:
4148 
     - itemId
4149 
    """
4150 
    self.send_getStorePricing(itemId)
4151 
    return self.recv_getStorePricing()
7190 amar.kumar 4152 
 
7256 rajveer 4153 
  def send_getStorePricing(self, itemId):
4154 
    self._oprot.writeMessageBegin('getStorePricing', TMessageType.CALL, self._seqid)
4155 
    args = getStorePricing_args()
4156 
    args.itemId = itemId
4157 
    args.write(self._oprot)
4158 
    self._oprot.writeMessageEnd()
4159 
    self._oprot.trans.flush()
4160 
 
4161 
  def recv_getStorePricing(self, ):
4162 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4163 
    if mtype == TMessageType.EXCEPTION:
4164 
      x = TApplicationException()
4165 
      x.read(self._iprot)
4166 
      self._iprot.readMessageEnd()
4167 
      raise x
4168 
    result = getStorePricing_result()
4169 
    result.read(self._iprot)
4170 
    self._iprot.readMessageEnd()
4171 
    if result.success is not None:
4172 
      return result.success
4173 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricing failed: unknown result");
4174 
 
7306 rajveer 4175 
  def getStorePricings(self, itemIds):
4176 
    """
4177 
    Parameters:
4178 
     - itemIds
4179 
    """
4180 
    self.send_getStorePricings(itemIds)
4181 
    return self.recv_getStorePricings()
4182 
 
4183 
  def send_getStorePricings(self, itemIds):
4184 
    self._oprot.writeMessageBegin('getStorePricings', TMessageType.CALL, self._seqid)
4185 
    args = getStorePricings_args()
4186 
    args.itemIds = itemIds
4187 
    args.write(self._oprot)
4188 
    self._oprot.writeMessageEnd()
4189 
    self._oprot.trans.flush()
4190 
 
4191 
  def recv_getStorePricings(self, ):
4192 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4193 
    if mtype == TMessageType.EXCEPTION:
4194 
      x = TApplicationException()
4195 
      x.read(self._iprot)
4196 
      self._iprot.readMessageEnd()
4197 
      raise x
4198 
    result = getStorePricings_result()
4199 
    result.read(self._iprot)
4200 
    self._iprot.readMessageEnd()
4201 
    if result.success is not None:
4202 
      return result.success
4203 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricings failed: unknown result");
4204 
 
7382 rajveer 4205 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 4206 
    """
4207 
    Parameters:
4208 
     - sp
7382 rajveer 4209 
     - allColors
7265 rajveer 4210 
    """
7382 rajveer 4211 
    self.send_updateStorePricing(sp, allColors)
7265 rajveer 4212 
    self.recv_updateStorePricing()
7256 rajveer 4213 
 
7382 rajveer 4214 
  def send_updateStorePricing(self, sp, allColors):
7265 rajveer 4215 
    self._oprot.writeMessageBegin('updateStorePricing', TMessageType.CALL, self._seqid)
4216 
    args = updateStorePricing_args()
4217 
    args.sp = sp
7382 rajveer 4218 
    args.allColors = allColors
7265 rajveer 4219 
    args.write(self._oprot)
4220 
    self._oprot.writeMessageEnd()
4221 
    self._oprot.trans.flush()
4222 
 
4223 
  def recv_updateStorePricing(self, ):
4224 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4225 
    if mtype == TMessageType.EXCEPTION:
4226 
      x = TApplicationException()
4227 
      x.read(self._iprot)
4228 
      self._iprot.readMessageEnd()
4229 
      raise x
4230 
    result = updateStorePricing_result()
4231 
    result.read(self._iprot)
4232 
    self._iprot.readMessageEnd()
4233 
    return
4234 
 
7281 kshitij.so 4235 
  def getAllAmazonListedItems(self, ):
4236 
    self.send_getAllAmazonListedItems()
4237 
    return self.recv_getAllAmazonListedItems()
7265 rajveer 4238 
 
7281 kshitij.so 4239 
  def send_getAllAmazonListedItems(self, ):
4240 
    self._oprot.writeMessageBegin('getAllAmazonListedItems', TMessageType.CALL, self._seqid)
4241 
    args = getAllAmazonListedItems_args()
4242 
    args.write(self._oprot)
4243 
    self._oprot.writeMessageEnd()
4244 
    self._oprot.trans.flush()
4245 
 
4246 
  def recv_getAllAmazonListedItems(self, ):
4247 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4248 
    if mtype == TMessageType.EXCEPTION:
4249 
      x = TApplicationException()
4250 
      x.read(self._iprot)
4251 
      self._iprot.readMessageEnd()
4252 
      raise x
4253 
    result = getAllAmazonListedItems_result()
4254 
    result.read(self._iprot)
4255 
    self._iprot.readMessageEnd()
4256 
    if result.success is not None:
4257 
      return result.success
4258 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonListedItems failed: unknown result");
4259 
 
8619 kshitij.so 4260 
  def searchAmazonItems(self, searchTerm, offset, limit):
4261 
    """
4262 
    Parameters:
4263 
     - searchTerm
4264 
     - offset
4265 
     - limit
4266 
    """
4267 
    self.send_searchAmazonItems(searchTerm, offset, limit)
4268 
    return self.recv_searchAmazonItems()
4269 
 
4270 
  def send_searchAmazonItems(self, searchTerm, offset, limit):
4271 
    self._oprot.writeMessageBegin('searchAmazonItems', TMessageType.CALL, self._seqid)
4272 
    args = searchAmazonItems_args()
4273 
    args.searchTerm = searchTerm
4274 
    args.offset = offset
4275 
    args.limit = limit
4276 
    args.write(self._oprot)
4277 
    self._oprot.writeMessageEnd()
4278 
    self._oprot.trans.flush()
4279 
 
4280 
  def recv_searchAmazonItems(self, ):
4281 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4282 
    if mtype == TMessageType.EXCEPTION:
4283 
      x = TApplicationException()
4284 
      x.read(self._iprot)
4285 
      self._iprot.readMessageEnd()
4286 
      raise x
4287 
    result = searchAmazonItems_result()
4288 
    result.read(self._iprot)
4289 
    self._iprot.readMessageEnd()
4290 
    if result.success is not None:
4291 
      return result.success
4292 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchAmazonItems failed: unknown result");
4293 
 
4294 
  def getAmazonSearchResultCount(self, searchTerm):
4295 
    """
4296 
    Parameters:
4297 
     - searchTerm
4298 
    """
4299 
    self.send_getAmazonSearchResultCount(searchTerm)
4300 
    return self.recv_getAmazonSearchResultCount()
4301 
 
4302 
  def send_getAmazonSearchResultCount(self, searchTerm):
4303 
    self._oprot.writeMessageBegin('getAmazonSearchResultCount', TMessageType.CALL, self._seqid)
4304 
    args = getAmazonSearchResultCount_args()
4305 
    args.searchTerm = searchTerm
4306 
    args.write(self._oprot)
4307 
    self._oprot.writeMessageEnd()
4308 
    self._oprot.trans.flush()
4309 
 
4310 
  def recv_getAmazonSearchResultCount(self, ):
4311 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4312 
    if mtype == TMessageType.EXCEPTION:
4313 
      x = TApplicationException()
4314 
      x.read(self._iprot)
4315 
      self._iprot.readMessageEnd()
4316 
      raise x
4317 
    result = getAmazonSearchResultCount_result()
4318 
    result.read(self._iprot)
4319 
    self._iprot.readMessageEnd()
4320 
    if result.success is not None:
4321 
      return result.success
4322 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonSearchResultCount failed: unknown result");
4323 
 
4324 
  def getCountForAmazonlistedItems(self, ):
4325 
    self.send_getCountForAmazonlistedItems()
4326 
    return self.recv_getCountForAmazonlistedItems()
4327 
 
4328 
  def send_getCountForAmazonlistedItems(self, ):
4329 
    self._oprot.writeMessageBegin('getCountForAmazonlistedItems', TMessageType.CALL, self._seqid)
4330 
    args = getCountForAmazonlistedItems_args()
4331 
    args.write(self._oprot)
4332 
    self._oprot.writeMessageEnd()
4333 
    self._oprot.trans.flush()
4334 
 
4335 
  def recv_getCountForAmazonlistedItems(self, ):
4336 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4337 
    if mtype == TMessageType.EXCEPTION:
4338 
      x = TApplicationException()
4339 
      x.read(self._iprot)
4340 
      self._iprot.readMessageEnd()
4341 
      raise x
4342 
    result = getCountForAmazonlistedItems_result()
4343 
    result.read(self._iprot)
4344 
    self._iprot.readMessageEnd()
4345 
    if result.success is not None:
4346 
      return result.success
4347 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForAmazonlistedItems failed: unknown result");
4348 
 
7281 kshitij.so 4349 
  def getAmazonItemDetails(self, itemId):
4350 
    """
4351 
    Parameters:
4352 
     - itemId
4353 
    """
4354 
    self.send_getAmazonItemDetails(itemId)
4355 
    return self.recv_getAmazonItemDetails()
4356 
 
4357 
  def send_getAmazonItemDetails(self, itemId):
4358 
    self._oprot.writeMessageBegin('getAmazonItemDetails', TMessageType.CALL, self._seqid)
4359 
    args = getAmazonItemDetails_args()
4360 
    args.itemId = itemId
4361 
    args.write(self._oprot)
4362 
    self._oprot.writeMessageEnd()
4363 
    self._oprot.trans.flush()
4364 
 
4365 
  def recv_getAmazonItemDetails(self, ):
4366 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4367 
    if mtype == TMessageType.EXCEPTION:
4368 
      x = TApplicationException()
4369 
      x.read(self._iprot)
4370 
      self._iprot.readMessageEnd()
4371 
      raise x
4372 
    result = getAmazonItemDetails_result()
4373 
    result.read(self._iprot)
4374 
    self._iprot.readMessageEnd()
4375 
    if result.success is not None:
4376 
      return result.success
4377 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonItemDetails failed: unknown result");
4378 
 
8168 kshitij.so 4379 
  def updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4380 
    """
4381 
    Parameters:
8168 kshitij.so 4382 
     - amazonlisted
7281 kshitij.so 4383 
    """
8168 kshitij.so 4384 
    self.send_updateAmazonItemDetails(amazonlisted)
7281 kshitij.so 4385 
    self.recv_updateAmazonItemDetails()
4386 
 
8168 kshitij.so 4387 
  def send_updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4388 
    self._oprot.writeMessageBegin('updateAmazonItemDetails', TMessageType.CALL, self._seqid)
4389 
    args = updateAmazonItemDetails_args()
8168 kshitij.so 4390 
    args.amazonlisted = amazonlisted
7281 kshitij.so 4391 
    args.write(self._oprot)
4392 
    self._oprot.writeMessageEnd()
4393 
    self._oprot.trans.flush()
4394 
 
4395 
  def recv_updateAmazonItemDetails(self, ):
4396 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4397 
    if mtype == TMessageType.EXCEPTION:
4398 
      x = TApplicationException()
4399 
      x.read(self._iprot)
4400 
      self._iprot.readMessageEnd()
4401 
      raise x
4402 
    result = updateAmazonItemDetails_result()
4403 
    result.read(self._iprot)
4404 
    self._iprot.readMessageEnd()
4405 
    return
4406 
 
4407 
  def addAmazonItem(self, amazonlisted):
4408 
    """
4409 
    Parameters:
4410 
     - amazonlisted
4411 
    """
4412 
    self.send_addAmazonItem(amazonlisted)
4413 
    self.recv_addAmazonItem()
4414 
 
4415 
  def send_addAmazonItem(self, amazonlisted):
4416 
    self._oprot.writeMessageBegin('addAmazonItem', TMessageType.CALL, self._seqid)
4417 
    args = addAmazonItem_args()
4418 
    args.amazonlisted = amazonlisted
4419 
    args.write(self._oprot)
4420 
    self._oprot.writeMessageEnd()
4421 
    self._oprot.trans.flush()
4422 
 
4423 
  def recv_addAmazonItem(self, ):
4424 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4425 
    if mtype == TMessageType.EXCEPTION:
4426 
      x = TApplicationException()
4427 
      x.read(self._iprot)
4428 
      self._iprot.readMessageEnd()
4429 
      raise x
4430 
    result = addAmazonItem_result()
4431 
    result.read(self._iprot)
4432 
    self._iprot.readMessageEnd()
4433 
    return
4434 
 
7291 vikram.rag 4435 
  def getAsinItems(self, ):
4436 
    self.send_getAsinItems()
4437 
    return self.recv_getAsinItems()
7281 kshitij.so 4438 
 
7291 vikram.rag 4439 
  def send_getAsinItems(self, ):
4440 
    self._oprot.writeMessageBegin('getAsinItems', TMessageType.CALL, self._seqid)
4441 
    args = getAsinItems_args()
4442 
    args.write(self._oprot)
4443 
    self._oprot.writeMessageEnd()
4444 
    self._oprot.trans.flush()
4445 
 
4446 
  def recv_getAsinItems(self, ):
4447 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4448 
    if mtype == TMessageType.EXCEPTION:
4449 
      x = TApplicationException()
4450 
      x.read(self._iprot)
4451 
      self._iprot.readMessageEnd()
4452 
      raise x
4453 
    result = getAsinItems_result()
4454 
    result.read(self._iprot)
4455 
    self._iprot.readMessageEnd()
4456 
    if result.success is not None:
4457 
      return result.success
4458 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAsinItems failed: unknown result");
4459 
 
4460 
  def getAllFbaListedItems(self, ):
4461 
    self.send_getAllFbaListedItems()
4462 
    return self.recv_getAllFbaListedItems()
4463 
 
4464 
  def send_getAllFbaListedItems(self, ):
4465 
    self._oprot.writeMessageBegin('getAllFbaListedItems', TMessageType.CALL, self._seqid)
4466 
    args = getAllFbaListedItems_args()
4467 
    args.write(self._oprot)
4468 
    self._oprot.writeMessageEnd()
4469 
    self._oprot.trans.flush()
4470 
 
4471 
  def recv_getAllFbaListedItems(self, ):
4472 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4473 
    if mtype == TMessageType.EXCEPTION:
4474 
      x = TApplicationException()
4475 
      x.read(self._iprot)
4476 
      self._iprot.readMessageEnd()
4477 
      raise x
4478 
    result = getAllFbaListedItems_result()
4479 
    result.read(self._iprot)
4480 
    self._iprot.readMessageEnd()
4481 
    if result.success is not None:
4482 
      return result.success
4483 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbaListedItems failed: unknown result");
4484 
 
4485 
  def getAllNonFbaListedItems(self, ):
4486 
    self.send_getAllNonFbaListedItems()
4487 
    return self.recv_getAllNonFbaListedItems()
4488 
 
4489 
  def send_getAllNonFbaListedItems(self, ):
4490 
    self._oprot.writeMessageBegin('getAllNonFbaListedItems', TMessageType.CALL, self._seqid)
4491 
    args = getAllNonFbaListedItems_args()
4492 
    args.write(self._oprot)
4493 
    self._oprot.writeMessageEnd()
4494 
    self._oprot.trans.flush()
4495 
 
4496 
  def recv_getAllNonFbaListedItems(self, ):
4497 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4498 
    if mtype == TMessageType.EXCEPTION:
4499 
      x = TApplicationException()
4500 
      x.read(self._iprot)
4501 
      self._iprot.readMessageEnd()
4502 
      raise x
4503 
    result = getAllNonFbaListedItems_result()
4504 
    result.read(self._iprot)
4505 
    self._iprot.readMessageEnd()
4506 
    if result.success is not None:
4507 
      return result.success
4508 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllNonFbaListedItems failed: unknown result");
4509 
 
7460 kshitij.so 4510 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
4511 
    """
4512 
    Parameters:
4513 
     - itemId
4514 
     - holdInventory
4515 
     - defaultInventory
4516 
    """
4517 
    self.send_updateItemInventory(itemId, holdInventory, defaultInventory)
4518 
    return self.recv_updateItemInventory()
7291 vikram.rag 4519 
 
7460 kshitij.so 4520 
  def send_updateItemInventory(self, itemId, holdInventory, defaultInventory):
4521 
    self._oprot.writeMessageBegin('updateItemInventory', TMessageType.CALL, self._seqid)
4522 
    args = updateItemInventory_args()
4523 
    args.itemId = itemId
4524 
    args.holdInventory = holdInventory
4525 
    args.defaultInventory = defaultInventory
4526 
    args.write(self._oprot)
4527 
    self._oprot.writeMessageEnd()
4528 
    self._oprot.trans.flush()
4529 
 
4530 
  def recv_updateItemInventory(self, ):
4531 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4532 
    if mtype == TMessageType.EXCEPTION:
4533 
      x = TApplicationException()
4534 
      x.read(self._iprot)
4535 
      self._iprot.readMessageEnd()
4536 
      raise x
4537 
    result = updateItemInventory_result()
4538 
    result.read(self._iprot)
4539 
    self._iprot.readMessageEnd()
4540 
    if result.success is not None:
4541 
      return result.success
4542 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItemInventory failed: unknown result");
4543 
 
7770 kshitij.so 4544 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4545 
    """
4546 
    Parameters:
4547 
     - type
4548 
     - sku
4549 
     - timestamp
4550 
    """
4551 
    self.send_updateTimestampForAmazonFeeds(type, sku, timestamp)
4552 
    return self.recv_updateTimestampForAmazonFeeds()
7460 kshitij.so 4553 
 
7770 kshitij.so 4554 
  def send_updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4555 
    self._oprot.writeMessageBegin('updateTimestampForAmazonFeeds', TMessageType.CALL, self._seqid)
4556 
    args = updateTimestampForAmazonFeeds_args()
4557 
    args.type = type
4558 
    args.sku = sku
4559 
    args.timestamp = timestamp
4560 
    args.write(self._oprot)
4561 
    self._oprot.writeMessageEnd()
4562 
    self._oprot.trans.flush()
4563 
 
4564 
  def recv_updateTimestampForAmazonFeeds(self, ):
4565 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4566 
    if mtype == TMessageType.EXCEPTION:
4567 
      x = TApplicationException()
4568 
      x.read(self._iprot)
4569 
      self._iprot.readMessageEnd()
4570 
      raise x
4571 
    result = updateTimestampForAmazonFeeds_result()
4572 
    result.read(self._iprot)
4573 
    self._iprot.readMessageEnd()
4574 
    if result.success is not None:
4575 
      return result.success
4576 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateTimestampForAmazonFeeds failed: unknown result");
4577 
 
7897 amar.kumar 4578 
  def getAllParentCategories(self, ):
4579 
    self.send_getAllParentCategories()
4580 
    return self.recv_getAllParentCategories()
7770 kshitij.so 4581 
 
7897 amar.kumar 4582 
  def send_getAllParentCategories(self, ):
4583 
    self._oprot.writeMessageBegin('getAllParentCategories', TMessageType.CALL, self._seqid)
4584 
    args = getAllParentCategories_args()
4585 
    args.write(self._oprot)
4586 
    self._oprot.writeMessageEnd()
4587 
    self._oprot.trans.flush()
4588 
 
4589 
  def recv_getAllParentCategories(self, ):
4590 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4591 
    if mtype == TMessageType.EXCEPTION:
4592 
      x = TApplicationException()
4593 
      x.read(self._iprot)
4594 
      self._iprot.readMessageEnd()
4595 
      raise x
4596 
    result = getAllParentCategories_result()
4597 
    result.read(self._iprot)
4598 
    self._iprot.readMessageEnd()
4599 
    if result.success is not None:
4600 
      return result.success
4601 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllParentCategories failed: unknown result");
4602 
 
7977 kshitij.so 4603 
  def addPageViewEvent(self, pageViewEvents):
4604 
    """
4605 
    Parameters:
4606 
     - pageViewEvents
4607 
    """
4608 
    self.send_addPageViewEvent(pageViewEvents)
4609 
    self.recv_addPageViewEvent()
7897 amar.kumar 4610 
 
7977 kshitij.so 4611 
  def send_addPageViewEvent(self, pageViewEvents):
4612 
    self._oprot.writeMessageBegin('addPageViewEvent', TMessageType.CALL, self._seqid)
4613 
    args = addPageViewEvent_args()
4614 
    args.pageViewEvents = pageViewEvents
4615 
    args.write(self._oprot)
4616 
    self._oprot.writeMessageEnd()
4617 
    self._oprot.trans.flush()
4618 
 
4619 
  def recv_addPageViewEvent(self, ):
4620 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4621 
    if mtype == TMessageType.EXCEPTION:
4622 
      x = TApplicationException()
4623 
      x.read(self._iprot)
4624 
      self._iprot.readMessageEnd()
4625 
      raise x
4626 
    result = addPageViewEvent_result()
4627 
    result.read(self._iprot)
4628 
    self._iprot.readMessageEnd()
4629 
    return
4630 
 
4631 
  def addCartEvent(self, cartEvents):
4632 
    """
4633 
    Parameters:
4634 
     - cartEvents
4635 
    """
4636 
    self.send_addCartEvent(cartEvents)
4637 
    self.recv_addCartEvent()
4638 
 
4639 
  def send_addCartEvent(self, cartEvents):
4640 
    self._oprot.writeMessageBegin('addCartEvent', TMessageType.CALL, self._seqid)
4641 
    args = addCartEvent_args()
4642 
    args.cartEvents = cartEvents
4643 
    args.write(self._oprot)
4644 
    self._oprot.writeMessageEnd()
4645 
    self._oprot.trans.flush()
4646 
 
4647 
  def recv_addCartEvent(self, ):
4648 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4649 
    if mtype == TMessageType.EXCEPTION:
4650 
      x = TApplicationException()
4651 
      x.read(self._iprot)
4652 
      self._iprot.readMessageEnd()
4653 
      raise x
4654 
    result = addCartEvent_result()
4655 
    result.read(self._iprot)
4656 
    self._iprot.readMessageEnd()
4657 
    return
4658 
 
8182 amar.kumar 4659 
  def addEbayItem(self, ebayItem):
4660 
    """
4661 
    Parameters:
4662 
     - ebayItem
4663 
    """
4664 
    self.send_addEbayItem(ebayItem)
4665 
    self.recv_addEbayItem()
4666 
 
4667 
  def send_addEbayItem(self, ebayItem):
4668 
    self._oprot.writeMessageBegin('addEbayItem', TMessageType.CALL, self._seqid)
4669 
    args = addEbayItem_args()
4670 
    args.ebayItem = ebayItem
4671 
    args.write(self._oprot)
4672 
    self._oprot.writeMessageEnd()
4673 
    self._oprot.trans.flush()
4674 
 
4675 
  def recv_addEbayItem(self, ):
4676 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4677 
    if mtype == TMessageType.EXCEPTION:
4678 
      x = TApplicationException()
4679 
      x.read(self._iprot)
4680 
      self._iprot.readMessageEnd()
4681 
      raise x
4682 
    result = addEbayItem_result()
4683 
    result.read(self._iprot)
4684 
    self._iprot.readMessageEnd()
4685 
    return
4686 
 
4687 
  def getEbayItem(self, listingId):
4688 
    """
4689 
    Parameters:
4690 
     - listingId
4691 
    """
4692 
    self.send_getEbayItem(listingId)
4693 
    return self.recv_getEbayItem()
4694 
 
4695 
  def send_getEbayItem(self, listingId):
4696 
    self._oprot.writeMessageBegin('getEbayItem', TMessageType.CALL, self._seqid)
4697 
    args = getEbayItem_args()
4698 
    args.listingId = listingId
4699 
    args.write(self._oprot)
4700 
    self._oprot.writeMessageEnd()
4701 
    self._oprot.trans.flush()
4702 
 
4703 
  def recv_getEbayItem(self, ):
4704 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4705 
    if mtype == TMessageType.EXCEPTION:
4706 
      x = TApplicationException()
4707 
      x.read(self._iprot)
4708 
      self._iprot.readMessageEnd()
4709 
      raise x
4710 
    result = getEbayItem_result()
4711 
    result.read(self._iprot)
4712 
    self._iprot.readMessageEnd()
4713 
    if result.success is not None:
4714 
      return result.success
4715 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEbayItem failed: unknown result");
4716 
 
4717 
  def updateEbayItem(self, ebayItem):
4718 
    """
4719 
    Parameters:
4720 
     - ebayItem
4721 
    """
4722 
    self.send_updateEbayItem(ebayItem)
4723 
    self.recv_updateEbayItem()
4724 
 
4725 
  def send_updateEbayItem(self, ebayItem):
4726 
    self._oprot.writeMessageBegin('updateEbayItem', TMessageType.CALL, self._seqid)
4727 
    args = updateEbayItem_args()
4728 
    args.ebayItem = ebayItem
4729 
    args.write(self._oprot)
4730 
    self._oprot.writeMessageEnd()
4731 
    self._oprot.trans.flush()
4732 
 
4733 
  def recv_updateEbayItem(self, ):
4734 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4735 
    if mtype == TMessageType.EXCEPTION:
4736 
      x = TApplicationException()
4737 
      x.read(self._iprot)
4738 
      self._iprot.readMessageEnd()
4739 
      raise x
4740 
    result = updateEbayItem_result()
4741 
    result.read(self._iprot)
4742 
    self._iprot.readMessageEnd()
4743 
    return
4744 
 
8139 kshitij.so 4745 
  def getAmazonListedItems(self, offset, limit):
4746 
    """
4747 
    Parameters:
4748 
     - offset
4749 
     - limit
4750 
    """
4751 
    self.send_getAmazonListedItems(offset, limit)
4752 
    return self.recv_getAmazonListedItems()
7977 kshitij.so 4753 
 
8139 kshitij.so 4754 
  def send_getAmazonListedItems(self, offset, limit):
4755 
    self._oprot.writeMessageBegin('getAmazonListedItems', TMessageType.CALL, self._seqid)
4756 
    args = getAmazonListedItems_args()
4757 
    args.offset = offset
4758 
    args.limit = limit
4759 
    args.write(self._oprot)
4760 
    self._oprot.writeMessageEnd()
4761 
    self._oprot.trans.flush()
4762 
 
4763 
  def recv_getAmazonListedItems(self, ):
4764 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4765 
    if mtype == TMessageType.EXCEPTION:
4766 
      x = TApplicationException()
4767 
      x.read(self._iprot)
4768 
      self._iprot.readMessageEnd()
4769 
      raise x
4770 
    result = getAmazonListedItems_result()
4771 
    result.read(self._iprot)
4772 
    self._iprot.readMessageEnd()
4773 
    if result.success is not None:
4774 
      return result.success
4775 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonListedItems failed: unknown result");
4776 
 
8168 kshitij.so 4777 
  def updateAmazonAttributesInBulk(self, amazonlisted):
4778 
    """
4779 
    Parameters:
4780 
     - amazonlisted
4781 
    """
4782 
    self.send_updateAmazonAttributesInBulk(amazonlisted)
4783 
    return self.recv_updateAmazonAttributesInBulk()
8139 kshitij.so 4784 
 
8168 kshitij.so 4785 
  def send_updateAmazonAttributesInBulk(self, amazonlisted):
4786 
    self._oprot.writeMessageBegin('updateAmazonAttributesInBulk', TMessageType.CALL, self._seqid)
4787 
    args = updateAmazonAttributesInBulk_args()
4788 
    args.amazonlisted = amazonlisted
4789 
    args.write(self._oprot)
4790 
    self._oprot.writeMessageEnd()
4791 
    self._oprot.trans.flush()
4792 
 
4793 
  def recv_updateAmazonAttributesInBulk(self, ):
4794 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4795 
    if mtype == TMessageType.EXCEPTION:
4796 
      x = TApplicationException()
4797 
      x.read(self._iprot)
4798 
      self._iprot.readMessageEnd()
4799 
      raise x
4800 
    result = updateAmazonAttributesInBulk_result()
4801 
    result.read(self._iprot)
4802 
    self._iprot.readMessageEnd()
4803 
    if result.success is not None:
4804 
      return result.success
4805 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateAmazonAttributesInBulk failed: unknown result");
4806 
 
8379 vikram.rag 4807 
  def getAllItemstoListOnFba(self, ):
4808 
    self.send_getAllItemstoListOnFba()
4809 
    return self.recv_getAllItemstoListOnFba()
8168 kshitij.so 4810 
 
8379 vikram.rag 4811 
  def send_getAllItemstoListOnFba(self, ):
4812 
    self._oprot.writeMessageBegin('getAllItemstoListOnFba', TMessageType.CALL, self._seqid)
4813 
    args = getAllItemstoListOnFba_args()
4814 
    args.write(self._oprot)
4815 
    self._oprot.writeMessageEnd()
4816 
    self._oprot.trans.flush()
4817 
 
4818 
  def recv_getAllItemstoListOnFba(self, ):
4819 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4820 
    if mtype == TMessageType.EXCEPTION:
4821 
      x = TApplicationException()
4822 
      x.read(self._iprot)
4823 
      self._iprot.readMessageEnd()
4824 
      raise x
4825 
    result = getAllItemstoListOnFba_result()
4826 
    result.read(self._iprot)
4827 
    self._iprot.readMessageEnd()
4828 
    if result.success is not None:
4829 
      return result.success
4830 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnFba failed: unknown result");
4831 
 
4832 
  def getAllItemstoListOnNonFba(self, ):
4833 
    self.send_getAllItemstoListOnNonFba()
4834 
    return self.recv_getAllItemstoListOnNonFba()
4835 
 
4836 
  def send_getAllItemstoListOnNonFba(self, ):
4837 
    self._oprot.writeMessageBegin('getAllItemstoListOnNonFba', TMessageType.CALL, self._seqid)
4838 
    args = getAllItemstoListOnNonFba_args()
4839 
    args.write(self._oprot)
4840 
    self._oprot.writeMessageEnd()
4841 
    self._oprot.trans.flush()
4842 
 
4843 
  def recv_getAllItemstoListOnNonFba(self, ):
4844 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4845 
    if mtype == TMessageType.EXCEPTION:
4846 
      x = TApplicationException()
4847 
      x.read(self._iprot)
4848 
      self._iprot.readMessageEnd()
4849 
      raise x
4850 
    result = getAllItemstoListOnNonFba_result()
4851 
    result.read(self._iprot)
4852 
    self._iprot.readMessageEnd()
4853 
    if result.success is not None:
4854 
      return result.success
4855 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnNonFba failed: unknown result");
4856 
 
8619 kshitij.so 4857 
  def updateAsin(self, item):
4858 
    """
4859 
    Parameters:
4860 
     - item
4861 
    """
4862 
    self.send_updateAsin(item)
4863 
    self.recv_updateAsin()
8616 vikram.rag 4864 
 
8619 kshitij.so 4865 
  def send_updateAsin(self, item):
4866 
    self._oprot.writeMessageBegin('updateAsin', TMessageType.CALL, self._seqid)
4867 
    args = updateAsin_args()
4868 
    args.item = item
4869 
    args.write(self._oprot)
4870 
    self._oprot.writeMessageEnd()
4871 
    self._oprot.trans.flush()
4872 
 
4873 
  def recv_updateAsin(self, ):
4874 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4875 
    if mtype == TMessageType.EXCEPTION:
4876 
      x = TApplicationException()
4877 
      x.read(self._iprot)
4878 
      self._iprot.readMessageEnd()
4879 
      raise x
4880 
    result = updateAsin_result()
4881 
    result.read(self._iprot)
4882 
    self._iprot.readMessageEnd()
4883 
    return
4884 
 
8739 vikram.rag 4885 
  def addOrUpdateSnapdealItem(self, snapdealitem):
4886 
    """
4887 
    Parameters:
4888 
     - snapdealitem
4889 
    """
4890 
    self.send_addOrUpdateSnapdealItem(snapdealitem)
4891 
    return self.recv_addOrUpdateSnapdealItem()
8619 kshitij.so 4892 
 
8739 vikram.rag 4893 
  def send_addOrUpdateSnapdealItem(self, snapdealitem):
4894 
    self._oprot.writeMessageBegin('addOrUpdateSnapdealItem', TMessageType.CALL, self._seqid)
4895 
    args = addOrUpdateSnapdealItem_args()
4896 
    args.snapdealitem = snapdealitem
4897 
    args.write(self._oprot)
4898 
    self._oprot.writeMessageEnd()
4899 
    self._oprot.trans.flush()
4900 
 
4901 
  def recv_addOrUpdateSnapdealItem(self, ):
4902 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4903 
    if mtype == TMessageType.EXCEPTION:
4904 
      x = TApplicationException()
4905 
      x.read(self._iprot)
4906 
      self._iprot.readMessageEnd()
4907 
      raise x
4908 
    result = addOrUpdateSnapdealItem_result()
4909 
    result.read(self._iprot)
4910 
    self._iprot.readMessageEnd()
4911 
    if result.success is not None:
4912 
      return result.success
4913 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addOrUpdateSnapdealItem failed: unknown result");
4914 
 
4915 
  def getSnapdealItem(self, item_id):
4916 
    """
4917 
    Parameters:
4918 
     - item_id
4919 
    """
4920 
    self.send_getSnapdealItem(item_id)
4921 
    return self.recv_getSnapdealItem()
4922 
 
4923 
  def send_getSnapdealItem(self, item_id):
4924 
    self._oprot.writeMessageBegin('getSnapdealItem', TMessageType.CALL, self._seqid)
4925 
    args = getSnapdealItem_args()
4926 
    args.item_id = item_id
4927 
    args.write(self._oprot)
4928 
    self._oprot.writeMessageEnd()
4929 
    self._oprot.trans.flush()
4930 
 
4931 
  def recv_getSnapdealItem(self, ):
4932 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4933 
    if mtype == TMessageType.EXCEPTION:
4934 
      x = TApplicationException()
4935 
      x.read(self._iprot)
4936 
      self._iprot.readMessageEnd()
4937 
      raise x
4938 
    result = getSnapdealItem_result()
4939 
    result.read(self._iprot)
4940 
    self._iprot.readMessageEnd()
4941 
    if result.success is not None:
4942 
      return result.success
4943 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItem failed: unknown result");
4944 
 
9242 kshitij.so 4945 
  def getSnapdealItemDetails(self, item_id):
4946 
    """
4947 
    Parameters:
4948 
     - item_id
4949 
    """
4950 
    self.send_getSnapdealItemDetails(item_id)
4951 
    return self.recv_getSnapdealItemDetails()
4952 
 
4953 
  def send_getSnapdealItemDetails(self, item_id):
4954 
    self._oprot.writeMessageBegin('getSnapdealItemDetails', TMessageType.CALL, self._seqid)
4955 
    args = getSnapdealItemDetails_args()
4956 
    args.item_id = item_id
4957 
    args.write(self._oprot)
4958 
    self._oprot.writeMessageEnd()
4959 
    self._oprot.trans.flush()
4960 
 
4961 
  def recv_getSnapdealItemDetails(self, ):
4962 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4963 
    if mtype == TMessageType.EXCEPTION:
4964 
      x = TApplicationException()
4965 
      x.read(self._iprot)
4966 
      self._iprot.readMessageEnd()
4967 
      raise x
4968 
    result = getSnapdealItemDetails_result()
4969 
    result.read(self._iprot)
4970 
    self._iprot.readMessageEnd()
4971 
    if result.success is not None:
4972 
      return result.success
4973 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItemDetails failed: unknown result");
4974 
 
8739 vikram.rag 4975 
  def getAllSnapdealItems(self, ):
4976 
    self.send_getAllSnapdealItems()
4977 
    return self.recv_getAllSnapdealItems()
4978 
 
4979 
  def send_getAllSnapdealItems(self, ):
4980 
    self._oprot.writeMessageBegin('getAllSnapdealItems', TMessageType.CALL, self._seqid)
4981 
    args = getAllSnapdealItems_args()
4982 
    args.write(self._oprot)
4983 
    self._oprot.writeMessageEnd()
4984 
    self._oprot.trans.flush()
4985 
 
4986 
  def recv_getAllSnapdealItems(self, ):
4987 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4988 
    if mtype == TMessageType.EXCEPTION:
4989 
      x = TApplicationException()
4990 
      x.read(self._iprot)
4991 
      self._iprot.readMessageEnd()
4992 
      raise x
4993 
    result = getAllSnapdealItems_result()
4994 
    result.read(self._iprot)
4995 
    self._iprot.readMessageEnd()
4996 
    if result.success is not None:
4997 
      return result.success
4998 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSnapdealItems failed: unknown result");
4999 
 
9242 kshitij.so 5000 
  def getSnapdealItems(self, offset, limit):
5001 
    """
5002 
    Parameters:
5003 
     - offset
5004 
     - limit
5005 
    """
5006 
    self.send_getSnapdealItems(offset, limit)
5007 
    return self.recv_getSnapdealItems()
8739 vikram.rag 5008 
 
9242 kshitij.so 5009 
  def send_getSnapdealItems(self, offset, limit):
5010 
    self._oprot.writeMessageBegin('getSnapdealItems', TMessageType.CALL, self._seqid)
5011 
    args = getSnapdealItems_args()
5012 
    args.offset = offset
5013 
    args.limit = limit
5014 
    args.write(self._oprot)
5015 
    self._oprot.writeMessageEnd()
5016 
    self._oprot.trans.flush()
5017 
 
5018 
  def recv_getSnapdealItems(self, ):
5019 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5020 
    if mtype == TMessageType.EXCEPTION:
5021 
      x = TApplicationException()
5022 
      x.read(self._iprot)
5023 
      self._iprot.readMessageEnd()
5024 
      raise x
5025 
    result = getSnapdealItems_result()
5026 
    result.read(self._iprot)
5027 
    self._iprot.readMessageEnd()
5028 
    if result.success is not None:
5029 
      return result.success
5030 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItems failed: unknown result");
5031 
 
5032 
  def searchSnapdealItems(self, searchTerm, offset, limit):
5033 
    """
5034 
    Parameters:
5035 
     - searchTerm
5036 
     - offset
5037 
     - limit
5038 
    """
5039 
    self.send_searchSnapdealItems(searchTerm, offset, limit)
5040 
    return self.recv_searchSnapdealItems()
5041 
 
5042 
  def send_searchSnapdealItems(self, searchTerm, offset, limit):
5043 
    self._oprot.writeMessageBegin('searchSnapdealItems', TMessageType.CALL, self._seqid)
5044 
    args = searchSnapdealItems_args()
5045 
    args.searchTerm = searchTerm
5046 
    args.offset = offset
5047 
    args.limit = limit
5048 
    args.write(self._oprot)
5049 
    self._oprot.writeMessageEnd()
5050 
    self._oprot.trans.flush()
5051 
 
5052 
  def recv_searchSnapdealItems(self, ):
5053 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5054 
    if mtype == TMessageType.EXCEPTION:
5055 
      x = TApplicationException()
5056 
      x.read(self._iprot)
5057 
      self._iprot.readMessageEnd()
5058 
      raise x
5059 
    result = searchSnapdealItems_result()
5060 
    result.read(self._iprot)
5061 
    self._iprot.readMessageEnd()
5062 
    if result.success is not None:
5063 
      return result.success
5064 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchSnapdealItems failed: unknown result");
5065 
 
5066 
  def getCountForSnapdealItems(self, ):
5067 
    self.send_getCountForSnapdealItems()
5068 
    return self.recv_getCountForSnapdealItems()
5069 
 
5070 
  def send_getCountForSnapdealItems(self, ):
5071 
    self._oprot.writeMessageBegin('getCountForSnapdealItems', TMessageType.CALL, self._seqid)
5072 
    args = getCountForSnapdealItems_args()
5073 
    args.write(self._oprot)
5074 
    self._oprot.writeMessageEnd()
5075 
    self._oprot.trans.flush()
5076 
 
5077 
  def recv_getCountForSnapdealItems(self, ):
5078 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5079 
    if mtype == TMessageType.EXCEPTION:
5080 
      x = TApplicationException()
5081 
      x.read(self._iprot)
5082 
      self._iprot.readMessageEnd()
5083 
      raise x
5084 
    result = getCountForSnapdealItems_result()
5085 
    result.read(self._iprot)
5086 
    self._iprot.readMessageEnd()
5087 
    if result.success is not None:
5088 
      return result.success
5089 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForSnapdealItems failed: unknown result");
5090 
 
5091 
  def getSnapdealSearchResultCount(self, searchTerm):
5092 
    """
5093 
    Parameters:
5094 
     - searchTerm
5095 
    """
5096 
    self.send_getSnapdealSearchResultCount(searchTerm)
5097 
    return self.recv_getSnapdealSearchResultCount()
5098 
 
5099 
  def send_getSnapdealSearchResultCount(self, searchTerm):
5100 
    self._oprot.writeMessageBegin('getSnapdealSearchResultCount', TMessageType.CALL, self._seqid)
5101 
    args = getSnapdealSearchResultCount_args()
5102 
    args.searchTerm = searchTerm
5103 
    args.write(self._oprot)
5104 
    self._oprot.writeMessageEnd()
5105 
    self._oprot.trans.flush()
5106 
 
5107 
  def recv_getSnapdealSearchResultCount(self, ):
5108 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5109 
    if mtype == TMessageType.EXCEPTION:
5110 
      x = TApplicationException()
5111 
      x.read(self._iprot)
5112 
      self._iprot.readMessageEnd()
5113 
      raise x
5114 
    result = getSnapdealSearchResultCount_result()
5115 
    result.read(self._iprot)
5116 
    self._iprot.readMessageEnd()
5117 
    if result.success is not None:
5118 
      return result.success
5119 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealSearchResultCount failed: unknown result");
5120 
 
9299 kshitij.so 5121 
  def getPrefferedInsurerForItem(self, itemId, insurerType):
5122 
    """
5123 
    Parameters:
5124 
     - itemId
5125 
     - insurerType
5126 
    """
5127 
    self.send_getPrefferedInsurerForItem(itemId, insurerType)
5128 
    return self.recv_getPrefferedInsurerForItem()
9242 kshitij.so 5129 
 
9299 kshitij.so 5130 
  def send_getPrefferedInsurerForItem(self, itemId, insurerType):
5131 
    self._oprot.writeMessageBegin('getPrefferedInsurerForItem', TMessageType.CALL, self._seqid)
5132 
    args = getPrefferedInsurerForItem_args()
5133 
    args.itemId = itemId
5134 
    args.insurerType = insurerType
5135 
    args.write(self._oprot)
5136 
    self._oprot.writeMessageEnd()
5137 
    self._oprot.trans.flush()
5138 
 
5139 
  def recv_getPrefferedInsurerForItem(self, ):
5140 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5141 
    if mtype == TMessageType.EXCEPTION:
5142 
      x = TApplicationException()
5143 
      x.read(self._iprot)
5144 
      self._iprot.readMessageEnd()
5145 
      raise x
5146 
    result = getPrefferedInsurerForItem_result()
5147 
    result.read(self._iprot)
5148 
    self._iprot.readMessageEnd()
5149 
    if result.success is not None:
5150 
      return result.success
5151 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrefferedInsurerForItem failed: unknown result");
5152 
 
9456 vikram.rag 5153 
  def getSnapdealItembySkuAtSnapdeal(self, skuAtSnapdeal):
5154 
    """
5155 
    Parameters:
5156 
     - skuAtSnapdeal
5157 
    """
5158 
    self.send_getSnapdealItembySkuAtSnapdeal(skuAtSnapdeal)
5159 
    return self.recv_getSnapdealItembySkuAtSnapdeal()
9299 kshitij.so 5160 
 
9456 vikram.rag 5161 
  def send_getSnapdealItembySkuAtSnapdeal(self, skuAtSnapdeal):
5162 
    self._oprot.writeMessageBegin('getSnapdealItembySkuAtSnapdeal', TMessageType.CALL, self._seqid)
5163 
    args = getSnapdealItembySkuAtSnapdeal_args()
5164 
    args.skuAtSnapdeal = skuAtSnapdeal
5165 
    args.write(self._oprot)
5166 
    self._oprot.writeMessageEnd()
5167 
    self._oprot.trans.flush()
5168 
 
5169 
  def recv_getSnapdealItembySkuAtSnapdeal(self, ):
5170 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5171 
    if mtype == TMessageType.EXCEPTION:
5172 
      x = TApplicationException()
5173 
      x.read(self._iprot)
5174 
      self._iprot.readMessageEnd()
5175 
      raise x
5176 
    result = getSnapdealItembySkuAtSnapdeal_result()
5177 
    result.read(self._iprot)
5178 
    self._iprot.readMessageEnd()
5179 
    if result.success is not None:
5180 
      return result.success
5181 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItembySkuAtSnapdeal failed: unknown result");
5182 
 
9621 manish.sha 5183 
  def getProductFeedSubmit(self, catalogItemId):
5184 
    """
5185 
    Parameters:
5186 
     - catalogItemId
5187 
    """
5188 
    self.send_getProductFeedSubmit(catalogItemId)
5189 
    return self.recv_getProductFeedSubmit()
9456 vikram.rag 5190 
 
9621 manish.sha 5191 
  def send_getProductFeedSubmit(self, catalogItemId):
5192 
    self._oprot.writeMessageBegin('getProductFeedSubmit', TMessageType.CALL, self._seqid)
5193 
    args = getProductFeedSubmit_args()
5194 
    args.catalogItemId = catalogItemId
5195 
    args.write(self._oprot)
5196 
    self._oprot.writeMessageEnd()
5197 
    self._oprot.trans.flush()
5198 
 
5199 
  def recv_getProductFeedSubmit(self, ):
5200 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5201 
    if mtype == TMessageType.EXCEPTION:
5202 
      x = TApplicationException()
5203 
      x.read(self._iprot)
5204 
      self._iprot.readMessageEnd()
5205 
      raise x
5206 
    result = getProductFeedSubmit_result()
5207 
    result.read(self._iprot)
5208 
    self._iprot.readMessageEnd()
5209 
    if result.success is not None:
5210 
      return result.success
5211 
    if result.cex is not None:
5212 
      raise result.cex
5213 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductFeedSubmit failed: unknown result");
5214 
 
5215 
  def addProductFeedSubmit(self, productFeedSubmit):
5216 
    """
5217 
    Parameters:
5218 
     - productFeedSubmit
5219 
    """
5220 
    self.send_addProductFeedSubmit(productFeedSubmit)
5221 
    return self.recv_addProductFeedSubmit()
5222 
 
5223 
  def send_addProductFeedSubmit(self, productFeedSubmit):
5224 
    self._oprot.writeMessageBegin('addProductFeedSubmit', TMessageType.CALL, self._seqid)
5225 
    args = addProductFeedSubmit_args()
5226 
    args.productFeedSubmit = productFeedSubmit
5227 
    args.write(self._oprot)
5228 
    self._oprot.writeMessageEnd()
5229 
    self._oprot.trans.flush()
5230 
 
5231 
  def recv_addProductFeedSubmit(self, ):
5232 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5233 
    if mtype == TMessageType.EXCEPTION:
5234 
      x = TApplicationException()
5235 
      x.read(self._iprot)
5236 
      self._iprot.readMessageEnd()
5237 
      raise x
5238 
    result = addProductFeedSubmit_result()
5239 
    result.read(self._iprot)
5240 
    self._iprot.readMessageEnd()
5241 
    if result.success is not None:
5242 
      return result.success
5243 
    if result.cex is not None:
5244 
      raise result.cex
5245 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductFeedSubmit failed: unknown result");
5246 
 
5247 
  def updateProductFeedSubmit(self, productFeedSubmit):
5248 
    """
5249 
    Parameters:
5250 
     - productFeedSubmit
5251 
    """
5252 
    self.send_updateProductFeedSubmit(productFeedSubmit)
5253 
    return self.recv_updateProductFeedSubmit()
5254 
 
5255 
  def send_updateProductFeedSubmit(self, productFeedSubmit):
5256 
    self._oprot.writeMessageBegin('updateProductFeedSubmit', TMessageType.CALL, self._seqid)
5257 
    args = updateProductFeedSubmit_args()
5258 
    args.productFeedSubmit = productFeedSubmit
5259 
    args.write(self._oprot)
5260 
    self._oprot.writeMessageEnd()
5261 
    self._oprot.trans.flush()
5262 
 
5263 
  def recv_updateProductFeedSubmit(self, ):
5264 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5265 
    if mtype == TMessageType.EXCEPTION:
5266 
      x = TApplicationException()
5267 
      x.read(self._iprot)
5268 
      self._iprot.readMessageEnd()
5269 
      raise x
5270 
    result = updateProductFeedSubmit_result()
5271 
    result.read(self._iprot)
5272 
    self._iprot.readMessageEnd()
5273 
    if result.success is not None:
5274 
      return result.success
5275 
    if result.cex is not None:
5276 
      raise result.cex
5277 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateProductFeedSubmit failed: unknown result");
5278 
 
5279 
  def deleteProductFeedSubmit(self, catalogItemId):
5280 
    """
5281 
    Parameters:
5282 
     - catalogItemId
5283 
    """
5284 
    self.send_deleteProductFeedSubmit(catalogItemId)
5285 
    return self.recv_deleteProductFeedSubmit()
5286 
 
5287 
  def send_deleteProductFeedSubmit(self, catalogItemId):
5288 
    self._oprot.writeMessageBegin('deleteProductFeedSubmit', TMessageType.CALL, self._seqid)
5289 
    args = deleteProductFeedSubmit_args()
5290 
    args.catalogItemId = catalogItemId
5291 
    args.write(self._oprot)
5292 
    self._oprot.writeMessageEnd()
5293 
    self._oprot.trans.flush()
5294 
 
5295 
  def recv_deleteProductFeedSubmit(self, ):
5296 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5297 
    if mtype == TMessageType.EXCEPTION:
5298 
      x = TApplicationException()
5299 
      x.read(self._iprot)
5300 
      self._iprot.readMessageEnd()
5301 
      raise x
5302 
    result = deleteProductFeedSubmit_result()
5303 
    result.read(self._iprot)
5304 
    self._iprot.readMessageEnd()
5305 
    if result.success is not None:
5306 
      return result.success
5307 
    if result.cex is not None:
5308 
      raise result.cex
5309 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteProductFeedSubmit failed: unknown result");
5310 
 
5311 
  def getAllProductFeedSubmit(self, ):
5312 
    self.send_getAllProductFeedSubmit()
5313 
    return self.recv_getAllProductFeedSubmit()
5314 
 
5315 
  def send_getAllProductFeedSubmit(self, ):
5316 
    self._oprot.writeMessageBegin('getAllProductFeedSubmit', TMessageType.CALL, self._seqid)
5317 
    args = getAllProductFeedSubmit_args()
5318 
    args.write(self._oprot)
5319 
    self._oprot.writeMessageEnd()
5320 
    self._oprot.trans.flush()
5321 
 
5322 
  def recv_getAllProductFeedSubmit(self, ):
5323 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5324 
    if mtype == TMessageType.EXCEPTION:
5325 
      x = TApplicationException()
5326 
      x.read(self._iprot)
5327 
      self._iprot.readMessageEnd()
5328 
      raise x
5329 
    result = getAllProductFeedSubmit_result()
5330 
    result.read(self._iprot)
5331 
    self._iprot.readMessageEnd()
5332 
    if result.success is not None:
5333 
      return result.success
5334 
    if result.cex is not None:
5335 
      raise result.cex
5336 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllProductFeedSubmit failed: unknown result");
5337 
 
9724 kshitij.so 5338 
  def getMarketplacedetailsForItem(self, itemId, sourceId):
5339 
    """
5340 
    Parameters:
5341 
     - itemId
5342 
     - sourceId
5343 
    """
5344 
    self.send_getMarketplacedetailsForItem(itemId, sourceId)
5345 
    return self.recv_getMarketplacedetailsForItem()
9621 manish.sha 5346 
 
9724 kshitij.so 5347 
  def send_getMarketplacedetailsForItem(self, itemId, sourceId):
5348 
    self._oprot.writeMessageBegin('getMarketplacedetailsForItem', TMessageType.CALL, self._seqid)
5349 
    args = getMarketplacedetailsForItem_args()
5350 
    args.itemId = itemId
5351 
    args.sourceId = sourceId
5352 
    args.write(self._oprot)
5353 
    self._oprot.writeMessageEnd()
5354 
    self._oprot.trans.flush()
5355 
 
5356 
  def recv_getMarketplacedetailsForItem(self, ):
5357 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5358 
    if mtype == TMessageType.EXCEPTION:
5359 
      x = TApplicationException()
5360 
      x.read(self._iprot)
5361 
      self._iprot.readMessageEnd()
5362 
      raise x
5363 
    result = getMarketplacedetailsForItem_result()
5364 
    result.read(self._iprot)
5365 
    self._iprot.readMessageEnd()
5366 
    if result.success is not None:
5367 
      return result.success
5368 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMarketplacedetailsForItem failed: unknown result");
5369 
 
5370 
  def updateMarketplaceAttributesForItem(self, marketPlaceItem):
5371 
    """
5372 
    Parameters:
5373 
     - marketPlaceItem
5374 
    """
5375 
    self.send_updateMarketplaceAttributesForItem(marketPlaceItem)
5376 
    return self.recv_updateMarketplaceAttributesForItem()
5377 
 
5378 
  def send_updateMarketplaceAttributesForItem(self, marketPlaceItem):
5379 
    self._oprot.writeMessageBegin('updateMarketplaceAttributesForItem', TMessageType.CALL, self._seqid)
5380 
    args = updateMarketplaceAttributesForItem_args()
5381 
    args.marketPlaceItem = marketPlaceItem
5382 
    args.write(self._oprot)
5383 
    self._oprot.writeMessageEnd()
5384 
    self._oprot.trans.flush()
5385 
 
5386 
  def recv_updateMarketplaceAttributesForItem(self, ):
5387 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5388 
    if mtype == TMessageType.EXCEPTION:
5389 
      x = TApplicationException()
5390 
      x.read(self._iprot)
5391 
      self._iprot.readMessageEnd()
5392 
      raise x
5393 
    result = updateMarketplaceAttributesForItem_result()
5394 
    result.read(self._iprot)
5395 
    self._iprot.readMessageEnd()
5396 
    if result.success is not None:
5397 
      return result.success
5398 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMarketplaceAttributesForItem failed: unknown result");
5399 
 
9779 kshitij.so 5400 
  def getCostingForMarketplace(self, source, item_id):
5401 
    """
5402 
    Parameters:
5403 
     - source
5404 
     - item_id
5405 
    """
5406 
    self.send_getCostingForMarketplace(source, item_id)
5407 
    return self.recv_getCostingForMarketplace()
5408 
 
5409 
  def send_getCostingForMarketplace(self, source, item_id):
5410 
    self._oprot.writeMessageBegin('getCostingForMarketplace', TMessageType.CALL, self._seqid)
5411 
    args = getCostingForMarketplace_args()
5412 
    args.source = source
5413 
    args.item_id = item_id
5414 
    args.write(self._oprot)
5415 
    self._oprot.writeMessageEnd()
5416 
    self._oprot.trans.flush()
5417 
 
5418 
  def recv_getCostingForMarketplace(self, ):
5419 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5420 
    if mtype == TMessageType.EXCEPTION:
5421 
      x = TApplicationException()
5422 
      x.read(self._iprot)
5423 
      self._iprot.readMessageEnd()
5424 
      raise x
5425 
    result = getCostingForMarketplace_result()
5426 
    result.read(self._iprot)
5427 
    self._iprot.readMessageEnd()
5428 
    if result.success is not None:
5429 
      return result.success
5430 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCostingForMarketplace failed: unknown result");
5431 
 
9776 vikram.rag 5432 
  def getMarketPlaceItemsForPriceUpdate(self, source):
5433 
    """
5434 
    Parameters:
5435 
     - source
5436 
    """
5437 
    self.send_getMarketPlaceItemsForPriceUpdate(source)
5438 
    return self.recv_getMarketPlaceItemsForPriceUpdate()
9724 kshitij.so 5439 
 
9776 vikram.rag 5440 
  def send_getMarketPlaceItemsForPriceUpdate(self, source):
5441 
    self._oprot.writeMessageBegin('getMarketPlaceItemsForPriceUpdate', TMessageType.CALL, self._seqid)
5442 
    args = getMarketPlaceItemsForPriceUpdate_args()
5443 
    args.source = source
5444 
    args.write(self._oprot)
5445 
    self._oprot.writeMessageEnd()
5446 
    self._oprot.trans.flush()
5447 
 
5448 
  def recv_getMarketPlaceItemsForPriceUpdate(self, ):
5449 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5450 
    if mtype == TMessageType.EXCEPTION:
5451 
      x = TApplicationException()
5452 
      x.read(self._iprot)
5453 
      self._iprot.readMessageEnd()
5454 
      raise x
5455 
    result = getMarketPlaceItemsForPriceUpdate_result()
5456 
    result.read(self._iprot)
5457 
    self._iprot.readMessageEnd()
5458 
    if result.success is not None:
5459 
      return result.success
5460 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMarketPlaceItemsForPriceUpdate failed: unknown result");
5461 
 
9816 kshitij.so 5462 
  def updateMarketPlacePriceUpdateStatus(self, skulist, timestamp, source):
9776 vikram.rag 5463 
    """
5464 
    Parameters:
5465 
     - skulist
5466 
     - timestamp
9816 kshitij.so 5467 
     - source
9776 vikram.rag 5468 
    """
9816 kshitij.so 5469 
    self.send_updateMarketPlacePriceUpdateStatus(skulist, timestamp, source)
9776 vikram.rag 5470 
    self.recv_updateMarketPlacePriceUpdateStatus()
5471 
 
9816 kshitij.so 5472 
  def send_updateMarketPlacePriceUpdateStatus(self, skulist, timestamp, source):
9776 vikram.rag 5473 
    self._oprot.writeMessageBegin('updateMarketPlacePriceUpdateStatus', TMessageType.CALL, self._seqid)
5474 
    args = updateMarketPlacePriceUpdateStatus_args()
5475 
    args.skulist = skulist
5476 
    args.timestamp = timestamp
9816 kshitij.so 5477 
    args.source = source
9776 vikram.rag 5478 
    args.write(self._oprot)
5479 
    self._oprot.writeMessageEnd()
5480 
    self._oprot.trans.flush()
5481 
 
5482 
  def recv_updateMarketPlacePriceUpdateStatus(self, ):
5483 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5484 
    if mtype == TMessageType.EXCEPTION:
5485 
      x = TApplicationException()
5486 
      x.read(self._iprot)
5487 
      self._iprot.readMessageEnd()
5488 
      raise x
5489 
    result = updateMarketPlacePriceUpdateStatus_result()
5490 
    result.read(self._iprot)
5491 
    self._iprot.readMessageEnd()
5492 
    return
5493 
 
9861 rajveer 5494 
  def updateItemHoldInventory(self, itemHoldMap):
5495 
    """
5496 
    Parameters:
5497 
     - itemHoldMap
5498 
    """
5499 
    self.send_updateItemHoldInventory(itemHoldMap)
5500 
    self.recv_updateItemHoldInventory()
9776 vikram.rag 5501 
 
9861 rajveer 5502 
  def send_updateItemHoldInventory(self, itemHoldMap):
5503 
    self._oprot.writeMessageBegin('updateItemHoldInventory', TMessageType.CALL, self._seqid)
5504 
    args = updateItemHoldInventory_args()
5505 
    args.itemHoldMap = itemHoldMap
5506 
    args.write(self._oprot)
5507 
    self._oprot.writeMessageEnd()
5508 
    self._oprot.trans.flush()
5509 
 
5510 
  def recv_updateItemHoldInventory(self, ):
5511 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5512 
    if mtype == TMessageType.EXCEPTION:
5513 
      x = TApplicationException()
5514 
      x.read(self._iprot)
5515 
      self._iprot.readMessageEnd()
5516 
      raise x
5517 
    result = updateItemHoldInventory_result()
5518 
    result.read(self._iprot)
5519 
    self._iprot.readMessageEnd()
5520 
    return
5521 
 
9895 vikram.rag 5522 
  def updateNlcAtMarketplaces(self, item_id, vendor_id, nlc):
5523 
    """
5524 
    Parameters:
5525 
     - item_id
5526 
     - vendor_id
5527 
     - nlc
5528 
    """
5529 
    self.send_updateNlcAtMarketplaces(item_id, vendor_id, nlc)
5530 
    self.recv_updateNlcAtMarketplaces()
9861 rajveer 5531 
 
9895 vikram.rag 5532 
  def send_updateNlcAtMarketplaces(self, item_id, vendor_id, nlc):
5533 
    self._oprot.writeMessageBegin('updateNlcAtMarketplaces', TMessageType.CALL, self._seqid)
5534 
    args = updateNlcAtMarketplaces_args()
5535 
    args.item_id = item_id
5536 
    args.vendor_id = vendor_id
5537 
    args.nlc = nlc
5538 
    args.write(self._oprot)
5539 
    self._oprot.writeMessageEnd()
5540 
    self._oprot.trans.flush()
5541 
 
5542 
  def recv_updateNlcAtMarketplaces(self, ):
5543 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5544 
    if mtype == TMessageType.EXCEPTION:
5545 
      x = TApplicationException()
5546 
      x.read(self._iprot)
5547 
      self._iprot.readMessageEnd()
5548 
      raise x
5549 
    result = updateNlcAtMarketplaces_result()
5550 
    result.read(self._iprot)
5551 
    self._iprot.readMessageEnd()
5552 
    return
5553 
 
9945 vikram.rag 5554 
  def getAllFlipkartItems(self, ):
5555 
    self.send_getAllFlipkartItems()
5556 
    return self.recv_getAllFlipkartItems()
9895 vikram.rag 5557 
 
9945 vikram.rag 5558 
  def send_getAllFlipkartItems(self, ):
5559 
    self._oprot.writeMessageBegin('getAllFlipkartItems', TMessageType.CALL, self._seqid)
5560 
    args = getAllFlipkartItems_args()
5561 
    args.write(self._oprot)
5562 
    self._oprot.writeMessageEnd()
5563 
    self._oprot.trans.flush()
5564 
 
5565 
  def recv_getAllFlipkartItems(self, ):
5566 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5567 
    if mtype == TMessageType.EXCEPTION:
5568 
      x = TApplicationException()
5569 
      x.read(self._iprot)
5570 
      self._iprot.readMessageEnd()
5571 
      raise x
5572 
    result = getAllFlipkartItems_result()
5573 
    result.read(self._iprot)
5574 
    self._iprot.readMessageEnd()
5575 
    if result.success is not None:
5576 
      return result.success
5577 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFlipkartItems failed: unknown result");
5578 
 
10097 kshitij.so 5579 
  def addOrUpdateFlipkartItem(self, flipkartitem):
5580 
    """
5581 
    Parameters:
5582 
     - flipkartitem
5583 
    """
5584 
    self.send_addOrUpdateFlipkartItem(flipkartitem)
5585 
    return self.recv_addOrUpdateFlipkartItem()
9945 vikram.rag 5586 
 
10097 kshitij.so 5587 
  def send_addOrUpdateFlipkartItem(self, flipkartitem):
5588 
    self._oprot.writeMessageBegin('addOrUpdateFlipkartItem', TMessageType.CALL, self._seqid)
5589 
    args = addOrUpdateFlipkartItem_args()
5590 
    args.flipkartitem = flipkartitem
5591 
    args.write(self._oprot)
5592 
    self._oprot.writeMessageEnd()
5593 
    self._oprot.trans.flush()
5594 
 
5595 
  def recv_addOrUpdateFlipkartItem(self, ):
5596 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5597 
    if mtype == TMessageType.EXCEPTION:
5598 
      x = TApplicationException()
5599 
      x.read(self._iprot)
5600 
      self._iprot.readMessageEnd()
5601 
      raise x
5602 
    result = addOrUpdateFlipkartItem_result()
5603 
    result.read(self._iprot)
5604 
    self._iprot.readMessageEnd()
5605 
    if result.success is not None:
5606 
      return result.success
5607 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addOrUpdateFlipkartItem failed: unknown result");
5608 
 
5609 
  def getFlipkartItem(self, item_id):
5610 
    """
5611 
    Parameters:
5612 
     - item_id
5613 
    """
5614 
    self.send_getFlipkartItem(item_id)
5615 
    return self.recv_getFlipkartItem()
5616 
 
5617 
  def send_getFlipkartItem(self, item_id):
5618 
    self._oprot.writeMessageBegin('getFlipkartItem', TMessageType.CALL, self._seqid)
5619 
    args = getFlipkartItem_args()
5620 
    args.item_id = item_id
5621 
    args.write(self._oprot)
5622 
    self._oprot.writeMessageEnd()
5623 
    self._oprot.trans.flush()
5624 
 
5625 
  def recv_getFlipkartItem(self, ):
5626 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5627 
    if mtype == TMessageType.EXCEPTION:
5628 
      x = TApplicationException()
5629 
      x.read(self._iprot)
5630 
      self._iprot.readMessageEnd()
5631 
      raise x
5632 
    result = getFlipkartItem_result()
5633 
    result.read(self._iprot)
5634 
    self._iprot.readMessageEnd()
5635 
    if result.success is not None:
5636 
      return result.success
5637 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartItem failed: unknown result");
5638 
 
5639 
  def getFlipkartItemDetails(self, item_id):
5640 
    """
5641 
    Parameters:
5642 
     - item_id
5643 
    """
5644 
    self.send_getFlipkartItemDetails(item_id)
5645 
    return self.recv_getFlipkartItemDetails()
5646 
 
5647 
  def send_getFlipkartItemDetails(self, item_id):
5648 
    self._oprot.writeMessageBegin('getFlipkartItemDetails', TMessageType.CALL, self._seqid)
5649 
    args = getFlipkartItemDetails_args()
5650 
    args.item_id = item_id
5651 
    args.write(self._oprot)
5652 
    self._oprot.writeMessageEnd()
5653 
    self._oprot.trans.flush()
5654 
 
5655 
  def recv_getFlipkartItemDetails(self, ):
5656 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5657 
    if mtype == TMessageType.EXCEPTION:
5658 
      x = TApplicationException()
5659 
      x.read(self._iprot)
5660 
      self._iprot.readMessageEnd()
5661 
      raise x
5662 
    result = getFlipkartItemDetails_result()
5663 
    result.read(self._iprot)
5664 
    self._iprot.readMessageEnd()
5665 
    if result.success is not None:
5666 
      return result.success
5667 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartItemDetails failed: unknown result");
5668 
 
5669 
  def getFlipkartItems(self, offset, limit):
5670 
    """
5671 
    Parameters:
5672 
     - offset
5673 
     - limit
5674 
    """
5675 
    self.send_getFlipkartItems(offset, limit)
5676 
    return self.recv_getFlipkartItems()
5677 
 
5678 
  def send_getFlipkartItems(self, offset, limit):
5679 
    self._oprot.writeMessageBegin('getFlipkartItems', TMessageType.CALL, self._seqid)
5680 
    args = getFlipkartItems_args()
5681 
    args.offset = offset
5682 
    args.limit = limit
5683 
    args.write(self._oprot)
5684 
    self._oprot.writeMessageEnd()
5685 
    self._oprot.trans.flush()
5686 
 
5687 
  def recv_getFlipkartItems(self, ):
5688 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5689 
    if mtype == TMessageType.EXCEPTION:
5690 
      x = TApplicationException()
5691 
      x.read(self._iprot)
5692 
      self._iprot.readMessageEnd()
5693 
      raise x
5694 
    result = getFlipkartItems_result()
5695 
    result.read(self._iprot)
5696 
    self._iprot.readMessageEnd()
5697 
    if result.success is not None:
5698 
      return result.success
5699 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartItems failed: unknown result");
5700 
 
5701 
  def searchFlipkartItems(self, searchTerm, offset, limit):
5702 
    """
5703 
    Parameters:
5704 
     - searchTerm
5705 
     - offset
5706 
     - limit
5707 
    """
5708 
    self.send_searchFlipkartItems(searchTerm, offset, limit)
5709 
    return self.recv_searchFlipkartItems()
5710 
 
5711 
  def send_searchFlipkartItems(self, searchTerm, offset, limit):
5712 
    self._oprot.writeMessageBegin('searchFlipkartItems', TMessageType.CALL, self._seqid)
5713 
    args = searchFlipkartItems_args()
5714 
    args.searchTerm = searchTerm
5715 
    args.offset = offset
5716 
    args.limit = limit
5717 
    args.write(self._oprot)
5718 
    self._oprot.writeMessageEnd()
5719 
    self._oprot.trans.flush()
5720 
 
5721 
  def recv_searchFlipkartItems(self, ):
5722 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5723 
    if mtype == TMessageType.EXCEPTION:
5724 
      x = TApplicationException()
5725 
      x.read(self._iprot)
5726 
      self._iprot.readMessageEnd()
5727 
      raise x
5728 
    result = searchFlipkartItems_result()
5729 
    result.read(self._iprot)
5730 
    self._iprot.readMessageEnd()
5731 
    if result.success is not None:
5732 
      return result.success
5733 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchFlipkartItems failed: unknown result");
5734 
 
5735 
  def getCountForFlipkartItems(self, ):
5736 
    self.send_getCountForFlipkartItems()
5737 
    return self.recv_getCountForFlipkartItems()
5738 
 
5739 
  def send_getCountForFlipkartItems(self, ):
5740 
    self._oprot.writeMessageBegin('getCountForFlipkartItems', TMessageType.CALL, self._seqid)
5741 
    args = getCountForFlipkartItems_args()
5742 
    args.write(self._oprot)
5743 
    self._oprot.writeMessageEnd()
5744 
    self._oprot.trans.flush()
5745 
 
5746 
  def recv_getCountForFlipkartItems(self, ):
5747 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5748 
    if mtype == TMessageType.EXCEPTION:
5749 
      x = TApplicationException()
5750 
      x.read(self._iprot)
5751 
      self._iprot.readMessageEnd()
5752 
      raise x
5753 
    result = getCountForFlipkartItems_result()
5754 
    result.read(self._iprot)
5755 
    self._iprot.readMessageEnd()
5756 
    if result.success is not None:
5757 
      return result.success
5758 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForFlipkartItems failed: unknown result");
5759 
 
5760 
  def getFlipkartSearchResultCount(self, searchTerm):
5761 
    """
5762 
    Parameters:
5763 
     - searchTerm
5764 
    """
5765 
    self.send_getFlipkartSearchResultCount(searchTerm)
5766 
    return self.recv_getFlipkartSearchResultCount()
5767 
 
5768 
  def send_getFlipkartSearchResultCount(self, searchTerm):
5769 
    self._oprot.writeMessageBegin('getFlipkartSearchResultCount', TMessageType.CALL, self._seqid)
5770 
    args = getFlipkartSearchResultCount_args()
5771 
    args.searchTerm = searchTerm
5772 
    args.write(self._oprot)
5773 
    self._oprot.writeMessageEnd()
5774 
    self._oprot.trans.flush()
5775 
 
5776 
  def recv_getFlipkartSearchResultCount(self, ):
5777 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5778 
    if mtype == TMessageType.EXCEPTION:
5779 
      x = TApplicationException()
5780 
      x.read(self._iprot)
5781 
      self._iprot.readMessageEnd()
5782 
      raise x
5783 
    result = getFlipkartSearchResultCount_result()
5784 
    result.read(self._iprot)
5785 
    self._iprot.readMessageEnd()
5786 
    if result.success is not None:
5787 
      return result.success
5788 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartSearchResultCount failed: unknown result");
5789 
 
5790 
  def getAllFkItems(self, ):
5791 
    self.send_getAllFkItems()
5792 
    return self.recv_getAllFkItems()
5793 
 
5794 
  def send_getAllFkItems(self, ):
5795 
    self._oprot.writeMessageBegin('getAllFkItems', TMessageType.CALL, self._seqid)
5796 
    args = getAllFkItems_args()
5797 
    args.write(self._oprot)
5798 
    self._oprot.writeMessageEnd()
5799 
    self._oprot.trans.flush()
5800 
 
5801 
  def recv_getAllFkItems(self, ):
5802 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5803 
    if mtype == TMessageType.EXCEPTION:
5804 
      x = TApplicationException()
5805 
      x.read(self._iprot)
5806 
      self._iprot.readMessageEnd()
5807 
      raise x
5808 
    result = getAllFkItems_result()
5809 
    result.read(self._iprot)
5810 
    self._iprot.readMessageEnd()
5811 
    if result.success is not None:
5812 
      return result.success
5813 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFkItems failed: unknown result");
5814 
 
10140 vikram.rag 5815 
  def getFlipkartItemBySkyAtFlipkart(self, sku):
5816 
    """
5817 
    Parameters:
5818 
     - sku
5819 
    """
5820 
    self.send_getFlipkartItemBySkyAtFlipkart(sku)
5821 
    return self.recv_getFlipkartItemBySkyAtFlipkart()
10097 kshitij.so 5822 
 
10140 vikram.rag 5823 
  def send_getFlipkartItemBySkyAtFlipkart(self, sku):
5824 
    self._oprot.writeMessageBegin('getFlipkartItemBySkyAtFlipkart', TMessageType.CALL, self._seqid)
5825 
    args = getFlipkartItemBySkyAtFlipkart_args()
5826 
    args.sku = sku
5827 
    args.write(self._oprot)
5828 
    self._oprot.writeMessageEnd()
5829 
    self._oprot.trans.flush()
5830 
 
5831 
  def recv_getFlipkartItemBySkyAtFlipkart(self, ):
5832 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5833 
    if mtype == TMessageType.EXCEPTION:
5834 
      x = TApplicationException()
5835 
      x.read(self._iprot)
5836 
      self._iprot.readMessageEnd()
5837 
      raise x
5838 
    result = getFlipkartItemBySkyAtFlipkart_result()
5839 
    result.read(self._iprot)
5840 
    self._iprot.readMessageEnd()
5841 
    if result.success is not None:
5842 
      return result.success
5843 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartItemBySkyAtFlipkart failed: unknown result");
5844 
 
10909 vikram.rag 5845 
  def getAllFbbListedItems(self, ):
5846 
    self.send_getAllFbbListedItems()
5847 
    return self.recv_getAllFbbListedItems()
10140 vikram.rag 5848 
 
10909 vikram.rag 5849 
  def send_getAllFbbListedItems(self, ):
5850 
    self._oprot.writeMessageBegin('getAllFbbListedItems', TMessageType.CALL, self._seqid)
5851 
    args = getAllFbbListedItems_args()
5852 
    args.write(self._oprot)
5853 
    self._oprot.writeMessageEnd()
5854 
    self._oprot.trans.flush()
5855 
 
5856 
  def recv_getAllFbbListedItems(self, ):
5857 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5858 
    if mtype == TMessageType.EXCEPTION:
5859 
      x = TApplicationException()
5860 
      x.read(self._iprot)
5861 
      self._iprot.readMessageEnd()
5862 
      raise x
5863 
    result = getAllFbbListedItems_result()
5864 
    result.read(self._iprot)
5865 
    self._iprot.readMessageEnd()
5866 
    if result.success is not None:
5867 
      return result.success
5868 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbbListedItems failed: unknown result");
5869 
 
10924 vikram.rag 5870 
  def getAllFbbPricingItems(self, ):
5871 
    self.send_getAllFbbPricingItems()
5872 
    return self.recv_getAllFbbPricingItems()
10909 vikram.rag 5873 
 
10924 vikram.rag 5874 
  def send_getAllFbbPricingItems(self, ):
5875 
    self._oprot.writeMessageBegin('getAllFbbPricingItems', TMessageType.CALL, self._seqid)
5876 
    args = getAllFbbPricingItems_args()
5877 
    args.write(self._oprot)
5878 
    self._oprot.writeMessageEnd()
5879 
    self._oprot.trans.flush()
5880 
 
5881 
  def recv_getAllFbbPricingItems(self, ):
5882 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5883 
    if mtype == TMessageType.EXCEPTION:
5884 
      x = TApplicationException()
5885 
      x.read(self._iprot)
5886 
      self._iprot.readMessageEnd()
5887 
      raise x
5888 
    result = getAllFbbPricingItems_result()
5889 
    result.read(self._iprot)
5890 
    self._iprot.readMessageEnd()
5891 
    if result.success is not None:
5892 
      return result.success
5893 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbbPricingItems failed: unknown result");
5894 
 
5895 
 
5944 mandeep.dh 5896 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
5897 
  def __init__(self, handler):
5898 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
5899 
    self._processMap["addItem"] = Processor.process_addItem
5900 
    self._processMap["updateItem"] = Processor.process_updateItem
5901 
    self._processMap["isActive"] = Processor.process_isActive
7438 amit.gupta 5902 
    self._processMap["getItemsStatus"] = Processor.process_getItemsStatus
5944 mandeep.dh 5903 
    self._processMap["getItemStatusDescription"] = Processor.process_getItemStatusDescription
5904 
    self._processMap["startItemOn"] = Processor.process_startItemOn
5905 
    self._processMap["retireItemOn"] = Processor.process_retireItemOn
5906 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
5907 
    self._processMap["getItem"] = Processor.process_getItem
5908 
    self._processMap["getItemsByCatalogId"] = Processor.process_getItemsByCatalogId
5909 
    self._processMap["getValidItemsByCatalogId"] = Processor.process_getValidItemsByCatalogId
5910 
    self._processMap["getAllItems"] = Processor.process_getAllItems
5911 
    self._processMap["getAllItemsByStatus"] = Processor.process_getAllItemsByStatus
5912 
    self._processMap["markItemAsContentComplete"] = Processor.process_markItemAsContentComplete
5913 
    self._processMap["getAllItemsInRange"] = Processor.process_getAllItemsInRange
5914 
    self._processMap["getAllItemsByStatusInRange"] = Processor.process_getAllItemsByStatusInRange
5915 
    self._processMap["getItemCountByStatus"] = Processor.process_getItemCountByStatus
5916 
    self._processMap["getBestSellers"] = Processor.process_getBestSellers
5917 
    self._processMap["getBestSellersCatalogIds"] = Processor.process_getBestSellersCatalogIds
5918 
    self._processMap["getBestSellersCount"] = Processor.process_getBestSellersCount
5919 
    self._processMap["getBestDeals"] = Processor.process_getBestDeals
5920 
    self._processMap["getBestDealsCatalogIds"] = Processor.process_getBestDealsCatalogIds
5921 
    self._processMap["getBestDealsCount"] = Processor.process_getBestDealsCount
5922 
    self._processMap["getComingSoon"] = Processor.process_getComingSoon
5923 
    self._processMap["getComingSoonCatalogIds"] = Processor.process_getComingSoonCatalogIds
5924 
    self._processMap["getComingSoonCount"] = Processor.process_getComingSoonCount
5925 
    self._processMap["getLatestArrivals"] = Processor.process_getLatestArrivals
5926 
    self._processMap["getLatestArrivalsCatalogIds"] = Processor.process_getLatestArrivalsCatalogIds
5927 
    self._processMap["getLatestArrivalsCount"] = Processor.process_getLatestArrivalsCount
5928 
    self._processMap["generateNewEntityID"] = Processor.process_generateNewEntityID
5929 
    self._processMap["addCategory"] = Processor.process_addCategory
5930 
    self._processMap["getCategory"] = Processor.process_getCategory
5931 
    self._processMap["getAllCategories"] = Processor.process_getAllCategories
5932 
    self._processMap["getAllSimilarItems"] = Processor.process_getAllSimilarItems
5933 
    self._processMap["addSimilarItem"] = Processor.process_addSimilarItem
6512 kshitij.so 5934 
    self._processMap["addTag"] = Processor.process_addTag
5935 
    self._processMap["deleteEntityTag"] = Processor.process_deleteEntityTag
5936 
    self._processMap["deleteTag"] = Processor.process_deleteTag
5937 
    self._processMap["getAllTags"] = Processor.process_getAllTags
5938 
    self._processMap["getAllEntitiesByTagName"] = Processor.process_getAllEntitiesByTagName
6845 amit.gupta 5939 
    self._processMap["getAllEntityTags"] = Processor.process_getAllEntityTags
6850 kshitij.so 5940 
    self._processMap["addBanner"] = Processor.process_addBanner
8579 kshitij.so 5941 
    self._processMap["updateBanner"] = Processor.process_updateBanner
6850 kshitij.so 5942 
    self._processMap["getAllBanners"] = Processor.process_getAllBanners
5943 
    self._processMap["deleteBanner"] = Processor.process_deleteBanner
5944 
    self._processMap["getBannerDetails"] = Processor.process_getBannerDetails
5945 
    self._processMap["getActiveBanners"] = Processor.process_getActiveBanners
6849 kshitij.so 5946 
    self._processMap["addBannerMap"] = Processor.process_addBannerMap
8579 kshitij.so 5947 
    self._processMap["updateBannerMap"] = Processor.process_updateBannerMap
6849 kshitij.so 5948 
    self._processMap["deleteBannerMap"] = Processor.process_deleteBannerMap
5949 
    self._processMap["getBannerMapDetails"] = Processor.process_getBannerMapDetails
8579 kshitij.so 5950 
    self._processMap["addBannerUri"] = Processor.process_addBannerUri
5951 
    self._processMap["getUriMapping"] = Processor.process_getUriMapping
5952 
    self._processMap["addCampaign"] = Processor.process_addCampaign
5953 
    self._processMap["getCampaigns"] = Processor.process_getCampaigns
5954 
    self._processMap["deleteCampaign"] = Processor.process_deleteCampaign
5955 
    self._processMap["getAllCampaigns"] = Processor.process_getAllCampaigns
9155 kshitij.so 5956 
    self._processMap["getActiveBannersForMobileSite"] = Processor.process_getActiveBannersForMobileSite
5944 mandeep.dh 5957 
    self._processMap["deleteSimilarItem"] = Processor.process_deleteSimilarItem
5958 
    self._processMap["checkSimilarItem"] = Processor.process_checkSimilarItem
5959 
    self._processMap["validateRiskyStatus"] = Processor.process_validateRiskyStatus
5960 
    self._processMap["changeItemRiskyFlag"] = Processor.process_changeItemRiskyFlag
5961 
    self._processMap["getItemsByRiskyFlag"] = Processor.process_getItemsByRiskyFlag
5962 
    self._processMap["getItemsForMasterSheet"] = Processor.process_getItemsForMasterSheet
5963 
    self._processMap["getSimilarItemsCatalogIds"] = Processor.process_getSimilarItemsCatalogIds
5964 
    self._processMap["addProductNotification"] = Processor.process_addProductNotification
5965 
    self._processMap["sendProductNotifications"] = Processor.process_sendProductNotifications
5966 
    self._processMap["getAllBrandsByCategory"] = Processor.process_getAllBrandsByCategory
5967 
    self._processMap["getAllBrands"] = Processor.process_getAllBrands
5968 
    self._processMap["getAllSources"] = Processor.process_getAllSources
5969 
    self._processMap["getItemPricingBySource"] = Processor.process_getItemPricingBySource
5970 
    self._processMap["addSourceItemPricing"] = Processor.process_addSourceItemPricing
5971 
    self._processMap["getAllSourcePricing"] = Processor.process_getAllSourcePricing
5972 
    self._processMap["getItemForSource"] = Processor.process_getItemForSource
5973 
    self._processMap["searchItemsInRange"] = Processor.process_searchItemsInRange
5974 
    self._processMap["getSearchResultCount"] = Processor.process_getSearchResultCount
5975 
    self._processMap["getProductNotifications"] = Processor.process_getProductNotifications
5976 
    self._processMap["getProductNotificationRequestCount"] = Processor.process_getProductNotificationRequestCount
5977 
    self._processMap["addAuthorizationLog"] = Processor.process_addAuthorizationLog
5978 
    self._processMap["addupdateVoucherForItem"] = Processor.process_addupdateVoucherForItem
5979 
    self._processMap["deleteVoucherForItem"] = Processor.process_deleteVoucherForItem
5980 
    self._processMap["getVoucherAmount"] = Processor.process_getVoucherAmount
5981 
    self._processMap["getAllItemVouchers"] = Processor.process_getAllItemVouchers
5982 
    self._processMap["isValidCatalogItemId"] = Processor.process_isValidCatalogItemId
6039 amit.gupta 5983 
    self._processMap["getVatPercentageForItem"] = Processor.process_getVatPercentageForItem
5984 
    self._processMap["getVatAmountForItem"] = Processor.process_getVatAmountForItem
6531 vikram.rag 5985 
    self._processMap["getAllIgnoredInventoryUpdateItemsList"] = Processor.process_getAllIgnoredInventoryUpdateItemsList
6821 amar.kumar 5986 
    self._processMap["getAllAliveItems"] = Processor.process_getAllAliveItems
6805 anupam.sin 5987 
    self._processMap["getInsuranceAmount"] = Processor.process_getInsuranceAmount
5988 
    self._processMap["getInsurer"] = Processor.process_getInsurer
6838 vikram.rag 5989 
    self._processMap["getAllInsurers"] = Processor.process_getAllInsurers
6962 rajveer 5990 
    self._processMap["updateInsuranceDeclaredAmount"] = Processor.process_updateInsuranceDeclaredAmount
7190 amar.kumar 5991 
    self._processMap["getFreebieForItem"] = Processor.process_getFreebieForItem
5992 
    self._processMap["addOrUpdateFreebieForItem"] = Processor.process_addOrUpdateFreebieForItem
7272 amit.gupta 5993 
    self._processMap["addOrUpdateBrandInfo"] = Processor.process_addOrUpdateBrandInfo
5994 
    self._processMap["getBrandInfo"] = Processor.process_getBrandInfo
7256 rajveer 5995 
    self._processMap["getStorePricing"] = Processor.process_getStorePricing
7306 rajveer 5996 
    self._processMap["getStorePricings"] = Processor.process_getStorePricings
7265 rajveer 5997 
    self._processMap["updateStorePricing"] = Processor.process_updateStorePricing
7281 kshitij.so 5998 
    self._processMap["getAllAmazonListedItems"] = Processor.process_getAllAmazonListedItems
8619 kshitij.so 5999 
    self._processMap["searchAmazonItems"] = Processor.process_searchAmazonItems
6000 
    self._processMap["getAmazonSearchResultCount"] = Processor.process_getAmazonSearchResultCount
6001 
    self._processMap["getCountForAmazonlistedItems"] = Processor.process_getCountForAmazonlistedItems
7281 kshitij.so 6002 
    self._processMap["getAmazonItemDetails"] = Processor.process_getAmazonItemDetails
6003 
    self._processMap["updateAmazonItemDetails"] = Processor.process_updateAmazonItemDetails
6004 
    self._processMap["addAmazonItem"] = Processor.process_addAmazonItem
7291 vikram.rag 6005 
    self._processMap["getAsinItems"] = Processor.process_getAsinItems
6006 
    self._processMap["getAllFbaListedItems"] = Processor.process_getAllFbaListedItems
6007 
    self._processMap["getAllNonFbaListedItems"] = Processor.process_getAllNonFbaListedItems
7460 kshitij.so 6008 
    self._processMap["updateItemInventory"] = Processor.process_updateItemInventory
7770 kshitij.so 6009 
    self._processMap["updateTimestampForAmazonFeeds"] = Processor.process_updateTimestampForAmazonFeeds
7897 amar.kumar 6010 
    self._processMap["getAllParentCategories"] = Processor.process_getAllParentCategories
7977 kshitij.so 6011 
    self._processMap["addPageViewEvent"] = Processor.process_addPageViewEvent
6012 
    self._processMap["addCartEvent"] = Processor.process_addCartEvent
8182 amar.kumar 6013 
    self._processMap["addEbayItem"] = Processor.process_addEbayItem
6014 
    self._processMap["getEbayItem"] = Processor.process_getEbayItem
6015 
    self._processMap["updateEbayItem"] = Processor.process_updateEbayItem
8139 kshitij.so 6016 
    self._processMap["getAmazonListedItems"] = Processor.process_getAmazonListedItems
8168 kshitij.so 6017 
    self._processMap["updateAmazonAttributesInBulk"] = Processor.process_updateAmazonAttributesInBulk
8379 vikram.rag 6018 
    self._processMap["getAllItemstoListOnFba"] = Processor.process_getAllItemstoListOnFba
6019 
    self._processMap["getAllItemstoListOnNonFba"] = Processor.process_getAllItemstoListOnNonFba
8619 kshitij.so 6020 
    self._processMap["updateAsin"] = Processor.process_updateAsin
8739 vikram.rag 6021 
    self._processMap["addOrUpdateSnapdealItem"] = Processor.process_addOrUpdateSnapdealItem
6022 
    self._processMap["getSnapdealItem"] = Processor.process_getSnapdealItem
9242 kshitij.so 6023 
    self._processMap["getSnapdealItemDetails"] = Processor.process_getSnapdealItemDetails
8739 vikram.rag 6024 
    self._processMap["getAllSnapdealItems"] = Processor.process_getAllSnapdealItems
9242 kshitij.so 6025 
    self._processMap["getSnapdealItems"] = Processor.process_getSnapdealItems
6026 
    self._processMap["searchSnapdealItems"] = Processor.process_searchSnapdealItems
6027 
    self._processMap["getCountForSnapdealItems"] = Processor.process_getCountForSnapdealItems
6028 
    self._processMap["getSnapdealSearchResultCount"] = Processor.process_getSnapdealSearchResultCount
9299 kshitij.so 6029 
    self._processMap["getPrefferedInsurerForItem"] = Processor.process_getPrefferedInsurerForItem
9456 vikram.rag 6030 
    self._processMap["getSnapdealItembySkuAtSnapdeal"] = Processor.process_getSnapdealItembySkuAtSnapdeal
9621 manish.sha 6031 
    self._processMap["getProductFeedSubmit"] = Processor.process_getProductFeedSubmit
6032 
    self._processMap["addProductFeedSubmit"] = Processor.process_addProductFeedSubmit
6033 
    self._processMap["updateProductFeedSubmit"] = Processor.process_updateProductFeedSubmit
6034 
    self._processMap["deleteProductFeedSubmit"] = Processor.process_deleteProductFeedSubmit
6035 
    self._processMap["getAllProductFeedSubmit"] = Processor.process_getAllProductFeedSubmit
9724 kshitij.so 6036 
    self._processMap["getMarketplacedetailsForItem"] = Processor.process_getMarketplacedetailsForItem
6037 
    self._processMap["updateMarketplaceAttributesForItem"] = Processor.process_updateMarketplaceAttributesForItem
9779 kshitij.so 6038 
    self._processMap["getCostingForMarketplace"] = Processor.process_getCostingForMarketplace
9776 vikram.rag 6039 
    self._processMap["getMarketPlaceItemsForPriceUpdate"] = Processor.process_getMarketPlaceItemsForPriceUpdate
6040 
    self._processMap["updateMarketPlacePriceUpdateStatus"] = Processor.process_updateMarketPlacePriceUpdateStatus
9861 rajveer 6041 
    self._processMap["updateItemHoldInventory"] = Processor.process_updateItemHoldInventory
9895 vikram.rag 6042 
    self._processMap["updateNlcAtMarketplaces"] = Processor.process_updateNlcAtMarketplaces
9945 vikram.rag 6043 
    self._processMap["getAllFlipkartItems"] = Processor.process_getAllFlipkartItems
10097 kshitij.so 6044 
    self._processMap["addOrUpdateFlipkartItem"] = Processor.process_addOrUpdateFlipkartItem
6045 
    self._processMap["getFlipkartItem"] = Processor.process_getFlipkartItem
6046 
    self._processMap["getFlipkartItemDetails"] = Processor.process_getFlipkartItemDetails
6047 
    self._processMap["getFlipkartItems"] = Processor.process_getFlipkartItems
6048 
    self._processMap["searchFlipkartItems"] = Processor.process_searchFlipkartItems
6049 
    self._processMap["getCountForFlipkartItems"] = Processor.process_getCountForFlipkartItems
6050 
    self._processMap["getFlipkartSearchResultCount"] = Processor.process_getFlipkartSearchResultCount
6051 
    self._processMap["getAllFkItems"] = Processor.process_getAllFkItems
10140 vikram.rag 6052 
    self._processMap["getFlipkartItemBySkyAtFlipkart"] = Processor.process_getFlipkartItemBySkyAtFlipkart
10909 vikram.rag 6053 
    self._processMap["getAllFbbListedItems"] = Processor.process_getAllFbbListedItems
10924 vikram.rag 6054 
    self._processMap["getAllFbbPricingItems"] = Processor.process_getAllFbbPricingItems
5944 mandeep.dh 6055 
 
6056 
  def process(self, iprot, oprot):
6057 
    (name, type, seqid) = iprot.readMessageBegin()
6058 
    if name not in self._processMap:
6059 
      iprot.skip(TType.STRUCT)
6060 
      iprot.readMessageEnd()
6061 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
6062 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
6063 
      x.write(oprot)
6064 
      oprot.writeMessageEnd()
6065 
      oprot.trans.flush()
6066 
      return
6067 
    else:
6068 
      self._processMap[name](self, seqid, iprot, oprot)
6069 
    return True
6070 
 
6071 
  def process_addItem(self, seqid, iprot, oprot):
6072 
    args = addItem_args()
6073 
    args.read(iprot)
6074 
    iprot.readMessageEnd()
6075 
    result = addItem_result()
6076 
    try:
6077 
      result.success = self._handler.addItem(args.item)
6078 
    except CatalogServiceException, cex:
6079 
      result.cex = cex
6080 
    oprot.writeMessageBegin("addItem", TMessageType.REPLY, seqid)
6081 
    result.write(oprot)
6082 
    oprot.writeMessageEnd()
6083 
    oprot.trans.flush()
6084 
 
6085 
  def process_updateItem(self, seqid, iprot, oprot):
6086 
    args = updateItem_args()
6087 
    args.read(iprot)
6088 
    iprot.readMessageEnd()
6089 
    result = updateItem_result()
6090 
    try:
6091 
      result.success = self._handler.updateItem(args.item)
6092 
    except CatalogServiceException, cex:
6093 
      result.cex = cex
6094 
    oprot.writeMessageBegin("updateItem", TMessageType.REPLY, seqid)
6095 
    result.write(oprot)
6096 
    oprot.writeMessageEnd()
6097 
    oprot.trans.flush()
6098 
 
6099 
  def process_isActive(self, seqid, iprot, oprot):
6100 
    args = isActive_args()
6101 
    args.read(iprot)
6102 
    iprot.readMessageEnd()
6103 
    result = isActive_result()
6104 
    try:
6105 
      result.success = self._handler.isActive(args.itemId)
6106 
    except CatalogServiceException, isex:
6107 
      result.isex = isex
6108 
    oprot.writeMessageBegin("isActive", TMessageType.REPLY, seqid)
6109 
    result.write(oprot)
6110 
    oprot.writeMessageEnd()
6111 
    oprot.trans.flush()
6112 
 
7438 amit.gupta 6113 
  def process_getItemsStatus(self, seqid, iprot, oprot):
6114 
    args = getItemsStatus_args()
6115 
    args.read(iprot)
6116 
    iprot.readMessageEnd()
6117 
    result = getItemsStatus_result()
6118 
    try:
6119 
      result.success = self._handler.getItemsStatus(args.itemIds)
6120 
    except CatalogServiceException, isex:
6121 
      result.isex = isex
6122 
    oprot.writeMessageBegin("getItemsStatus", TMessageType.REPLY, seqid)
6123 
    result.write(oprot)
6124 
    oprot.writeMessageEnd()
6125 
    oprot.trans.flush()
6126 
 
5944 mandeep.dh 6127 
  def process_getItemStatusDescription(self, seqid, iprot, oprot):
6128 
    args = getItemStatusDescription_args()
6129 
    args.read(iprot)
6130 
    iprot.readMessageEnd()
6131 
    result = getItemStatusDescription_result()
6132 
    try:
6133 
      result.success = self._handler.getItemStatusDescription(args.itemId)
6134 
    except CatalogServiceException, isex:
6135 
      result.isex = isex
6136 
    oprot.writeMessageBegin("getItemStatusDescription", TMessageType.REPLY, seqid)
6137 
    result.write(oprot)
6138 
    oprot.writeMessageEnd()
6139 
    oprot.trans.flush()
6140 
 
6141 
  def process_startItemOn(self, seqid, iprot, oprot):
6142 
    args = startItemOn_args()
6143 
    args.read(iprot)
6144 
    iprot.readMessageEnd()
6145 
    result = startItemOn_result()
6146 
    try:
6147 
      self._handler.startItemOn(args.item_id, args.timestamp)
6148 
    except CatalogServiceException, cex:
6149 
      result.cex = cex
6150 
    oprot.writeMessageBegin("startItemOn", TMessageType.REPLY, seqid)
6151 
    result.write(oprot)
6152 
    oprot.writeMessageEnd()
6153 
    oprot.trans.flush()
6154 
 
6155 
  def process_retireItemOn(self, seqid, iprot, oprot):
6156 
    args = retireItemOn_args()
6157 
    args.read(iprot)
6158 
    iprot.readMessageEnd()
6159 
    result = retireItemOn_result()
6160 
    try:
6161 
      self._handler.retireItemOn(args.item_id, args.timestamp)
6162 
    except CatalogServiceException, cex:
6163 
      result.cex = cex
6164 
    oprot.writeMessageBegin("retireItemOn", TMessageType.REPLY, seqid)
6165 
    result.write(oprot)
6166 
    oprot.writeMessageEnd()
6167 
    oprot.trans.flush()
6168 
 
6169 
  def process_changeItemStatus(self, seqid, iprot, oprot):
6170 
    args = changeItemStatus_args()
6171 
    args.read(iprot)
6172 
    iprot.readMessageEnd()
6173 
    result = changeItemStatus_result()
6174 
    try:
6175 
      self._handler.changeItemStatus(args.item_id, args.timestamp, args.newstatus)
6176 
    except CatalogServiceException, cex:
6177 
      result.cex = cex
6178 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
6179 
    result.write(oprot)
6180 
    oprot.writeMessageEnd()
6181 
    oprot.trans.flush()
6182 
 
6183 
  def process_getItem(self, seqid, iprot, oprot):
6184 
    args = getItem_args()
6185 
    args.read(iprot)
6186 
    iprot.readMessageEnd()
6187 
    result = getItem_result()
6188 
    try:
6189 
      result.success = self._handler.getItem(args.item_id)
6190 
    except CatalogServiceException, cex:
6191 
      result.cex = cex
6192 
    oprot.writeMessageBegin("getItem", TMessageType.REPLY, seqid)
6193 
    result.write(oprot)
6194 
    oprot.writeMessageEnd()
6195 
    oprot.trans.flush()
6196 
 
6197 
  def process_getItemsByCatalogId(self, seqid, iprot, oprot):
6198 
    args = getItemsByCatalogId_args()
6199 
    args.read(iprot)
6200 
    iprot.readMessageEnd()
6201 
    result = getItemsByCatalogId_result()
6202 
    try:
6203 
      result.success = self._handler.getItemsByCatalogId(args.catalog_item_id)
6204 
    except CatalogServiceException, cex:
6205 
      result.cex = cex
6206 
    oprot.writeMessageBegin("getItemsByCatalogId", TMessageType.REPLY, seqid)
6207 
    result.write(oprot)
6208 
    oprot.writeMessageEnd()
6209 
    oprot.trans.flush()
6210 
 
6211 
  def process_getValidItemsByCatalogId(self, seqid, iprot, oprot):
6212 
    args = getValidItemsByCatalogId_args()
6213 
    args.read(iprot)
6214 
    iprot.readMessageEnd()
6215 
    result = getValidItemsByCatalogId_result()
6216 
    try:
6217 
      result.success = self._handler.getValidItemsByCatalogId(args.catalog_item_id)
6218 
    except CatalogServiceException, cex:
6219 
      result.cex = cex
6220 
    oprot.writeMessageBegin("getValidItemsByCatalogId", TMessageType.REPLY, seqid)
6221 
    result.write(oprot)
6222 
    oprot.writeMessageEnd()
6223 
    oprot.trans.flush()
6224 
 
6225 
  def process_getAllItems(self, seqid, iprot, oprot):
6226 
    args = getAllItems_args()
6227 
    args.read(iprot)
6228 
    iprot.readMessageEnd()
6229 
    result = getAllItems_result()
6230 
    try:
6231 
      result.success = self._handler.getAllItems(args.isActive)
6232 
    except CatalogServiceException, cex:
6233 
      result.cex = cex
6234 
    oprot.writeMessageBegin("getAllItems", TMessageType.REPLY, seqid)
6235 
    result.write(oprot)
6236 
    oprot.writeMessageEnd()
6237 
    oprot.trans.flush()
6238 
 
6239 
  def process_getAllItemsByStatus(self, seqid, iprot, oprot):
6240 
    args = getAllItemsByStatus_args()
6241 
    args.read(iprot)
6242 
    iprot.readMessageEnd()
6243 
    result = getAllItemsByStatus_result()
6244 
    try:
6245 
      result.success = self._handler.getAllItemsByStatus(args.itemStatus)
6246 
    except CatalogServiceException, cex:
6247 
      result.cex = cex
6248 
    oprot.writeMessageBegin("getAllItemsByStatus", TMessageType.REPLY, seqid)
6249 
    result.write(oprot)
6250 
    oprot.writeMessageEnd()
6251 
    oprot.trans.flush()
6252 
 
6253 
  def process_markItemAsContentComplete(self, seqid, iprot, oprot):
6254 
    args = markItemAsContentComplete_args()
6255 
    args.read(iprot)
6256 
    iprot.readMessageEnd()
6257 
    result = markItemAsContentComplete_result()
6258 
    try:
9253 rajveer 6259 
      result.success = self._handler.markItemAsContentComplete(args.entityId, args.category, args.brand, args.modelName, args.modelNumber, args.isAndroid)
5944 mandeep.dh 6260 
    except CatalogServiceException, cex:
6261 
      result.cex = cex
6262 
    oprot.writeMessageBegin("markItemAsContentComplete", TMessageType.REPLY, seqid)
6263 
    result.write(oprot)
6264 
    oprot.writeMessageEnd()
6265 
    oprot.trans.flush()
6266 
 
6267 
  def process_getAllItemsInRange(self, seqid, iprot, oprot):
6268 
    args = getAllItemsInRange_args()
6269 
    args.read(iprot)
6270 
    iprot.readMessageEnd()
6271 
    result = getAllItemsInRange_result()
6272 
    try:
6273 
      result.success = self._handler.getAllItemsInRange(args.offset, args.limit)
6274 
    except CatalogServiceException, cex:
6275 
      result.cex = cex
6276 
    oprot.writeMessageBegin("getAllItemsInRange", TMessageType.REPLY, seqid)
6277 
    result.write(oprot)
6278 
    oprot.writeMessageEnd()
6279 
    oprot.trans.flush()
6280 
 
6281 
  def process_getAllItemsByStatusInRange(self, seqid, iprot, oprot):
6282 
    args = getAllItemsByStatusInRange_args()
6283 
    args.read(iprot)
6284 
    iprot.readMessageEnd()
6285 
    result = getAllItemsByStatusInRange_result()
6286 
    try:
6287 
      result.success = self._handler.getAllItemsByStatusInRange(args.itemStatus, args.offset, args.limit)
6288 
    except CatalogServiceException, cex:
6289 
      result.cex = cex
6290 
    oprot.writeMessageBegin("getAllItemsByStatusInRange", TMessageType.REPLY, seqid)
6291 
    result.write(oprot)
6292 
    oprot.writeMessageEnd()
6293 
    oprot.trans.flush()
6294 
 
6295 
  def process_getItemCountByStatus(self, seqid, iprot, oprot):
6296 
    args = getItemCountByStatus_args()
6297 
    args.read(iprot)
6298 
    iprot.readMessageEnd()
6299 
    result = getItemCountByStatus_result()
6300 
    result.success = self._handler.getItemCountByStatus(args.useStatus, args.itemStatus)
6301 
    oprot.writeMessageBegin("getItemCountByStatus", TMessageType.REPLY, seqid)
6302 
    result.write(oprot)
6303 
    oprot.writeMessageEnd()
6304 
    oprot.trans.flush()
6305 
 
6306 
  def process_getBestSellers(self, seqid, iprot, oprot):
6307 
    args = getBestSellers_args()
6308 
    args.read(iprot)
6309 
    iprot.readMessageEnd()
6310 
    result = getBestSellers_result()
6311 
    try:
6312 
      result.success = self._handler.getBestSellers()
6313 
    except CatalogServiceException, isex:
6314 
      result.isex = isex
6315 
    oprot.writeMessageBegin("getBestSellers", TMessageType.REPLY, seqid)
6316 
    result.write(oprot)
6317 
    oprot.writeMessageEnd()
6318 
    oprot.trans.flush()
6319 
 
6320 
  def process_getBestSellersCatalogIds(self, seqid, iprot, oprot):
6321 
    args = getBestSellersCatalogIds_args()
6322 
    args.read(iprot)
6323 
    iprot.readMessageEnd()
6324 
    result = getBestSellersCatalogIds_result()
6325 
    try:
6326 
      result.success = self._handler.getBestSellersCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
6327 
    except CatalogServiceException, cex:
6328 
      result.cex = cex
6329 
    oprot.writeMessageBegin("getBestSellersCatalogIds", TMessageType.REPLY, seqid)
6330 
    result.write(oprot)
6331 
    oprot.writeMessageEnd()
6332 
    oprot.trans.flush()
6333 
 
6334 
  def process_getBestSellersCount(self, seqid, iprot, oprot):
6335 
    args = getBestSellersCount_args()
6336 
    args.read(iprot)
6337 
    iprot.readMessageEnd()
6338 
    result = getBestSellersCount_result()
6339 
    try:
6340 
      result.success = self._handler.getBestSellersCount()
6341 
    except CatalogServiceException, cex:
6342 
      result.cex = cex
6343 
    oprot.writeMessageBegin("getBestSellersCount", TMessageType.REPLY, seqid)
6344 
    result.write(oprot)
6345 
    oprot.writeMessageEnd()
6346 
    oprot.trans.flush()
6347 
 
6348 
  def process_getBestDeals(self, seqid, iprot, oprot):
6349 
    args = getBestDeals_args()
6350 
    args.read(iprot)
6351 
    iprot.readMessageEnd()
6352 
    result = getBestDeals_result()
6353 
    try:
6354 
      result.success = self._handler.getBestDeals()
6355 
    except CatalogServiceException, isex:
6356 
      result.isex = isex
6357 
    oprot.writeMessageBegin("getBestDeals", TMessageType.REPLY, seqid)
6358 
    result.write(oprot)
6359 
    oprot.writeMessageEnd()
6360 
    oprot.trans.flush()
6361 
 
6362 
  def process_getBestDealsCatalogIds(self, seqid, iprot, oprot):
6363 
    args = getBestDealsCatalogIds_args()
6364 
    args.read(iprot)
6365 
    iprot.readMessageEnd()
6366 
    result = getBestDealsCatalogIds_result()
6367 
    try:
6368 
      result.success = self._handler.getBestDealsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
6369 
    except CatalogServiceException, cex:
6370 
      result.cex = cex
6371 
    oprot.writeMessageBegin("getBestDealsCatalogIds", TMessageType.REPLY, seqid)
6372 
    result.write(oprot)
6373 
    oprot.writeMessageEnd()
6374 
    oprot.trans.flush()
6375 
 
6376 
  def process_getBestDealsCount(self, seqid, iprot, oprot):
6377 
    args = getBestDealsCount_args()
6378 
    args.read(iprot)
6379 
    iprot.readMessageEnd()
6380 
    result = getBestDealsCount_result()
6381 
    try:
6382 
      result.success = self._handler.getBestDealsCount()
6383 
    except CatalogServiceException, cex:
6384 
      result.cex = cex
6385 
    oprot.writeMessageBegin("getBestDealsCount", TMessageType.REPLY, seqid)
6386 
    result.write(oprot)
6387 
    oprot.writeMessageEnd()
6388 
    oprot.trans.flush()
6389 
 
6390 
  def process_getComingSoon(self, seqid, iprot, oprot):
6391 
    args = getComingSoon_args()
6392 
    args.read(iprot)
6393 
    iprot.readMessageEnd()
6394 
    result = getComingSoon_result()
6395 
    try:
6396 
      result.success = self._handler.getComingSoon()
6397 
    except CatalogServiceException, isex:
6398 
      result.isex = isex
6399 
    oprot.writeMessageBegin("getComingSoon", TMessageType.REPLY, seqid)
6400 
    result.write(oprot)
6401 
    oprot.writeMessageEnd()
6402 
    oprot.trans.flush()
6403 
 
6404 
  def process_getComingSoonCatalogIds(self, seqid, iprot, oprot):
6405 
    args = getComingSoonCatalogIds_args()
6406 
    args.read(iprot)
6407 
    iprot.readMessageEnd()
6408 
    result = getComingSoonCatalogIds_result()
6409 
    try:
6410 
      result.success = self._handler.getComingSoonCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
6411 
    except CatalogServiceException, cex:
6412 
      result.cex = cex
6413 
    oprot.writeMessageBegin("getComingSoonCatalogIds", TMessageType.REPLY, seqid)
6414 
    result.write(oprot)
6415 
    oprot.writeMessageEnd()
6416 
    oprot.trans.flush()
6417 
 
6418 
  def process_getComingSoonCount(self, seqid, iprot, oprot):
6419 
    args = getComingSoonCount_args()
6420 
    args.read(iprot)
6421 
    iprot.readMessageEnd()
6422 
    result = getComingSoonCount_result()
6423 
    try:
6424 
      result.success = self._handler.getComingSoonCount()
6425 
    except CatalogServiceException, cex:
6426 
      result.cex = cex
6427 
    oprot.writeMessageBegin("getComingSoonCount", TMessageType.REPLY, seqid)
6428 
    result.write(oprot)
6429 
    oprot.writeMessageEnd()
6430 
    oprot.trans.flush()
6431 
 
6432 
  def process_getLatestArrivals(self, seqid, iprot, oprot):
6433 
    args = getLatestArrivals_args()
6434 
    args.read(iprot)
6435 
    iprot.readMessageEnd()
6436 
    result = getLatestArrivals_result()
6437 
    try:
6438 
      result.success = self._handler.getLatestArrivals()
6439 
    except CatalogServiceException, isex:
6440 
      result.isex = isex
6441 
    oprot.writeMessageBegin("getLatestArrivals", TMessageType.REPLY, seqid)
6442 
    result.write(oprot)
6443 
    oprot.writeMessageEnd()
6444 
    oprot.trans.flush()
6445 
 
6446 
  def process_getLatestArrivalsCatalogIds(self, seqid, iprot, oprot):
6447 
    args = getLatestArrivalsCatalogIds_args()
6448 
    args.read(iprot)
6449 
    iprot.readMessageEnd()
6450 
    result = getLatestArrivalsCatalogIds_result()
6451 
    try:
6452 
      result.success = self._handler.getLatestArrivalsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.categories)
6453 
    except CatalogServiceException, cex:
6454 
      result.cex = cex
6455 
    oprot.writeMessageBegin("getLatestArrivalsCatalogIds", TMessageType.REPLY, seqid)
6456 
    result.write(oprot)
6457 
    oprot.writeMessageEnd()
6458 
    oprot.trans.flush()
6459 
 
6460 
  def process_getLatestArrivalsCount(self, seqid, iprot, oprot):
6461 
    args = getLatestArrivalsCount_args()
6462 
    args.read(iprot)
6463 
    iprot.readMessageEnd()
6464 
    result = getLatestArrivalsCount_result()
6465 
    try:
6466 
      result.success = self._handler.getLatestArrivalsCount()
6467 
    except CatalogServiceException, cex:
6468 
      result.cex = cex
6469 
    oprot.writeMessageBegin("getLatestArrivalsCount", TMessageType.REPLY, seqid)
6470 
    result.write(oprot)
6471 
    oprot.writeMessageEnd()
6472 
    oprot.trans.flush()
6473 
 
6474 
  def process_generateNewEntityID(self, seqid, iprot, oprot):
6475 
    args = generateNewEntityID_args()
6476 
    args.read(iprot)
6477 
    iprot.readMessageEnd()
6478 
    result = generateNewEntityID_result()
6479 
    result.success = self._handler.generateNewEntityID()
6480 
    oprot.writeMessageBegin("generateNewEntityID", TMessageType.REPLY, seqid)
6481 
    result.write(oprot)
6482 
    oprot.writeMessageEnd()
6483 
    oprot.trans.flush()
6484 
 
6485 
  def process_addCategory(self, seqid, iprot, oprot):
6486 
    args = addCategory_args()
6487 
    args.read(iprot)
6488 
    iprot.readMessageEnd()
6489 
    result = addCategory_result()
6490 
    result.success = self._handler.addCategory(args.category)
6491 
    oprot.writeMessageBegin("addCategory", TMessageType.REPLY, seqid)
6492 
    result.write(oprot)
6493 
    oprot.writeMessageEnd()
6494 
    oprot.trans.flush()
6495 
 
6496 
  def process_getCategory(self, seqid, iprot, oprot):
6497 
    args = getCategory_args()
6498 
    args.read(iprot)
6499 
    iprot.readMessageEnd()
6500 
    result = getCategory_result()
6501 
    result.success = self._handler.getCategory(args.id)
6502 
    oprot.writeMessageBegin("getCategory", TMessageType.REPLY, seqid)
6503 
    result.write(oprot)
6504 
    oprot.writeMessageEnd()
6505 
    oprot.trans.flush()
6506 
 
6507 
  def process_getAllCategories(self, seqid, iprot, oprot):
6508 
    args = getAllCategories_args()
6509 
    args.read(iprot)
6510 
    iprot.readMessageEnd()
6511 
    result = getAllCategories_result()
6512 
    result.success = self._handler.getAllCategories()
6513 
    oprot.writeMessageBegin("getAllCategories", TMessageType.REPLY, seqid)
6514 
    result.write(oprot)
6515 
    oprot.writeMessageEnd()
6516 
    oprot.trans.flush()
6517 
 
6518 
  def process_getAllSimilarItems(self, seqid, iprot, oprot):
6519 
    args = getAllSimilarItems_args()
6520 
    args.read(iprot)
6521 
    iprot.readMessageEnd()
6522 
    result = getAllSimilarItems_result()
6523 
    result.success = self._handler.getAllSimilarItems(args.itemId)
6524 
    oprot.writeMessageBegin("getAllSimilarItems", TMessageType.REPLY, seqid)
6525 
    result.write(oprot)
6526 
    oprot.writeMessageEnd()
6527 
    oprot.trans.flush()
6528 
 
6529 
  def process_addSimilarItem(self, seqid, iprot, oprot):
6530 
    args = addSimilarItem_args()
6531 
    args.read(iprot)
6532 
    iprot.readMessageEnd()
6533 
    result = addSimilarItem_result()
6534 
    try:
6535 
      result.success = self._handler.addSimilarItem(args.itemId, args.catalogItemId)
6536 
    except CatalogServiceException, cex:
6537 
      result.cex = cex
6538 
    oprot.writeMessageBegin("addSimilarItem", TMessageType.REPLY, seqid)
6539 
    result.write(oprot)
6540 
    oprot.writeMessageEnd()
6541 
    oprot.trans.flush()
6542 
 
6512 kshitij.so 6543 
  def process_addTag(self, seqid, iprot, oprot):
6544 
    args = addTag_args()
6545 
    args.read(iprot)
6546 
    iprot.readMessageEnd()
6547 
    result = addTag_result()
6548 
    result.success = self._handler.addTag(args.displayName, args.itemId)
6549 
    oprot.writeMessageBegin("addTag", TMessageType.REPLY, seqid)
6550 
    result.write(oprot)
6551 
    oprot.writeMessageEnd()
6552 
    oprot.trans.flush()
6553 
 
6554 
  def process_deleteEntityTag(self, seqid, iprot, oprot):
6555 
    args = deleteEntityTag_args()
6556 
    args.read(iprot)
6557 
    iprot.readMessageEnd()
6558 
    result = deleteEntityTag_result()
6559 
    result.success = self._handler.deleteEntityTag(args.displayName, args.itemId)
6560 
    oprot.writeMessageBegin("deleteEntityTag", TMessageType.REPLY, seqid)
6561 
    result.write(oprot)
6562 
    oprot.writeMessageEnd()
6563 
    oprot.trans.flush()
6564 
 
6565 
  def process_deleteTag(self, seqid, iprot, oprot):
6566 
    args = deleteTag_args()
6567 
    args.read(iprot)
6568 
    iprot.readMessageEnd()
6569 
    result = deleteTag_result()
6570 
    result.success = self._handler.deleteTag(args.displayName)
6571 
    oprot.writeMessageBegin("deleteTag", TMessageType.REPLY, seqid)
6572 
    result.write(oprot)
6573 
    oprot.writeMessageEnd()
6574 
    oprot.trans.flush()
6575 
 
6576 
  def process_getAllTags(self, seqid, iprot, oprot):
6577 
    args = getAllTags_args()
6578 
    args.read(iprot)
6579 
    iprot.readMessageEnd()
6580 
    result = getAllTags_result()
6581 
    result.success = self._handler.getAllTags()
6582 
    oprot.writeMessageBegin("getAllTags", TMessageType.REPLY, seqid)
6583 
    result.write(oprot)
6584 
    oprot.writeMessageEnd()
6585 
    oprot.trans.flush()
6586 
 
6587 
  def process_getAllEntitiesByTagName(self, seqid, iprot, oprot):
6588 
    args = getAllEntitiesByTagName_args()
6589 
    args.read(iprot)
6590 
    iprot.readMessageEnd()
6591 
    result = getAllEntitiesByTagName_result()
6592 
    result.success = self._handler.getAllEntitiesByTagName(args.displayName)
6593 
    oprot.writeMessageBegin("getAllEntitiesByTagName", TMessageType.REPLY, seqid)
6594 
    result.write(oprot)
6595 
    oprot.writeMessageEnd()
6596 
    oprot.trans.flush()
6597 
 
6845 amit.gupta 6598 
  def process_getAllEntityTags(self, seqid, iprot, oprot):
6599 
    args = getAllEntityTags_args()
6600 
    args.read(iprot)
6601 
    iprot.readMessageEnd()
6602 
    result = getAllEntityTags_result()
6603 
    result.success = self._handler.getAllEntityTags()
6604 
    oprot.writeMessageBegin("getAllEntityTags", TMessageType.REPLY, seqid)
6605 
    result.write(oprot)
6606 
    oprot.writeMessageEnd()
6607 
    oprot.trans.flush()
6608 
 
6850 kshitij.so 6609 
  def process_addBanner(self, seqid, iprot, oprot):
6610 
    args = addBanner_args()
6611 
    args.read(iprot)
6612 
    iprot.readMessageEnd()
6613 
    result = addBanner_result()
10097 kshitij.so 6614 
    result.success = self._handler.addBanner(args.bannerCongregate)
6850 kshitij.so 6615 
    oprot.writeMessageBegin("addBanner", TMessageType.REPLY, seqid)
6616 
    result.write(oprot)
6617 
    oprot.writeMessageEnd()
6618 
    oprot.trans.flush()
6619 
 
8579 kshitij.so 6620 
  def process_updateBanner(self, seqid, iprot, oprot):
6621 
    args = updateBanner_args()
6622 
    args.read(iprot)
6623 
    iprot.readMessageEnd()
6624 
    result = updateBanner_result()
6625 
    result.success = self._handler.updateBanner(args.banner)
6626 
    oprot.writeMessageBegin("updateBanner", TMessageType.REPLY, seqid)
6627 
    result.write(oprot)
6628 
    oprot.writeMessageEnd()
6629 
    oprot.trans.flush()
6630 
 
6850 kshitij.so 6631 
  def process_getAllBanners(self, seqid, iprot, oprot):
6632 
    args = getAllBanners_args()
6633 
    args.read(iprot)
6634 
    iprot.readMessageEnd()
6635 
    result = getAllBanners_result()
6636 
    result.success = self._handler.getAllBanners()
6637 
    oprot.writeMessageBegin("getAllBanners", TMessageType.REPLY, seqid)
6638 
    result.write(oprot)
6639 
    oprot.writeMessageEnd()
6640 
    oprot.trans.flush()
6641 
 
6642 
  def process_deleteBanner(self, seqid, iprot, oprot):
6643 
    args = deleteBanner_args()
6644 
    args.read(iprot)
6645 
    iprot.readMessageEnd()
6646 
    result = deleteBanner_result()
9155 kshitij.so 6647 
    result.success = self._handler.deleteBanner(args.bannerName, args.bannerType)
6850 kshitij.so 6648 
    oprot.writeMessageBegin("deleteBanner", TMessageType.REPLY, seqid)
6649 
    result.write(oprot)
6650 
    oprot.writeMessageEnd()
6651 
    oprot.trans.flush()
6652 
 
6653 
  def process_getBannerDetails(self, seqid, iprot, oprot):
6654 
    args = getBannerDetails_args()
6655 
    args.read(iprot)
6656 
    iprot.readMessageEnd()
6657 
    result = getBannerDetails_result()
9155 kshitij.so 6658 
    result.success = self._handler.getBannerDetails(args.bannerName, args.bannerType)
6850 kshitij.so 6659 
    oprot.writeMessageBegin("getBannerDetails", TMessageType.REPLY, seqid)
6660 
    result.write(oprot)
6661 
    oprot.writeMessageEnd()
6662 
    oprot.trans.flush()
6663 
 
6664 
  def process_getActiveBanners(self, seqid, iprot, oprot):
6665 
    args = getActiveBanners_args()
6666 
    args.read(iprot)
6667 
    iprot.readMessageEnd()
6668 
    result = getActiveBanners_result()
6669 
    result.success = self._handler.getActiveBanners()
6670 
    oprot.writeMessageBegin("getActiveBanners", TMessageType.REPLY, seqid)
6671 
    result.write(oprot)
6672 
    oprot.writeMessageEnd()
6673 
    oprot.trans.flush()
6674 
 
6849 kshitij.so 6675 
  def process_addBannerMap(self, seqid, iprot, oprot):
6676 
    args = addBannerMap_args()
6677 
    args.read(iprot)
6678 
    iprot.readMessageEnd()
6679 
    result = addBannerMap_result()
8579 kshitij.so 6680 
    result.success = self._handler.addBannerMap(args.bannerMaps)
6849 kshitij.so 6681 
    oprot.writeMessageBegin("addBannerMap", TMessageType.REPLY, seqid)
6682 
    result.write(oprot)
6683 
    oprot.writeMessageEnd()
6684 
    oprot.trans.flush()
6685 
 
8579 kshitij.so 6686 
  def process_updateBannerMap(self, seqid, iprot, oprot):
6687 
    args = updateBannerMap_args()
6688 
    args.read(iprot)
6689 
    iprot.readMessageEnd()
6690 
    result = updateBannerMap_result()
6691 
    result.success = self._handler.updateBannerMap(args.bannerMap)
6692 
    oprot.writeMessageBegin("updateBannerMap", TMessageType.REPLY, seqid)
6693 
    result.write(oprot)
6694 
    oprot.writeMessageEnd()
6695 
    oprot.trans.flush()
6696 
 
6849 kshitij.so 6697 
  def process_deleteBannerMap(self, seqid, iprot, oprot):
6698 
    args = deleteBannerMap_args()
6699 
    args.read(iprot)
6700 
    iprot.readMessageEnd()
6701 
    result = deleteBannerMap_result()
6702 
    result.success = self._handler.deleteBannerMap(args.bannerName)
6703 
    oprot.writeMessageBegin("deleteBannerMap", TMessageType.REPLY, seqid)
6704 
    result.write(oprot)
6705 
    oprot.writeMessageEnd()
6706 
    oprot.trans.flush()
6707 
 
6708 
  def process_getBannerMapDetails(self, seqid, iprot, oprot):
6709 
    args = getBannerMapDetails_args()
6710 
    args.read(iprot)
6711 
    iprot.readMessageEnd()
6712 
    result = getBannerMapDetails_result()
9155 kshitij.so 6713 
    result.success = self._handler.getBannerMapDetails(args.bannerName, args.bannerType)
6849 kshitij.so 6714 
    oprot.writeMessageBegin("getBannerMapDetails", TMessageType.REPLY, seqid)
6715 
    result.write(oprot)
6716 
    oprot.writeMessageEnd()
6717 
    oprot.trans.flush()
6718 
 
8579 kshitij.so 6719 
  def process_addBannerUri(self, seqid, iprot, oprot):
6720 
    args = addBannerUri_args()
6721 
    args.read(iprot)
6722 
    iprot.readMessageEnd()
6723 
    result = addBannerUri_result()
6724 
    self._handler.addBannerUri(args.bannerUriMappings)
6725 
    oprot.writeMessageBegin("addBannerUri", TMessageType.REPLY, seqid)
6726 
    result.write(oprot)
6727 
    oprot.writeMessageEnd()
6728 
    oprot.trans.flush()
6729 
 
6730 
  def process_getUriMapping(self, seqid, iprot, oprot):
6731 
    args = getUriMapping_args()
6732 
    args.read(iprot)
6733 
    iprot.readMessageEnd()
6734 
    result = getUriMapping_result()
9155 kshitij.so 6735 
    result.success = self._handler.getUriMapping(args.bannerName, args.bannerType)
8579 kshitij.so 6736 
    oprot.writeMessageBegin("getUriMapping", TMessageType.REPLY, seqid)
6737 
    result.write(oprot)
6738 
    oprot.writeMessageEnd()
6739 
    oprot.trans.flush()
6740 
 
6741 
  def process_addCampaign(self, seqid, iprot, oprot):
6742 
    args = addCampaign_args()
6743 
    args.read(iprot)
6744 
    iprot.readMessageEnd()
6745 
    result = addCampaign_result()
6746 
    self._handler.addCampaign(args.campaign)
6747 
    oprot.writeMessageBegin("addCampaign", TMessageType.REPLY, seqid)
6748 
    result.write(oprot)
6749 
    oprot.writeMessageEnd()
6750 
    oprot.trans.flush()
6751 
 
6752 
  def process_getCampaigns(self, seqid, iprot, oprot):
6753 
    args = getCampaigns_args()
6754 
    args.read(iprot)
6755 
    iprot.readMessageEnd()
6756 
    result = getCampaigns_result()
6757 
    result.success = self._handler.getCampaigns(args.campaignName)
6758 
    oprot.writeMessageBegin("getCampaigns", TMessageType.REPLY, seqid)
6759 
    result.write(oprot)
6760 
    oprot.writeMessageEnd()
6761 
    oprot.trans.flush()
6762 
 
6763 
  def process_deleteCampaign(self, seqid, iprot, oprot):
6764 
    args = deleteCampaign_args()
6765 
    args.read(iprot)
6766 
    iprot.readMessageEnd()
6767 
    result = deleteCampaign_result()
6768 
    self._handler.deleteCampaign(args.campaignId)
6769 
    oprot.writeMessageBegin("deleteCampaign", TMessageType.REPLY, seqid)
6770 
    result.write(oprot)
6771 
    oprot.writeMessageEnd()
6772 
    oprot.trans.flush()
6773 
 
6774 
  def process_getAllCampaigns(self, seqid, iprot, oprot):
6775 
    args = getAllCampaigns_args()
6776 
    args.read(iprot)
6777 
    iprot.readMessageEnd()
6778 
    result = getAllCampaigns_result()
6779 
    result.success = self._handler.getAllCampaigns()
6780 
    oprot.writeMessageBegin("getAllCampaigns", TMessageType.REPLY, seqid)
6781 
    result.write(oprot)
6782 
    oprot.writeMessageEnd()
6783 
    oprot.trans.flush()
6784 
 
9155 kshitij.so 6785 
  def process_getActiveBannersForMobileSite(self, seqid, iprot, oprot):
6786 
    args = getActiveBannersForMobileSite_args()
6787 
    args.read(iprot)
6788 
    iprot.readMessageEnd()
6789 
    result = getActiveBannersForMobileSite_result()
6790 
    result.success = self._handler.getActiveBannersForMobileSite()
6791 
    oprot.writeMessageBegin("getActiveBannersForMobileSite", TMessageType.REPLY, seqid)
6792 
    result.write(oprot)
6793 
    oprot.writeMessageEnd()
6794 
    oprot.trans.flush()
6795 
 
5944 mandeep.dh 6796 
  def process_deleteSimilarItem(self, seqid, iprot, oprot):
6797 
    args = deleteSimilarItem_args()
6798 
    args.read(iprot)
6799 
    iprot.readMessageEnd()
6800 
    result = deleteSimilarItem_result()
6801 
    try:
6802 
      result.success = self._handler.deleteSimilarItem(args.itemId, args.catalogItemId)
6803 
    except CatalogServiceException, cex:
6804 
      result.cex = cex
6805 
    oprot.writeMessageBegin("deleteSimilarItem", TMessageType.REPLY, seqid)
6806 
    result.write(oprot)
6807 
    oprot.writeMessageEnd()
6808 
    oprot.trans.flush()
6809 
 
6810 
  def process_checkSimilarItem(self, seqid, iprot, oprot):
6811 
    args = checkSimilarItem_args()
6812 
    args.read(iprot)
6813 
    iprot.readMessageEnd()
6814 
    result = checkSimilarItem_result()
6815 
    result.success = self._handler.checkSimilarItem(args.brand, args.modelNumber, args.modelName, args.color)
6816 
    oprot.writeMessageBegin("checkSimilarItem", TMessageType.REPLY, seqid)
6817 
    result.write(oprot)
6818 
    oprot.writeMessageEnd()
6819 
    oprot.trans.flush()
6820 
 
6821 
  def process_validateRiskyStatus(self, seqid, iprot, oprot):
6822 
    args = validateRiskyStatus_args()
6823 
    args.read(iprot)
6824 
    iprot.readMessageEnd()
6825 
    result = validateRiskyStatus_result()
6826 
    self._handler.validateRiskyStatus(args.itemId)
6827 
    oprot.writeMessageBegin("validateRiskyStatus", TMessageType.REPLY, seqid)
6828 
    result.write(oprot)
6829 
    oprot.writeMessageEnd()
6830 
    oprot.trans.flush()
6831 
 
6832 
  def process_changeItemRiskyFlag(self, seqid, iprot, oprot):
6833 
    args = changeItemRiskyFlag_args()
6834 
    args.read(iprot)
6835 
    iprot.readMessageEnd()
6836 
    result = changeItemRiskyFlag_result()
6837 
    self._handler.changeItemRiskyFlag(args.itemId, args.risky)
6838 
    oprot.writeMessageBegin("changeItemRiskyFlag", TMessageType.REPLY, seqid)
6839 
    result.write(oprot)
6840 
    oprot.writeMessageEnd()
6841 
    oprot.trans.flush()
6842 
 
6843 
  def process_getItemsByRiskyFlag(self, seqid, iprot, oprot):
6844 
    args = getItemsByRiskyFlag_args()
6845 
    args.read(iprot)
6846 
    iprot.readMessageEnd()
6847 
    result = getItemsByRiskyFlag_result()
6848 
    result.success = self._handler.getItemsByRiskyFlag()
6849 
    oprot.writeMessageBegin("getItemsByRiskyFlag", TMessageType.REPLY, seqid)
6850 
    result.write(oprot)
6851 
    oprot.writeMessageEnd()
6852 
    oprot.trans.flush()
6853 
 
6854 
  def process_getItemsForMasterSheet(self, seqid, iprot, oprot):
6855 
    args = getItemsForMasterSheet_args()
6856 
    args.read(iprot)
6857 
    iprot.readMessageEnd()
6858 
    result = getItemsForMasterSheet_result()
6859 
    result.success = self._handler.getItemsForMasterSheet(args.category, args.brand)
6860 
    oprot.writeMessageBegin("getItemsForMasterSheet", TMessageType.REPLY, seqid)
6861 
    result.write(oprot)
6862 
    oprot.writeMessageEnd()
6863 
    oprot.trans.flush()
6864 
 
6865 
  def process_getSimilarItemsCatalogIds(self, seqid, iprot, oprot):
6866 
    args = getSimilarItemsCatalogIds_args()
6867 
    args.read(iprot)
6868 
    iprot.readMessageEnd()
6869 
    result = getSimilarItemsCatalogIds_result()
6870 
    result.success = self._handler.getSimilarItemsCatalogIds(args.beginIndex, args.totalItems, args.itemId)
6871 
    oprot.writeMessageBegin("getSimilarItemsCatalogIds", TMessageType.REPLY, seqid)
6872 
    result.write(oprot)
6873 
    oprot.writeMessageEnd()
6874 
    oprot.trans.flush()
6875 
 
6876 
  def process_addProductNotification(self, seqid, iprot, oprot):
6877 
    args = addProductNotification_args()
6878 
    args.read(iprot)
6879 
    iprot.readMessageEnd()
6880 
    result = addProductNotification_result()
6881 
    result.success = self._handler.addProductNotification(args.itemId, args.email)
6882 
    oprot.writeMessageBegin("addProductNotification", TMessageType.REPLY, seqid)
6883 
    result.write(oprot)
6884 
    oprot.writeMessageEnd()
6885 
    oprot.trans.flush()
6886 
 
6887 
  def process_sendProductNotifications(self, seqid, iprot, oprot):
6888 
    args = sendProductNotifications_args()
6889 
    args.read(iprot)
6890 
    iprot.readMessageEnd()
6891 
    result = sendProductNotifications_result()
6892 
    result.success = self._handler.sendProductNotifications()
6893 
    oprot.writeMessageBegin("sendProductNotifications", TMessageType.REPLY, seqid)
6894 
    result.write(oprot)
6895 
    oprot.writeMessageEnd()
6896 
    oprot.trans.flush()
6897 
 
6898 
  def process_getAllBrandsByCategory(self, seqid, iprot, oprot):
6899 
    args = getAllBrandsByCategory_args()
6900 
    args.read(iprot)
6901 
    iprot.readMessageEnd()
6902 
    result = getAllBrandsByCategory_result()
6903 
    result.success = self._handler.getAllBrandsByCategory(args.categoryId)
6904 
    oprot.writeMessageBegin("getAllBrandsByCategory", TMessageType.REPLY, seqid)
6905 
    result.write(oprot)
6906 
    oprot.writeMessageEnd()
6907 
    oprot.trans.flush()
6908 
 
6909 
  def process_getAllBrands(self, seqid, iprot, oprot):
6910 
    args = getAllBrands_args()
6911 
    args.read(iprot)
6912 
    iprot.readMessageEnd()
6913 
    result = getAllBrands_result()
6914 
    result.success = self._handler.getAllBrands()
6915 
    oprot.writeMessageBegin("getAllBrands", TMessageType.REPLY, seqid)
6916 
    result.write(oprot)
6917 
    oprot.writeMessageEnd()
6918 
    oprot.trans.flush()
6919 
 
6920 
  def process_getAllSources(self, seqid, iprot, oprot):
6921 
    args = getAllSources_args()
6922 
    args.read(iprot)
6923 
    iprot.readMessageEnd()
6924 
    result = getAllSources_result()
6925 
    result.success = self._handler.getAllSources()
6926 
    oprot.writeMessageBegin("getAllSources", TMessageType.REPLY, seqid)
6927 
    result.write(oprot)
6928 
    oprot.writeMessageEnd()
6929 
    oprot.trans.flush()
6930 
 
6931 
  def process_getItemPricingBySource(self, seqid, iprot, oprot):
6932 
    args = getItemPricingBySource_args()
6933 
    args.read(iprot)
6934 
    iprot.readMessageEnd()
6935 
    result = getItemPricingBySource_result()
6936 
    try:
6937 
      result.success = self._handler.getItemPricingBySource(args.itemId, args.sourceId)
6938 
    except CatalogServiceException, cex:
6939 
      result.cex = cex
6940 
    oprot.writeMessageBegin("getItemPricingBySource", TMessageType.REPLY, seqid)
6941 
    result.write(oprot)
6942 
    oprot.writeMessageEnd()
6943 
    oprot.trans.flush()
6944 
 
6945 
  def process_addSourceItemPricing(self, seqid, iprot, oprot):
6946 
    args = addSourceItemPricing_args()
6947 
    args.read(iprot)
6948 
    iprot.readMessageEnd()
6949 
    result = addSourceItemPricing_result()
6950 
    try:
6951 
      self._handler.addSourceItemPricing(args.sourceItemPricing)
6952 
    except CatalogServiceException, cex:
6953 
      result.cex = cex
6954 
    oprot.writeMessageBegin("addSourceItemPricing", TMessageType.REPLY, seqid)
6955 
    result.write(oprot)
6956 
    oprot.writeMessageEnd()
6957 
    oprot.trans.flush()
6958 
 
6959 
  def process_getAllSourcePricing(self, seqid, iprot, oprot):
6960 
    args = getAllSourcePricing_args()
6961 
    args.read(iprot)
6962 
    iprot.readMessageEnd()
6963 
    result = getAllSourcePricing_result()
6964 
    try:
6965 
      result.success = self._handler.getAllSourcePricing(args.itemId)
6966 
    except CatalogServiceException, cex:
6967 
      result.cex = cex
6968 
    oprot.writeMessageBegin("getAllSourcePricing", TMessageType.REPLY, seqid)
6969 
    result.write(oprot)
6970 
    oprot.writeMessageEnd()
6971 
    oprot.trans.flush()
6972 
 
6973 
  def process_getItemForSource(self, seqid, iprot, oprot):
6974 
    args = getItemForSource_args()
6975 
    args.read(iprot)
6976 
    iprot.readMessageEnd()
6977 
    result = getItemForSource_result()
6978 
    try:
6979 
      result.success = self._handler.getItemForSource(args.item_id, args.sourceId)
6980 
    except CatalogServiceException, cex:
6981 
      result.cex = cex
6982 
    oprot.writeMessageBegin("getItemForSource", TMessageType.REPLY, seqid)
6983 
    result.write(oprot)
6984 
    oprot.writeMessageEnd()
6985 
    oprot.trans.flush()
6986 
 
6987 
  def process_searchItemsInRange(self, seqid, iprot, oprot):
6988 
    args = searchItemsInRange_args()
6989 
    args.read(iprot)
6990 
    iprot.readMessageEnd()
6991 
    result = searchItemsInRange_result()
6992 
    result.success = self._handler.searchItemsInRange(args.searchTerms, args.offset, args.limit)
6993 
    oprot.writeMessageBegin("searchItemsInRange", TMessageType.REPLY, seqid)
6994 
    result.write(oprot)
6995 
    oprot.writeMessageEnd()
6996 
    oprot.trans.flush()
6997 
 
6998 
  def process_getSearchResultCount(self, seqid, iprot, oprot):
6999 
    args = getSearchResultCount_args()
7000 
    args.read(iprot)
7001 
    iprot.readMessageEnd()
7002 
    result = getSearchResultCount_result()
7003 
    result.success = self._handler.getSearchResultCount(args.searchTerms)
7004 
    oprot.writeMessageBegin("getSearchResultCount", TMessageType.REPLY, seqid)
7005 
    result.write(oprot)
7006 
    oprot.writeMessageEnd()
7007 
    oprot.trans.flush()
7008 
 
7009 
  def process_getProductNotifications(self, seqid, iprot, oprot):
7010 
    args = getProductNotifications_args()
7011 
    args.read(iprot)
7012 
    iprot.readMessageEnd()
7013 
    result = getProductNotifications_result()
7014 
    result.success = self._handler.getProductNotifications(args.startDateTime)
7015 
    oprot.writeMessageBegin("getProductNotifications", TMessageType.REPLY, seqid)
7016 
    result.write(oprot)
7017 
    oprot.writeMessageEnd()
7018 
    oprot.trans.flush()
7019 
 
7020 
  def process_getProductNotificationRequestCount(self, seqid, iprot, oprot):
7021 
    args = getProductNotificationRequestCount_args()
7022 
    args.read(iprot)
7023 
    iprot.readMessageEnd()
7024 
    result = getProductNotificationRequestCount_result()
7897 amar.kumar 7025 
    result.success = self._handler.getProductNotificationRequestCount(args.startDateTime, args.categoryId)
5944 mandeep.dh 7026 
    oprot.writeMessageBegin("getProductNotificationRequestCount", TMessageType.REPLY, seqid)
7027 
    result.write(oprot)
7028 
    oprot.writeMessageEnd()
7029 
    oprot.trans.flush()
7030 
 
7031 
  def process_addAuthorizationLog(self, seqid, iprot, oprot):
7032 
    args = addAuthorizationLog_args()
7033 
    args.read(iprot)
7034 
    iprot.readMessageEnd()
7035 
    result = addAuthorizationLog_result()
7036 
    try:
7037 
      result.success = self._handler.addAuthorizationLog(args.itemId, args.username, args.reason)
7038 
    except CatalogServiceException, cex:
7039 
      result.cex = cex
7040 
    oprot.writeMessageBegin("addAuthorizationLog", TMessageType.REPLY, seqid)
7041 
    result.write(oprot)
7042 
    oprot.writeMessageEnd()
7043 
    oprot.trans.flush()
7044 
 
7045 
  def process_addupdateVoucherForItem(self, seqid, iprot, oprot):
7046 
    args = addupdateVoucherForItem_args()
7047 
    args.read(iprot)
7048 
    iprot.readMessageEnd()
7049 
    result = addupdateVoucherForItem_result()
7050 
    try:
7051 
      result.success = self._handler.addupdateVoucherForItem(args.catalog_item_id, args.voucherType, args.voucherAmount)
7052 
    except CatalogServiceException, cex:
7053 
      result.cex = cex
7054 
    oprot.writeMessageBegin("addupdateVoucherForItem", TMessageType.REPLY, seqid)
7055 
    result.write(oprot)
7056 
    oprot.writeMessageEnd()
7057 
    oprot.trans.flush()
7058 
 
7059 
  def process_deleteVoucherForItem(self, seqid, iprot, oprot):
7060 
    args = deleteVoucherForItem_args()
7061 
    args.read(iprot)
7062 
    iprot.readMessageEnd()
7063 
    result = deleteVoucherForItem_result()
7064 
    try:
7065 
      result.success = self._handler.deleteVoucherForItem(args.catalog_item_id, args.voucherType)
7066 
    except CatalogServiceException, cex:
7067 
      result.cex = cex
7068 
    oprot.writeMessageBegin("deleteVoucherForItem", TMessageType.REPLY, seqid)
7069 
    result.write(oprot)
7070 
    oprot.writeMessageEnd()
7071 
    oprot.trans.flush()
7072 
 
7073 
  def process_getVoucherAmount(self, seqid, iprot, oprot):
7074 
    args = getVoucherAmount_args()
7075 
    args.read(iprot)
7076 
    iprot.readMessageEnd()
7077 
    result = getVoucherAmount_result()
7078 
    result.success = self._handler.getVoucherAmount(args.itemId, args.voucherType)
7079 
    oprot.writeMessageBegin("getVoucherAmount", TMessageType.REPLY, seqid)
7080 
    result.write(oprot)
7081 
    oprot.writeMessageEnd()
7082 
    oprot.trans.flush()
7083 
 
7084 
  def process_getAllItemVouchers(self, seqid, iprot, oprot):
7085 
    args = getAllItemVouchers_args()
7086 
    args.read(iprot)
7087 
    iprot.readMessageEnd()
7088 
    result = getAllItemVouchers_result()
7089 
    result.success = self._handler.getAllItemVouchers(args.itemId)
7090 
    oprot.writeMessageBegin("getAllItemVouchers", TMessageType.REPLY, seqid)
7091 
    result.write(oprot)
7092 
    oprot.writeMessageEnd()
7093 
    oprot.trans.flush()
7094 
 
7095 
  def process_isValidCatalogItemId(self, seqid, iprot, oprot):
7096 
    args = isValidCatalogItemId_args()
7097 
    args.read(iprot)
7098 
    iprot.readMessageEnd()
7099 
    result = isValidCatalogItemId_result()
7100 
    result.success = self._handler.isValidCatalogItemId(args.catalog_item_id)
7101 
    oprot.writeMessageBegin("isValidCatalogItemId", TMessageType.REPLY, seqid)
7102 
    result.write(oprot)
7103 
    oprot.writeMessageEnd()
7104 
    oprot.trans.flush()
7105 
 
6039 amit.gupta 7106 
  def process_getVatPercentageForItem(self, seqid, iprot, oprot):
7107 
    args = getVatPercentageForItem_args()
7108 
    args.read(iprot)
7109 
    iprot.readMessageEnd()
7110 
    result = getVatPercentageForItem_result()
7340 amit.gupta 7111 
    try:
7112 
      result.success = self._handler.getVatPercentageForItem(args.itemId, args.stateId, args.price)
7113 
    except CatalogServiceException, cex:
7114 
      result.cex = cex
6039 amit.gupta 7115 
    oprot.writeMessageBegin("getVatPercentageForItem", TMessageType.REPLY, seqid)
7116 
    result.write(oprot)
7117 
    oprot.writeMessageEnd()
7118 
    oprot.trans.flush()
5944 mandeep.dh 7119 
 
6039 amit.gupta 7120 
  def process_getVatAmountForItem(self, seqid, iprot, oprot):
7121 
    args = getVatAmountForItem_args()
7122 
    args.read(iprot)
7123 
    iprot.readMessageEnd()
7124 
    result = getVatAmountForItem_result()
7125 
    result.success = self._handler.getVatAmountForItem(args.itemId, args.price)
7126 
    oprot.writeMessageBegin("getVatAmountForItem", TMessageType.REPLY, seqid)
7127 
    result.write(oprot)
7128 
    oprot.writeMessageEnd()
7129 
    oprot.trans.flush()
7130 
 
6531 vikram.rag 7131 
  def process_getAllIgnoredInventoryUpdateItemsList(self, seqid, iprot, oprot):
7132 
    args = getAllIgnoredInventoryUpdateItemsList_args()
7133 
    args.read(iprot)
7134 
    iprot.readMessageEnd()
7135 
    result = getAllIgnoredInventoryUpdateItemsList_result()
7136 
    result.success = self._handler.getAllIgnoredInventoryUpdateItemsList(args.offset, args.limit)
7137 
    oprot.writeMessageBegin("getAllIgnoredInventoryUpdateItemsList", TMessageType.REPLY, seqid)
7138 
    result.write(oprot)
7139 
    oprot.writeMessageEnd()
7140 
    oprot.trans.flush()
6039 amit.gupta 7141 
 
6821 amar.kumar 7142 
  def process_getAllAliveItems(self, seqid, iprot, oprot):
7143 
    args = getAllAliveItems_args()
7144 
    args.read(iprot)
7145 
    iprot.readMessageEnd()
7146 
    result = getAllAliveItems_result()
7147 
    result.success = self._handler.getAllAliveItems()
7148 
    oprot.writeMessageBegin("getAllAliveItems", TMessageType.REPLY, seqid)
7149 
    result.write(oprot)
7150 
    oprot.writeMessageEnd()
7151 
    oprot.trans.flush()
7152 
 
6805 anupam.sin 7153 
  def process_getInsuranceAmount(self, seqid, iprot, oprot):
7154 
    args = getInsuranceAmount_args()
7155 
    args.read(iprot)
7156 
    iprot.readMessageEnd()
7157 
    result = getInsuranceAmount_result()
6921 anupam.sin 7158 
    result.success = self._handler.getInsuranceAmount(args.itemId, args.price, args.insurerId, args.quantity)
6805 anupam.sin 7159 
    oprot.writeMessageBegin("getInsuranceAmount", TMessageType.REPLY, seqid)
7160 
    result.write(oprot)
7161 
    oprot.writeMessageEnd()
7162 
    oprot.trans.flush()
6531 vikram.rag 7163 
 
6805 anupam.sin 7164 
  def process_getInsurer(self, seqid, iprot, oprot):
7165 
    args = getInsurer_args()
7166 
    args.read(iprot)
7167 
    iprot.readMessageEnd()
7168 
    result = getInsurer_result()
7169 
    result.success = self._handler.getInsurer(args.insurerId)
7170 
    oprot.writeMessageBegin("getInsurer", TMessageType.REPLY, seqid)
7171 
    result.write(oprot)
7172 
    oprot.writeMessageEnd()
7173 
    oprot.trans.flush()
7174 
 
6838 vikram.rag 7175 
  def process_getAllInsurers(self, seqid, iprot, oprot):
7176 
    args = getAllInsurers_args()
7177 
    args.read(iprot)
7178 
    iprot.readMessageEnd()
7179 
    result = getAllInsurers_result()
7180 
    result.success = self._handler.getAllInsurers()
7181 
    oprot.writeMessageBegin("getAllInsurers", TMessageType.REPLY, seqid)
7182 
    result.write(oprot)
7183 
    oprot.writeMessageEnd()
7184 
    oprot.trans.flush()
6805 anupam.sin 7185 
 
6962 rajveer 7186 
  def process_updateInsuranceDeclaredAmount(self, seqid, iprot, oprot):
7187 
    args = updateInsuranceDeclaredAmount_args()
7188 
    args.read(iprot)
7189 
    iprot.readMessageEnd()
7190 
    result = updateInsuranceDeclaredAmount_result()
7191 
    self._handler.updateInsuranceDeclaredAmount(args.insurerId, args.amount)
7192 
    oprot.writeMessageBegin("updateInsuranceDeclaredAmount", TMessageType.REPLY, seqid)
7193 
    result.write(oprot)
7194 
    oprot.writeMessageEnd()
7195 
    oprot.trans.flush()
6838 vikram.rag 7196 
 
7190 amar.kumar 7197 
  def process_getFreebieForItem(self, seqid, iprot, oprot):
7198 
    args = getFreebieForItem_args()
7199 
    args.read(iprot)
7200 
    iprot.readMessageEnd()
7201 
    result = getFreebieForItem_result()
7202 
    result.success = self._handler.getFreebieForItem(args.itemId)
7203 
    oprot.writeMessageBegin("getFreebieForItem", TMessageType.REPLY, seqid)
7204 
    result.write(oprot)
7205 
    oprot.writeMessageEnd()
7206 
    oprot.trans.flush()
6962 rajveer 7207 
 
7190 amar.kumar 7208 
  def process_addOrUpdateFreebieForItem(self, seqid, iprot, oprot):
7209 
    args = addOrUpdateFreebieForItem_args()
7210 
    args.read(iprot)
7211 
    iprot.readMessageEnd()
7212 
    result = addOrUpdateFreebieForItem_result()
7213 
    self._handler.addOrUpdateFreebieForItem(args.freebieItem)
7214 
    oprot.writeMessageBegin("addOrUpdateFreebieForItem", TMessageType.REPLY, seqid)
7215 
    result.write(oprot)
7216 
    oprot.writeMessageEnd()
7217 
    oprot.trans.flush()
7218 
 
7272 amit.gupta 7219 
  def process_addOrUpdateBrandInfo(self, seqid, iprot, oprot):
7220 
    args = addOrUpdateBrandInfo_args()
7221 
    args.read(iprot)
7222 
    iprot.readMessageEnd()
7223 
    result = addOrUpdateBrandInfo_result()
7224 
    self._handler.addOrUpdateBrandInfo(args.brandInfo)
7225 
    oprot.writeMessageBegin("addOrUpdateBrandInfo", TMessageType.REPLY, seqid)
7226 
    result.write(oprot)
7227 
    oprot.writeMessageEnd()
7228 
    oprot.trans.flush()
7229 
 
7230 
  def process_getBrandInfo(self, seqid, iprot, oprot):
7231 
    args = getBrandInfo_args()
7232 
    args.read(iprot)
7233 
    iprot.readMessageEnd()
7234 
    result = getBrandInfo_result()
7235 
    result.success = self._handler.getBrandInfo()
7236 
    oprot.writeMessageBegin("getBrandInfo", TMessageType.REPLY, seqid)
7237 
    result.write(oprot)
7238 
    oprot.writeMessageEnd()
7239 
    oprot.trans.flush()
7240 
 
7256 rajveer 7241 
  def process_getStorePricing(self, seqid, iprot, oprot):
7242 
    args = getStorePricing_args()
7243 
    args.read(iprot)
7244 
    iprot.readMessageEnd()
7245 
    result = getStorePricing_result()
7246 
    result.success = self._handler.getStorePricing(args.itemId)
7247 
    oprot.writeMessageBegin("getStorePricing", TMessageType.REPLY, seqid)
7248 
    result.write(oprot)
7249 
    oprot.writeMessageEnd()
7250 
    oprot.trans.flush()
7190 amar.kumar 7251 
 
7306 rajveer 7252 
  def process_getStorePricings(self, seqid, iprot, oprot):
7253 
    args = getStorePricings_args()
7254 
    args.read(iprot)
7255 
    iprot.readMessageEnd()
7256 
    result = getStorePricings_result()
7257 
    result.success = self._handler.getStorePricings(args.itemIds)
7258 
    oprot.writeMessageBegin("getStorePricings", TMessageType.REPLY, seqid)
7259 
    result.write(oprot)
7260 
    oprot.writeMessageEnd()
7261 
    oprot.trans.flush()
7262 
 
7265 rajveer 7263 
  def process_updateStorePricing(self, seqid, iprot, oprot):
7264 
    args = updateStorePricing_args()
7265 
    args.read(iprot)
7266 
    iprot.readMessageEnd()
7267 
    result = updateStorePricing_result()
7382 rajveer 7268 
    self._handler.updateStorePricing(args.sp, args.allColors)
7265 rajveer 7269 
    oprot.writeMessageBegin("updateStorePricing", TMessageType.REPLY, seqid)
7270 
    result.write(oprot)
7271 
    oprot.writeMessageEnd()
7272 
    oprot.trans.flush()
7256 rajveer 7273 
 
7281 kshitij.so 7274 
  def process_getAllAmazonListedItems(self, seqid, iprot, oprot):
7275 
    args = getAllAmazonListedItems_args()
7276 
    args.read(iprot)
7277 
    iprot.readMessageEnd()
7278 
    result = getAllAmazonListedItems_result()
7279 
    result.success = self._handler.getAllAmazonListedItems()
7280 
    oprot.writeMessageBegin("getAllAmazonListedItems", TMessageType.REPLY, seqid)
7281 
    result.write(oprot)
7282 
    oprot.writeMessageEnd()
7283 
    oprot.trans.flush()
7265 rajveer 7284 
 
8619 kshitij.so 7285 
  def process_searchAmazonItems(self, seqid, iprot, oprot):
7286 
    args = searchAmazonItems_args()
7287 
    args.read(iprot)
7288 
    iprot.readMessageEnd()
7289 
    result = searchAmazonItems_result()
7290 
    result.success = self._handler.searchAmazonItems(args.searchTerm, args.offset, args.limit)
7291 
    oprot.writeMessageBegin("searchAmazonItems", TMessageType.REPLY, seqid)
7292 
    result.write(oprot)
7293 
    oprot.writeMessageEnd()
7294 
    oprot.trans.flush()
7295 
 
7296 
  def process_getAmazonSearchResultCount(self, seqid, iprot, oprot):
7297 
    args = getAmazonSearchResultCount_args()
7298 
    args.read(iprot)
7299 
    iprot.readMessageEnd()
7300 
    result = getAmazonSearchResultCount_result()
7301 
    result.success = self._handler.getAmazonSearchResultCount(args.searchTerm)
7302 
    oprot.writeMessageBegin("getAmazonSearchResultCount", TMessageType.REPLY, seqid)
7303 
    result.write(oprot)
7304 
    oprot.writeMessageEnd()
7305 
    oprot.trans.flush()
7306 
 
7307 
  def process_getCountForAmazonlistedItems(self, seqid, iprot, oprot):
7308 
    args = getCountForAmazonlistedItems_args()
7309 
    args.read(iprot)
7310 
    iprot.readMessageEnd()
7311 
    result = getCountForAmazonlistedItems_result()
7312 
    result.success = self._handler.getCountForAmazonlistedItems()
7313 
    oprot.writeMessageBegin("getCountForAmazonlistedItems", TMessageType.REPLY, seqid)
7314 
    result.write(oprot)
7315 
    oprot.writeMessageEnd()
7316 
    oprot.trans.flush()
7317 
 
7281 kshitij.so 7318 
  def process_getAmazonItemDetails(self, seqid, iprot, oprot):
7319 
    args = getAmazonItemDetails_args()
7320 
    args.read(iprot)
7321 
    iprot.readMessageEnd()
7322 
    result = getAmazonItemDetails_result()
7323 
    result.success = self._handler.getAmazonItemDetails(args.itemId)
7324 
    oprot.writeMessageBegin("getAmazonItemDetails", TMessageType.REPLY, seqid)
7325 
    result.write(oprot)
7326 
    oprot.writeMessageEnd()
7327 
    oprot.trans.flush()
7328 
 
7329 
  def process_updateAmazonItemDetails(self, seqid, iprot, oprot):
7330 
    args = updateAmazonItemDetails_args()
7331 
    args.read(iprot)
7332 
    iprot.readMessageEnd()
7333 
    result = updateAmazonItemDetails_result()
8168 kshitij.so 7334 
    self._handler.updateAmazonItemDetails(args.amazonlisted)
7281 kshitij.so 7335 
    oprot.writeMessageBegin("updateAmazonItemDetails", TMessageType.REPLY, seqid)
7336 
    result.write(oprot)
7337 
    oprot.writeMessageEnd()
7338 
    oprot.trans.flush()
7339 
 
7340 
  def process_addAmazonItem(self, seqid, iprot, oprot):
7341 
    args = addAmazonItem_args()
7342 
    args.read(iprot)
7343 
    iprot.readMessageEnd()
7344 
    result = addAmazonItem_result()
7345 
    self._handler.addAmazonItem(args.amazonlisted)
7346 
    oprot.writeMessageBegin("addAmazonItem", TMessageType.REPLY, seqid)
7347 
    result.write(oprot)
7348 
    oprot.writeMessageEnd()
7349 
    oprot.trans.flush()
7350 
 
7291 vikram.rag 7351 
  def process_getAsinItems(self, seqid, iprot, oprot):
7352 
    args = getAsinItems_args()
7353 
    args.read(iprot)
7354 
    iprot.readMessageEnd()
7355 
    result = getAsinItems_result()
7356 
    result.success = self._handler.getAsinItems()
7357 
    oprot.writeMessageBegin("getAsinItems", TMessageType.REPLY, seqid)
7358 
    result.write(oprot)
7359 
    oprot.writeMessageEnd()
7360 
    oprot.trans.flush()
7281 kshitij.so 7361 
 
7291 vikram.rag 7362 
  def process_getAllFbaListedItems(self, seqid, iprot, oprot):
7363 
    args = getAllFbaListedItems_args()
7364 
    args.read(iprot)
7365 
    iprot.readMessageEnd()
7366 
    result = getAllFbaListedItems_result()
7367 
    result.success = self._handler.getAllFbaListedItems()
7368 
    oprot.writeMessageBegin("getAllFbaListedItems", TMessageType.REPLY, seqid)
7369 
    result.write(oprot)
7370 
    oprot.writeMessageEnd()
7371 
    oprot.trans.flush()
7372 
 
7373 
  def process_getAllNonFbaListedItems(self, seqid, iprot, oprot):
7374 
    args = getAllNonFbaListedItems_args()
7375 
    args.read(iprot)
7376 
    iprot.readMessageEnd()
7377 
    result = getAllNonFbaListedItems_result()
7378 
    result.success = self._handler.getAllNonFbaListedItems()
7379 
    oprot.writeMessageBegin("getAllNonFbaListedItems", TMessageType.REPLY, seqid)
7380 
    result.write(oprot)
7381 
    oprot.writeMessageEnd()
7382 
    oprot.trans.flush()
7383 
 
7460 kshitij.so 7384 
  def process_updateItemInventory(self, seqid, iprot, oprot):
7385 
    args = updateItemInventory_args()
7386 
    args.read(iprot)
7387 
    iprot.readMessageEnd()
7388 
    result = updateItemInventory_result()
7389 
    result.success = self._handler.updateItemInventory(args.itemId, args.holdInventory, args.defaultInventory)
7390 
    oprot.writeMessageBegin("updateItemInventory", TMessageType.REPLY, seqid)
7391 
    result.write(oprot)
7392 
    oprot.writeMessageEnd()
7393 
    oprot.trans.flush()
7291 vikram.rag 7394 
 
7770 kshitij.so 7395 
  def process_updateTimestampForAmazonFeeds(self, seqid, iprot, oprot):
7396 
    args = updateTimestampForAmazonFeeds_args()
7397 
    args.read(iprot)
7398 
    iprot.readMessageEnd()
7399 
    result = updateTimestampForAmazonFeeds_result()
7400 
    result.success = self._handler.updateTimestampForAmazonFeeds(args.type, args.sku, args.timestamp)
7401 
    oprot.writeMessageBegin("updateTimestampForAmazonFeeds", TMessageType.REPLY, seqid)
7402 
    result.write(oprot)
7403 
    oprot.writeMessageEnd()
7404 
    oprot.trans.flush()
7460 kshitij.so 7405 
 
7897 amar.kumar 7406 
  def process_getAllParentCategories(self, seqid, iprot, oprot):
7407 
    args = getAllParentCategories_args()
7408 
    args.read(iprot)
7409 
    iprot.readMessageEnd()
7410 
    result = getAllParentCategories_result()
7411 
    result.success = self._handler.getAllParentCategories()
7412 
    oprot.writeMessageBegin("getAllParentCategories", TMessageType.REPLY, seqid)
7413 
    result.write(oprot)
7414 
    oprot.writeMessageEnd()
7415 
    oprot.trans.flush()
7770 kshitij.so 7416 
 
7977 kshitij.so 7417 
  def process_addPageViewEvent(self, seqid, iprot, oprot):
7418 
    args = addPageViewEvent_args()
7419 
    args.read(iprot)
7420 
    iprot.readMessageEnd()
7421 
    result = addPageViewEvent_result()
7422 
    self._handler.addPageViewEvent(args.pageViewEvents)
7423 
    oprot.writeMessageBegin("addPageViewEvent", TMessageType.REPLY, seqid)
7424 
    result.write(oprot)
7425 
    oprot.writeMessageEnd()
7426 
    oprot.trans.flush()
7897 amar.kumar 7427 
 
7977 kshitij.so 7428 
  def process_addCartEvent(self, seqid, iprot, oprot):
7429 
    args = addCartEvent_args()
7430 
    args.read(iprot)
7431 
    iprot.readMessageEnd()
7432 
    result = addCartEvent_result()
7433 
    self._handler.addCartEvent(args.cartEvents)
7434 
    oprot.writeMessageBegin("addCartEvent", TMessageType.REPLY, seqid)
7435 
    result.write(oprot)
7436 
    oprot.writeMessageEnd()
7437 
    oprot.trans.flush()
7438 
 
8182 amar.kumar 7439 
  def process_addEbayItem(self, seqid, iprot, oprot):
7440 
    args = addEbayItem_args()
7441 
    args.read(iprot)
7442 
    iprot.readMessageEnd()
7443 
    result = addEbayItem_result()
7444 
    self._handler.addEbayItem(args.ebayItem)
7445 
    oprot.writeMessageBegin("addEbayItem", TMessageType.REPLY, seqid)
7446 
    result.write(oprot)
7447 
    oprot.writeMessageEnd()
7448 
    oprot.trans.flush()
7449 
 
7450 
  def process_getEbayItem(self, seqid, iprot, oprot):
7451 
    args = getEbayItem_args()
7452 
    args.read(iprot)
7453 
    iprot.readMessageEnd()
7454 
    result = getEbayItem_result()
7455 
    result.success = self._handler.getEbayItem(args.listingId)
7456 
    oprot.writeMessageBegin("getEbayItem", TMessageType.REPLY, seqid)
7457 
    result.write(oprot)
7458 
    oprot.writeMessageEnd()
7459 
    oprot.trans.flush()
7460 
 
7461 
  def process_updateEbayItem(self, seqid, iprot, oprot):
7462 
    args = updateEbayItem_args()
7463 
    args.read(iprot)
7464 
    iprot.readMessageEnd()
7465 
    result = updateEbayItem_result()
7466 
    self._handler.updateEbayItem(args.ebayItem)
7467 
    oprot.writeMessageBegin("updateEbayItem", TMessageType.REPLY, seqid)
7468 
    result.write(oprot)
7469 
    oprot.writeMessageEnd()
7470 
    oprot.trans.flush()
7471 
 
8139 kshitij.so 7472 
  def process_getAmazonListedItems(self, seqid, iprot, oprot):
7473 
    args = getAmazonListedItems_args()
7474 
    args.read(iprot)
7475 
    iprot.readMessageEnd()
7476 
    result = getAmazonListedItems_result()
7477 
    result.success = self._handler.getAmazonListedItems(args.offset, args.limit)
7478 
    oprot.writeMessageBegin("getAmazonListedItems", TMessageType.REPLY, seqid)
7479 
    result.write(oprot)
7480 
    oprot.writeMessageEnd()
7481 
    oprot.trans.flush()
7977 kshitij.so 7482 
 
8168 kshitij.so 7483 
  def process_updateAmazonAttributesInBulk(self, seqid, iprot, oprot):
7484 
    args = updateAmazonAttributesInBulk_args()
7485 
    args.read(iprot)
7486 
    iprot.readMessageEnd()
7487 
    result = updateAmazonAttributesInBulk_result()
7488 
    result.success = self._handler.updateAmazonAttributesInBulk(args.amazonlisted)
7489 
    oprot.writeMessageBegin("updateAmazonAttributesInBulk", TMessageType.REPLY, seqid)
7490 
    result.write(oprot)
7491 
    oprot.writeMessageEnd()
7492 
    oprot.trans.flush()
8139 kshitij.so 7493 
 
8379 vikram.rag 7494 
  def process_getAllItemstoListOnFba(self, seqid, iprot, oprot):
7495 
    args = getAllItemstoListOnFba_args()
7496 
    args.read(iprot)
7497 
    iprot.readMessageEnd()
7498 
    result = getAllItemstoListOnFba_result()
7499 
    result.success = self._handler.getAllItemstoListOnFba()
7500 
    oprot.writeMessageBegin("getAllItemstoListOnFba", TMessageType.REPLY, seqid)
7501 
    result.write(oprot)
7502 
    oprot.writeMessageEnd()
7503 
    oprot.trans.flush()
8168 kshitij.so 7504 
 
8379 vikram.rag 7505 
  def process_getAllItemstoListOnNonFba(self, seqid, iprot, oprot):
7506 
    args = getAllItemstoListOnNonFba_args()
7507 
    args.read(iprot)
7508 
    iprot.readMessageEnd()
7509 
    result = getAllItemstoListOnNonFba_result()
7510 
    result.success = self._handler.getAllItemstoListOnNonFba()
7511 
    oprot.writeMessageBegin("getAllItemstoListOnNonFba", TMessageType.REPLY, seqid)
7512 
    result.write(oprot)
7513 
    oprot.writeMessageEnd()
7514 
    oprot.trans.flush()
7515 
 
8619 kshitij.so 7516 
  def process_updateAsin(self, seqid, iprot, oprot):
7517 
    args = updateAsin_args()
7518 
    args.read(iprot)
7519 
    iprot.readMessageEnd()
7520 
    result = updateAsin_result()
7521 
    self._handler.updateAsin(args.item)
7522 
    oprot.writeMessageBegin("updateAsin", TMessageType.REPLY, seqid)
7523 
    result.write(oprot)
7524 
    oprot.writeMessageEnd()
7525 
    oprot.trans.flush()
8616 vikram.rag 7526 
 
8739 vikram.rag 7527 
  def process_addOrUpdateSnapdealItem(self, seqid, iprot, oprot):
7528 
    args = addOrUpdateSnapdealItem_args()
7529 
    args.read(iprot)
7530 
    iprot.readMessageEnd()
7531 
    result = addOrUpdateSnapdealItem_result()
7532 
    result.success = self._handler.addOrUpdateSnapdealItem(args.snapdealitem)
7533 
    oprot.writeMessageBegin("addOrUpdateSnapdealItem", TMessageType.REPLY, seqid)
7534 
    result.write(oprot)
7535 
    oprot.writeMessageEnd()
7536 
    oprot.trans.flush()
8619 kshitij.so 7537 
 
8739 vikram.rag 7538 
  def process_getSnapdealItem(self, seqid, iprot, oprot):
7539 
    args = getSnapdealItem_args()
7540 
    args.read(iprot)
7541 
    iprot.readMessageEnd()
7542 
    result = getSnapdealItem_result()
7543 
    result.success = self._handler.getSnapdealItem(args.item_id)
7544 
    oprot.writeMessageBegin("getSnapdealItem", TMessageType.REPLY, seqid)
7545 
    result.write(oprot)
7546 
    oprot.writeMessageEnd()
7547 
    oprot.trans.flush()
7548 
 
9242 kshitij.so 7549 
  def process_getSnapdealItemDetails(self, seqid, iprot, oprot):
7550 
    args = getSnapdealItemDetails_args()
7551 
    args.read(iprot)
7552 
    iprot.readMessageEnd()
7553 
    result = getSnapdealItemDetails_result()
7554 
    result.success = self._handler.getSnapdealItemDetails(args.item_id)
7555 
    oprot.writeMessageBegin("getSnapdealItemDetails", TMessageType.REPLY, seqid)
7556 
    result.write(oprot)
7557 
    oprot.writeMessageEnd()
7558 
    oprot.trans.flush()
7559 
 
8739 vikram.rag 7560 
  def process_getAllSnapdealItems(self, seqid, iprot, oprot):
7561 
    args = getAllSnapdealItems_args()
7562 
    args.read(iprot)
7563 
    iprot.readMessageEnd()
7564 
    result = getAllSnapdealItems_result()
7565 
    result.success = self._handler.getAllSnapdealItems()
7566 
    oprot.writeMessageBegin("getAllSnapdealItems", TMessageType.REPLY, seqid)
7567 
    result.write(oprot)
7568 
    oprot.writeMessageEnd()
7569 
    oprot.trans.flush()
7570 
 
9242 kshitij.so 7571 
  def process_getSnapdealItems(self, seqid, iprot, oprot):
7572 
    args = getSnapdealItems_args()
7573 
    args.read(iprot)
7574 
    iprot.readMessageEnd()
7575 
    result = getSnapdealItems_result()
7576 
    result.success = self._handler.getSnapdealItems(args.offset, args.limit)
7577 
    oprot.writeMessageBegin("getSnapdealItems", TMessageType.REPLY, seqid)
7578 
    result.write(oprot)
7579 
    oprot.writeMessageEnd()
7580 
    oprot.trans.flush()
8739 vikram.rag 7581 
 
9242 kshitij.so 7582 
  def process_searchSnapdealItems(self, seqid, iprot, oprot):
7583 
    args = searchSnapdealItems_args()
7584 
    args.read(iprot)
7585 
    iprot.readMessageEnd()
7586 
    result = searchSnapdealItems_result()
7587 
    result.success = self._handler.searchSnapdealItems(args.searchTerm, args.offset, args.limit)
7588 
    oprot.writeMessageBegin("searchSnapdealItems", TMessageType.REPLY, seqid)
7589 
    result.write(oprot)
7590 
    oprot.writeMessageEnd()
7591 
    oprot.trans.flush()
7592 
 
7593 
  def process_getCountForSnapdealItems(self, seqid, iprot, oprot):
7594 
    args = getCountForSnapdealItems_args()
7595 
    args.read(iprot)
7596 
    iprot.readMessageEnd()
7597 
    result = getCountForSnapdealItems_result()
7598 
    result.success = self._handler.getCountForSnapdealItems()
7599 
    oprot.writeMessageBegin("getCountForSnapdealItems", TMessageType.REPLY, seqid)
7600 
    result.write(oprot)
7601 
    oprot.writeMessageEnd()
7602 
    oprot.trans.flush()
7603 
 
7604 
  def process_getSnapdealSearchResultCount(self, seqid, iprot, oprot):
7605 
    args = getSnapdealSearchResultCount_args()
7606 
    args.read(iprot)
7607 
    iprot.readMessageEnd()
7608 
    result = getSnapdealSearchResultCount_result()
7609 
    result.success = self._handler.getSnapdealSearchResultCount(args.searchTerm)
7610 
    oprot.writeMessageBegin("getSnapdealSearchResultCount", TMessageType.REPLY, seqid)
7611 
    result.write(oprot)
7612 
    oprot.writeMessageEnd()
7613 
    oprot.trans.flush()
7614 
 
9299 kshitij.so 7615 
  def process_getPrefferedInsurerForItem(self, seqid, iprot, oprot):
7616 
    args = getPrefferedInsurerForItem_args()
7617 
    args.read(iprot)
7618 
    iprot.readMessageEnd()
7619 
    result = getPrefferedInsurerForItem_result()
7620 
    result.success = self._handler.getPrefferedInsurerForItem(args.itemId, args.insurerType)
7621 
    oprot.writeMessageBegin("getPrefferedInsurerForItem", TMessageType.REPLY, seqid)
7622 
    result.write(oprot)
7623 
    oprot.writeMessageEnd()
7624 
    oprot.trans.flush()
9242 kshitij.so 7625 
 
9456 vikram.rag 7626 
  def process_getSnapdealItembySkuAtSnapdeal(self, seqid, iprot, oprot):
7627 
    args = getSnapdealItembySkuAtSnapdeal_args()
7628 
    args.read(iprot)
7629 
    iprot.readMessageEnd()
7630 
    result = getSnapdealItembySkuAtSnapdeal_result()
7631 
    result.success = self._handler.getSnapdealItembySkuAtSnapdeal(args.skuAtSnapdeal)
7632 
    oprot.writeMessageBegin("getSnapdealItembySkuAtSnapdeal", TMessageType.REPLY, seqid)
7633 
    result.write(oprot)
7634 
    oprot.writeMessageEnd()
7635 
    oprot.trans.flush()
9299 kshitij.so 7636 
 
9621 manish.sha 7637 
  def process_getProductFeedSubmit(self, seqid, iprot, oprot):
7638 
    args = getProductFeedSubmit_args()
7639 
    args.read(iprot)
7640 
    iprot.readMessageEnd()
7641 
    result = getProductFeedSubmit_result()
7642 
    try:
7643 
      result.success = self._handler.getProductFeedSubmit(args.catalogItemId)
7644 
    except CatalogServiceException, cex:
7645 
      result.cex = cex
7646 
    oprot.writeMessageBegin("getProductFeedSubmit", TMessageType.REPLY, seqid)
7647 
    result.write(oprot)
7648 
    oprot.writeMessageEnd()
7649 
    oprot.trans.flush()
9456 vikram.rag 7650 
 
9621 manish.sha 7651 
  def process_addProductFeedSubmit(self, seqid, iprot, oprot):
7652 
    args = addProductFeedSubmit_args()
7653 
    args.read(iprot)
7654 
    iprot.readMessageEnd()
7655 
    result = addProductFeedSubmit_result()
7656 
    try:
7657 
      result.success = self._handler.addProductFeedSubmit(args.productFeedSubmit)
7658 
    except CatalogServiceException, cex:
7659 
      result.cex = cex
7660 
    oprot.writeMessageBegin("addProductFeedSubmit", TMessageType.REPLY, seqid)
7661 
    result.write(oprot)
7662 
    oprot.writeMessageEnd()
7663 
    oprot.trans.flush()
7664 
 
7665 
  def process_updateProductFeedSubmit(self, seqid, iprot, oprot):
7666 
    args = updateProductFeedSubmit_args()
7667 
    args.read(iprot)
7668 
    iprot.readMessageEnd()
7669 
    result = updateProductFeedSubmit_result()
7670 
    try:
7671 
      result.success = self._handler.updateProductFeedSubmit(args.productFeedSubmit)
7672 
    except CatalogServiceException, cex:
7673 
      result.cex = cex
7674 
    oprot.writeMessageBegin("updateProductFeedSubmit", TMessageType.REPLY, seqid)
7675 
    result.write(oprot)
7676 
    oprot.writeMessageEnd()
7677 
    oprot.trans.flush()
7678 
 
7679 
  def process_deleteProductFeedSubmit(self, seqid, iprot, oprot):
7680 
    args = deleteProductFeedSubmit_args()
7681 
    args.read(iprot)
7682 
    iprot.readMessageEnd()
7683 
    result = deleteProductFeedSubmit_result()
7684 
    try:
7685 
      result.success = self._handler.deleteProductFeedSubmit(args.catalogItemId)
7686 
    except CatalogServiceException, cex:
7687 
      result.cex = cex
7688 
    oprot.writeMessageBegin("deleteProductFeedSubmit", TMessageType.REPLY, seqid)
7689 
    result.write(oprot)
7690 
    oprot.writeMessageEnd()
7691 
    oprot.trans.flush()
7692 
 
7693 
  def process_getAllProductFeedSubmit(self, seqid, iprot, oprot):
7694 
    args = getAllProductFeedSubmit_args()
7695 
    args.read(iprot)
7696 
    iprot.readMessageEnd()
7697 
    result = getAllProductFeedSubmit_result()
7698 
    try:
7699 
      result.success = self._handler.getAllProductFeedSubmit()
7700 
    except CatalogServiceException, cex:
7701 
      result.cex = cex
7702 
    oprot.writeMessageBegin("getAllProductFeedSubmit", TMessageType.REPLY, seqid)
7703 
    result.write(oprot)
7704 
    oprot.writeMessageEnd()
7705 
    oprot.trans.flush()
7706 
 
9724 kshitij.so 7707 
  def process_getMarketplacedetailsForItem(self, seqid, iprot, oprot):
7708 
    args = getMarketplacedetailsForItem_args()
7709 
    args.read(iprot)
7710 
    iprot.readMessageEnd()
7711 
    result = getMarketplacedetailsForItem_result()
7712 
    result.success = self._handler.getMarketplacedetailsForItem(args.itemId, args.sourceId)
7713 
    oprot.writeMessageBegin("getMarketplacedetailsForItem", TMessageType.REPLY, seqid)
7714 
    result.write(oprot)
7715 
    oprot.writeMessageEnd()
7716 
    oprot.trans.flush()
9621 manish.sha 7717 
 
9724 kshitij.so 7718 
  def process_updateMarketplaceAttributesForItem(self, seqid, iprot, oprot):
7719 
    args = updateMarketplaceAttributesForItem_args()
7720 
    args.read(iprot)
7721 
    iprot.readMessageEnd()
7722 
    result = updateMarketplaceAttributesForItem_result()
7723 
    result.success = self._handler.updateMarketplaceAttributesForItem(args.marketPlaceItem)
7724 
    oprot.writeMessageBegin("updateMarketplaceAttributesForItem", TMessageType.REPLY, seqid)
7725 
    result.write(oprot)
7726 
    oprot.writeMessageEnd()
7727 
    oprot.trans.flush()
7728 
 
9779 kshitij.so 7729 
  def process_getCostingForMarketplace(self, seqid, iprot, oprot):
7730 
    args = getCostingForMarketplace_args()
7731 
    args.read(iprot)
7732 
    iprot.readMessageEnd()
7733 
    result = getCostingForMarketplace_result()
7734 
    result.success = self._handler.getCostingForMarketplace(args.source, args.item_id)
7735 
    oprot.writeMessageBegin("getCostingForMarketplace", TMessageType.REPLY, seqid)
7736 
    result.write(oprot)
7737 
    oprot.writeMessageEnd()
7738 
    oprot.trans.flush()
7739 
 
9776 vikram.rag 7740 
  def process_getMarketPlaceItemsForPriceUpdate(self, seqid, iprot, oprot):
7741 
    args = getMarketPlaceItemsForPriceUpdate_args()
7742 
    args.read(iprot)
7743 
    iprot.readMessageEnd()
7744 
    result = getMarketPlaceItemsForPriceUpdate_result()
7745 
    result.success = self._handler.getMarketPlaceItemsForPriceUpdate(args.source)
7746 
    oprot.writeMessageBegin("getMarketPlaceItemsForPriceUpdate", TMessageType.REPLY, seqid)
7747 
    result.write(oprot)
7748 
    oprot.writeMessageEnd()
7749 
    oprot.trans.flush()
9724 kshitij.so 7750 
 
9776 vikram.rag 7751 
  def process_updateMarketPlacePriceUpdateStatus(self, seqid, iprot, oprot):
7752 
    args = updateMarketPlacePriceUpdateStatus_args()
7753 
    args.read(iprot)
7754 
    iprot.readMessageEnd()
7755 
    result = updateMarketPlacePriceUpdateStatus_result()
9816 kshitij.so 7756 
    self._handler.updateMarketPlacePriceUpdateStatus(args.skulist, args.timestamp, args.source)
9776 vikram.rag 7757 
    oprot.writeMessageBegin("updateMarketPlacePriceUpdateStatus", TMessageType.REPLY, seqid)
7758 
    result.write(oprot)
7759 
    oprot.writeMessageEnd()
7760 
    oprot.trans.flush()
7761 
 
9861 rajveer 7762 
  def process_updateItemHoldInventory(self, seqid, iprot, oprot):
7763 
    args = updateItemHoldInventory_args()
7764 
    args.read(iprot)
7765 
    iprot.readMessageEnd()
7766 
    result = updateItemHoldInventory_result()
7767 
    self._handler.updateItemHoldInventory(args.itemHoldMap)
7768 
    oprot.writeMessageBegin("updateItemHoldInventory", TMessageType.REPLY, seqid)
7769 
    result.write(oprot)
7770 
    oprot.writeMessageEnd()
7771 
    oprot.trans.flush()
9776 vikram.rag 7772 
 
9895 vikram.rag 7773 
  def process_updateNlcAtMarketplaces(self, seqid, iprot, oprot):
7774 
    args = updateNlcAtMarketplaces_args()
7775 
    args.read(iprot)
7776 
    iprot.readMessageEnd()
7777 
    result = updateNlcAtMarketplaces_result()
7778 
    self._handler.updateNlcAtMarketplaces(args.item_id, args.vendor_id, args.nlc)
7779 
    oprot.writeMessageBegin("updateNlcAtMarketplaces", TMessageType.REPLY, seqid)
7780 
    result.write(oprot)
7781 
    oprot.writeMessageEnd()
7782 
    oprot.trans.flush()
9861 rajveer 7783 
 
9945 vikram.rag 7784 
  def process_getAllFlipkartItems(self, seqid, iprot, oprot):
7785 
    args = getAllFlipkartItems_args()
7786 
    args.read(iprot)
7787 
    iprot.readMessageEnd()
7788 
    result = getAllFlipkartItems_result()
7789 
    result.success = self._handler.getAllFlipkartItems()
7790 
    oprot.writeMessageBegin("getAllFlipkartItems", TMessageType.REPLY, seqid)
7791 
    result.write(oprot)
7792 
    oprot.writeMessageEnd()
7793 
    oprot.trans.flush()
9895 vikram.rag 7794 
 
10097 kshitij.so 7795 
  def process_addOrUpdateFlipkartItem(self, seqid, iprot, oprot):
7796 
    args = addOrUpdateFlipkartItem_args()
7797 
    args.read(iprot)
7798 
    iprot.readMessageEnd()
7799 
    result = addOrUpdateFlipkartItem_result()
7800 
    result.success = self._handler.addOrUpdateFlipkartItem(args.flipkartitem)
7801 
    oprot.writeMessageBegin("addOrUpdateFlipkartItem", TMessageType.REPLY, seqid)
7802 
    result.write(oprot)
7803 
    oprot.writeMessageEnd()
7804 
    oprot.trans.flush()
9945 vikram.rag 7805 
 
10097 kshitij.so 7806 
  def process_getFlipkartItem(self, seqid, iprot, oprot):
7807 
    args = getFlipkartItem_args()
7808 
    args.read(iprot)
7809 
    iprot.readMessageEnd()
7810 
    result = getFlipkartItem_result()
7811 
    result.success = self._handler.getFlipkartItem(args.item_id)
7812 
    oprot.writeMessageBegin("getFlipkartItem", TMessageType.REPLY, seqid)
7813 
    result.write(oprot)
7814 
    oprot.writeMessageEnd()
7815 
    oprot.trans.flush()
7816 
 
7817 
  def process_getFlipkartItemDetails(self, seqid, iprot, oprot):
7818 
    args = getFlipkartItemDetails_args()
7819 
    args.read(iprot)
7820 
    iprot.readMessageEnd()
7821 
    result = getFlipkartItemDetails_result()
7822 
    result.success = self._handler.getFlipkartItemDetails(args.item_id)
7823 
    oprot.writeMessageBegin("getFlipkartItemDetails", TMessageType.REPLY, seqid)
7824 
    result.write(oprot)
7825 
    oprot.writeMessageEnd()
7826 
    oprot.trans.flush()
7827 
 
7828 
  def process_getFlipkartItems(self, seqid, iprot, oprot):
7829 
    args = getFlipkartItems_args()
7830 
    args.read(iprot)
7831 
    iprot.readMessageEnd()
7832 
    result = getFlipkartItems_result()
7833 
    result.success = self._handler.getFlipkartItems(args.offset, args.limit)
7834 
    oprot.writeMessageBegin("getFlipkartItems", TMessageType.REPLY, seqid)
7835 
    result.write(oprot)
7836 
    oprot.writeMessageEnd()
7837 
    oprot.trans.flush()
7838 
 
7839 
  def process_searchFlipkartItems(self, seqid, iprot, oprot):
7840 
    args = searchFlipkartItems_args()
7841 
    args.read(iprot)
7842 
    iprot.readMessageEnd()
7843 
    result = searchFlipkartItems_result()
7844 
    result.success = self._handler.searchFlipkartItems(args.searchTerm, args.offset, args.limit)
7845 
    oprot.writeMessageBegin("searchFlipkartItems", TMessageType.REPLY, seqid)
7846 
    result.write(oprot)
7847 
    oprot.writeMessageEnd()
7848 
    oprot.trans.flush()
7849 
 
7850 
  def process_getCountForFlipkartItems(self, seqid, iprot, oprot):
7851 
    args = getCountForFlipkartItems_args()
7852 
    args.read(iprot)
7853 
    iprot.readMessageEnd()
7854 
    result = getCountForFlipkartItems_result()
7855 
    result.success = self._handler.getCountForFlipkartItems()
7856 
    oprot.writeMessageBegin("getCountForFlipkartItems", TMessageType.REPLY, seqid)
7857 
    result.write(oprot)
7858 
    oprot.writeMessageEnd()
7859 
    oprot.trans.flush()
7860 
 
7861 
  def process_getFlipkartSearchResultCount(self, seqid, iprot, oprot):
7862 
    args = getFlipkartSearchResultCount_args()
7863 
    args.read(iprot)
7864 
    iprot.readMessageEnd()
7865 
    result = getFlipkartSearchResultCount_result()
7866 
    result.success = self._handler.getFlipkartSearchResultCount(args.searchTerm)
7867 
    oprot.writeMessageBegin("getFlipkartSearchResultCount", TMessageType.REPLY, seqid)
7868 
    result.write(oprot)
7869 
    oprot.writeMessageEnd()
7870 
    oprot.trans.flush()
7871 
 
7872 
  def process_getAllFkItems(self, seqid, iprot, oprot):
7873 
    args = getAllFkItems_args()
7874 
    args.read(iprot)
7875 
    iprot.readMessageEnd()
7876 
    result = getAllFkItems_result()
7877 
    result.success = self._handler.getAllFkItems()
7878 
    oprot.writeMessageBegin("getAllFkItems", TMessageType.REPLY, seqid)
7879 
    result.write(oprot)
7880 
    oprot.writeMessageEnd()
7881 
    oprot.trans.flush()
7882 
 
10140 vikram.rag 7883 
  def process_getFlipkartItemBySkyAtFlipkart(self, seqid, iprot, oprot):
7884 
    args = getFlipkartItemBySkyAtFlipkart_args()
7885 
    args.read(iprot)
7886 
    iprot.readMessageEnd()
7887 
    result = getFlipkartItemBySkyAtFlipkart_result()
7888 
    result.success = self._handler.getFlipkartItemBySkyAtFlipkart(args.sku)
7889 
    oprot.writeMessageBegin("getFlipkartItemBySkyAtFlipkart", TMessageType.REPLY, seqid)
7890 
    result.write(oprot)
7891 
    oprot.writeMessageEnd()
7892 
    oprot.trans.flush()
10097 kshitij.so 7893 
 
10909 vikram.rag 7894 
  def process_getAllFbbListedItems(self, seqid, iprot, oprot):
7895 
    args = getAllFbbListedItems_args()
7896 
    args.read(iprot)
7897 
    iprot.readMessageEnd()
7898 
    result = getAllFbbListedItems_result()
7899 
    result.success = self._handler.getAllFbbListedItems()
7900 
    oprot.writeMessageBegin("getAllFbbListedItems", TMessageType.REPLY, seqid)
7901 
    result.write(oprot)
7902 
    oprot.writeMessageEnd()
7903 
    oprot.trans.flush()
10140 vikram.rag 7904 
 
10924 vikram.rag 7905 
  def process_getAllFbbPricingItems(self, seqid, iprot, oprot):
7906 
    args = getAllFbbPricingItems_args()
7907 
    args.read(iprot)
7908 
    iprot.readMessageEnd()
7909 
    result = getAllFbbPricingItems_result()
7910 
    result.success = self._handler.getAllFbbPricingItems()
7911 
    oprot.writeMessageBegin("getAllFbbPricingItems", TMessageType.REPLY, seqid)
7912 
    result.write(oprot)
7913 
    oprot.writeMessageEnd()
7914 
    oprot.trans.flush()
10909 vikram.rag 7915 
 
10924 vikram.rag 7916 
 
5944 mandeep.dh 7917 
# HELPER FUNCTIONS AND STRUCTURES
7918 
 
7919 
class addItem_args:
7920 
  """
7921 
  Attributes:
7922 
   - item
7923 
  """
7924 
 
7925 
  thrift_spec = (
7926 
    None, # 0
7927 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
7928 
  )
7929 
 
7930 
  def __init__(self, item=None,):
7931 
    self.item = item
7932 
 
7933 
  def read(self, iprot):
7934 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7935 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7936 
      return
7937 
    iprot.readStructBegin()
7938 
    while True:
7939 
      (fname, ftype, fid) = iprot.readFieldBegin()
7940 
      if ftype == TType.STOP:
7941 
        break
7942 
      if fid == 1:
7943 
        if ftype == TType.STRUCT:
7944 
          self.item = Item()
7945 
          self.item.read(iprot)
7946 
        else:
7947 
          iprot.skip(ftype)
7948 
      else:
7949 
        iprot.skip(ftype)
7950 
      iprot.readFieldEnd()
7951 
    iprot.readStructEnd()
7952 
 
7953 
  def write(self, oprot):
7954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7956 
      return
7957 
    oprot.writeStructBegin('addItem_args')
7958 
    if self.item is not None:
7959 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
7960 
      self.item.write(oprot)
7961 
      oprot.writeFieldEnd()
7962 
    oprot.writeFieldStop()
7963 
    oprot.writeStructEnd()
7964 
 
7965 
  def validate(self):
7966 
    return
7967 
 
7968 
 
7969 
  def __repr__(self):
7970 
    L = ['%s=%r' % (key, value)
7971 
      for key, value in self.__dict__.iteritems()]
7972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7973 
 
7974 
  def __eq__(self, other):
7975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7976 
 
7977 
  def __ne__(self, other):
7978 
    return not (self == other)
7979 
 
7980 
class addItem_result:
7981 
  """
7982 
  Attributes:
7983 
   - success
7984 
   - cex
7985 
  """
7986 
 
7987 
  thrift_spec = (
7988 
    (0, TType.I64, 'success', None, None, ), # 0
7989 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7990 
  )
7991 
 
7992 
  def __init__(self, success=None, cex=None,):
7993 
    self.success = success
7994 
    self.cex = cex
7995 
 
7996 
  def read(self, iprot):
7997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7999 
      return
8000 
    iprot.readStructBegin()
8001 
    while True:
8002 
      (fname, ftype, fid) = iprot.readFieldBegin()
8003 
      if ftype == TType.STOP:
8004 
        break
8005 
      if fid == 0:
8006 
        if ftype == TType.I64:
8007 
          self.success = iprot.readI64();
8008 
        else:
8009 
          iprot.skip(ftype)
8010 
      elif fid == 1:
8011 
        if ftype == TType.STRUCT:
8012 
          self.cex = CatalogServiceException()
8013 
          self.cex.read(iprot)
8014 
        else:
8015 
          iprot.skip(ftype)
8016 
      else:
8017 
        iprot.skip(ftype)
8018 
      iprot.readFieldEnd()
8019 
    iprot.readStructEnd()
8020 
 
8021 
  def write(self, oprot):
8022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8024 
      return
8025 
    oprot.writeStructBegin('addItem_result')
8026 
    if self.success is not None:
8027 
      oprot.writeFieldBegin('success', TType.I64, 0)
8028 
      oprot.writeI64(self.success)
8029 
      oprot.writeFieldEnd()
8030 
    if self.cex is not None:
8031 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8032 
      self.cex.write(oprot)
8033 
      oprot.writeFieldEnd()
8034 
    oprot.writeFieldStop()
8035 
    oprot.writeStructEnd()
8036 
 
8037 
  def validate(self):
8038 
    return
8039 
 
8040 
 
8041 
  def __repr__(self):
8042 
    L = ['%s=%r' % (key, value)
8043 
      for key, value in self.__dict__.iteritems()]
8044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8045 
 
8046 
  def __eq__(self, other):
8047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8048 
 
8049 
  def __ne__(self, other):
8050 
    return not (self == other)
8051 
 
8052 
class updateItem_args:
8053 
  """
8054 
  Attributes:
8055 
   - item
8056 
  """
8057 
 
8058 
  thrift_spec = (
8059 
    None, # 0
8060 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
8061 
  )
8062 
 
8063 
  def __init__(self, item=None,):
8064 
    self.item = item
8065 
 
8066 
  def read(self, iprot):
8067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8069 
      return
8070 
    iprot.readStructBegin()
8071 
    while True:
8072 
      (fname, ftype, fid) = iprot.readFieldBegin()
8073 
      if ftype == TType.STOP:
8074 
        break
8075 
      if fid == 1:
8076 
        if ftype == TType.STRUCT:
8077 
          self.item = Item()
8078 
          self.item.read(iprot)
8079 
        else:
8080 
          iprot.skip(ftype)
8081 
      else:
8082 
        iprot.skip(ftype)
8083 
      iprot.readFieldEnd()
8084 
    iprot.readStructEnd()
8085 
 
8086 
  def write(self, oprot):
8087 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8088 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8089 
      return
8090 
    oprot.writeStructBegin('updateItem_args')
8091 
    if self.item is not None:
8092 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
8093 
      self.item.write(oprot)
8094 
      oprot.writeFieldEnd()
8095 
    oprot.writeFieldStop()
8096 
    oprot.writeStructEnd()
8097 
 
8098 
  def validate(self):
8099 
    return
8100 
 
8101 
 
8102 
  def __repr__(self):
8103 
    L = ['%s=%r' % (key, value)
8104 
      for key, value in self.__dict__.iteritems()]
8105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8106 
 
8107 
  def __eq__(self, other):
8108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8109 
 
8110 
  def __ne__(self, other):
8111 
    return not (self == other)
8112 
 
8113 
class updateItem_result:
8114 
  """
8115 
  Attributes:
8116 
   - success
8117 
   - cex
8118 
  """
8119 
 
8120 
  thrift_spec = (
8121 
    (0, TType.I64, 'success', None, None, ), # 0
8122 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8123 
  )
8124 
 
8125 
  def __init__(self, success=None, cex=None,):
8126 
    self.success = success
8127 
    self.cex = cex
8128 
 
8129 
  def read(self, iprot):
8130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8132 
      return
8133 
    iprot.readStructBegin()
8134 
    while True:
8135 
      (fname, ftype, fid) = iprot.readFieldBegin()
8136 
      if ftype == TType.STOP:
8137 
        break
8138 
      if fid == 0:
8139 
        if ftype == TType.I64:
8140 
          self.success = iprot.readI64();
8141 
        else:
8142 
          iprot.skip(ftype)
8143 
      elif fid == 1:
8144 
        if ftype == TType.STRUCT:
8145 
          self.cex = CatalogServiceException()
8146 
          self.cex.read(iprot)
8147 
        else:
8148 
          iprot.skip(ftype)
8149 
      else:
8150 
        iprot.skip(ftype)
8151 
      iprot.readFieldEnd()
8152 
    iprot.readStructEnd()
8153 
 
8154 
  def write(self, oprot):
8155 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8156 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8157 
      return
8158 
    oprot.writeStructBegin('updateItem_result')
8159 
    if self.success is not None:
8160 
      oprot.writeFieldBegin('success', TType.I64, 0)
8161 
      oprot.writeI64(self.success)
8162 
      oprot.writeFieldEnd()
8163 
    if self.cex is not None:
8164 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8165 
      self.cex.write(oprot)
8166 
      oprot.writeFieldEnd()
8167 
    oprot.writeFieldStop()
8168 
    oprot.writeStructEnd()
8169 
 
8170 
  def validate(self):
8171 
    return
8172 
 
8173 
 
8174 
  def __repr__(self):
8175 
    L = ['%s=%r' % (key, value)
8176 
      for key, value in self.__dict__.iteritems()]
8177 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8178 
 
8179 
  def __eq__(self, other):
8180 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8181 
 
8182 
  def __ne__(self, other):
8183 
    return not (self == other)
8184 
 
8185 
class isActive_args:
8186 
  """
8187 
  Attributes:
8188 
   - itemId
8189 
  """
8190 
 
8191 
  thrift_spec = (
8192 
    None, # 0
8193 
    (1, TType.I64, 'itemId', None, None, ), # 1
8194 
  )
8195 
 
8196 
  def __init__(self, itemId=None,):
8197 
    self.itemId = itemId
8198 
 
8199 
  def read(self, iprot):
8200 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8201 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8202 
      return
8203 
    iprot.readStructBegin()
8204 
    while True:
8205 
      (fname, ftype, fid) = iprot.readFieldBegin()
8206 
      if ftype == TType.STOP:
8207 
        break
8208 
      if fid == 1:
8209 
        if ftype == TType.I64:
8210 
          self.itemId = iprot.readI64();
8211 
        else:
8212 
          iprot.skip(ftype)
8213 
      else:
8214 
        iprot.skip(ftype)
8215 
      iprot.readFieldEnd()
8216 
    iprot.readStructEnd()
8217 
 
8218 
  def write(self, oprot):
8219 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8220 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8221 
      return
8222 
    oprot.writeStructBegin('isActive_args')
8223 
    if self.itemId is not None:
8224 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
8225 
      oprot.writeI64(self.itemId)
8226 
      oprot.writeFieldEnd()
8227 
    oprot.writeFieldStop()
8228 
    oprot.writeStructEnd()
8229 
 
8230 
  def validate(self):
8231 
    return
8232 
 
8233 
 
8234 
  def __repr__(self):
8235 
    L = ['%s=%r' % (key, value)
8236 
      for key, value in self.__dict__.iteritems()]
8237 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8238 
 
8239 
  def __eq__(self, other):
8240 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8241 
 
8242 
  def __ne__(self, other):
8243 
    return not (self == other)
8244 
 
8245 
class isActive_result:
8246 
  """
8247 
  Attributes:
8248 
   - success
8249 
   - isex
8250 
  """
8251 
 
8252 
  thrift_spec = (
8253 
    (0, TType.STRUCT, 'success', (ItemShippingInfo, ItemShippingInfo.thrift_spec), None, ), # 0
8254 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8255 
  )
8256 
 
8257 
  def __init__(self, success=None, isex=None,):
8258 
    self.success = success
8259 
    self.isex = isex
8260 
 
8261 
  def read(self, iprot):
8262 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8263 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8264 
      return
8265 
    iprot.readStructBegin()
8266 
    while True:
8267 
      (fname, ftype, fid) = iprot.readFieldBegin()
8268 
      if ftype == TType.STOP:
8269 
        break
8270 
      if fid == 0:
8271 
        if ftype == TType.STRUCT:
8272 
          self.success = ItemShippingInfo()
8273 
          self.success.read(iprot)
8274 
        else:
8275 
          iprot.skip(ftype)
8276 
      elif fid == 1:
8277 
        if ftype == TType.STRUCT:
8278 
          self.isex = CatalogServiceException()
8279 
          self.isex.read(iprot)
8280 
        else:
8281 
          iprot.skip(ftype)
8282 
      else:
8283 
        iprot.skip(ftype)
8284 
      iprot.readFieldEnd()
8285 
    iprot.readStructEnd()
8286 
 
8287 
  def write(self, oprot):
8288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8290 
      return
8291 
    oprot.writeStructBegin('isActive_result')
8292 
    if self.success is not None:
8293 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8294 
      self.success.write(oprot)
8295 
      oprot.writeFieldEnd()
8296 
    if self.isex is not None:
8297 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8298 
      self.isex.write(oprot)
8299 
      oprot.writeFieldEnd()
8300 
    oprot.writeFieldStop()
8301 
    oprot.writeStructEnd()
8302 
 
8303 
  def validate(self):
8304 
    return
8305 
 
8306 
 
8307 
  def __repr__(self):
8308 
    L = ['%s=%r' % (key, value)
8309 
      for key, value in self.__dict__.iteritems()]
8310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8311 
 
8312 
  def __eq__(self, other):
8313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8314 
 
8315 
  def __ne__(self, other):
8316 
    return not (self == other)
8317 
 
7438 amit.gupta 8318 
class getItemsStatus_args:
8319 
  """
8320 
  Attributes:
8321 
   - itemIds
8322 
  """
8323 
 
8324 
  thrift_spec = (
8325 
    None, # 0
8326 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
8327 
  )
8328 
 
8329 
  def __init__(self, itemIds=None,):
8330 
    self.itemIds = itemIds
8331 
 
8332 
  def read(self, iprot):
8333 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8334 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8335 
      return
8336 
    iprot.readStructBegin()
8337 
    while True:
8338 
      (fname, ftype, fid) = iprot.readFieldBegin()
8339 
      if ftype == TType.STOP:
8340 
        break
8341 
      if fid == 1:
8342 
        if ftype == TType.LIST:
8343 
          self.itemIds = []
8590 kshitij.so 8344 
          (_etype33, _size30) = iprot.readListBegin()
8345 
          for _i34 in xrange(_size30):
8346 
            _elem35 = iprot.readI64();
8347 
            self.itemIds.append(_elem35)
7438 amit.gupta 8348 
          iprot.readListEnd()
8349 
        else:
8350 
          iprot.skip(ftype)
8351 
      else:
8352 
        iprot.skip(ftype)
8353 
      iprot.readFieldEnd()
8354 
    iprot.readStructEnd()
8355 
 
8356 
  def write(self, oprot):
8357 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8358 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8359 
      return
8360 
    oprot.writeStructBegin('getItemsStatus_args')
8361 
    if self.itemIds is not None:
8362 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
8363 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
8590 kshitij.so 8364 
      for iter36 in self.itemIds:
8365 
        oprot.writeI64(iter36)
7438 amit.gupta 8366 
      oprot.writeListEnd()
8367 
      oprot.writeFieldEnd()
8368 
    oprot.writeFieldStop()
8369 
    oprot.writeStructEnd()
8370 
 
8371 
  def validate(self):
8372 
    return
8373 
 
8374 
 
8375 
  def __repr__(self):
8376 
    L = ['%s=%r' % (key, value)
8377 
      for key, value in self.__dict__.iteritems()]
8378 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8379 
 
8380 
  def __eq__(self, other):
8381 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8382 
 
8383 
  def __ne__(self, other):
8384 
    return not (self == other)
8385 
 
8386 
class getItemsStatus_result:
8387 
  """
8388 
  Attributes:
8389 
   - success
8390 
   - isex
8391 
  """
8392 
 
8393 
  thrift_spec = (
8394 
    (0, TType.MAP, 'success', (TType.I64,None,TType.BOOL,None), None, ), # 0
8395 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8396 
  )
8397 
 
8398 
  def __init__(self, success=None, isex=None,):
8399 
    self.success = success
8400 
    self.isex = isex
8401 
 
8402 
  def read(self, iprot):
8403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8405 
      return
8406 
    iprot.readStructBegin()
8407 
    while True:
8408 
      (fname, ftype, fid) = iprot.readFieldBegin()
8409 
      if ftype == TType.STOP:
8410 
        break
8411 
      if fid == 0:
8412 
        if ftype == TType.MAP:
8413 
          self.success = {}
8590 kshitij.so 8414 
          (_ktype38, _vtype39, _size37 ) = iprot.readMapBegin()
8415 
          for _i41 in xrange(_size37):
8416 
            _key42 = iprot.readI64();
8417 
            _val43 = iprot.readBool();
8418 
            self.success[_key42] = _val43
7438 amit.gupta 8419 
          iprot.readMapEnd()
8420 
        else:
8421 
          iprot.skip(ftype)
8422 
      elif fid == 1:
8423 
        if ftype == TType.STRUCT:
8424 
          self.isex = CatalogServiceException()
8425 
          self.isex.read(iprot)
8426 
        else:
8427 
          iprot.skip(ftype)
8428 
      else:
8429 
        iprot.skip(ftype)
8430 
      iprot.readFieldEnd()
8431 
    iprot.readStructEnd()
8432 
 
8433 
  def write(self, oprot):
8434 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8435 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8436 
      return
8437 
    oprot.writeStructBegin('getItemsStatus_result')
8438 
    if self.success is not None:
8439 
      oprot.writeFieldBegin('success', TType.MAP, 0)
8440 
      oprot.writeMapBegin(TType.I64, TType.BOOL, len(self.success))
8590 kshitij.so 8441 
      for kiter44,viter45 in self.success.items():
8442 
        oprot.writeI64(kiter44)
8443 
        oprot.writeBool(viter45)
7438 amit.gupta 8444 
      oprot.writeMapEnd()
8445 
      oprot.writeFieldEnd()
8446 
    if self.isex is not None:
8447 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8448 
      self.isex.write(oprot)
8449 
      oprot.writeFieldEnd()
8450 
    oprot.writeFieldStop()
8451 
    oprot.writeStructEnd()
8452 
 
8453 
  def validate(self):
8454 
    return
8455 
 
8456 
 
8457 
  def __repr__(self):
8458 
    L = ['%s=%r' % (key, value)
8459 
      for key, value in self.__dict__.iteritems()]
8460 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8461 
 
8462 
  def __eq__(self, other):
8463 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8464 
 
8465 
  def __ne__(self, other):
8466 
    return not (self == other)
8467 
 
5944 mandeep.dh 8468 
class getItemStatusDescription_args:
8469 
  """
8470 
  Attributes:
8471 
   - itemId
8472 
  """
8473 
 
8474 
  thrift_spec = (
8475 
    None, # 0
8476 
    (1, TType.I64, 'itemId', None, None, ), # 1
8477 
  )
8478 
 
8479 
  def __init__(self, itemId=None,):
8480 
    self.itemId = itemId
8481 
 
8482 
  def read(self, iprot):
8483 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8484 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8485 
      return
8486 
    iprot.readStructBegin()
8487 
    while True:
8488 
      (fname, ftype, fid) = iprot.readFieldBegin()
8489 
      if ftype == TType.STOP:
8490 
        break
8491 
      if fid == 1:
8492 
        if ftype == TType.I64:
8493 
          self.itemId = iprot.readI64();
8494 
        else:
8495 
          iprot.skip(ftype)
8496 
      else:
8497 
        iprot.skip(ftype)
8498 
      iprot.readFieldEnd()
8499 
    iprot.readStructEnd()
8500 
 
8501 
  def write(self, oprot):
8502 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8503 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8504 
      return
8505 
    oprot.writeStructBegin('getItemStatusDescription_args')
8506 
    if self.itemId is not None:
8507 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
8508 
      oprot.writeI64(self.itemId)
8509 
      oprot.writeFieldEnd()
8510 
    oprot.writeFieldStop()
8511 
    oprot.writeStructEnd()
8512 
 
8513 
  def validate(self):
8514 
    return
8515 
 
8516 
 
8517 
  def __repr__(self):
8518 
    L = ['%s=%r' % (key, value)
8519 
      for key, value in self.__dict__.iteritems()]
8520 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8521 
 
8522 
  def __eq__(self, other):
8523 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8524 
 
8525 
  def __ne__(self, other):
8526 
    return not (self == other)
8527 
 
8528 
class getItemStatusDescription_result:
8529 
  """
8530 
  Attributes:
8531 
   - success
8532 
   - isex
8533 
  """
8534 
 
8535 
  thrift_spec = (
8536 
    (0, TType.STRING, 'success', None, None, ), # 0
8537 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8538 
  )
8539 
 
8540 
  def __init__(self, success=None, isex=None,):
8541 
    self.success = success
8542 
    self.isex = isex
8543 
 
8544 
  def read(self, iprot):
8545 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8546 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8547 
      return
8548 
    iprot.readStructBegin()
8549 
    while True:
8550 
      (fname, ftype, fid) = iprot.readFieldBegin()
8551 
      if ftype == TType.STOP:
8552 
        break
8553 
      if fid == 0:
8554 
        if ftype == TType.STRING:
8555 
          self.success = iprot.readString();
8556 
        else:
8557 
          iprot.skip(ftype)
8558 
      elif fid == 1:
8559 
        if ftype == TType.STRUCT:
8560 
          self.isex = CatalogServiceException()
8561 
          self.isex.read(iprot)
8562 
        else:
8563 
          iprot.skip(ftype)
8564 
      else:
8565 
        iprot.skip(ftype)
8566 
      iprot.readFieldEnd()
8567 
    iprot.readStructEnd()
8568 
 
8569 
  def write(self, oprot):
8570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8572 
      return
8573 
    oprot.writeStructBegin('getItemStatusDescription_result')
8574 
    if self.success is not None:
8575 
      oprot.writeFieldBegin('success', TType.STRING, 0)
8576 
      oprot.writeString(self.success)
8577 
      oprot.writeFieldEnd()
8578 
    if self.isex is not None:
8579 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8580 
      self.isex.write(oprot)
8581 
      oprot.writeFieldEnd()
8582 
    oprot.writeFieldStop()
8583 
    oprot.writeStructEnd()
8584 
 
8585 
  def validate(self):
8586 
    return
8587 
 
8588 
 
8589 
  def __repr__(self):
8590 
    L = ['%s=%r' % (key, value)
8591 
      for key, value in self.__dict__.iteritems()]
8592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8593 
 
8594 
  def __eq__(self, other):
8595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8596 
 
8597 
  def __ne__(self, other):
8598 
    return not (self == other)
8599 
 
8600 
class startItemOn_args:
8601 
  """
8602 
  Attributes:
8603 
   - item_id
8604 
   - timestamp
8605 
  """
8606 
 
8607 
  thrift_spec = (
8608 
    None, # 0
8609 
    (1, TType.I64, 'item_id', None, None, ), # 1
8610 
    (2, TType.I64, 'timestamp', None, None, ), # 2
8611 
  )
8612 
 
8613 
  def __init__(self, item_id=None, timestamp=None,):
8614 
    self.item_id = item_id
8615 
    self.timestamp = timestamp
8616 
 
8617 
  def read(self, iprot):
8618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8620 
      return
8621 
    iprot.readStructBegin()
8622 
    while True:
8623 
      (fname, ftype, fid) = iprot.readFieldBegin()
8624 
      if ftype == TType.STOP:
8625 
        break
8626 
      if fid == 1:
8627 
        if ftype == TType.I64:
8628 
          self.item_id = iprot.readI64();
8629 
        else:
8630 
          iprot.skip(ftype)
8631 
      elif fid == 2:
8632 
        if ftype == TType.I64:
8633 
          self.timestamp = iprot.readI64();
8634 
        else:
8635 
          iprot.skip(ftype)
8636 
      else:
8637 
        iprot.skip(ftype)
8638 
      iprot.readFieldEnd()
8639 
    iprot.readStructEnd()
8640 
 
8641 
  def write(self, oprot):
8642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8644 
      return
8645 
    oprot.writeStructBegin('startItemOn_args')
8646 
    if self.item_id is not None:
8647 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
8648 
      oprot.writeI64(self.item_id)
8649 
      oprot.writeFieldEnd()
8650 
    if self.timestamp is not None:
8651 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
8652 
      oprot.writeI64(self.timestamp)
8653 
      oprot.writeFieldEnd()
8654 
    oprot.writeFieldStop()
8655 
    oprot.writeStructEnd()
8656 
 
8657 
  def validate(self):
8658 
    return
8659 
 
8660 
 
8661 
  def __repr__(self):
8662 
    L = ['%s=%r' % (key, value)
8663 
      for key, value in self.__dict__.iteritems()]
8664 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8665 
 
8666 
  def __eq__(self, other):
8667 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8668 
 
8669 
  def __ne__(self, other):
8670 
    return not (self == other)
8671 
 
8672 
class startItemOn_result:
8673 
  """
8674 
  Attributes:
8675 
   - cex
8676 
  """
8677 
 
8678 
  thrift_spec = (
8679 
    None, # 0
8680 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8681 
  )
8682 
 
8683 
  def __init__(self, cex=None,):
8684 
    self.cex = cex
8685 
 
8686 
  def read(self, iprot):
8687 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8688 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8689 
      return
8690 
    iprot.readStructBegin()
8691 
    while True:
8692 
      (fname, ftype, fid) = iprot.readFieldBegin()
8693 
      if ftype == TType.STOP:
8694 
        break
8695 
      if fid == 1:
8696 
        if ftype == TType.STRUCT:
8697 
          self.cex = CatalogServiceException()
8698 
          self.cex.read(iprot)
8699 
        else:
8700 
          iprot.skip(ftype)
8701 
      else:
8702 
        iprot.skip(ftype)
8703 
      iprot.readFieldEnd()
8704 
    iprot.readStructEnd()
8705 
 
8706 
  def write(self, oprot):
8707 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8708 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8709 
      return
8710 
    oprot.writeStructBegin('startItemOn_result')
8711 
    if self.cex is not None:
8712 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8713 
      self.cex.write(oprot)
8714 
      oprot.writeFieldEnd()
8715 
    oprot.writeFieldStop()
8716 
    oprot.writeStructEnd()
8717 
 
8718 
  def validate(self):
8719 
    return
8720 
 
8721 
 
8722 
  def __repr__(self):
8723 
    L = ['%s=%r' % (key, value)
8724 
      for key, value in self.__dict__.iteritems()]
8725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8726 
 
8727 
  def __eq__(self, other):
8728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8729 
 
8730 
  def __ne__(self, other):
8731 
    return not (self == other)
8732 
 
8733 
class retireItemOn_args:
8734 
  """
8735 
  Attributes:
8736 
   - item_id
8737 
   - timestamp
8738 
  """
8739 
 
8740 
  thrift_spec = (
8741 
    None, # 0
8742 
    (1, TType.I64, 'item_id', None, None, ), # 1
8743 
    (2, TType.I64, 'timestamp', None, None, ), # 2
8744 
  )
8745 
 
8746 
  def __init__(self, item_id=None, timestamp=None,):
8747 
    self.item_id = item_id
8748 
    self.timestamp = timestamp
8749 
 
8750 
  def read(self, iprot):
8751 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8752 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8753 
      return
8754 
    iprot.readStructBegin()
8755 
    while True:
8756 
      (fname, ftype, fid) = iprot.readFieldBegin()
8757 
      if ftype == TType.STOP:
8758 
        break
8759 
      if fid == 1:
8760 
        if ftype == TType.I64:
8761 
          self.item_id = iprot.readI64();
8762 
        else:
8763 
          iprot.skip(ftype)
8764 
      elif fid == 2:
8765 
        if ftype == TType.I64:
8766 
          self.timestamp = iprot.readI64();
8767 
        else:
8768 
          iprot.skip(ftype)
8769 
      else:
8770 
        iprot.skip(ftype)
8771 
      iprot.readFieldEnd()
8772 
    iprot.readStructEnd()
8773 
 
8774 
  def write(self, oprot):
8775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8777 
      return
8778 
    oprot.writeStructBegin('retireItemOn_args')
8779 
    if self.item_id is not None:
8780 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
8781 
      oprot.writeI64(self.item_id)
8782 
      oprot.writeFieldEnd()
8783 
    if self.timestamp is not None:
8784 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
8785 
      oprot.writeI64(self.timestamp)
8786 
      oprot.writeFieldEnd()
8787 
    oprot.writeFieldStop()
8788 
    oprot.writeStructEnd()
8789 
 
8790 
  def validate(self):
8791 
    return
8792 
 
8793 
 
8794 
  def __repr__(self):
8795 
    L = ['%s=%r' % (key, value)
8796 
      for key, value in self.__dict__.iteritems()]
8797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8798 
 
8799 
  def __eq__(self, other):
8800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8801 
 
8802 
  def __ne__(self, other):
8803 
    return not (self == other)
8804 
 
8805 
class retireItemOn_result:
8806 
  """
8807 
  Attributes:
8808 
   - cex
8809 
  """
8810 
 
8811 
  thrift_spec = (
8812 
    None, # 0
8813 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8814 
  )
8815 
 
8816 
  def __init__(self, cex=None,):
8817 
    self.cex = cex
8818 
 
8819 
  def read(self, iprot):
8820 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8821 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8822 
      return
8823 
    iprot.readStructBegin()
8824 
    while True:
8825 
      (fname, ftype, fid) = iprot.readFieldBegin()
8826 
      if ftype == TType.STOP:
8827 
        break
8828 
      if fid == 1:
8829 
        if ftype == TType.STRUCT:
8830 
          self.cex = CatalogServiceException()
8831 
          self.cex.read(iprot)
8832 
        else:
8833 
          iprot.skip(ftype)
8834 
      else:
8835 
        iprot.skip(ftype)
8836 
      iprot.readFieldEnd()
8837 
    iprot.readStructEnd()
8838 
 
8839 
  def write(self, oprot):
8840 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8841 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8842 
      return
8843 
    oprot.writeStructBegin('retireItemOn_result')
8844 
    if self.cex is not None:
8845 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8846 
      self.cex.write(oprot)
8847 
      oprot.writeFieldEnd()
8848 
    oprot.writeFieldStop()
8849 
    oprot.writeStructEnd()
8850 
 
8851 
  def validate(self):
8852 
    return
8853 
 
8854 
 
8855 
  def __repr__(self):
8856 
    L = ['%s=%r' % (key, value)
8857 
      for key, value in self.__dict__.iteritems()]
8858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8859 
 
8860 
  def __eq__(self, other):
8861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8862 
 
8863 
  def __ne__(self, other):
8864 
    return not (self == other)
8865 
 
8866 
class changeItemStatus_args:
8867 
  """
8868 
  Attributes:
8869 
   - item_id
8870 
   - timestamp
8871 
   - newstatus
8872 
  """
8873 
 
8874 
  thrift_spec = (
8875 
    None, # 0
8876 
    (1, TType.I64, 'item_id', None, None, ), # 1
8877 
    (2, TType.I64, 'timestamp', None, None, ), # 2
8878 
    (3, TType.I32, 'newstatus', None, None, ), # 3
8879 
  )
8880 
 
8881 
  def __init__(self, item_id=None, timestamp=None, newstatus=None,):
8882 
    self.item_id = item_id
8883 
    self.timestamp = timestamp
8884 
    self.newstatus = newstatus
8885 
 
8886 
  def read(self, iprot):
8887 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8888 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8889 
      return
8890 
    iprot.readStructBegin()
8891 
    while True:
8892 
      (fname, ftype, fid) = iprot.readFieldBegin()
8893 
      if ftype == TType.STOP:
8894 
        break
8895 
      if fid == 1:
8896 
        if ftype == TType.I64:
8897 
          self.item_id = iprot.readI64();
8898 
        else:
8899 
          iprot.skip(ftype)
8900 
      elif fid == 2:
8901 
        if ftype == TType.I64:
8902 
          self.timestamp = iprot.readI64();
8903 
        else:
8904 
          iprot.skip(ftype)
8905 
      elif fid == 3:
8906 
        if ftype == TType.I32:
8907 
          self.newstatus = iprot.readI32();
8908 
        else:
8909 
          iprot.skip(ftype)
8910 
      else:
8911 
        iprot.skip(ftype)
8912 
      iprot.readFieldEnd()
8913 
    iprot.readStructEnd()
8914 
 
8915 
  def write(self, oprot):
8916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8918 
      return
8919 
    oprot.writeStructBegin('changeItemStatus_args')
8920 
    if self.item_id is not None:
8921 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
8922 
      oprot.writeI64(self.item_id)
8923 
      oprot.writeFieldEnd()
8924 
    if self.timestamp is not None:
8925 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
8926 
      oprot.writeI64(self.timestamp)
8927 
      oprot.writeFieldEnd()
8928 
    if self.newstatus is not None:
8929 
      oprot.writeFieldBegin('newstatus', TType.I32, 3)
8930 
      oprot.writeI32(self.newstatus)
8931 
      oprot.writeFieldEnd()
8932 
    oprot.writeFieldStop()
8933 
    oprot.writeStructEnd()
8934 
 
8935 
  def validate(self):
8936 
    return
8937 
 
8938 
 
8939 
  def __repr__(self):
8940 
    L = ['%s=%r' % (key, value)
8941 
      for key, value in self.__dict__.iteritems()]
8942 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8943 
 
8944 
  def __eq__(self, other):
8945 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8946 
 
8947 
  def __ne__(self, other):
8948 
    return not (self == other)
8949 
 
8950 
class changeItemStatus_result:
8951 
  """
8952 
  Attributes:
8953 
   - cex
8954 
  """
8955 
 
8956 
  thrift_spec = (
8957 
    None, # 0
8958 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8959 
  )
8960 
 
8961 
  def __init__(self, cex=None,):
8962 
    self.cex = cex
8963 
 
8964 
  def read(self, iprot):
8965 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8966 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8967 
      return
8968 
    iprot.readStructBegin()
8969 
    while True:
8970 
      (fname, ftype, fid) = iprot.readFieldBegin()
8971 
      if ftype == TType.STOP:
8972 
        break
8973 
      if fid == 1:
8974 
        if ftype == TType.STRUCT:
8975 
          self.cex = CatalogServiceException()
8976 
          self.cex.read(iprot)
8977 
        else:
8978 
          iprot.skip(ftype)
8979 
      else:
8980 
        iprot.skip(ftype)
8981 
      iprot.readFieldEnd()
8982 
    iprot.readStructEnd()
8983 
 
8984 
  def write(self, oprot):
8985 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8986 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8987 
      return
8988 
    oprot.writeStructBegin('changeItemStatus_result')
8989 
    if self.cex is not None:
8990 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8991 
      self.cex.write(oprot)
8992 
      oprot.writeFieldEnd()
8993 
    oprot.writeFieldStop()
8994 
    oprot.writeStructEnd()
8995 
 
8996 
  def validate(self):
8997 
    return
8998 
 
8999 
 
9000 
  def __repr__(self):
9001 
    L = ['%s=%r' % (key, value)
9002 
      for key, value in self.__dict__.iteritems()]
9003 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9004 
 
9005 
  def __eq__(self, other):
9006 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9007 
 
9008 
  def __ne__(self, other):
9009 
    return not (self == other)
9010 
 
9011 
class getItem_args:
9012 
  """
9013 
  Attributes:
9014 
   - item_id
9015 
  """
9016 
 
9017 
  thrift_spec = (
9018 
    None, # 0
9019 
    (1, TType.I64, 'item_id', None, None, ), # 1
9020 
  )
9021 
 
9022 
  def __init__(self, item_id=None,):
9023 
    self.item_id = item_id
9024 
 
9025 
  def read(self, iprot):
9026 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9027 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9028 
      return
9029 
    iprot.readStructBegin()
9030 
    while True:
9031 
      (fname, ftype, fid) = iprot.readFieldBegin()
9032 
      if ftype == TType.STOP:
9033 
        break
9034 
      if fid == 1:
9035 
        if ftype == TType.I64:
9036 
          self.item_id = iprot.readI64();
9037 
        else:
9038 
          iprot.skip(ftype)
9039 
      else:
9040 
        iprot.skip(ftype)
9041 
      iprot.readFieldEnd()
9042 
    iprot.readStructEnd()
9043 
 
9044 
  def write(self, oprot):
9045 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9046 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9047 
      return
9048 
    oprot.writeStructBegin('getItem_args')
9049 
    if self.item_id is not None:
9050 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
9051 
      oprot.writeI64(self.item_id)
9052 
      oprot.writeFieldEnd()
9053 
    oprot.writeFieldStop()
9054 
    oprot.writeStructEnd()
9055 
 
9056 
  def validate(self):
9057 
    return
9058 
 
9059 
 
9060 
  def __repr__(self):
9061 
    L = ['%s=%r' % (key, value)
9062 
      for key, value in self.__dict__.iteritems()]
9063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9064 
 
9065 
  def __eq__(self, other):
9066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9067 
 
9068 
  def __ne__(self, other):
9069 
    return not (self == other)
9070 
 
9071 
class getItem_result:
9072 
  """
9073 
  Attributes:
9074 
   - success
9075 
   - cex
9076 
  """
9077 
 
9078 
  thrift_spec = (
9079 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
9080 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9081 
  )
9082 
 
9083 
  def __init__(self, success=None, cex=None,):
9084 
    self.success = success
9085 
    self.cex = cex
9086 
 
9087 
  def read(self, iprot):
9088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9090 
      return
9091 
    iprot.readStructBegin()
9092 
    while True:
9093 
      (fname, ftype, fid) = iprot.readFieldBegin()
9094 
      if ftype == TType.STOP:
9095 
        break
9096 
      if fid == 0:
9097 
        if ftype == TType.STRUCT:
9098 
          self.success = Item()
9099 
          self.success.read(iprot)
9100 
        else:
9101 
          iprot.skip(ftype)
9102 
      elif fid == 1:
9103 
        if ftype == TType.STRUCT:
9104 
          self.cex = CatalogServiceException()
9105 
          self.cex.read(iprot)
9106 
        else:
9107 
          iprot.skip(ftype)
9108 
      else:
9109 
        iprot.skip(ftype)
9110 
      iprot.readFieldEnd()
9111 
    iprot.readStructEnd()
9112 
 
9113 
  def write(self, oprot):
9114 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9115 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9116 
      return
9117 
    oprot.writeStructBegin('getItem_result')
9118 
    if self.success is not None:
9119 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9120 
      self.success.write(oprot)
9121 
      oprot.writeFieldEnd()
9122 
    if self.cex is not None:
9123 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9124 
      self.cex.write(oprot)
9125 
      oprot.writeFieldEnd()
9126 
    oprot.writeFieldStop()
9127 
    oprot.writeStructEnd()
9128 
 
9129 
  def validate(self):
9130 
    return
9131 
 
9132 
 
9133 
  def __repr__(self):
9134 
    L = ['%s=%r' % (key, value)
9135 
      for key, value in self.__dict__.iteritems()]
9136 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9137 
 
9138 
  def __eq__(self, other):
9139 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9140 
 
9141 
  def __ne__(self, other):
9142 
    return not (self == other)
9143 
 
9144 
class getItemsByCatalogId_args:
9145 
  """
9146 
  Attributes:
9147 
   - catalog_item_id
9148 
  """
9149 
 
9150 
  thrift_spec = (
9151 
    None, # 0
9152 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
9153 
  )
9154 
 
9155 
  def __init__(self, catalog_item_id=None,):
9156 
    self.catalog_item_id = catalog_item_id
9157 
 
9158 
  def read(self, iprot):
9159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9161 
      return
9162 
    iprot.readStructBegin()
9163 
    while True:
9164 
      (fname, ftype, fid) = iprot.readFieldBegin()
9165 
      if ftype == TType.STOP:
9166 
        break
9167 
      if fid == 1:
9168 
        if ftype == TType.I64:
9169 
          self.catalog_item_id = iprot.readI64();
9170 
        else:
9171 
          iprot.skip(ftype)
9172 
      else:
9173 
        iprot.skip(ftype)
9174 
      iprot.readFieldEnd()
9175 
    iprot.readStructEnd()
9176 
 
9177 
  def write(self, oprot):
9178 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9179 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9180 
      return
9181 
    oprot.writeStructBegin('getItemsByCatalogId_args')
9182 
    if self.catalog_item_id is not None:
9183 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
9184 
      oprot.writeI64(self.catalog_item_id)
9185 
      oprot.writeFieldEnd()
9186 
    oprot.writeFieldStop()
9187 
    oprot.writeStructEnd()
9188 
 
9189 
  def validate(self):
9190 
    return
9191 
 
9192 
 
9193 
  def __repr__(self):
9194 
    L = ['%s=%r' % (key, value)
9195 
      for key, value in self.__dict__.iteritems()]
9196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9197 
 
9198 
  def __eq__(self, other):
9199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9200 
 
9201 
  def __ne__(self, other):
9202 
    return not (self == other)
9203 
 
9204 
class getItemsByCatalogId_result:
9205 
  """
9206 
  Attributes:
9207 
   - success
9208 
   - cex
9209 
  """
9210 
 
9211 
  thrift_spec = (
9212 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9213 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9214 
  )
9215 
 
9216 
  def __init__(self, success=None, cex=None,):
9217 
    self.success = success
9218 
    self.cex = cex
9219 
 
9220 
  def read(self, iprot):
9221 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9222 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9223 
      return
9224 
    iprot.readStructBegin()
9225 
    while True:
9226 
      (fname, ftype, fid) = iprot.readFieldBegin()
9227 
      if ftype == TType.STOP:
9228 
        break
9229 
      if fid == 0:
9230 
        if ftype == TType.LIST:
9231 
          self.success = []
8590 kshitij.so 9232 
          (_etype49, _size46) = iprot.readListBegin()
9233 
          for _i50 in xrange(_size46):
9234 
            _elem51 = Item()
9235 
            _elem51.read(iprot)
9236 
            self.success.append(_elem51)
5944 mandeep.dh 9237 
          iprot.readListEnd()
9238 
        else:
9239 
          iprot.skip(ftype)
9240 
      elif fid == 1:
9241 
        if ftype == TType.STRUCT:
9242 
          self.cex = CatalogServiceException()
9243 
          self.cex.read(iprot)
9244 
        else:
9245 
          iprot.skip(ftype)
9246 
      else:
9247 
        iprot.skip(ftype)
9248 
      iprot.readFieldEnd()
9249 
    iprot.readStructEnd()
9250 
 
9251 
  def write(self, oprot):
9252 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9253 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9254 
      return
9255 
    oprot.writeStructBegin('getItemsByCatalogId_result')
9256 
    if self.success is not None:
9257 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9258 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9259 
      for iter52 in self.success:
9260 
        iter52.write(oprot)
5944 mandeep.dh 9261 
      oprot.writeListEnd()
9262 
      oprot.writeFieldEnd()
9263 
    if self.cex is not None:
9264 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9265 
      self.cex.write(oprot)
9266 
      oprot.writeFieldEnd()
9267 
    oprot.writeFieldStop()
9268 
    oprot.writeStructEnd()
9269 
 
9270 
  def validate(self):
9271 
    return
9272 
 
9273 
 
9274 
  def __repr__(self):
9275 
    L = ['%s=%r' % (key, value)
9276 
      for key, value in self.__dict__.iteritems()]
9277 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9278 
 
9279 
  def __eq__(self, other):
9280 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9281 
 
9282 
  def __ne__(self, other):
9283 
    return not (self == other)
9284 
 
9285 
class getValidItemsByCatalogId_args:
9286 
  """
9287 
  Attributes:
9288 
   - catalog_item_id
9289 
  """
9290 
 
9291 
  thrift_spec = (
9292 
    None, # 0
9293 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
9294 
  )
9295 
 
9296 
  def __init__(self, catalog_item_id=None,):
9297 
    self.catalog_item_id = catalog_item_id
9298 
 
9299 
  def read(self, iprot):
9300 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9301 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9302 
      return
9303 
    iprot.readStructBegin()
9304 
    while True:
9305 
      (fname, ftype, fid) = iprot.readFieldBegin()
9306 
      if ftype == TType.STOP:
9307 
        break
9308 
      if fid == 1:
9309 
        if ftype == TType.I64:
9310 
          self.catalog_item_id = iprot.readI64();
9311 
        else:
9312 
          iprot.skip(ftype)
9313 
      else:
9314 
        iprot.skip(ftype)
9315 
      iprot.readFieldEnd()
9316 
    iprot.readStructEnd()
9317 
 
9318 
  def write(self, oprot):
9319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9321 
      return
9322 
    oprot.writeStructBegin('getValidItemsByCatalogId_args')
9323 
    if self.catalog_item_id is not None:
9324 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
9325 
      oprot.writeI64(self.catalog_item_id)
9326 
      oprot.writeFieldEnd()
9327 
    oprot.writeFieldStop()
9328 
    oprot.writeStructEnd()
9329 
 
9330 
  def validate(self):
9331 
    return
9332 
 
9333 
 
9334 
  def __repr__(self):
9335 
    L = ['%s=%r' % (key, value)
9336 
      for key, value in self.__dict__.iteritems()]
9337 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9338 
 
9339 
  def __eq__(self, other):
9340 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9341 
 
9342 
  def __ne__(self, other):
9343 
    return not (self == other)
9344 
 
9345 
class getValidItemsByCatalogId_result:
9346 
  """
9347 
  Attributes:
9348 
   - success
9349 
   - cex
9350 
  """
9351 
 
9352 
  thrift_spec = (
9353 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9354 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9355 
  )
9356 
 
9357 
  def __init__(self, success=None, cex=None,):
9358 
    self.success = success
9359 
    self.cex = cex
9360 
 
9361 
  def read(self, iprot):
9362 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9363 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9364 
      return
9365 
    iprot.readStructBegin()
9366 
    while True:
9367 
      (fname, ftype, fid) = iprot.readFieldBegin()
9368 
      if ftype == TType.STOP:
9369 
        break
9370 
      if fid == 0:
9371 
        if ftype == TType.LIST:
9372 
          self.success = []
8590 kshitij.so 9373 
          (_etype56, _size53) = iprot.readListBegin()
9374 
          for _i57 in xrange(_size53):
9375 
            _elem58 = Item()
9376 
            _elem58.read(iprot)
9377 
            self.success.append(_elem58)
5944 mandeep.dh 9378 
          iprot.readListEnd()
9379 
        else:
9380 
          iprot.skip(ftype)
9381 
      elif fid == 1:
9382 
        if ftype == TType.STRUCT:
9383 
          self.cex = CatalogServiceException()
9384 
          self.cex.read(iprot)
9385 
        else:
9386 
          iprot.skip(ftype)
9387 
      else:
9388 
        iprot.skip(ftype)
9389 
      iprot.readFieldEnd()
9390 
    iprot.readStructEnd()
9391 
 
9392 
  def write(self, oprot):
9393 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9394 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9395 
      return
9396 
    oprot.writeStructBegin('getValidItemsByCatalogId_result')
9397 
    if self.success is not None:
9398 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9399 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9400 
      for iter59 in self.success:
9401 
        iter59.write(oprot)
5944 mandeep.dh 9402 
      oprot.writeListEnd()
9403 
      oprot.writeFieldEnd()
9404 
    if self.cex is not None:
9405 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9406 
      self.cex.write(oprot)
9407 
      oprot.writeFieldEnd()
9408 
    oprot.writeFieldStop()
9409 
    oprot.writeStructEnd()
9410 
 
9411 
  def validate(self):
9412 
    return
9413 
 
9414 
 
9415 
  def __repr__(self):
9416 
    L = ['%s=%r' % (key, value)
9417 
      for key, value in self.__dict__.iteritems()]
9418 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9419 
 
9420 
  def __eq__(self, other):
9421 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9422 
 
9423 
  def __ne__(self, other):
9424 
    return not (self == other)
9425 
 
9426 
class getAllItems_args:
9427 
  """
9428 
  Attributes:
9429 
   - isActive
9430 
  """
9431 
 
9432 
  thrift_spec = (
9433 
    None, # 0
9434 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
9435 
  )
9436 
 
9437 
  def __init__(self, isActive=None,):
9438 
    self.isActive = isActive
9439 
 
9440 
  def read(self, iprot):
9441 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9442 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9443 
      return
9444 
    iprot.readStructBegin()
9445 
    while True:
9446 
      (fname, ftype, fid) = iprot.readFieldBegin()
9447 
      if ftype == TType.STOP:
9448 
        break
9449 
      if fid == 1:
9450 
        if ftype == TType.BOOL:
9451 
          self.isActive = iprot.readBool();
9452 
        else:
9453 
          iprot.skip(ftype)
9454 
      else:
9455 
        iprot.skip(ftype)
9456 
      iprot.readFieldEnd()
9457 
    iprot.readStructEnd()
9458 
 
9459 
  def write(self, oprot):
9460 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9461 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9462 
      return
9463 
    oprot.writeStructBegin('getAllItems_args')
9464 
    if self.isActive is not None:
9465 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
9466 
      oprot.writeBool(self.isActive)
9467 
      oprot.writeFieldEnd()
9468 
    oprot.writeFieldStop()
9469 
    oprot.writeStructEnd()
9470 
 
9471 
  def validate(self):
9472 
    return
9473 
 
9474 
 
9475 
  def __repr__(self):
9476 
    L = ['%s=%r' % (key, value)
9477 
      for key, value in self.__dict__.iteritems()]
9478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9479 
 
9480 
  def __eq__(self, other):
9481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9482 
 
9483 
  def __ne__(self, other):
9484 
    return not (self == other)
9485 
 
9486 
class getAllItems_result:
9487 
  """
9488 
  Attributes:
9489 
   - success
9490 
   - cex
9491 
  """
9492 
 
9493 
  thrift_spec = (
9494 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9495 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9496 
  )
9497 
 
9498 
  def __init__(self, success=None, cex=None,):
9499 
    self.success = success
9500 
    self.cex = cex
9501 
 
9502 
  def read(self, iprot):
9503 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9504 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9505 
      return
9506 
    iprot.readStructBegin()
9507 
    while True:
9508 
      (fname, ftype, fid) = iprot.readFieldBegin()
9509 
      if ftype == TType.STOP:
9510 
        break
9511 
      if fid == 0:
9512 
        if ftype == TType.LIST:
9513 
          self.success = []
8590 kshitij.so 9514 
          (_etype63, _size60) = iprot.readListBegin()
9515 
          for _i64 in xrange(_size60):
9516 
            _elem65 = Item()
9517 
            _elem65.read(iprot)
9518 
            self.success.append(_elem65)
5944 mandeep.dh 9519 
          iprot.readListEnd()
9520 
        else:
9521 
          iprot.skip(ftype)
9522 
      elif fid == 1:
9523 
        if ftype == TType.STRUCT:
9524 
          self.cex = CatalogServiceException()
9525 
          self.cex.read(iprot)
9526 
        else:
9527 
          iprot.skip(ftype)
9528 
      else:
9529 
        iprot.skip(ftype)
9530 
      iprot.readFieldEnd()
9531 
    iprot.readStructEnd()
9532 
 
9533 
  def write(self, oprot):
9534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9536 
      return
9537 
    oprot.writeStructBegin('getAllItems_result')
9538 
    if self.success is not None:
9539 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9540 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9541 
      for iter66 in self.success:
9542 
        iter66.write(oprot)
5944 mandeep.dh 9543 
      oprot.writeListEnd()
9544 
      oprot.writeFieldEnd()
9545 
    if self.cex is not None:
9546 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9547 
      self.cex.write(oprot)
9548 
      oprot.writeFieldEnd()
9549 
    oprot.writeFieldStop()
9550 
    oprot.writeStructEnd()
9551 
 
9552 
  def validate(self):
9553 
    return
9554 
 
9555 
 
9556 
  def __repr__(self):
9557 
    L = ['%s=%r' % (key, value)
9558 
      for key, value in self.__dict__.iteritems()]
9559 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9560 
 
9561 
  def __eq__(self, other):
9562 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9563 
 
9564 
  def __ne__(self, other):
9565 
    return not (self == other)
9566 
 
9567 
class getAllItemsByStatus_args:
9568 
  """
9569 
  Attributes:
9570 
   - itemStatus
9571 
  """
9572 
 
9573 
  thrift_spec = (
9574 
    None, # 0
9575 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
9576 
  )
9577 
 
9578 
  def __init__(self, itemStatus=None,):
9579 
    self.itemStatus = itemStatus
9580 
 
9581 
  def read(self, iprot):
9582 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9583 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9584 
      return
9585 
    iprot.readStructBegin()
9586 
    while True:
9587 
      (fname, ftype, fid) = iprot.readFieldBegin()
9588 
      if ftype == TType.STOP:
9589 
        break
9590 
      if fid == 1:
9591 
        if ftype == TType.I32:
9592 
          self.itemStatus = iprot.readI32();
9593 
        else:
9594 
          iprot.skip(ftype)
9595 
      else:
9596 
        iprot.skip(ftype)
9597 
      iprot.readFieldEnd()
9598 
    iprot.readStructEnd()
9599 
 
9600 
  def write(self, oprot):
9601 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9602 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9603 
      return
9604 
    oprot.writeStructBegin('getAllItemsByStatus_args')
9605 
    if self.itemStatus is not None:
9606 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
9607 
      oprot.writeI32(self.itemStatus)
9608 
      oprot.writeFieldEnd()
9609 
    oprot.writeFieldStop()
9610 
    oprot.writeStructEnd()
9611 
 
9612 
  def validate(self):
9613 
    return
9614 
 
9615 
 
9616 
  def __repr__(self):
9617 
    L = ['%s=%r' % (key, value)
9618 
      for key, value in self.__dict__.iteritems()]
9619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9620 
 
9621 
  def __eq__(self, other):
9622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9623 
 
9624 
  def __ne__(self, other):
9625 
    return not (self == other)
9626 
 
9627 
class getAllItemsByStatus_result:
9628 
  """
9629 
  Attributes:
9630 
   - success
9631 
   - cex
9632 
  """
9633 
 
9634 
  thrift_spec = (
9635 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9636 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9637 
  )
9638 
 
9639 
  def __init__(self, success=None, cex=None,):
9640 
    self.success = success
9641 
    self.cex = cex
9642 
 
9643 
  def read(self, iprot):
9644 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9645 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9646 
      return
9647 
    iprot.readStructBegin()
9648 
    while True:
9649 
      (fname, ftype, fid) = iprot.readFieldBegin()
9650 
      if ftype == TType.STOP:
9651 
        break
9652 
      if fid == 0:
9653 
        if ftype == TType.LIST:
9654 
          self.success = []
8590 kshitij.so 9655 
          (_etype70, _size67) = iprot.readListBegin()
9656 
          for _i71 in xrange(_size67):
9657 
            _elem72 = Item()
9658 
            _elem72.read(iprot)
9659 
            self.success.append(_elem72)
5944 mandeep.dh 9660 
          iprot.readListEnd()
9661 
        else:
9662 
          iprot.skip(ftype)
9663 
      elif fid == 1:
9664 
        if ftype == TType.STRUCT:
9665 
          self.cex = CatalogServiceException()
9666 
          self.cex.read(iprot)
9667 
        else:
9668 
          iprot.skip(ftype)
9669 
      else:
9670 
        iprot.skip(ftype)
9671 
      iprot.readFieldEnd()
9672 
    iprot.readStructEnd()
9673 
 
9674 
  def write(self, oprot):
9675 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9676 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9677 
      return
9678 
    oprot.writeStructBegin('getAllItemsByStatus_result')
9679 
    if self.success is not None:
9680 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9681 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9682 
      for iter73 in self.success:
9683 
        iter73.write(oprot)
5944 mandeep.dh 9684 
      oprot.writeListEnd()
9685 
      oprot.writeFieldEnd()
9686 
    if self.cex is not None:
9687 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9688 
      self.cex.write(oprot)
9689 
      oprot.writeFieldEnd()
9690 
    oprot.writeFieldStop()
9691 
    oprot.writeStructEnd()
9692 
 
9693 
  def validate(self):
9694 
    return
9695 
 
9696 
 
9697 
  def __repr__(self):
9698 
    L = ['%s=%r' % (key, value)
9699 
      for key, value in self.__dict__.iteritems()]
9700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9701 
 
9702 
  def __eq__(self, other):
9703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9704 
 
9705 
  def __ne__(self, other):
9706 
    return not (self == other)
9707 
 
9708 
class markItemAsContentComplete_args:
9709 
  """
9710 
  Attributes:
9711 
   - entityId
9712 
   - category
9713 
   - brand
9714 
   - modelName
9715 
   - modelNumber
9253 rajveer 9716 
   - isAndroid
5944 mandeep.dh 9717 
  """
9718 
 
9719 
  thrift_spec = (
9720 
    None, # 0
9721 
    (1, TType.I64, 'entityId', None, None, ), # 1
9722 
    (2, TType.I64, 'category', None, None, ), # 2
9723 
    (3, TType.STRING, 'brand', None, None, ), # 3
9724 
    (4, TType.STRING, 'modelName', None, None, ), # 4
9725 
    (5, TType.STRING, 'modelNumber', None, None, ), # 5
9253 rajveer 9726 
    (6, TType.BOOL, 'isAndroid', None, None, ), # 6
5944 mandeep.dh 9727 
  )
9728 
 
9253 rajveer 9729 
  def __init__(self, entityId=None, category=None, brand=None, modelName=None, modelNumber=None, isAndroid=None,):
5944 mandeep.dh 9730 
    self.entityId = entityId
9731 
    self.category = category
9732 
    self.brand = brand
9733 
    self.modelName = modelName
9734 
    self.modelNumber = modelNumber
9253 rajveer 9735 
    self.isAndroid = isAndroid
5944 mandeep.dh 9736 
 
9737 
  def read(self, iprot):
9738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9740 
      return
9741 
    iprot.readStructBegin()
9742 
    while True:
9743 
      (fname, ftype, fid) = iprot.readFieldBegin()
9744 
      if ftype == TType.STOP:
9745 
        break
9746 
      if fid == 1:
9747 
        if ftype == TType.I64:
9748 
          self.entityId = iprot.readI64();
9749 
        else:
9750 
          iprot.skip(ftype)
9751 
      elif fid == 2:
9752 
        if ftype == TType.I64:
9753 
          self.category = iprot.readI64();
9754 
        else:
9755 
          iprot.skip(ftype)
9756 
      elif fid == 3:
9757 
        if ftype == TType.STRING:
9758 
          self.brand = iprot.readString();
9759 
        else:
9760 
          iprot.skip(ftype)
9761 
      elif fid == 4:
9762 
        if ftype == TType.STRING:
9763 
          self.modelName = iprot.readString();
9764 
        else:
9765 
          iprot.skip(ftype)
9766 
      elif fid == 5:
9767 
        if ftype == TType.STRING:
9768 
          self.modelNumber = iprot.readString();
9769 
        else:
9770 
          iprot.skip(ftype)
9253 rajveer 9771 
      elif fid == 6:
9772 
        if ftype == TType.BOOL:
9773 
          self.isAndroid = iprot.readBool();
9774 
        else:
9775 
          iprot.skip(ftype)
5944 mandeep.dh 9776 
      else:
9777 
        iprot.skip(ftype)
9778 
      iprot.readFieldEnd()
9779 
    iprot.readStructEnd()
9780 
 
9781 
  def write(self, oprot):
9782 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9783 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9784 
      return
9785 
    oprot.writeStructBegin('markItemAsContentComplete_args')
9786 
    if self.entityId is not None:
9787 
      oprot.writeFieldBegin('entityId', TType.I64, 1)
9788 
      oprot.writeI64(self.entityId)
9789 
      oprot.writeFieldEnd()
9790 
    if self.category is not None:
9791 
      oprot.writeFieldBegin('category', TType.I64, 2)
9792 
      oprot.writeI64(self.category)
9793 
      oprot.writeFieldEnd()
9794 
    if self.brand is not None:
9795 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9796 
      oprot.writeString(self.brand)
9797 
      oprot.writeFieldEnd()
9798 
    if self.modelName is not None:
9799 
      oprot.writeFieldBegin('modelName', TType.STRING, 4)
9800 
      oprot.writeString(self.modelName)
9801 
      oprot.writeFieldEnd()
9802 
    if self.modelNumber is not None:
9803 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 5)
9804 
      oprot.writeString(self.modelNumber)
9805 
      oprot.writeFieldEnd()
9253 rajveer 9806 
    if self.isAndroid is not None:
9807 
      oprot.writeFieldBegin('isAndroid', TType.BOOL, 6)
9808 
      oprot.writeBool(self.isAndroid)
9809 
      oprot.writeFieldEnd()
5944 mandeep.dh 9810 
    oprot.writeFieldStop()
9811 
    oprot.writeStructEnd()
9812 
 
9813 
  def validate(self):
9814 
    return
9815 
 
9816 
 
9817 
  def __repr__(self):
9818 
    L = ['%s=%r' % (key, value)
9819 
      for key, value in self.__dict__.iteritems()]
9820 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9821 
 
9822 
  def __eq__(self, other):
9823 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9824 
 
9825 
  def __ne__(self, other):
9826 
    return not (self == other)
9827 
 
9828 
class markItemAsContentComplete_result:
9829 
  """
9830 
  Attributes:
9831 
   - success
9832 
   - cex
9833 
  """
9834 
 
9835 
  thrift_spec = (
9836 
    (0, TType.BOOL, 'success', None, None, ), # 0
9837 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9838 
  )
9839 
 
9840 
  def __init__(self, success=None, cex=None,):
9841 
    self.success = success
9842 
    self.cex = cex
9843 
 
9844 
  def read(self, iprot):
9845 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9846 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9847 
      return
9848 
    iprot.readStructBegin()
9849 
    while True:
9850 
      (fname, ftype, fid) = iprot.readFieldBegin()
9851 
      if ftype == TType.STOP:
9852 
        break
9853 
      if fid == 0:
9854 
        if ftype == TType.BOOL:
9855 
          self.success = iprot.readBool();
9856 
        else:
9857 
          iprot.skip(ftype)
9858 
      elif fid == 1:
9859 
        if ftype == TType.STRUCT:
9860 
          self.cex = CatalogServiceException()
9861 
          self.cex.read(iprot)
9862 
        else:
9863 
          iprot.skip(ftype)
9864 
      else:
9865 
        iprot.skip(ftype)
9866 
      iprot.readFieldEnd()
9867 
    iprot.readStructEnd()
9868 
 
9869 
  def write(self, oprot):
9870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9872 
      return
9873 
    oprot.writeStructBegin('markItemAsContentComplete_result')
9874 
    if self.success is not None:
9875 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9876 
      oprot.writeBool(self.success)
9877 
      oprot.writeFieldEnd()
9878 
    if self.cex is not None:
9879 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9880 
      self.cex.write(oprot)
9881 
      oprot.writeFieldEnd()
9882 
    oprot.writeFieldStop()
9883 
    oprot.writeStructEnd()
9884 
 
9885 
  def validate(self):
9886 
    return
9887 
 
9888 
 
9889 
  def __repr__(self):
9890 
    L = ['%s=%r' % (key, value)
9891 
      for key, value in self.__dict__.iteritems()]
9892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9893 
 
9894 
  def __eq__(self, other):
9895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9896 
 
9897 
  def __ne__(self, other):
9898 
    return not (self == other)
9899 
 
9900 
class getAllItemsInRange_args:
9901 
  """
9902 
  Attributes:
9903 
   - offset
9904 
   - limit
9905 
  """
9906 
 
9907 
  thrift_spec = (
9908 
    None, # 0
9909 
    (1, TType.I64, 'offset', None, None, ), # 1
9910 
    (2, TType.I64, 'limit', None, None, ), # 2
9911 
  )
9912 
 
9913 
  def __init__(self, offset=None, limit=None,):
9914 
    self.offset = offset
9915 
    self.limit = limit
9916 
 
9917 
  def read(self, iprot):
9918 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9919 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9920 
      return
9921 
    iprot.readStructBegin()
9922 
    while True:
9923 
      (fname, ftype, fid) = iprot.readFieldBegin()
9924 
      if ftype == TType.STOP:
9925 
        break
9926 
      if fid == 1:
9927 
        if ftype == TType.I64:
9928 
          self.offset = iprot.readI64();
9929 
        else:
9930 
          iprot.skip(ftype)
9931 
      elif fid == 2:
9932 
        if ftype == TType.I64:
9933 
          self.limit = iprot.readI64();
9934 
        else:
9935 
          iprot.skip(ftype)
9936 
      else:
9937 
        iprot.skip(ftype)
9938 
      iprot.readFieldEnd()
9939 
    iprot.readStructEnd()
9940 
 
9941 
  def write(self, oprot):
9942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9944 
      return
9945 
    oprot.writeStructBegin('getAllItemsInRange_args')
9946 
    if self.offset is not None:
9947 
      oprot.writeFieldBegin('offset', TType.I64, 1)
9948 
      oprot.writeI64(self.offset)
9949 
      oprot.writeFieldEnd()
9950 
    if self.limit is not None:
9951 
      oprot.writeFieldBegin('limit', TType.I64, 2)
9952 
      oprot.writeI64(self.limit)
9953 
      oprot.writeFieldEnd()
9954 
    oprot.writeFieldStop()
9955 
    oprot.writeStructEnd()
9956 
 
9957 
  def validate(self):
9958 
    return
9959 
 
9960 
 
9961 
  def __repr__(self):
9962 
    L = ['%s=%r' % (key, value)
9963 
      for key, value in self.__dict__.iteritems()]
9964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9965 
 
9966 
  def __eq__(self, other):
9967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9968 
 
9969 
  def __ne__(self, other):
9970 
    return not (self == other)
9971 
 
9972 
class getAllItemsInRange_result:
9973 
  """
9974 
  Attributes:
9975 
   - success
9976 
   - cex
9977 
  """
9978 
 
9979 
  thrift_spec = (
9980 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9981 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9982 
  )
9983 
 
9984 
  def __init__(self, success=None, cex=None,):
9985 
    self.success = success
9986 
    self.cex = cex
9987 
 
9988 
  def read(self, iprot):
9989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9991 
      return
9992 
    iprot.readStructBegin()
9993 
    while True:
9994 
      (fname, ftype, fid) = iprot.readFieldBegin()
9995 
      if ftype == TType.STOP:
9996 
        break
9997 
      if fid == 0:
9998 
        if ftype == TType.LIST:
9999 
          self.success = []
8590 kshitij.so 10000 
          (_etype77, _size74) = iprot.readListBegin()
10001 
          for _i78 in xrange(_size74):
10002 
            _elem79 = Item()
10003 
            _elem79.read(iprot)
10004 
            self.success.append(_elem79)
5944 mandeep.dh 10005 
          iprot.readListEnd()
10006 
        else:
10007 
          iprot.skip(ftype)
10008 
      elif fid == 1:
10009 
        if ftype == TType.STRUCT:
10010 
          self.cex = CatalogServiceException()
10011 
          self.cex.read(iprot)
10012 
        else:
10013 
          iprot.skip(ftype)
10014 
      else:
10015 
        iprot.skip(ftype)
10016 
      iprot.readFieldEnd()
10017 
    iprot.readStructEnd()
10018 
 
10019 
  def write(self, oprot):
10020 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10021 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10022 
      return
10023 
    oprot.writeStructBegin('getAllItemsInRange_result')
10024 
    if self.success is not None:
10025 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10026 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10027 
      for iter80 in self.success:
10028 
        iter80.write(oprot)
5944 mandeep.dh 10029 
      oprot.writeListEnd()
10030 
      oprot.writeFieldEnd()
10031 
    if self.cex is not None:
10032 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10033 
      self.cex.write(oprot)
10034 
      oprot.writeFieldEnd()
10035 
    oprot.writeFieldStop()
10036 
    oprot.writeStructEnd()
10037 
 
10038 
  def validate(self):
10039 
    return
10040 
 
10041 
 
10042 
  def __repr__(self):
10043 
    L = ['%s=%r' % (key, value)
10044 
      for key, value in self.__dict__.iteritems()]
10045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10046 
 
10047 
  def __eq__(self, other):
10048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10049 
 
10050 
  def __ne__(self, other):
10051 
    return not (self == other)
10052 
 
10053 
class getAllItemsByStatusInRange_args:
10054 
  """
10055 
  Attributes:
10056 
   - itemStatus
10057 
   - offset
10058 
   - limit
10059 
  """
10060 
 
10061 
  thrift_spec = (
10062 
    None, # 0
10063 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
10064 
    (2, TType.I64, 'offset', None, None, ), # 2
10065 
    (3, TType.I64, 'limit', None, None, ), # 3
10066 
  )
10067 
 
10068 
  def __init__(self, itemStatus=None, offset=None, limit=None,):
10069 
    self.itemStatus = itemStatus
10070 
    self.offset = offset
10071 
    self.limit = limit
10072 
 
10073 
  def read(self, iprot):
10074 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10075 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10076 
      return
10077 
    iprot.readStructBegin()
10078 
    while True:
10079 
      (fname, ftype, fid) = iprot.readFieldBegin()
10080 
      if ftype == TType.STOP:
10081 
        break
10082 
      if fid == 1:
10083 
        if ftype == TType.I32:
10084 
          self.itemStatus = iprot.readI32();
10085 
        else:
10086 
          iprot.skip(ftype)
10087 
      elif fid == 2:
10088 
        if ftype == TType.I64:
10089 
          self.offset = iprot.readI64();
10090 
        else:
10091 
          iprot.skip(ftype)
10092 
      elif fid == 3:
10093 
        if ftype == TType.I64:
10094 
          self.limit = iprot.readI64();
10095 
        else:
10096 
          iprot.skip(ftype)
10097 
      else:
10098 
        iprot.skip(ftype)
10099 
      iprot.readFieldEnd()
10100 
    iprot.readStructEnd()
10101 
 
10102 
  def write(self, oprot):
10103 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10104 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10105 
      return
10106 
    oprot.writeStructBegin('getAllItemsByStatusInRange_args')
10107 
    if self.itemStatus is not None:
10108 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
10109 
      oprot.writeI32(self.itemStatus)
10110 
      oprot.writeFieldEnd()
10111 
    if self.offset is not None:
10112 
      oprot.writeFieldBegin('offset', TType.I64, 2)
10113 
      oprot.writeI64(self.offset)
10114 
      oprot.writeFieldEnd()
10115 
    if self.limit is not None:
10116 
      oprot.writeFieldBegin('limit', TType.I64, 3)
10117 
      oprot.writeI64(self.limit)
10118 
      oprot.writeFieldEnd()
10119 
    oprot.writeFieldStop()
10120 
    oprot.writeStructEnd()
10121 
 
10122 
  def validate(self):
10123 
    return
10124 
 
10125 
 
10126 
  def __repr__(self):
10127 
    L = ['%s=%r' % (key, value)
10128 
      for key, value in self.__dict__.iteritems()]
10129 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10130 
 
10131 
  def __eq__(self, other):
10132 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10133 
 
10134 
  def __ne__(self, other):
10135 
    return not (self == other)
10136 
 
10137 
class getAllItemsByStatusInRange_result:
10138 
  """
10139 
  Attributes:
10140 
   - success
10141 
   - cex
10142 
  """
10143 
 
10144 
  thrift_spec = (
10145 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10146 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10147 
  )
10148 
 
10149 
  def __init__(self, success=None, cex=None,):
10150 
    self.success = success
10151 
    self.cex = cex
10152 
 
10153 
  def read(self, iprot):
10154 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10155 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10156 
      return
10157 
    iprot.readStructBegin()
10158 
    while True:
10159 
      (fname, ftype, fid) = iprot.readFieldBegin()
10160 
      if ftype == TType.STOP:
10161 
        break
10162 
      if fid == 0:
10163 
        if ftype == TType.LIST:
10164 
          self.success = []
8590 kshitij.so 10165 
          (_etype84, _size81) = iprot.readListBegin()
10166 
          for _i85 in xrange(_size81):
10167 
            _elem86 = Item()
10168 
            _elem86.read(iprot)
10169 
            self.success.append(_elem86)
5944 mandeep.dh 10170 
          iprot.readListEnd()
10171 
        else:
10172 
          iprot.skip(ftype)
10173 
      elif fid == 1:
10174 
        if ftype == TType.STRUCT:
10175 
          self.cex = CatalogServiceException()
10176 
          self.cex.read(iprot)
10177 
        else:
10178 
          iprot.skip(ftype)
10179 
      else:
10180 
        iprot.skip(ftype)
10181 
      iprot.readFieldEnd()
10182 
    iprot.readStructEnd()
10183 
 
10184 
  def write(self, oprot):
10185 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10186 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10187 
      return
10188 
    oprot.writeStructBegin('getAllItemsByStatusInRange_result')
10189 
    if self.success is not None:
10190 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10191 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10192 
      for iter87 in self.success:
10193 
        iter87.write(oprot)
5944 mandeep.dh 10194 
      oprot.writeListEnd()
10195 
      oprot.writeFieldEnd()
10196 
    if self.cex is not None:
10197 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10198 
      self.cex.write(oprot)
10199 
      oprot.writeFieldEnd()
10200 
    oprot.writeFieldStop()
10201 
    oprot.writeStructEnd()
10202 
 
10203 
  def validate(self):
10204 
    return
10205 
 
10206 
 
10207 
  def __repr__(self):
10208 
    L = ['%s=%r' % (key, value)
10209 
      for key, value in self.__dict__.iteritems()]
10210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10211 
 
10212 
  def __eq__(self, other):
10213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10214 
 
10215 
  def __ne__(self, other):
10216 
    return not (self == other)
10217 
 
10218 
class getItemCountByStatus_args:
10219 
  """
10220 
  Attributes:
10221 
   - useStatus
10222 
   - itemStatus
10223 
  """
10224 
 
10225 
  thrift_spec = (
10226 
    None, # 0
10227 
    (1, TType.BOOL, 'useStatus', None, None, ), # 1
10228 
    (2, TType.I32, 'itemStatus', None, None, ), # 2
10229 
  )
10230 
 
10231 
  def __init__(self, useStatus=None, itemStatus=None,):
10232 
    self.useStatus = useStatus
10233 
    self.itemStatus = itemStatus
10234 
 
10235 
  def read(self, iprot):
10236 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10237 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10238 
      return
10239 
    iprot.readStructBegin()
10240 
    while True:
10241 
      (fname, ftype, fid) = iprot.readFieldBegin()
10242 
      if ftype == TType.STOP:
10243 
        break
10244 
      if fid == 1:
10245 
        if ftype == TType.BOOL:
10246 
          self.useStatus = iprot.readBool();
10247 
        else:
10248 
          iprot.skip(ftype)
10249 
      elif fid == 2:
10250 
        if ftype == TType.I32:
10251 
          self.itemStatus = iprot.readI32();
10252 
        else:
10253 
          iprot.skip(ftype)
10254 
      else:
10255 
        iprot.skip(ftype)
10256 
      iprot.readFieldEnd()
10257 
    iprot.readStructEnd()
10258 
 
10259 
  def write(self, oprot):
10260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10262 
      return
10263 
    oprot.writeStructBegin('getItemCountByStatus_args')
10264 
    if self.useStatus is not None:
10265 
      oprot.writeFieldBegin('useStatus', TType.BOOL, 1)
10266 
      oprot.writeBool(self.useStatus)
10267 
      oprot.writeFieldEnd()
10268 
    if self.itemStatus is not None:
10269 
      oprot.writeFieldBegin('itemStatus', TType.I32, 2)
10270 
      oprot.writeI32(self.itemStatus)
10271 
      oprot.writeFieldEnd()
10272 
    oprot.writeFieldStop()
10273 
    oprot.writeStructEnd()
10274 
 
10275 
  def validate(self):
10276 
    return
10277 
 
10278 
 
10279 
  def __repr__(self):
10280 
    L = ['%s=%r' % (key, value)
10281 
      for key, value in self.__dict__.iteritems()]
10282 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10283 
 
10284 
  def __eq__(self, other):
10285 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10286 
 
10287 
  def __ne__(self, other):
10288 
    return not (self == other)
10289 
 
10290 
class getItemCountByStatus_result:
10291 
  """
10292 
  Attributes:
10293 
   - success
10294 
  """
10295 
 
10296 
  thrift_spec = (
10297 
    (0, TType.I32, 'success', None, None, ), # 0
10298 
  )
10299 
 
10300 
  def __init__(self, success=None,):
10301 
    self.success = success
10302 
 
10303 
  def read(self, iprot):
10304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10306 
      return
10307 
    iprot.readStructBegin()
10308 
    while True:
10309 
      (fname, ftype, fid) = iprot.readFieldBegin()
10310 
      if ftype == TType.STOP:
10311 
        break
10312 
      if fid == 0:
10313 
        if ftype == TType.I32:
10314 
          self.success = iprot.readI32();
10315 
        else:
10316 
          iprot.skip(ftype)
10317 
      else:
10318 
        iprot.skip(ftype)
10319 
      iprot.readFieldEnd()
10320 
    iprot.readStructEnd()
10321 
 
10322 
  def write(self, oprot):
10323 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10324 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10325 
      return
10326 
    oprot.writeStructBegin('getItemCountByStatus_result')
10327 
    if self.success is not None:
10328 
      oprot.writeFieldBegin('success', TType.I32, 0)
10329 
      oprot.writeI32(self.success)
10330 
      oprot.writeFieldEnd()
10331 
    oprot.writeFieldStop()
10332 
    oprot.writeStructEnd()
10333 
 
10334 
  def validate(self):
10335 
    return
10336 
 
10337 
 
10338 
  def __repr__(self):
10339 
    L = ['%s=%r' % (key, value)
10340 
      for key, value in self.__dict__.iteritems()]
10341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10342 
 
10343 
  def __eq__(self, other):
10344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10345 
 
10346 
  def __ne__(self, other):
10347 
    return not (self == other)
10348 
 
10349 
class getBestSellers_args:
10350 
 
10351 
  thrift_spec = (
10352 
  )
10353 
 
10354 
  def read(self, iprot):
10355 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10356 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10357 
      return
10358 
    iprot.readStructBegin()
10359 
    while True:
10360 
      (fname, ftype, fid) = iprot.readFieldBegin()
10361 
      if ftype == TType.STOP:
10362 
        break
10363 
      else:
10364 
        iprot.skip(ftype)
10365 
      iprot.readFieldEnd()
10366 
    iprot.readStructEnd()
10367 
 
10368 
  def write(self, oprot):
10369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10371 
      return
10372 
    oprot.writeStructBegin('getBestSellers_args')
10373 
    oprot.writeFieldStop()
10374 
    oprot.writeStructEnd()
10375 
 
10376 
  def validate(self):
10377 
    return
10378 
 
10379 
 
10380 
  def __repr__(self):
10381 
    L = ['%s=%r' % (key, value)
10382 
      for key, value in self.__dict__.iteritems()]
10383 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10384 
 
10385 
  def __eq__(self, other):
10386 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10387 
 
10388 
  def __ne__(self, other):
10389 
    return not (self == other)
10390 
 
10391 
class getBestSellers_result:
10392 
  """
10393 
  Attributes:
10394 
   - success
10395 
   - isex
10396 
  """
10397 
 
10398 
  thrift_spec = (
10399 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10400 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10401 
  )
10402 
 
10403 
  def __init__(self, success=None, isex=None,):
10404 
    self.success = success
10405 
    self.isex = isex
10406 
 
10407 
  def read(self, iprot):
10408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10410 
      return
10411 
    iprot.readStructBegin()
10412 
    while True:
10413 
      (fname, ftype, fid) = iprot.readFieldBegin()
10414 
      if ftype == TType.STOP:
10415 
        break
10416 
      if fid == 0:
10417 
        if ftype == TType.LIST:
10418 
          self.success = []
8590 kshitij.so 10419 
          (_etype91, _size88) = iprot.readListBegin()
10420 
          for _i92 in xrange(_size88):
10421 
            _elem93 = Item()
10422 
            _elem93.read(iprot)
10423 
            self.success.append(_elem93)
5944 mandeep.dh 10424 
          iprot.readListEnd()
10425 
        else:
10426 
          iprot.skip(ftype)
10427 
      elif fid == 1:
10428 
        if ftype == TType.STRUCT:
10429 
          self.isex = CatalogServiceException()
10430 
          self.isex.read(iprot)
10431 
        else:
10432 
          iprot.skip(ftype)
10433 
      else:
10434 
        iprot.skip(ftype)
10435 
      iprot.readFieldEnd()
10436 
    iprot.readStructEnd()
10437 
 
10438 
  def write(self, oprot):
10439 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10440 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10441 
      return
10442 
    oprot.writeStructBegin('getBestSellers_result')
10443 
    if self.success is not None:
10444 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10445 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10446 
      for iter94 in self.success:
10447 
        iter94.write(oprot)
5944 mandeep.dh 10448 
      oprot.writeListEnd()
10449 
      oprot.writeFieldEnd()
10450 
    if self.isex is not None:
10451 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
10452 
      self.isex.write(oprot)
10453 
      oprot.writeFieldEnd()
10454 
    oprot.writeFieldStop()
10455 
    oprot.writeStructEnd()
10456 
 
10457 
  def validate(self):
10458 
    return
10459 
 
10460 
 
10461 
  def __repr__(self):
10462 
    L = ['%s=%r' % (key, value)
10463 
      for key, value in self.__dict__.iteritems()]
10464 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10465 
 
10466 
  def __eq__(self, other):
10467 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10468 
 
10469 
  def __ne__(self, other):
10470 
    return not (self == other)
10471 
 
10472 
class getBestSellersCatalogIds_args:
10473 
  """
10474 
  Attributes:
10475 
   - beginIndex
10476 
   - totalItems
10477 
   - brand
10478 
   - category
10479 
  """
10480 
 
10481 
  thrift_spec = (
10482 
    None, # 0
10483 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
10484 
    (2, TType.I64, 'totalItems', None, None, ), # 2
10485 
    (3, TType.STRING, 'brand', None, None, ), # 3
10486 
    (4, TType.I64, 'category', None, None, ), # 4
10487 
  )
10488 
 
10489 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
10490 
    self.beginIndex = beginIndex
10491 
    self.totalItems = totalItems
10492 
    self.brand = brand
10493 
    self.category = category
10494 
 
10495 
  def read(self, iprot):
10496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10498 
      return
10499 
    iprot.readStructBegin()
10500 
    while True:
10501 
      (fname, ftype, fid) = iprot.readFieldBegin()
10502 
      if ftype == TType.STOP:
10503 
        break
10504 
      if fid == 1:
10505 
        if ftype == TType.I64:
10506 
          self.beginIndex = iprot.readI64();
10507 
        else:
10508 
          iprot.skip(ftype)
10509 
      elif fid == 2:
10510 
        if ftype == TType.I64:
10511 
          self.totalItems = iprot.readI64();
10512 
        else:
10513 
          iprot.skip(ftype)
10514 
      elif fid == 3:
10515 
        if ftype == TType.STRING:
10516 
          self.brand = iprot.readString();
10517 
        else:
10518 
          iprot.skip(ftype)
10519 
      elif fid == 4:
10520 
        if ftype == TType.I64:
10521 
          self.category = iprot.readI64();
10522 
        else:
10523 
          iprot.skip(ftype)
10524 
      else:
10525 
        iprot.skip(ftype)
10526 
      iprot.readFieldEnd()
10527 
    iprot.readStructEnd()
10528 
 
10529 
  def write(self, oprot):
10530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10532 
      return
10533 
    oprot.writeStructBegin('getBestSellersCatalogIds_args')
10534 
    if self.beginIndex is not None:
10535 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
10536 
      oprot.writeI64(self.beginIndex)
10537 
      oprot.writeFieldEnd()
10538 
    if self.totalItems is not None:
10539 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
10540 
      oprot.writeI64(self.totalItems)
10541 
      oprot.writeFieldEnd()
10542 
    if self.brand is not None:
10543 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
10544 
      oprot.writeString(self.brand)
10545 
      oprot.writeFieldEnd()
10546 
    if self.category is not None:
10547 
      oprot.writeFieldBegin('category', TType.I64, 4)
10548 
      oprot.writeI64(self.category)
10549 
      oprot.writeFieldEnd()
10550 
    oprot.writeFieldStop()
10551 
    oprot.writeStructEnd()
10552 
 
10553 
  def validate(self):
10554 
    return
10555 
 
10556 
 
10557 
  def __repr__(self):
10558 
    L = ['%s=%r' % (key, value)
10559 
      for key, value in self.__dict__.iteritems()]
10560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10561 
 
10562 
  def __eq__(self, other):
10563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10564 
 
10565 
  def __ne__(self, other):
10566 
    return not (self == other)
10567 
 
10568 
class getBestSellersCatalogIds_result:
10569 
  """
10570 
  Attributes:
10571 
   - success
10572 
   - cex
10573 
  """
10574 
 
10575 
  thrift_spec = (
10576 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10577 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10578 
  )
10579 
 
10580 
  def __init__(self, success=None, cex=None,):
10581 
    self.success = success
10582 
    self.cex = cex
10583 
 
10584 
  def read(self, iprot):
10585 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10586 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10587 
      return
10588 
    iprot.readStructBegin()
10589 
    while True:
10590 
      (fname, ftype, fid) = iprot.readFieldBegin()
10591 
      if ftype == TType.STOP:
10592 
        break
10593 
      if fid == 0:
10594 
        if ftype == TType.LIST:
10595 
          self.success = []
8590 kshitij.so 10596 
          (_etype98, _size95) = iprot.readListBegin()
10597 
          for _i99 in xrange(_size95):
10598 
            _elem100 = iprot.readI64();
10599 
            self.success.append(_elem100)
5944 mandeep.dh 10600 
          iprot.readListEnd()
10601 
        else:
10602 
          iprot.skip(ftype)
10603 
      elif fid == 1:
10604 
        if ftype == TType.STRUCT:
10605 
          self.cex = CatalogServiceException()
10606 
          self.cex.read(iprot)
10607 
        else:
10608 
          iprot.skip(ftype)
10609 
      else:
10610 
        iprot.skip(ftype)
10611 
      iprot.readFieldEnd()
10612 
    iprot.readStructEnd()
10613 
 
10614 
  def write(self, oprot):
10615 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10616 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10617 
      return
10618 
    oprot.writeStructBegin('getBestSellersCatalogIds_result')
10619 
    if self.success is not None:
10620 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10621 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 10622 
      for iter101 in self.success:
10623 
        oprot.writeI64(iter101)
5944 mandeep.dh 10624 
      oprot.writeListEnd()
10625 
      oprot.writeFieldEnd()
10626 
    if self.cex is not None:
10627 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10628 
      self.cex.write(oprot)
10629 
      oprot.writeFieldEnd()
10630 
    oprot.writeFieldStop()
10631 
    oprot.writeStructEnd()
10632 
 
10633 
  def validate(self):
10634 
    return
10635 
 
10636 
 
10637 
  def __repr__(self):
10638 
    L = ['%s=%r' % (key, value)
10639 
      for key, value in self.__dict__.iteritems()]
10640 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10641 
 
10642 
  def __eq__(self, other):
10643 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10644 
 
10645 
  def __ne__(self, other):
10646 
    return not (self == other)
10647 
 
10648 
class getBestSellersCount_args:
10649 
 
10650 
  thrift_spec = (
10651 
  )
10652 
 
10653 
  def read(self, iprot):
10654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10656 
      return
10657 
    iprot.readStructBegin()
10658 
    while True:
10659 
      (fname, ftype, fid) = iprot.readFieldBegin()
10660 
      if ftype == TType.STOP:
10661 
        break
10662 
      else:
10663 
        iprot.skip(ftype)
10664 
      iprot.readFieldEnd()
10665 
    iprot.readStructEnd()
10666 
 
10667 
  def write(self, oprot):
10668 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10669 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10670 
      return
10671 
    oprot.writeStructBegin('getBestSellersCount_args')
10672 
    oprot.writeFieldStop()
10673 
    oprot.writeStructEnd()
10674 
 
10675 
  def validate(self):
10676 
    return
10677 
 
10678 
 
10679 
  def __repr__(self):
10680 
    L = ['%s=%r' % (key, value)
10681 
      for key, value in self.__dict__.iteritems()]
10682 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10683 
 
10684 
  def __eq__(self, other):
10685 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10686 
 
10687 
  def __ne__(self, other):
10688 
    return not (self == other)
10689 
 
10690 
class getBestSellersCount_result:
10691 
  """
10692 
  Attributes:
10693 
   - success
10694 
   - cex
10695 
  """
10696 
 
10697 
  thrift_spec = (
10698 
    (0, TType.I64, 'success', None, None, ), # 0
10699 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10700 
  )
10701 
 
10702 
  def __init__(self, success=None, cex=None,):
10703 
    self.success = success
10704 
    self.cex = cex
10705 
 
10706 
  def read(self, iprot):
10707 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10708 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10709 
      return
10710 
    iprot.readStructBegin()
10711 
    while True:
10712 
      (fname, ftype, fid) = iprot.readFieldBegin()
10713 
      if ftype == TType.STOP:
10714 
        break
10715 
      if fid == 0:
10716 
        if ftype == TType.I64:
10717 
          self.success = iprot.readI64();
10718 
        else:
10719 
          iprot.skip(ftype)
10720 
      elif fid == 1:
10721 
        if ftype == TType.STRUCT:
10722 
          self.cex = CatalogServiceException()
10723 
          self.cex.read(iprot)
10724 
        else:
10725 
          iprot.skip(ftype)
10726 
      else:
10727 
        iprot.skip(ftype)
10728 
      iprot.readFieldEnd()
10729 
    iprot.readStructEnd()
10730 
 
10731 
  def write(self, oprot):
10732 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10733 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10734 
      return
10735 
    oprot.writeStructBegin('getBestSellersCount_result')
10736 
    if self.success is not None:
10737 
      oprot.writeFieldBegin('success', TType.I64, 0)
10738 
      oprot.writeI64(self.success)
10739 
      oprot.writeFieldEnd()
10740 
    if self.cex is not None:
10741 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10742 
      self.cex.write(oprot)
10743 
      oprot.writeFieldEnd()
10744 
    oprot.writeFieldStop()
10745 
    oprot.writeStructEnd()
10746 
 
10747 
  def validate(self):
10748 
    return
10749 
 
10750 
 
10751 
  def __repr__(self):
10752 
    L = ['%s=%r' % (key, value)
10753 
      for key, value in self.__dict__.iteritems()]
10754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10755 
 
10756 
  def __eq__(self, other):
10757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10758 
 
10759 
  def __ne__(self, other):
10760 
    return not (self == other)
10761 
 
10762 
class getBestDeals_args:
10763 
 
10764 
  thrift_spec = (
10765 
  )
10766 
 
10767 
  def read(self, iprot):
10768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10770 
      return
10771 
    iprot.readStructBegin()
10772 
    while True:
10773 
      (fname, ftype, fid) = iprot.readFieldBegin()
10774 
      if ftype == TType.STOP:
10775 
        break
10776 
      else:
10777 
        iprot.skip(ftype)
10778 
      iprot.readFieldEnd()
10779 
    iprot.readStructEnd()
10780 
 
10781 
  def write(self, oprot):
10782 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10783 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10784 
      return
10785 
    oprot.writeStructBegin('getBestDeals_args')
10786 
    oprot.writeFieldStop()
10787 
    oprot.writeStructEnd()
10788 
 
10789 
  def validate(self):
10790 
    return
10791 
 
10792 
 
10793 
  def __repr__(self):
10794 
    L = ['%s=%r' % (key, value)
10795 
      for key, value in self.__dict__.iteritems()]
10796 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10797 
 
10798 
  def __eq__(self, other):
10799 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10800 
 
10801 
  def __ne__(self, other):
10802 
    return not (self == other)
10803 
 
10804 
class getBestDeals_result:
10805 
  """
10806 
  Attributes:
10807 
   - success
10808 
   - isex
10809 
  """
10810 
 
10811 
  thrift_spec = (
10812 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10813 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10814 
  )
10815 
 
10816 
  def __init__(self, success=None, isex=None,):
10817 
    self.success = success
10818 
    self.isex = isex
10819 
 
10820 
  def read(self, iprot):
10821 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10822 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10823 
      return
10824 
    iprot.readStructBegin()
10825 
    while True:
10826 
      (fname, ftype, fid) = iprot.readFieldBegin()
10827 
      if ftype == TType.STOP:
10828 
        break
10829 
      if fid == 0:
10830 
        if ftype == TType.LIST:
10831 
          self.success = []
8590 kshitij.so 10832 
          (_etype105, _size102) = iprot.readListBegin()
10833 
          for _i106 in xrange(_size102):
10834 
            _elem107 = Item()
10835 
            _elem107.read(iprot)
10836 
            self.success.append(_elem107)
5944 mandeep.dh 10837 
          iprot.readListEnd()
10838 
        else:
10839 
          iprot.skip(ftype)
10840 
      elif fid == 1:
10841 
        if ftype == TType.STRUCT:
10842 
          self.isex = CatalogServiceException()
10843 
          self.isex.read(iprot)
10844 
        else:
10845 
          iprot.skip(ftype)
10846 
      else:
10847 
        iprot.skip(ftype)
10848 
      iprot.readFieldEnd()
10849 
    iprot.readStructEnd()
10850 
 
10851 
  def write(self, oprot):
10852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10854 
      return
10855 
    oprot.writeStructBegin('getBestDeals_result')
10856 
    if self.success is not None:
10857 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10858 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10859 
      for iter108 in self.success:
10860 
        iter108.write(oprot)
5944 mandeep.dh 10861 
      oprot.writeListEnd()
10862 
      oprot.writeFieldEnd()
10863 
    if self.isex is not None:
10864 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
10865 
      self.isex.write(oprot)
10866 
      oprot.writeFieldEnd()
10867 
    oprot.writeFieldStop()
10868 
    oprot.writeStructEnd()
10869 
 
10870 
  def validate(self):
10871 
    return
10872 
 
10873 
 
10874 
  def __repr__(self):
10875 
    L = ['%s=%r' % (key, value)
10876 
      for key, value in self.__dict__.iteritems()]
10877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10878 
 
10879 
  def __eq__(self, other):
10880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10881 
 
10882 
  def __ne__(self, other):
10883 
    return not (self == other)
10884 
 
10885 
class getBestDealsCatalogIds_args:
10886 
  """
10887 
  Attributes:
10888 
   - beginIndex
10889 
   - totalItems
10890 
   - brand
10891 
   - category
10892 
  """
10893 
 
10894 
  thrift_spec = (
10895 
    None, # 0
10896 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
10897 
    (2, TType.I64, 'totalItems', None, None, ), # 2
10898 
    (3, TType.STRING, 'brand', None, None, ), # 3
10899 
    (4, TType.I64, 'category', None, None, ), # 4
10900 
  )
10901 
 
10902 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
10903 
    self.beginIndex = beginIndex
10904 
    self.totalItems = totalItems
10905 
    self.brand = brand
10906 
    self.category = category
10907 
 
10908 
  def read(self, iprot):
10909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10911 
      return
10912 
    iprot.readStructBegin()
10913 
    while True:
10914 
      (fname, ftype, fid) = iprot.readFieldBegin()
10915 
      if ftype == TType.STOP:
10916 
        break
10917 
      if fid == 1:
10918 
        if ftype == TType.I64:
10919 
          self.beginIndex = iprot.readI64();
10920 
        else:
10921 
          iprot.skip(ftype)
10922 
      elif fid == 2:
10923 
        if ftype == TType.I64:
10924 
          self.totalItems = iprot.readI64();
10925 
        else:
10926 
          iprot.skip(ftype)
10927 
      elif fid == 3:
10928 
        if ftype == TType.STRING:
10929 
          self.brand = iprot.readString();
10930 
        else:
10931 
          iprot.skip(ftype)
10932 
      elif fid == 4:
10933 
        if ftype == TType.I64:
10934 
          self.category = iprot.readI64();
10935 
        else:
10936 
          iprot.skip(ftype)
10937 
      else:
10938 
        iprot.skip(ftype)
10939 
      iprot.readFieldEnd()
10940 
    iprot.readStructEnd()
10941 
 
10942 
  def write(self, oprot):
10943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10945 
      return
10946 
    oprot.writeStructBegin('getBestDealsCatalogIds_args')
10947 
    if self.beginIndex is not None:
10948 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
10949 
      oprot.writeI64(self.beginIndex)
10950 
      oprot.writeFieldEnd()
10951 
    if self.totalItems is not None:
10952 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
10953 
      oprot.writeI64(self.totalItems)
10954 
      oprot.writeFieldEnd()
10955 
    if self.brand is not None:
10956 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
10957 
      oprot.writeString(self.brand)
10958 
      oprot.writeFieldEnd()
10959 
    if self.category is not None:
10960 
      oprot.writeFieldBegin('category', TType.I64, 4)
10961 
      oprot.writeI64(self.category)
10962 
      oprot.writeFieldEnd()
10963 
    oprot.writeFieldStop()
10964 
    oprot.writeStructEnd()
10965 
 
10966 
  def validate(self):
10967 
    return
10968 
 
10969 
 
10970 
  def __repr__(self):
10971 
    L = ['%s=%r' % (key, value)
10972 
      for key, value in self.__dict__.iteritems()]
10973 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10974 
 
10975 
  def __eq__(self, other):
10976 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10977 
 
10978 
  def __ne__(self, other):
10979 
    return not (self == other)
10980 
 
10981 
class getBestDealsCatalogIds_result:
10982 
  """
10983 
  Attributes:
10984 
   - success
10985 
   - cex
10986 
  """
10987 
 
10988 
  thrift_spec = (
10989 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10990 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10991 
  )
10992 
 
10993 
  def __init__(self, success=None, cex=None,):
10994 
    self.success = success
10995 
    self.cex = cex
10996 
 
10997 
  def read(self, iprot):
10998 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10999 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11000 
      return
11001 
    iprot.readStructBegin()
11002 
    while True:
11003 
      (fname, ftype, fid) = iprot.readFieldBegin()
11004 
      if ftype == TType.STOP:
11005 
        break
11006 
      if fid == 0:
11007 
        if ftype == TType.LIST:
11008 
          self.success = []
8590 kshitij.so 11009 
          (_etype112, _size109) = iprot.readListBegin()
11010 
          for _i113 in xrange(_size109):
11011 
            _elem114 = iprot.readI64();
11012 
            self.success.append(_elem114)
5944 mandeep.dh 11013 
          iprot.readListEnd()
11014 
        else:
11015 
          iprot.skip(ftype)
11016 
      elif fid == 1:
11017 
        if ftype == TType.STRUCT:
11018 
          self.cex = CatalogServiceException()
11019 
          self.cex.read(iprot)
11020 
        else:
11021 
          iprot.skip(ftype)
11022 
      else:
11023 
        iprot.skip(ftype)
11024 
      iprot.readFieldEnd()
11025 
    iprot.readStructEnd()
11026 
 
11027 
  def write(self, oprot):
11028 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11029 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11030 
      return
11031 
    oprot.writeStructBegin('getBestDealsCatalogIds_result')
11032 
    if self.success is not None:
11033 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11034 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 11035 
      for iter115 in self.success:
11036 
        oprot.writeI64(iter115)
5944 mandeep.dh 11037 
      oprot.writeListEnd()
11038 
      oprot.writeFieldEnd()
11039 
    if self.cex is not None:
11040 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11041 
      self.cex.write(oprot)
11042 
      oprot.writeFieldEnd()
11043 
    oprot.writeFieldStop()
11044 
    oprot.writeStructEnd()
11045 
 
11046 
  def validate(self):
11047 
    return
11048 
 
11049 
 
11050 
  def __repr__(self):
11051 
    L = ['%s=%r' % (key, value)
11052 
      for key, value in self.__dict__.iteritems()]
11053 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11054 
 
11055 
  def __eq__(self, other):
11056 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11057 
 
11058 
  def __ne__(self, other):
11059 
    return not (self == other)
11060 
 
11061 
class getBestDealsCount_args:
11062 
 
11063 
  thrift_spec = (
11064 
  )
11065 
 
11066 
  def read(self, iprot):
11067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11069 
      return
11070 
    iprot.readStructBegin()
11071 
    while True:
11072 
      (fname, ftype, fid) = iprot.readFieldBegin()
11073 
      if ftype == TType.STOP:
11074 
        break
11075 
      else:
11076 
        iprot.skip(ftype)
11077 
      iprot.readFieldEnd()
11078 
    iprot.readStructEnd()
11079 
 
11080 
  def write(self, oprot):
11081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11083 
      return
11084 
    oprot.writeStructBegin('getBestDealsCount_args')
11085 
    oprot.writeFieldStop()
11086 
    oprot.writeStructEnd()
11087 
 
11088 
  def validate(self):
11089 
    return
11090 
 
11091 
 
11092 
  def __repr__(self):
11093 
    L = ['%s=%r' % (key, value)
11094 
      for key, value in self.__dict__.iteritems()]
11095 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11096 
 
11097 
  def __eq__(self, other):
11098 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11099 
 
11100 
  def __ne__(self, other):
11101 
    return not (self == other)
11102 
 
11103 
class getBestDealsCount_result:
11104 
  """
11105 
  Attributes:
11106 
   - success
11107 
   - cex
11108 
  """
11109 
 
11110 
  thrift_spec = (
11111 
    (0, TType.I64, 'success', None, None, ), # 0
11112 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11113 
  )
11114 
 
11115 
  def __init__(self, success=None, cex=None,):
11116 
    self.success = success
11117 
    self.cex = cex
11118 
 
11119 
  def read(self, iprot):
11120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11122 
      return
11123 
    iprot.readStructBegin()
11124 
    while True:
11125 
      (fname, ftype, fid) = iprot.readFieldBegin()
11126 
      if ftype == TType.STOP:
11127 
        break
11128 
      if fid == 0:
11129 
        if ftype == TType.I64:
11130 
          self.success = iprot.readI64();
11131 
        else:
11132 
          iprot.skip(ftype)
11133 
      elif fid == 1:
11134 
        if ftype == TType.STRUCT:
11135 
          self.cex = CatalogServiceException()
11136 
          self.cex.read(iprot)
11137 
        else:
11138 
          iprot.skip(ftype)
11139 
      else:
11140 
        iprot.skip(ftype)
11141 
      iprot.readFieldEnd()
11142 
    iprot.readStructEnd()
11143 
 
11144 
  def write(self, oprot):
11145 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11146 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11147 
      return
11148 
    oprot.writeStructBegin('getBestDealsCount_result')
11149 
    if self.success is not None:
11150 
      oprot.writeFieldBegin('success', TType.I64, 0)
11151 
      oprot.writeI64(self.success)
11152 
      oprot.writeFieldEnd()
11153 
    if self.cex is not None:
11154 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11155 
      self.cex.write(oprot)
11156 
      oprot.writeFieldEnd()
11157 
    oprot.writeFieldStop()
11158 
    oprot.writeStructEnd()
11159 
 
11160 
  def validate(self):
11161 
    return
11162 
 
11163 
 
11164 
  def __repr__(self):
11165 
    L = ['%s=%r' % (key, value)
11166 
      for key, value in self.__dict__.iteritems()]
11167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11168 
 
11169 
  def __eq__(self, other):
11170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11171 
 
11172 
  def __ne__(self, other):
11173 
    return not (self == other)
11174 
 
11175 
class getComingSoon_args:
11176 
 
11177 
  thrift_spec = (
11178 
  )
11179 
 
11180 
  def read(self, iprot):
11181 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11182 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11183 
      return
11184 
    iprot.readStructBegin()
11185 
    while True:
11186 
      (fname, ftype, fid) = iprot.readFieldBegin()
11187 
      if ftype == TType.STOP:
11188 
        break
11189 
      else:
11190 
        iprot.skip(ftype)
11191 
      iprot.readFieldEnd()
11192 
    iprot.readStructEnd()
11193 
 
11194 
  def write(self, oprot):
11195 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11196 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11197 
      return
11198 
    oprot.writeStructBegin('getComingSoon_args')
11199 
    oprot.writeFieldStop()
11200 
    oprot.writeStructEnd()
11201 
 
11202 
  def validate(self):
11203 
    return
11204 
 
11205 
 
11206 
  def __repr__(self):
11207 
    L = ['%s=%r' % (key, value)
11208 
      for key, value in self.__dict__.iteritems()]
11209 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11210 
 
11211 
  def __eq__(self, other):
11212 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11213 
 
11214 
  def __ne__(self, other):
11215 
    return not (self == other)
11216 
 
11217 
class getComingSoon_result:
11218 
  """
11219 
  Attributes:
11220 
   - success
11221 
   - isex
11222 
  """
11223 
 
11224 
  thrift_spec = (
11225 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11226 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11227 
  )
11228 
 
11229 
  def __init__(self, success=None, isex=None,):
11230 
    self.success = success
11231 
    self.isex = isex
11232 
 
11233 
  def read(self, iprot):
11234 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11235 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11236 
      return
11237 
    iprot.readStructBegin()
11238 
    while True:
11239 
      (fname, ftype, fid) = iprot.readFieldBegin()
11240 
      if ftype == TType.STOP:
11241 
        break
11242 
      if fid == 0:
11243 
        if ftype == TType.LIST:
11244 
          self.success = []
8590 kshitij.so 11245 
          (_etype119, _size116) = iprot.readListBegin()
11246 
          for _i120 in xrange(_size116):
11247 
            _elem121 = Item()
11248 
            _elem121.read(iprot)
11249 
            self.success.append(_elem121)
5944 mandeep.dh 11250 
          iprot.readListEnd()
11251 
        else:
11252 
          iprot.skip(ftype)
11253 
      elif fid == 1:
11254 
        if ftype == TType.STRUCT:
11255 
          self.isex = CatalogServiceException()
11256 
          self.isex.read(iprot)
11257 
        else:
11258 
          iprot.skip(ftype)
11259 
      else:
11260 
        iprot.skip(ftype)
11261 
      iprot.readFieldEnd()
11262 
    iprot.readStructEnd()
11263 
 
11264 
  def write(self, oprot):
11265 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11266 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11267 
      return
11268 
    oprot.writeStructBegin('getComingSoon_result')
11269 
    if self.success is not None:
11270 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11271 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 11272 
      for iter122 in self.success:
11273 
        iter122.write(oprot)
5944 mandeep.dh 11274 
      oprot.writeListEnd()
11275 
      oprot.writeFieldEnd()
11276 
    if self.isex is not None:
11277 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
11278 
      self.isex.write(oprot)
11279 
      oprot.writeFieldEnd()
11280 
    oprot.writeFieldStop()
11281 
    oprot.writeStructEnd()
11282 
 
11283 
  def validate(self):
11284 
    return
11285 
 
11286 
 
11287 
  def __repr__(self):
11288 
    L = ['%s=%r' % (key, value)
11289 
      for key, value in self.__dict__.iteritems()]
11290 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11291 
 
11292 
  def __eq__(self, other):
11293 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11294 
 
11295 
  def __ne__(self, other):
11296 
    return not (self == other)
11297 
 
11298 
class getComingSoonCatalogIds_args:
11299 
  """
11300 
  Attributes:
11301 
   - beginIndex
11302 
   - totalItems
11303 
   - brand
11304 
   - category
11305 
  """
11306 
 
11307 
  thrift_spec = (
11308 
    None, # 0
11309 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
11310 
    (2, TType.I64, 'totalItems', None, None, ), # 2
11311 
    (3, TType.STRING, 'brand', None, None, ), # 3
11312 
    (4, TType.I64, 'category', None, None, ), # 4
11313 
  )
11314 
 
11315 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
11316 
    self.beginIndex = beginIndex
11317 
    self.totalItems = totalItems
11318 
    self.brand = brand
11319 
    self.category = category
11320 
 
11321 
  def read(self, iprot):
11322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11324 
      return
11325 
    iprot.readStructBegin()
11326 
    while True:
11327 
      (fname, ftype, fid) = iprot.readFieldBegin()
11328 
      if ftype == TType.STOP:
11329 
        break
11330 
      if fid == 1:
11331 
        if ftype == TType.I64:
11332 
          self.beginIndex = iprot.readI64();
11333 
        else:
11334 
          iprot.skip(ftype)
11335 
      elif fid == 2:
11336 
        if ftype == TType.I64:
11337 
          self.totalItems = iprot.readI64();
11338 
        else:
11339 
          iprot.skip(ftype)
11340 
      elif fid == 3:
11341 
        if ftype == TType.STRING:
11342 
          self.brand = iprot.readString();
11343 
        else:
11344 
          iprot.skip(ftype)
11345 
      elif fid == 4:
11346 
        if ftype == TType.I64:
11347 
          self.category = iprot.readI64();
11348 
        else:
11349 
          iprot.skip(ftype)
11350 
      else:
11351 
        iprot.skip(ftype)
11352 
      iprot.readFieldEnd()
11353 
    iprot.readStructEnd()
11354 
 
11355 
  def write(self, oprot):
11356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11358 
      return
11359 
    oprot.writeStructBegin('getComingSoonCatalogIds_args')
11360 
    if self.beginIndex is not None:
11361 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
11362 
      oprot.writeI64(self.beginIndex)
11363 
      oprot.writeFieldEnd()
11364 
    if self.totalItems is not None:
11365 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
11366 
      oprot.writeI64(self.totalItems)
11367 
      oprot.writeFieldEnd()
11368 
    if self.brand is not None:
11369 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
11370 
      oprot.writeString(self.brand)
11371 
      oprot.writeFieldEnd()
11372 
    if self.category is not None:
11373 
      oprot.writeFieldBegin('category', TType.I64, 4)
11374 
      oprot.writeI64(self.category)
11375 
      oprot.writeFieldEnd()
11376 
    oprot.writeFieldStop()
11377 
    oprot.writeStructEnd()
11378 
 
11379 
  def validate(self):
11380 
    return
11381 
 
11382 
 
11383 
  def __repr__(self):
11384 
    L = ['%s=%r' % (key, value)
11385 
      for key, value in self.__dict__.iteritems()]
11386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11387 
 
11388 
  def __eq__(self, other):
11389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11390 
 
11391 
  def __ne__(self, other):
11392 
    return not (self == other)
11393 
 
11394 
class getComingSoonCatalogIds_result:
11395 
  """
11396 
  Attributes:
11397 
   - success
11398 
   - cex
11399 
  """
11400 
 
11401 
  thrift_spec = (
11402 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11403 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11404 
  )
11405 
 
11406 
  def __init__(self, success=None, cex=None,):
11407 
    self.success = success
11408 
    self.cex = cex
11409 
 
11410 
  def read(self, iprot):
11411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11413 
      return
11414 
    iprot.readStructBegin()
11415 
    while True:
11416 
      (fname, ftype, fid) = iprot.readFieldBegin()
11417 
      if ftype == TType.STOP:
11418 
        break
11419 
      if fid == 0:
11420 
        if ftype == TType.LIST:
11421 
          self.success = []
8590 kshitij.so 11422 
          (_etype126, _size123) = iprot.readListBegin()
11423 
          for _i127 in xrange(_size123):
11424 
            _elem128 = iprot.readI64();
11425 
            self.success.append(_elem128)
5944 mandeep.dh 11426 
          iprot.readListEnd()
11427 
        else:
11428 
          iprot.skip(ftype)
11429 
      elif fid == 1:
11430 
        if ftype == TType.STRUCT:
11431 
          self.cex = CatalogServiceException()
11432 
          self.cex.read(iprot)
11433 
        else:
11434 
          iprot.skip(ftype)
11435 
      else:
11436 
        iprot.skip(ftype)
11437 
      iprot.readFieldEnd()
11438 
    iprot.readStructEnd()
11439 
 
11440 
  def write(self, oprot):
11441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11443 
      return
11444 
    oprot.writeStructBegin('getComingSoonCatalogIds_result')
11445 
    if self.success is not None:
11446 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11447 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 11448 
      for iter129 in self.success:
11449 
        oprot.writeI64(iter129)
5944 mandeep.dh 11450 
      oprot.writeListEnd()
11451 
      oprot.writeFieldEnd()
11452 
    if self.cex is not None:
11453 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11454 
      self.cex.write(oprot)
11455 
      oprot.writeFieldEnd()
11456 
    oprot.writeFieldStop()
11457 
    oprot.writeStructEnd()
11458 
 
11459 
  def validate(self):
11460 
    return
11461 
 
11462 
 
11463 
  def __repr__(self):
11464 
    L = ['%s=%r' % (key, value)
11465 
      for key, value in self.__dict__.iteritems()]
11466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11467 
 
11468 
  def __eq__(self, other):
11469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11470 
 
11471 
  def __ne__(self, other):
11472 
    return not (self == other)
11473 
 
11474 
class getComingSoonCount_args:
11475 
 
11476 
  thrift_spec = (
11477 
  )
11478 
 
11479 
  def read(self, iprot):
11480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11482 
      return
11483 
    iprot.readStructBegin()
11484 
    while True:
11485 
      (fname, ftype, fid) = iprot.readFieldBegin()
11486 
      if ftype == TType.STOP:
11487 
        break
11488 
      else:
11489 
        iprot.skip(ftype)
11490 
      iprot.readFieldEnd()
11491 
    iprot.readStructEnd()
11492 
 
11493 
  def write(self, oprot):
11494 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11495 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11496 
      return
11497 
    oprot.writeStructBegin('getComingSoonCount_args')
11498 
    oprot.writeFieldStop()
11499 
    oprot.writeStructEnd()
11500 
 
11501 
  def validate(self):
11502 
    return
11503 
 
11504 
 
11505 
  def __repr__(self):
11506 
    L = ['%s=%r' % (key, value)
11507 
      for key, value in self.__dict__.iteritems()]
11508 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11509 
 
11510 
  def __eq__(self, other):
11511 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11512 
 
11513 
  def __ne__(self, other):
11514 
    return not (self == other)
11515 
 
11516 
class getComingSoonCount_result:
11517 
  """
11518 
  Attributes:
11519 
   - success
11520 
   - cex
11521 
  """
11522 
 
11523 
  thrift_spec = (
11524 
    (0, TType.I64, 'success', None, None, ), # 0
11525 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11526 
  )
11527 
 
11528 
  def __init__(self, success=None, cex=None,):
11529 
    self.success = success
11530 
    self.cex = cex
11531 
 
11532 
  def read(self, iprot):
11533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11535 
      return
11536 
    iprot.readStructBegin()
11537 
    while True:
11538 
      (fname, ftype, fid) = iprot.readFieldBegin()
11539 
      if ftype == TType.STOP:
11540 
        break
11541 
      if fid == 0:
11542 
        if ftype == TType.I64:
11543 
          self.success = iprot.readI64();
11544 
        else:
11545 
          iprot.skip(ftype)
11546 
      elif fid == 1:
11547 
        if ftype == TType.STRUCT:
11548 
          self.cex = CatalogServiceException()
11549 
          self.cex.read(iprot)
11550 
        else:
11551 
          iprot.skip(ftype)
11552 
      else:
11553 
        iprot.skip(ftype)
11554 
      iprot.readFieldEnd()
11555 
    iprot.readStructEnd()
11556 
 
11557 
  def write(self, oprot):
11558 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11559 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11560 
      return
11561 
    oprot.writeStructBegin('getComingSoonCount_result')
11562 
    if self.success is not None:
11563 
      oprot.writeFieldBegin('success', TType.I64, 0)
11564 
      oprot.writeI64(self.success)
11565 
      oprot.writeFieldEnd()
11566 
    if self.cex is not None:
11567 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11568 
      self.cex.write(oprot)
11569 
      oprot.writeFieldEnd()
11570 
    oprot.writeFieldStop()
11571 
    oprot.writeStructEnd()
11572 
 
11573 
  def validate(self):
11574 
    return
11575 
 
11576 
 
11577 
  def __repr__(self):
11578 
    L = ['%s=%r' % (key, value)
11579 
      for key, value in self.__dict__.iteritems()]
11580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11581 
 
11582 
  def __eq__(self, other):
11583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11584 
 
11585 
  def __ne__(self, other):
11586 
    return not (self == other)
11587 
 
11588 
class getLatestArrivals_args:
11589 
 
11590 
  thrift_spec = (
11591 
  )
11592 
 
11593 
  def read(self, iprot):
11594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11596 
      return
11597 
    iprot.readStructBegin()
11598 
    while True:
11599 
      (fname, ftype, fid) = iprot.readFieldBegin()
11600 
      if ftype == TType.STOP:
11601 
        break
11602 
      else:
11603 
        iprot.skip(ftype)
11604 
      iprot.readFieldEnd()
11605 
    iprot.readStructEnd()
11606 
 
11607 
  def write(self, oprot):
11608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11610 
      return
11611 
    oprot.writeStructBegin('getLatestArrivals_args')
11612 
    oprot.writeFieldStop()
11613 
    oprot.writeStructEnd()
11614 
 
11615 
  def validate(self):
11616 
    return
11617 
 
11618 
 
11619 
  def __repr__(self):
11620 
    L = ['%s=%r' % (key, value)
11621 
      for key, value in self.__dict__.iteritems()]
11622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11623 
 
11624 
  def __eq__(self, other):
11625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11626 
 
11627 
  def __ne__(self, other):
11628 
    return not (self == other)
11629 
 
11630 
class getLatestArrivals_result:
11631 
  """
11632 
  Attributes:
11633 
   - success
11634 
   - isex
11635 
  """
11636 
 
11637 
  thrift_spec = (
11638 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11639 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11640 
  )
11641 
 
11642 
  def __init__(self, success=None, isex=None,):
11643 
    self.success = success
11644 
    self.isex = isex
11645 
 
11646 
  def read(self, iprot):
11647 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11648 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11649 
      return
11650 
    iprot.readStructBegin()
11651 
    while True:
11652 
      (fname, ftype, fid) = iprot.readFieldBegin()
11653 
      if ftype == TType.STOP:
11654 
        break
11655 
      if fid == 0:
11656 
        if ftype == TType.LIST:
11657 
          self.success = []
8590 kshitij.so 11658 
          (_etype133, _size130) = iprot.readListBegin()
11659 
          for _i134 in xrange(_size130):
11660 
            _elem135 = Item()
11661 
            _elem135.read(iprot)
11662 
            self.success.append(_elem135)
5944 mandeep.dh 11663 
          iprot.readListEnd()
11664 
        else:
11665 
          iprot.skip(ftype)
11666 
      elif fid == 1:
11667 
        if ftype == TType.STRUCT:
11668 
          self.isex = CatalogServiceException()
11669 
          self.isex.read(iprot)
11670 
        else:
11671 
          iprot.skip(ftype)
11672 
      else:
11673 
        iprot.skip(ftype)
11674 
      iprot.readFieldEnd()
11675 
    iprot.readStructEnd()
11676 
 
11677 
  def write(self, oprot):
11678 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11679 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11680 
      return
11681 
    oprot.writeStructBegin('getLatestArrivals_result')
11682 
    if self.success is not None:
11683 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11684 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 11685 
      for iter136 in self.success:
11686 
        iter136.write(oprot)
5944 mandeep.dh 11687 
      oprot.writeListEnd()
11688 
      oprot.writeFieldEnd()
11689 
    if self.isex is not None:
11690 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
11691 
      self.isex.write(oprot)
11692 
      oprot.writeFieldEnd()
11693 
    oprot.writeFieldStop()
11694 
    oprot.writeStructEnd()
11695 
 
11696 
  def validate(self):
11697 
    return
11698 
 
11699 
 
11700 
  def __repr__(self):
11701 
    L = ['%s=%r' % (key, value)
11702 
      for key, value in self.__dict__.iteritems()]
11703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11704 
 
11705 
  def __eq__(self, other):
11706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11707 
 
11708 
  def __ne__(self, other):
11709 
    return not (self == other)
11710 
 
11711 
class getLatestArrivalsCatalogIds_args:
11712 
  """
11713 
  Attributes:
11714 
   - beginIndex
11715 
   - totalItems
11716 
   - brand
11717 
   - categories
11718 
  """
11719 
 
11720 
  thrift_spec = (
11721 
    None, # 0
11722 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
11723 
    (2, TType.I64, 'totalItems', None, None, ), # 2
11724 
    (3, TType.STRING, 'brand', None, None, ), # 3
11725 
    (4, TType.LIST, 'categories', (TType.I64,None), None, ), # 4
11726 
  )
11727 
 
11728 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, categories=None,):
11729 
    self.beginIndex = beginIndex
11730 
    self.totalItems = totalItems
11731 
    self.brand = brand
11732 
    self.categories = categories
11733 
 
11734 
  def read(self, iprot):
11735 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11736 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11737 
      return
11738 
    iprot.readStructBegin()
11739 
    while True:
11740 
      (fname, ftype, fid) = iprot.readFieldBegin()
11741 
      if ftype == TType.STOP:
11742 
        break
11743 
      if fid == 1:
11744 
        if ftype == TType.I64:
11745 
          self.beginIndex = iprot.readI64();
11746 
        else:
11747 
          iprot.skip(ftype)
11748 
      elif fid == 2:
11749 
        if ftype == TType.I64:
11750 
          self.totalItems = iprot.readI64();
11751 
        else:
11752 
          iprot.skip(ftype)
11753 
      elif fid == 3:
11754 
        if ftype == TType.STRING:
11755 
          self.brand = iprot.readString();
11756 
        else:
11757 
          iprot.skip(ftype)
11758 
      elif fid == 4:
11759 
        if ftype == TType.LIST:
11760 
          self.categories = []
8590 kshitij.so 11761 
          (_etype140, _size137) = iprot.readListBegin()
11762 
          for _i141 in xrange(_size137):
11763 
            _elem142 = iprot.readI64();
11764 
            self.categories.append(_elem142)
5944 mandeep.dh 11765 
          iprot.readListEnd()
11766 
        else:
11767 
          iprot.skip(ftype)
11768 
      else:
11769 
        iprot.skip(ftype)
11770 
      iprot.readFieldEnd()
11771 
    iprot.readStructEnd()
11772 
 
11773 
  def write(self, oprot):
11774 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11775 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11776 
      return
11777 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_args')
11778 
    if self.beginIndex is not None:
11779 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
11780 
      oprot.writeI64(self.beginIndex)
11781 
      oprot.writeFieldEnd()
11782 
    if self.totalItems is not None:
11783 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
11784 
      oprot.writeI64(self.totalItems)
11785 
      oprot.writeFieldEnd()
11786 
    if self.brand is not None:
11787 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
11788 
      oprot.writeString(self.brand)
11789 
      oprot.writeFieldEnd()
11790 
    if self.categories is not None:
11791 
      oprot.writeFieldBegin('categories', TType.LIST, 4)
11792 
      oprot.writeListBegin(TType.I64, len(self.categories))
8590 kshitij.so 11793 
      for iter143 in self.categories:
11794 
        oprot.writeI64(iter143)
5944 mandeep.dh 11795 
      oprot.writeListEnd()
11796 
      oprot.writeFieldEnd()
11797 
    oprot.writeFieldStop()
11798 
    oprot.writeStructEnd()
11799 
 
11800 
  def validate(self):
11801 
    return
11802 
 
11803 
 
11804 
  def __repr__(self):
11805 
    L = ['%s=%r' % (key, value)
11806 
      for key, value in self.__dict__.iteritems()]
11807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11808 
 
11809 
  def __eq__(self, other):
11810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11811 
 
11812 
  def __ne__(self, other):
11813 
    return not (self == other)
11814 
 
11815 
class getLatestArrivalsCatalogIds_result:
11816 
  """
11817 
  Attributes:
11818 
   - success
11819 
   - cex
11820 
  """
11821 
 
11822 
  thrift_spec = (
11823 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11824 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11825 
  )
11826 
 
11827 
  def __init__(self, success=None, cex=None,):
11828 
    self.success = success
11829 
    self.cex = cex
11830 
 
11831 
  def read(self, iprot):
11832 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11833 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11834 
      return
11835 
    iprot.readStructBegin()
11836 
    while True:
11837 
      (fname, ftype, fid) = iprot.readFieldBegin()
11838 
      if ftype == TType.STOP:
11839 
        break
11840 
      if fid == 0:
11841 
        if ftype == TType.LIST:
11842 
          self.success = []
8590 kshitij.so 11843 
          (_etype147, _size144) = iprot.readListBegin()
11844 
          for _i148 in xrange(_size144):
11845 
            _elem149 = iprot.readI64();
11846 
            self.success.append(_elem149)
5944 mandeep.dh 11847 
          iprot.readListEnd()
11848 
        else:
11849 
          iprot.skip(ftype)
11850 
      elif fid == 1:
11851 
        if ftype == TType.STRUCT:
11852 
          self.cex = CatalogServiceException()
11853 
          self.cex.read(iprot)
11854 
        else:
11855 
          iprot.skip(ftype)
11856 
      else:
11857 
        iprot.skip(ftype)
11858 
      iprot.readFieldEnd()
11859 
    iprot.readStructEnd()
11860 
 
11861 
  def write(self, oprot):
11862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11864 
      return
11865 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_result')
11866 
    if self.success is not None:
11867 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11868 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 11869 
      for iter150 in self.success:
11870 
        oprot.writeI64(iter150)
5944 mandeep.dh 11871 
      oprot.writeListEnd()
11872 
      oprot.writeFieldEnd()
11873 
    if self.cex is not None:
11874 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11875 
      self.cex.write(oprot)
11876 
      oprot.writeFieldEnd()
11877 
    oprot.writeFieldStop()
11878 
    oprot.writeStructEnd()
11879 
 
11880 
  def validate(self):
11881 
    return
11882 
 
11883 
 
11884 
  def __repr__(self):
11885 
    L = ['%s=%r' % (key, value)
11886 
      for key, value in self.__dict__.iteritems()]
11887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11888 
 
11889 
  def __eq__(self, other):
11890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11891 
 
11892 
  def __ne__(self, other):
11893 
    return not (self == other)
11894 
 
11895 
class getLatestArrivalsCount_args:
11896 
 
11897 
  thrift_spec = (
11898 
  )
11899 
 
11900 
  def read(self, iprot):
11901 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11902 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11903 
      return
11904 
    iprot.readStructBegin()
11905 
    while True:
11906 
      (fname, ftype, fid) = iprot.readFieldBegin()
11907 
      if ftype == TType.STOP:
11908 
        break
11909 
      else:
11910 
        iprot.skip(ftype)
11911 
      iprot.readFieldEnd()
11912 
    iprot.readStructEnd()
11913 
 
11914 
  def write(self, oprot):
11915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11917 
      return
11918 
    oprot.writeStructBegin('getLatestArrivalsCount_args')
11919 
    oprot.writeFieldStop()
11920 
    oprot.writeStructEnd()
11921 
 
11922 
  def validate(self):
11923 
    return
11924 
 
11925 
 
11926 
  def __repr__(self):
11927 
    L = ['%s=%r' % (key, value)
11928 
      for key, value in self.__dict__.iteritems()]
11929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11930 
 
11931 
  def __eq__(self, other):
11932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11933 
 
11934 
  def __ne__(self, other):
11935 
    return not (self == other)
11936 
 
11937 
class getLatestArrivalsCount_result:
11938 
  """
11939 
  Attributes:
11940 
   - success
11941 
   - cex
11942 
  """
11943 
 
11944 
  thrift_spec = (
11945 
    (0, TType.I64, 'success', None, None, ), # 0
11946 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11947 
  )
11948 
 
11949 
  def __init__(self, success=None, cex=None,):
11950 
    self.success = success
11951 
    self.cex = cex
11952 
 
11953 
  def read(self, iprot):
11954 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11955 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11956 
      return
11957 
    iprot.readStructBegin()
11958 
    while True:
11959 
      (fname, ftype, fid) = iprot.readFieldBegin()
11960 
      if ftype == TType.STOP:
11961 
        break
11962 
      if fid == 0:
11963 
        if ftype == TType.I64:
11964 
          self.success = iprot.readI64();
11965 
        else:
11966 
          iprot.skip(ftype)
11967 
      elif fid == 1:
11968 
        if ftype == TType.STRUCT:
11969 
          self.cex = CatalogServiceException()
11970 
          self.cex.read(iprot)
11971 
        else:
11972 
          iprot.skip(ftype)
11973 
      else:
11974 
        iprot.skip(ftype)
11975 
      iprot.readFieldEnd()
11976 
    iprot.readStructEnd()
11977 
 
11978 
  def write(self, oprot):
11979 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11980 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11981 
      return
11982 
    oprot.writeStructBegin('getLatestArrivalsCount_result')
11983 
    if self.success is not None:
11984 
      oprot.writeFieldBegin('success', TType.I64, 0)
11985 
      oprot.writeI64(self.success)
11986 
      oprot.writeFieldEnd()
11987 
    if self.cex is not None:
11988 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11989 
      self.cex.write(oprot)
11990 
      oprot.writeFieldEnd()
11991 
    oprot.writeFieldStop()
11992 
    oprot.writeStructEnd()
11993 
 
11994 
  def validate(self):
11995 
    return
11996 
 
11997 
 
11998 
  def __repr__(self):
11999 
    L = ['%s=%r' % (key, value)
12000 
      for key, value in self.__dict__.iteritems()]
12001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12002 
 
12003 
  def __eq__(self, other):
12004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12005 
 
12006 
  def __ne__(self, other):
12007 
    return not (self == other)
12008 
 
12009 
class generateNewEntityID_args:
12010 
 
12011 
  thrift_spec = (
12012 
  )
12013 
 
12014 
  def read(self, iprot):
12015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12017 
      return
12018 
    iprot.readStructBegin()
12019 
    while True:
12020 
      (fname, ftype, fid) = iprot.readFieldBegin()
12021 
      if ftype == TType.STOP:
12022 
        break
12023 
      else:
12024 
        iprot.skip(ftype)
12025 
      iprot.readFieldEnd()
12026 
    iprot.readStructEnd()
12027 
 
12028 
  def write(self, oprot):
12029 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12030 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12031 
      return
12032 
    oprot.writeStructBegin('generateNewEntityID_args')
12033 
    oprot.writeFieldStop()
12034 
    oprot.writeStructEnd()
12035 
 
12036 
  def validate(self):
12037 
    return
12038 
 
12039 
 
12040 
  def __repr__(self):
12041 
    L = ['%s=%r' % (key, value)
12042 
      for key, value in self.__dict__.iteritems()]
12043 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12044 
 
12045 
  def __eq__(self, other):
12046 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12047 
 
12048 
  def __ne__(self, other):
12049 
    return not (self == other)
12050 
 
12051 
class generateNewEntityID_result:
12052 
  """
12053 
  Attributes:
12054 
   - success
12055 
  """
12056 
 
12057 
  thrift_spec = (
12058 
    (0, TType.I64, 'success', None, None, ), # 0
12059 
  )
12060 
 
12061 
  def __init__(self, success=None,):
12062 
    self.success = success
12063 
 
12064 
  def read(self, iprot):
12065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12067 
      return
12068 
    iprot.readStructBegin()
12069 
    while True:
12070 
      (fname, ftype, fid) = iprot.readFieldBegin()
12071 
      if ftype == TType.STOP:
12072 
        break
12073 
      if fid == 0:
12074 
        if ftype == TType.I64:
12075 
          self.success = iprot.readI64();
12076 
        else:
12077 
          iprot.skip(ftype)
12078 
      else:
12079 
        iprot.skip(ftype)
12080 
      iprot.readFieldEnd()
12081 
    iprot.readStructEnd()
12082 
 
12083 
  def write(self, oprot):
12084 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12085 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12086 
      return
12087 
    oprot.writeStructBegin('generateNewEntityID_result')
12088 
    if self.success is not None:
12089 
      oprot.writeFieldBegin('success', TType.I64, 0)
12090 
      oprot.writeI64(self.success)
12091 
      oprot.writeFieldEnd()
12092 
    oprot.writeFieldStop()
12093 
    oprot.writeStructEnd()
12094 
 
12095 
  def validate(self):
12096 
    return
12097 
 
12098 
 
12099 
  def __repr__(self):
12100 
    L = ['%s=%r' % (key, value)
12101 
      for key, value in self.__dict__.iteritems()]
12102 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12103 
 
12104 
  def __eq__(self, other):
12105 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12106 
 
12107 
  def __ne__(self, other):
12108 
    return not (self == other)
12109 
 
12110 
class addCategory_args:
12111 
  """
12112 
  Attributes:
12113 
   - category
12114 
  """
12115 
 
12116 
  thrift_spec = (
12117 
    None, # 0
12118 
    (1, TType.STRUCT, 'category', (Category, Category.thrift_spec), None, ), # 1
12119 
  )
12120 
 
12121 
  def __init__(self, category=None,):
12122 
    self.category = category
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 == 1:
12134 
        if ftype == TType.STRUCT:
12135 
          self.category = Category()
12136 
          self.category.read(iprot)
12137 
        else:
12138 
          iprot.skip(ftype)
12139 
      else:
12140 
        iprot.skip(ftype)
12141 
      iprot.readFieldEnd()
12142 
    iprot.readStructEnd()
12143 
 
12144 
  def write(self, oprot):
12145 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12146 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12147 
      return
12148 
    oprot.writeStructBegin('addCategory_args')
12149 
    if self.category is not None:
12150 
      oprot.writeFieldBegin('category', TType.STRUCT, 1)
12151 
      self.category.write(oprot)
12152 
      oprot.writeFieldEnd()
12153 
    oprot.writeFieldStop()
12154 
    oprot.writeStructEnd()
12155 
 
12156 
  def validate(self):
12157 
    return
12158 
 
12159 
 
12160 
  def __repr__(self):
12161 
    L = ['%s=%r' % (key, value)
12162 
      for key, value in self.__dict__.iteritems()]
12163 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12164 
 
12165 
  def __eq__(self, other):
12166 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12167 
 
12168 
  def __ne__(self, other):
12169 
    return not (self == other)
12170 
 
12171 
class addCategory_result:
12172 
  """
12173 
  Attributes:
12174 
   - success
12175 
  """
12176 
 
12177 
  thrift_spec = (
12178 
    (0, TType.BOOL, 'success', None, None, ), # 0
12179 
  )
12180 
 
12181 
  def __init__(self, success=None,):
12182 
    self.success = success
12183 
 
12184 
  def read(self, iprot):
12185 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12186 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12187 
      return
12188 
    iprot.readStructBegin()
12189 
    while True:
12190 
      (fname, ftype, fid) = iprot.readFieldBegin()
12191 
      if ftype == TType.STOP:
12192 
        break
12193 
      if fid == 0:
12194 
        if ftype == TType.BOOL:
12195 
          self.success = iprot.readBool();
12196 
        else:
12197 
          iprot.skip(ftype)
12198 
      else:
12199 
        iprot.skip(ftype)
12200 
      iprot.readFieldEnd()
12201 
    iprot.readStructEnd()
12202 
 
12203 
  def write(self, oprot):
12204 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12205 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12206 
      return
12207 
    oprot.writeStructBegin('addCategory_result')
12208 
    if self.success is not None:
12209 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12210 
      oprot.writeBool(self.success)
12211 
      oprot.writeFieldEnd()
12212 
    oprot.writeFieldStop()
12213 
    oprot.writeStructEnd()
12214 
 
12215 
  def validate(self):
12216 
    return
12217 
 
12218 
 
12219 
  def __repr__(self):
12220 
    L = ['%s=%r' % (key, value)
12221 
      for key, value in self.__dict__.iteritems()]
12222 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12223 
 
12224 
  def __eq__(self, other):
12225 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12226 
 
12227 
  def __ne__(self, other):
12228 
    return not (self == other)
12229 
 
12230 
class getCategory_args:
12231 
  """
12232 
  Attributes:
12233 
   - id
12234 
  """
12235 
 
12236 
  thrift_spec = (
12237 
    None, # 0
12238 
    (1, TType.I64, 'id', None, None, ), # 1
12239 
  )
12240 
 
12241 
  def __init__(self, id=None,):
12242 
    self.id = id
12243 
 
12244 
  def read(self, iprot):
12245 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12246 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12247 
      return
12248 
    iprot.readStructBegin()
12249 
    while True:
12250 
      (fname, ftype, fid) = iprot.readFieldBegin()
12251 
      if ftype == TType.STOP:
12252 
        break
12253 
      if fid == 1:
12254 
        if ftype == TType.I64:
12255 
          self.id = iprot.readI64();
12256 
        else:
12257 
          iprot.skip(ftype)
12258 
      else:
12259 
        iprot.skip(ftype)
12260 
      iprot.readFieldEnd()
12261 
    iprot.readStructEnd()
12262 
 
12263 
  def write(self, oprot):
12264 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12265 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12266 
      return
12267 
    oprot.writeStructBegin('getCategory_args')
12268 
    if self.id is not None:
12269 
      oprot.writeFieldBegin('id', TType.I64, 1)
12270 
      oprot.writeI64(self.id)
12271 
      oprot.writeFieldEnd()
12272 
    oprot.writeFieldStop()
12273 
    oprot.writeStructEnd()
12274 
 
12275 
  def validate(self):
12276 
    return
12277 
 
12278 
 
12279 
  def __repr__(self):
12280 
    L = ['%s=%r' % (key, value)
12281 
      for key, value in self.__dict__.iteritems()]
12282 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12283 
 
12284 
  def __eq__(self, other):
12285 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12286 
 
12287 
  def __ne__(self, other):
12288 
    return not (self == other)
12289 
 
12290 
class getCategory_result:
12291 
  """
12292 
  Attributes:
12293 
   - success
12294 
  """
12295 
 
12296 
  thrift_spec = (
12297 
    (0, TType.STRUCT, 'success', (Category, Category.thrift_spec), None, ), # 0
12298 
  )
12299 
 
12300 
  def __init__(self, success=None,):
12301 
    self.success = success
12302 
 
12303 
  def read(self, iprot):
12304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12306 
      return
12307 
    iprot.readStructBegin()
12308 
    while True:
12309 
      (fname, ftype, fid) = iprot.readFieldBegin()
12310 
      if ftype == TType.STOP:
12311 
        break
12312 
      if fid == 0:
12313 
        if ftype == TType.STRUCT:
12314 
          self.success = Category()
12315 
          self.success.read(iprot)
12316 
        else:
12317 
          iprot.skip(ftype)
12318 
      else:
12319 
        iprot.skip(ftype)
12320 
      iprot.readFieldEnd()
12321 
    iprot.readStructEnd()
12322 
 
12323 
  def write(self, oprot):
12324 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12325 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12326 
      return
12327 
    oprot.writeStructBegin('getCategory_result')
12328 
    if self.success is not None:
12329 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12330 
      self.success.write(oprot)
12331 
      oprot.writeFieldEnd()
12332 
    oprot.writeFieldStop()
12333 
    oprot.writeStructEnd()
12334 
 
12335 
  def validate(self):
12336 
    return
12337 
 
12338 
 
12339 
  def __repr__(self):
12340 
    L = ['%s=%r' % (key, value)
12341 
      for key, value in self.__dict__.iteritems()]
12342 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12343 
 
12344 
  def __eq__(self, other):
12345 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12346 
 
12347 
  def __ne__(self, other):
12348 
    return not (self == other)
12349 
 
12350 
class getAllCategories_args:
12351 
 
12352 
  thrift_spec = (
12353 
  )
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 
      else:
12365 
        iprot.skip(ftype)
12366 
      iprot.readFieldEnd()
12367 
    iprot.readStructEnd()
12368 
 
12369 
  def write(self, oprot):
12370 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12371 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12372 
      return
12373 
    oprot.writeStructBegin('getAllCategories_args')
12374 
    oprot.writeFieldStop()
12375 
    oprot.writeStructEnd()
12376 
 
12377 
  def validate(self):
12378 
    return
12379 
 
12380 
 
12381 
  def __repr__(self):
12382 
    L = ['%s=%r' % (key, value)
12383 
      for key, value in self.__dict__.iteritems()]
12384 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12385 
 
12386 
  def __eq__(self, other):
12387 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12388 
 
12389 
  def __ne__(self, other):
12390 
    return not (self == other)
12391 
 
12392 
class getAllCategories_result:
12393 
  """
12394 
  Attributes:
12395 
   - success
12396 
  """
12397 
 
12398 
  thrift_spec = (
12399 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
12400 
  )
12401 
 
12402 
  def __init__(self, success=None,):
12403 
    self.success = success
12404 
 
12405 
  def read(self, iprot):
12406 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12407 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12408 
      return
12409 
    iprot.readStructBegin()
12410 
    while True:
12411 
      (fname, ftype, fid) = iprot.readFieldBegin()
12412 
      if ftype == TType.STOP:
12413 
        break
12414 
      if fid == 0:
12415 
        if ftype == TType.LIST:
12416 
          self.success = []
8590 kshitij.so 12417 
          (_etype154, _size151) = iprot.readListBegin()
12418 
          for _i155 in xrange(_size151):
12419 
            _elem156 = Category()
12420 
            _elem156.read(iprot)
12421 
            self.success.append(_elem156)
5944 mandeep.dh 12422 
          iprot.readListEnd()
12423 
        else:
12424 
          iprot.skip(ftype)
12425 
      else:
12426 
        iprot.skip(ftype)
12427 
      iprot.readFieldEnd()
12428 
    iprot.readStructEnd()
12429 
 
12430 
  def write(self, oprot):
12431 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12432 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12433 
      return
12434 
    oprot.writeStructBegin('getAllCategories_result')
12435 
    if self.success is not None:
12436 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12437 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 12438 
      for iter157 in self.success:
12439 
        iter157.write(oprot)
5944 mandeep.dh 12440 
      oprot.writeListEnd()
12441 
      oprot.writeFieldEnd()
12442 
    oprot.writeFieldStop()
12443 
    oprot.writeStructEnd()
12444 
 
12445 
  def validate(self):
12446 
    return
12447 
 
12448 
 
12449 
  def __repr__(self):
12450 
    L = ['%s=%r' % (key, value)
12451 
      for key, value in self.__dict__.iteritems()]
12452 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12453 
 
12454 
  def __eq__(self, other):
12455 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12456 
 
12457 
  def __ne__(self, other):
12458 
    return not (self == other)
12459 
 
12460 
class getAllSimilarItems_args:
12461 
  """
12462 
  Attributes:
12463 
   - itemId
12464 
  """
12465 
 
12466 
  thrift_spec = (
12467 
    None, # 0
12468 
    (1, TType.I64, 'itemId', None, None, ), # 1
12469 
  )
12470 
 
12471 
  def __init__(self, itemId=None,):
12472 
    self.itemId = itemId
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 == 1:
12484 
        if ftype == TType.I64:
12485 
          self.itemId = iprot.readI64();
12486 
        else:
12487 
          iprot.skip(ftype)
12488 
      else:
12489 
        iprot.skip(ftype)
12490 
      iprot.readFieldEnd()
12491 
    iprot.readStructEnd()
12492 
 
12493 
  def write(self, oprot):
12494 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12495 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12496 
      return
12497 
    oprot.writeStructBegin('getAllSimilarItems_args')
12498 
    if self.itemId is not None:
12499 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12500 
      oprot.writeI64(self.itemId)
12501 
      oprot.writeFieldEnd()
12502 
    oprot.writeFieldStop()
12503 
    oprot.writeStructEnd()
12504 
 
12505 
  def validate(self):
12506 
    return
12507 
 
12508 
 
12509 
  def __repr__(self):
12510 
    L = ['%s=%r' % (key, value)
12511 
      for key, value in self.__dict__.iteritems()]
12512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12513 
 
12514 
  def __eq__(self, other):
12515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12516 
 
12517 
  def __ne__(self, other):
12518 
    return not (self == other)
12519 
 
12520 
class getAllSimilarItems_result:
12521 
  """
12522 
  Attributes:
12523 
   - success
12524 
  """
12525 
 
12526 
  thrift_spec = (
12527 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12528 
  )
12529 
 
12530 
  def __init__(self, success=None,):
12531 
    self.success = success
12532 
 
12533 
  def read(self, iprot):
12534 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12535 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12536 
      return
12537 
    iprot.readStructBegin()
12538 
    while True:
12539 
      (fname, ftype, fid) = iprot.readFieldBegin()
12540 
      if ftype == TType.STOP:
12541 
        break
12542 
      if fid == 0:
12543 
        if ftype == TType.LIST:
12544 
          self.success = []
8590 kshitij.so 12545 
          (_etype161, _size158) = iprot.readListBegin()
12546 
          for _i162 in xrange(_size158):
12547 
            _elem163 = Item()
12548 
            _elem163.read(iprot)
12549 
            self.success.append(_elem163)
5944 mandeep.dh 12550 
          iprot.readListEnd()
12551 
        else:
12552 
          iprot.skip(ftype)
12553 
      else:
12554 
        iprot.skip(ftype)
12555 
      iprot.readFieldEnd()
12556 
    iprot.readStructEnd()
12557 
 
12558 
  def write(self, oprot):
12559 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12560 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12561 
      return
12562 
    oprot.writeStructBegin('getAllSimilarItems_result')
12563 
    if self.success is not None:
12564 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12565 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 12566 
      for iter164 in self.success:
12567 
        iter164.write(oprot)
5944 mandeep.dh 12568 
      oprot.writeListEnd()
12569 
      oprot.writeFieldEnd()
12570 
    oprot.writeFieldStop()
12571 
    oprot.writeStructEnd()
12572 
 
12573 
  def validate(self):
12574 
    return
12575 
 
12576 
 
12577 
  def __repr__(self):
12578 
    L = ['%s=%r' % (key, value)
12579 
      for key, value in self.__dict__.iteritems()]
12580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12581 
 
12582 
  def __eq__(self, other):
12583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12584 
 
12585 
  def __ne__(self, other):
12586 
    return not (self == other)
12587 
 
12588 
class addSimilarItem_args:
12589 
  """
12590 
  Attributes:
12591 
   - itemId
12592 
   - catalogItemId
12593 
  """
12594 
 
12595 
  thrift_spec = (
12596 
    None, # 0
12597 
    (1, TType.I64, 'itemId', None, None, ), # 1
12598 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
12599 
  )
12600 
 
12601 
  def __init__(self, itemId=None, catalogItemId=None,):
12602 
    self.itemId = itemId
12603 
    self.catalogItemId = catalogItemId
12604 
 
12605 
  def read(self, iprot):
12606 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12607 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12608 
      return
12609 
    iprot.readStructBegin()
12610 
    while True:
12611 
      (fname, ftype, fid) = iprot.readFieldBegin()
12612 
      if ftype == TType.STOP:
12613 
        break
12614 
      if fid == 1:
12615 
        if ftype == TType.I64:
12616 
          self.itemId = iprot.readI64();
12617 
        else:
12618 
          iprot.skip(ftype)
12619 
      elif fid == 2:
12620 
        if ftype == TType.I64:
12621 
          self.catalogItemId = iprot.readI64();
12622 
        else:
12623 
          iprot.skip(ftype)
12624 
      else:
12625 
        iprot.skip(ftype)
12626 
      iprot.readFieldEnd()
12627 
    iprot.readStructEnd()
12628 
 
12629 
  def write(self, oprot):
12630 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12631 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12632 
      return
12633 
    oprot.writeStructBegin('addSimilarItem_args')
12634 
    if self.itemId is not None:
12635 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12636 
      oprot.writeI64(self.itemId)
12637 
      oprot.writeFieldEnd()
12638 
    if self.catalogItemId is not None:
12639 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
12640 
      oprot.writeI64(self.catalogItemId)
12641 
      oprot.writeFieldEnd()
12642 
    oprot.writeFieldStop()
12643 
    oprot.writeStructEnd()
12644 
 
12645 
  def validate(self):
12646 
    return
12647 
 
12648 
 
12649 
  def __repr__(self):
12650 
    L = ['%s=%r' % (key, value)
12651 
      for key, value in self.__dict__.iteritems()]
12652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12653 
 
12654 
  def __eq__(self, other):
12655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12656 
 
12657 
  def __ne__(self, other):
12658 
    return not (self == other)
12659 
 
12660 
class addSimilarItem_result:
12661 
  """
12662 
  Attributes:
12663 
   - success
12664 
   - cex
12665 
  """
12666 
 
12667 
  thrift_spec = (
12668 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
12669 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12670 
  )
12671 
 
12672 
  def __init__(self, success=None, cex=None,):
12673 
    self.success = success
12674 
    self.cex = cex
12675 
 
12676 
  def read(self, iprot):
12677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12679 
      return
12680 
    iprot.readStructBegin()
12681 
    while True:
12682 
      (fname, ftype, fid) = iprot.readFieldBegin()
12683 
      if ftype == TType.STOP:
12684 
        break
12685 
      if fid == 0:
12686 
        if ftype == TType.STRUCT:
12687 
          self.success = Item()
12688 
          self.success.read(iprot)
12689 
        else:
12690 
          iprot.skip(ftype)
12691 
      elif fid == 1:
12692 
        if ftype == TType.STRUCT:
12693 
          self.cex = CatalogServiceException()
12694 
          self.cex.read(iprot)
12695 
        else:
12696 
          iprot.skip(ftype)
12697 
      else:
12698 
        iprot.skip(ftype)
12699 
      iprot.readFieldEnd()
12700 
    iprot.readStructEnd()
12701 
 
12702 
  def write(self, oprot):
12703 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12704 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12705 
      return
12706 
    oprot.writeStructBegin('addSimilarItem_result')
12707 
    if self.success is not None:
12708 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12709 
      self.success.write(oprot)
12710 
      oprot.writeFieldEnd()
12711 
    if self.cex is not None:
12712 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
12713 
      self.cex.write(oprot)
12714 
      oprot.writeFieldEnd()
12715 
    oprot.writeFieldStop()
12716 
    oprot.writeStructEnd()
12717 
 
12718 
  def validate(self):
12719 
    return
12720 
 
12721 
 
12722 
  def __repr__(self):
12723 
    L = ['%s=%r' % (key, value)
12724 
      for key, value in self.__dict__.iteritems()]
12725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12726 
 
12727 
  def __eq__(self, other):
12728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12729 
 
12730 
  def __ne__(self, other):
12731 
    return not (self == other)
12732 
 
6512 kshitij.so 12733 
class addTag_args:
12734 
  """
12735 
  Attributes:
12736 
   - displayName
12737 
   - itemId
12738 
  """
12739 
 
12740 
  thrift_spec = (
12741 
    None, # 0
12742 
    (1, TType.STRING, 'displayName', None, None, ), # 1
12743 
    (2, TType.I64, 'itemId', None, None, ), # 2
12744 
  )
12745 
 
12746 
  def __init__(self, displayName=None, itemId=None,):
12747 
    self.displayName = displayName
12748 
    self.itemId = itemId
12749 
 
12750 
  def read(self, iprot):
12751 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12752 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12753 
      return
12754 
    iprot.readStructBegin()
12755 
    while True:
12756 
      (fname, ftype, fid) = iprot.readFieldBegin()
12757 
      if ftype == TType.STOP:
12758 
        break
12759 
      if fid == 1:
12760 
        if ftype == TType.STRING:
12761 
          self.displayName = iprot.readString();
12762 
        else:
12763 
          iprot.skip(ftype)
12764 
      elif fid == 2:
12765 
        if ftype == TType.I64:
12766 
          self.itemId = iprot.readI64();
12767 
        else:
12768 
          iprot.skip(ftype)
12769 
      else:
12770 
        iprot.skip(ftype)
12771 
      iprot.readFieldEnd()
12772 
    iprot.readStructEnd()
12773 
 
12774 
  def write(self, oprot):
12775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12777 
      return
12778 
    oprot.writeStructBegin('addTag_args')
12779 
    if self.displayName is not None:
12780 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
12781 
      oprot.writeString(self.displayName)
12782 
      oprot.writeFieldEnd()
12783 
    if self.itemId is not None:
12784 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12785 
      oprot.writeI64(self.itemId)
12786 
      oprot.writeFieldEnd()
12787 
    oprot.writeFieldStop()
12788 
    oprot.writeStructEnd()
12789 
 
12790 
  def validate(self):
12791 
    return
12792 
 
12793 
 
12794 
  def __repr__(self):
12795 
    L = ['%s=%r' % (key, value)
12796 
      for key, value in self.__dict__.iteritems()]
12797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12798 
 
12799 
  def __eq__(self, other):
12800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12801 
 
12802 
  def __ne__(self, other):
12803 
    return not (self == other)
12804 
 
12805 
class addTag_result:
12806 
  """
12807 
  Attributes:
12808 
   - success
12809 
  """
12810 
 
12811 
  thrift_spec = (
12812 
    (0, TType.BOOL, 'success', None, None, ), # 0
12813 
  )
12814 
 
12815 
  def __init__(self, success=None,):
12816 
    self.success = success
12817 
 
12818 
  def read(self, iprot):
12819 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12820 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12821 
      return
12822 
    iprot.readStructBegin()
12823 
    while True:
12824 
      (fname, ftype, fid) = iprot.readFieldBegin()
12825 
      if ftype == TType.STOP:
12826 
        break
12827 
      if fid == 0:
12828 
        if ftype == TType.BOOL:
12829 
          self.success = iprot.readBool();
12830 
        else:
12831 
          iprot.skip(ftype)
12832 
      else:
12833 
        iprot.skip(ftype)
12834 
      iprot.readFieldEnd()
12835 
    iprot.readStructEnd()
12836 
 
12837 
  def write(self, oprot):
12838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12840 
      return
12841 
    oprot.writeStructBegin('addTag_result')
12842 
    if self.success is not None:
12843 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12844 
      oprot.writeBool(self.success)
12845 
      oprot.writeFieldEnd()
12846 
    oprot.writeFieldStop()
12847 
    oprot.writeStructEnd()
12848 
 
12849 
  def validate(self):
12850 
    return
12851 
 
12852 
 
12853 
  def __repr__(self):
12854 
    L = ['%s=%r' % (key, value)
12855 
      for key, value in self.__dict__.iteritems()]
12856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12857 
 
12858 
  def __eq__(self, other):
12859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12860 
 
12861 
  def __ne__(self, other):
12862 
    return not (self == other)
12863 
 
12864 
class deleteEntityTag_args:
12865 
  """
12866 
  Attributes:
12867 
   - displayName
12868 
   - itemId
12869 
  """
12870 
 
12871 
  thrift_spec = (
12872 
    None, # 0
12873 
    (1, TType.STRING, 'displayName', None, None, ), # 1
12874 
    (2, TType.I64, 'itemId', None, None, ), # 2
12875 
  )
12876 
 
12877 
  def __init__(self, displayName=None, itemId=None,):
12878 
    self.displayName = displayName
12879 
    self.itemId = itemId
12880 
 
12881 
  def read(self, iprot):
12882 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12883 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12884 
      return
12885 
    iprot.readStructBegin()
12886 
    while True:
12887 
      (fname, ftype, fid) = iprot.readFieldBegin()
12888 
      if ftype == TType.STOP:
12889 
        break
12890 
      if fid == 1:
12891 
        if ftype == TType.STRING:
12892 
          self.displayName = iprot.readString();
12893 
        else:
12894 
          iprot.skip(ftype)
12895 
      elif fid == 2:
12896 
        if ftype == TType.I64:
12897 
          self.itemId = iprot.readI64();
12898 
        else:
12899 
          iprot.skip(ftype)
12900 
      else:
12901 
        iprot.skip(ftype)
12902 
      iprot.readFieldEnd()
12903 
    iprot.readStructEnd()
12904 
 
12905 
  def write(self, oprot):
12906 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12907 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12908 
      return
12909 
    oprot.writeStructBegin('deleteEntityTag_args')
12910 
    if self.displayName is not None:
12911 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
12912 
      oprot.writeString(self.displayName)
12913 
      oprot.writeFieldEnd()
12914 
    if self.itemId is not None:
12915 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12916 
      oprot.writeI64(self.itemId)
12917 
      oprot.writeFieldEnd()
12918 
    oprot.writeFieldStop()
12919 
    oprot.writeStructEnd()
12920 
 
12921 
  def validate(self):
12922 
    return
12923 
 
12924 
 
12925 
  def __repr__(self):
12926 
    L = ['%s=%r' % (key, value)
12927 
      for key, value in self.__dict__.iteritems()]
12928 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12929 
 
12930 
  def __eq__(self, other):
12931 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12932 
 
12933 
  def __ne__(self, other):
12934 
    return not (self == other)
12935 
 
12936 
class deleteEntityTag_result:
12937 
  """
12938 
  Attributes:
12939 
   - success
12940 
  """
12941 
 
12942 
  thrift_spec = (
12943 
    (0, TType.BOOL, 'success', None, None, ), # 0
12944 
  )
12945 
 
12946 
  def __init__(self, success=None,):
12947 
    self.success = success
12948 
 
12949 
  def read(self, iprot):
12950 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12951 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12952 
      return
12953 
    iprot.readStructBegin()
12954 
    while True:
12955 
      (fname, ftype, fid) = iprot.readFieldBegin()
12956 
      if ftype == TType.STOP:
12957 
        break
12958 
      if fid == 0:
12959 
        if ftype == TType.BOOL:
12960 
          self.success = iprot.readBool();
12961 
        else:
12962 
          iprot.skip(ftype)
12963 
      else:
12964 
        iprot.skip(ftype)
12965 
      iprot.readFieldEnd()
12966 
    iprot.readStructEnd()
12967 
 
12968 
  def write(self, oprot):
12969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12971 
      return
12972 
    oprot.writeStructBegin('deleteEntityTag_result')
12973 
    if self.success is not None:
12974 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12975 
      oprot.writeBool(self.success)
12976 
      oprot.writeFieldEnd()
12977 
    oprot.writeFieldStop()
12978 
    oprot.writeStructEnd()
12979 
 
12980 
  def validate(self):
12981 
    return
12982 
 
12983 
 
12984 
  def __repr__(self):
12985 
    L = ['%s=%r' % (key, value)
12986 
      for key, value in self.__dict__.iteritems()]
12987 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12988 
 
12989 
  def __eq__(self, other):
12990 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12991 
 
12992 
  def __ne__(self, other):
12993 
    return not (self == other)
12994 
 
12995 
class deleteTag_args:
12996 
  """
12997 
  Attributes:
12998 
   - displayName
12999 
  """
13000 
 
13001 
  thrift_spec = (
13002 
    None, # 0
13003 
    (1, TType.STRING, 'displayName', None, None, ), # 1
13004 
  )
13005 
 
13006 
  def __init__(self, displayName=None,):
13007 
    self.displayName = displayName
13008 
 
13009 
  def read(self, iprot):
13010 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13011 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13012 
      return
13013 
    iprot.readStructBegin()
13014 
    while True:
13015 
      (fname, ftype, fid) = iprot.readFieldBegin()
13016 
      if ftype == TType.STOP:
13017 
        break
13018 
      if fid == 1:
13019 
        if ftype == TType.STRING:
13020 
          self.displayName = iprot.readString();
13021 
        else:
13022 
          iprot.skip(ftype)
13023 
      else:
13024 
        iprot.skip(ftype)
13025 
      iprot.readFieldEnd()
13026 
    iprot.readStructEnd()
13027 
 
13028 
  def write(self, oprot):
13029 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13030 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13031 
      return
13032 
    oprot.writeStructBegin('deleteTag_args')
13033 
    if self.displayName is not None:
13034 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
13035 
      oprot.writeString(self.displayName)
13036 
      oprot.writeFieldEnd()
13037 
    oprot.writeFieldStop()
13038 
    oprot.writeStructEnd()
13039 
 
13040 
  def validate(self):
13041 
    return
13042 
 
13043 
 
13044 
  def __repr__(self):
13045 
    L = ['%s=%r' % (key, value)
13046 
      for key, value in self.__dict__.iteritems()]
13047 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13048 
 
13049 
  def __eq__(self, other):
13050 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13051 
 
13052 
  def __ne__(self, other):
13053 
    return not (self == other)
13054 
 
13055 
class deleteTag_result:
13056 
  """
13057 
  Attributes:
13058 
   - success
13059 
  """
13060 
 
13061 
  thrift_spec = (
13062 
    (0, TType.BOOL, 'success', None, None, ), # 0
13063 
  )
13064 
 
13065 
  def __init__(self, success=None,):
13066 
    self.success = success
13067 
 
13068 
  def read(self, iprot):
13069 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13070 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13071 
      return
13072 
    iprot.readStructBegin()
13073 
    while True:
13074 
      (fname, ftype, fid) = iprot.readFieldBegin()
13075 
      if ftype == TType.STOP:
13076 
        break
13077 
      if fid == 0:
13078 
        if ftype == TType.BOOL:
13079 
          self.success = iprot.readBool();
13080 
        else:
13081 
          iprot.skip(ftype)
13082 
      else:
13083 
        iprot.skip(ftype)
13084 
      iprot.readFieldEnd()
13085 
    iprot.readStructEnd()
13086 
 
13087 
  def write(self, oprot):
13088 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13089 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13090 
      return
13091 
    oprot.writeStructBegin('deleteTag_result')
13092 
    if self.success is not None:
13093 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13094 
      oprot.writeBool(self.success)
13095 
      oprot.writeFieldEnd()
13096 
    oprot.writeFieldStop()
13097 
    oprot.writeStructEnd()
13098 
 
13099 
  def validate(self):
13100 
    return
13101 
 
13102 
 
13103 
  def __repr__(self):
13104 
    L = ['%s=%r' % (key, value)
13105 
      for key, value in self.__dict__.iteritems()]
13106 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13107 
 
13108 
  def __eq__(self, other):
13109 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13110 
 
13111 
  def __ne__(self, other):
13112 
    return not (self == other)
13113 
 
13114 
class getAllTags_args:
13115 
 
13116 
  thrift_spec = (
13117 
  )
13118 
 
13119 
  def read(self, iprot):
13120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13122 
      return
13123 
    iprot.readStructBegin()
13124 
    while True:
13125 
      (fname, ftype, fid) = iprot.readFieldBegin()
13126 
      if ftype == TType.STOP:
13127 
        break
13128 
      else:
13129 
        iprot.skip(ftype)
13130 
      iprot.readFieldEnd()
13131 
    iprot.readStructEnd()
13132 
 
13133 
  def write(self, oprot):
13134 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13135 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13136 
      return
13137 
    oprot.writeStructBegin('getAllTags_args')
13138 
    oprot.writeFieldStop()
13139 
    oprot.writeStructEnd()
13140 
 
13141 
  def validate(self):
13142 
    return
13143 
 
13144 
 
13145 
  def __repr__(self):
13146 
    L = ['%s=%r' % (key, value)
13147 
      for key, value in self.__dict__.iteritems()]
13148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13149 
 
13150 
  def __eq__(self, other):
13151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13152 
 
13153 
  def __ne__(self, other):
13154 
    return not (self == other)
13155 
 
13156 
class getAllTags_result:
13157 
  """
13158 
  Attributes:
13159 
   - success
13160 
  """
13161 
 
13162 
  thrift_spec = (
13163 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
13164 
  )
13165 
 
13166 
  def __init__(self, success=None,):
13167 
    self.success = success
13168 
 
13169 
  def read(self, iprot):
13170 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13171 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13172 
      return
13173 
    iprot.readStructBegin()
13174 
    while True:
13175 
      (fname, ftype, fid) = iprot.readFieldBegin()
13176 
      if ftype == TType.STOP:
13177 
        break
13178 
      if fid == 0:
13179 
        if ftype == TType.LIST:
13180 
          self.success = []
8590 kshitij.so 13181 
          (_etype168, _size165) = iprot.readListBegin()
13182 
          for _i169 in xrange(_size165):
13183 
            _elem170 = iprot.readString();
13184 
            self.success.append(_elem170)
6512 kshitij.so 13185 
          iprot.readListEnd()
13186 
        else:
13187 
          iprot.skip(ftype)
13188 
      else:
13189 
        iprot.skip(ftype)
13190 
      iprot.readFieldEnd()
13191 
    iprot.readStructEnd()
13192 
 
13193 
  def write(self, oprot):
13194 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13195 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13196 
      return
13197 
    oprot.writeStructBegin('getAllTags_result')
13198 
    if self.success is not None:
13199 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13200 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 13201 
      for iter171 in self.success:
13202 
        oprot.writeString(iter171)
6512 kshitij.so 13203 
      oprot.writeListEnd()
13204 
      oprot.writeFieldEnd()
13205 
    oprot.writeFieldStop()
13206 
    oprot.writeStructEnd()
13207 
 
13208 
  def validate(self):
13209 
    return
13210 
 
13211 
 
13212 
  def __repr__(self):
13213 
    L = ['%s=%r' % (key, value)
13214 
      for key, value in self.__dict__.iteritems()]
13215 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13216 
 
13217 
  def __eq__(self, other):
13218 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13219 
 
13220 
  def __ne__(self, other):
13221 
    return not (self == other)
13222 
 
13223 
class getAllEntitiesByTagName_args:
13224 
  """
13225 
  Attributes:
13226 
   - displayName
13227 
  """
13228 
 
13229 
  thrift_spec = (
13230 
    None, # 0
13231 
    (1, TType.STRING, 'displayName', None, None, ), # 1
13232 
  )
13233 
 
13234 
  def __init__(self, displayName=None,):
13235 
    self.displayName = displayName
13236 
 
13237 
  def read(self, iprot):
13238 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13239 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13240 
      return
13241 
    iprot.readStructBegin()
13242 
    while True:
13243 
      (fname, ftype, fid) = iprot.readFieldBegin()
13244 
      if ftype == TType.STOP:
13245 
        break
13246 
      if fid == 1:
13247 
        if ftype == TType.STRING:
13248 
          self.displayName = iprot.readString();
13249 
        else:
13250 
          iprot.skip(ftype)
13251 
      else:
13252 
        iprot.skip(ftype)
13253 
      iprot.readFieldEnd()
13254 
    iprot.readStructEnd()
13255 
 
13256 
  def write(self, oprot):
13257 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13258 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13259 
      return
13260 
    oprot.writeStructBegin('getAllEntitiesByTagName_args')
13261 
    if self.displayName is not None:
13262 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
13263 
      oprot.writeString(self.displayName)
13264 
      oprot.writeFieldEnd()
13265 
    oprot.writeFieldStop()
13266 
    oprot.writeStructEnd()
13267 
 
13268 
  def validate(self):
13269 
    return
13270 
 
13271 
 
13272 
  def __repr__(self):
13273 
    L = ['%s=%r' % (key, value)
13274 
      for key, value in self.__dict__.iteritems()]
13275 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13276 
 
13277 
  def __eq__(self, other):
13278 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13279 
 
13280 
  def __ne__(self, other):
13281 
    return not (self == other)
13282 
 
13283 
class getAllEntitiesByTagName_result:
13284 
  """
13285 
  Attributes:
13286 
   - success
13287 
  """
13288 
 
13289 
  thrift_spec = (
13290 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
13291 
  )
13292 
 
13293 
  def __init__(self, success=None,):
13294 
    self.success = success
13295 
 
13296 
  def read(self, iprot):
13297 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13298 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13299 
      return
13300 
    iprot.readStructBegin()
13301 
    while True:
13302 
      (fname, ftype, fid) = iprot.readFieldBegin()
13303 
      if ftype == TType.STOP:
13304 
        break
13305 
      if fid == 0:
13306 
        if ftype == TType.LIST:
13307 
          self.success = []
8590 kshitij.so 13308 
          (_etype175, _size172) = iprot.readListBegin()
13309 
          for _i176 in xrange(_size172):
13310 
            _elem177 = iprot.readI64();
13311 
            self.success.append(_elem177)
6512 kshitij.so 13312 
          iprot.readListEnd()
13313 
        else:
13314 
          iprot.skip(ftype)
13315 
      else:
13316 
        iprot.skip(ftype)
13317 
      iprot.readFieldEnd()
13318 
    iprot.readStructEnd()
13319 
 
13320 
  def write(self, oprot):
13321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13323 
      return
13324 
    oprot.writeStructBegin('getAllEntitiesByTagName_result')
13325 
    if self.success is not None:
13326 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13327 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 13328 
      for iter178 in self.success:
13329 
        oprot.writeI64(iter178)
6512 kshitij.so 13330 
      oprot.writeListEnd()
13331 
      oprot.writeFieldEnd()
13332 
    oprot.writeFieldStop()
13333 
    oprot.writeStructEnd()
13334 
 
13335 
  def validate(self):
13336 
    return
13337 
 
13338 
 
13339 
  def __repr__(self):
13340 
    L = ['%s=%r' % (key, value)
13341 
      for key, value in self.__dict__.iteritems()]
13342 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13343 
 
13344 
  def __eq__(self, other):
13345 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13346 
 
13347 
  def __ne__(self, other):
13348 
    return not (self == other)
13349 
 
6845 amit.gupta 13350 
class getAllEntityTags_args:
13351 
 
13352 
  thrift_spec = (
13353 
  )
13354 
 
13355 
  def read(self, iprot):
13356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13358 
      return
13359 
    iprot.readStructBegin()
13360 
    while True:
13361 
      (fname, ftype, fid) = iprot.readFieldBegin()
13362 
      if ftype == TType.STOP:
13363 
        break
13364 
      else:
13365 
        iprot.skip(ftype)
13366 
      iprot.readFieldEnd()
13367 
    iprot.readStructEnd()
13368 
 
13369 
  def write(self, oprot):
13370 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13371 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13372 
      return
13373 
    oprot.writeStructBegin('getAllEntityTags_args')
13374 
    oprot.writeFieldStop()
13375 
    oprot.writeStructEnd()
13376 
 
13377 
  def validate(self):
13378 
    return
13379 
 
13380 
 
13381 
  def __repr__(self):
13382 
    L = ['%s=%r' % (key, value)
13383 
      for key, value in self.__dict__.iteritems()]
13384 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13385 
 
13386 
  def __eq__(self, other):
13387 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13388 
 
13389 
  def __ne__(self, other):
13390 
    return not (self == other)
13391 
 
13392 
class getAllEntityTags_result:
13393 
  """
13394 
  Attributes:
13395 
   - success
13396 
  """
13397 
 
13398 
  thrift_spec = (
13399 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRING,None)), None, ), # 0
13400 
  )
13401 
 
13402 
  def __init__(self, success=None,):
13403 
    self.success = success
13404 
 
13405 
  def read(self, iprot):
13406 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13407 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13408 
      return
13409 
    iprot.readStructBegin()
13410 
    while True:
13411 
      (fname, ftype, fid) = iprot.readFieldBegin()
13412 
      if ftype == TType.STOP:
13413 
        break
13414 
      if fid == 0:
13415 
        if ftype == TType.MAP:
13416 
          self.success = {}
8590 kshitij.so 13417 
          (_ktype180, _vtype181, _size179 ) = iprot.readMapBegin()
13418 
          for _i183 in xrange(_size179):
13419 
            _key184 = iprot.readI64();
13420 
            _val185 = []
13421 
            (_etype189, _size186) = iprot.readListBegin()
13422 
            for _i190 in xrange(_size186):
13423 
              _elem191 = iprot.readString();
13424 
              _val185.append(_elem191)
6845 amit.gupta 13425 
            iprot.readListEnd()
8590 kshitij.so 13426 
            self.success[_key184] = _val185
6845 amit.gupta 13427 
          iprot.readMapEnd()
13428 
        else:
13429 
          iprot.skip(ftype)
13430 
      else:
13431 
        iprot.skip(ftype)
13432 
      iprot.readFieldEnd()
13433 
    iprot.readStructEnd()
13434 
 
13435 
  def write(self, oprot):
13436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13438 
      return
13439 
    oprot.writeStructBegin('getAllEntityTags_result')
13440 
    if self.success is not None:
13441 
      oprot.writeFieldBegin('success', TType.MAP, 0)
13442 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
8590 kshitij.so 13443 
      for kiter192,viter193 in self.success.items():
13444 
        oprot.writeI64(kiter192)
13445 
        oprot.writeListBegin(TType.STRING, len(viter193))
13446 
        for iter194 in viter193:
13447 
          oprot.writeString(iter194)
6845 amit.gupta 13448 
        oprot.writeListEnd()
13449 
      oprot.writeMapEnd()
13450 
      oprot.writeFieldEnd()
13451 
    oprot.writeFieldStop()
13452 
    oprot.writeStructEnd()
13453 
 
13454 
  def validate(self):
13455 
    return
13456 
 
13457 
 
13458 
  def __repr__(self):
13459 
    L = ['%s=%r' % (key, value)
13460 
      for key, value in self.__dict__.iteritems()]
13461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13462 
 
13463 
  def __eq__(self, other):
13464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13465 
 
13466 
  def __ne__(self, other):
13467 
    return not (self == other)
13468 
 
6850 kshitij.so 13469 
class addBanner_args:
13470 
  """
13471 
  Attributes:
8590 kshitij.so 13472 
   - bannerCongregate
6850 kshitij.so 13473 
  """
13474 
 
13475 
  thrift_spec = (
13476 
    None, # 0
8590 kshitij.so 13477 
    (1, TType.STRUCT, 'bannerCongregate', (BannerCongregate, BannerCongregate.thrift_spec), None, ), # 1
6850 kshitij.so 13478 
  )
13479 
 
8590 kshitij.so 13480 
  def __init__(self, bannerCongregate=None,):
13481 
    self.bannerCongregate = bannerCongregate
6850 kshitij.so 13482 
 
13483 
  def read(self, iprot):
13484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13486 
      return
13487 
    iprot.readStructBegin()
13488 
    while True:
13489 
      (fname, ftype, fid) = iprot.readFieldBegin()
13490 
      if ftype == TType.STOP:
13491 
        break
13492 
      if fid == 1:
8579 kshitij.so 13493 
        if ftype == TType.STRUCT:
8590 kshitij.so 13494 
          self.bannerCongregate = BannerCongregate()
13495 
          self.bannerCongregate.read(iprot)
6850 kshitij.so 13496 
        else:
13497 
          iprot.skip(ftype)
8579 kshitij.so 13498 
      else:
13499 
        iprot.skip(ftype)
13500 
      iprot.readFieldEnd()
13501 
    iprot.readStructEnd()
13502 
 
13503 
  def write(self, oprot):
13504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13506 
      return
13507 
    oprot.writeStructBegin('addBanner_args')
8590 kshitij.so 13508 
    if self.bannerCongregate is not None:
13509 
      oprot.writeFieldBegin('bannerCongregate', TType.STRUCT, 1)
13510 
      self.bannerCongregate.write(oprot)
8579 kshitij.so 13511 
      oprot.writeFieldEnd()
13512 
    oprot.writeFieldStop()
13513 
    oprot.writeStructEnd()
13514 
 
13515 
  def validate(self):
13516 
    return
13517 
 
13518 
 
13519 
  def __repr__(self):
13520 
    L = ['%s=%r' % (key, value)
13521 
      for key, value in self.__dict__.iteritems()]
13522 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13523 
 
13524 
  def __eq__(self, other):
13525 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13526 
 
13527 
  def __ne__(self, other):
13528 
    return not (self == other)
13529 
 
13530 
class addBanner_result:
10097 kshitij.so 13531 
  """
13532 
  Attributes:
13533 
   - success
13534 
  """
8579 kshitij.so 13535 
 
13536 
  thrift_spec = (
10097 kshitij.so 13537 
    (0, TType.BOOL, 'success', None, None, ), # 0
8579 kshitij.so 13538 
  )
13539 
 
10097 kshitij.so 13540 
  def __init__(self, success=None,):
13541 
    self.success = success
13542 
 
8579 kshitij.so 13543 
  def read(self, iprot):
13544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13546 
      return
13547 
    iprot.readStructBegin()
13548 
    while True:
13549 
      (fname, ftype, fid) = iprot.readFieldBegin()
13550 
      if ftype == TType.STOP:
13551 
        break
10097 kshitij.so 13552 
      if fid == 0:
13553 
        if ftype == TType.BOOL:
13554 
          self.success = iprot.readBool();
13555 
        else:
13556 
          iprot.skip(ftype)
8579 kshitij.so 13557 
      else:
13558 
        iprot.skip(ftype)
13559 
      iprot.readFieldEnd()
13560 
    iprot.readStructEnd()
13561 
 
13562 
  def write(self, oprot):
13563 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13564 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13565 
      return
13566 
    oprot.writeStructBegin('addBanner_result')
10097 kshitij.so 13567 
    if self.success is not None:
13568 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13569 
      oprot.writeBool(self.success)
13570 
      oprot.writeFieldEnd()
8579 kshitij.so 13571 
    oprot.writeFieldStop()
13572 
    oprot.writeStructEnd()
13573 
 
13574 
  def validate(self):
13575 
    return
13576 
 
13577 
 
13578 
  def __repr__(self):
13579 
    L = ['%s=%r' % (key, value)
13580 
      for key, value in self.__dict__.iteritems()]
13581 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13582 
 
13583 
  def __eq__(self, other):
13584 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13585 
 
13586 
  def __ne__(self, other):
13587 
    return not (self == other)
13588 
 
13589 
class updateBanner_args:
13590 
  """
13591 
  Attributes:
13592 
   - banner
13593 
  """
13594 
 
13595 
  thrift_spec = (
13596 
    None, # 0
13597 
    (1, TType.STRUCT, 'banner', (Banner, Banner.thrift_spec), None, ), # 1
13598 
  )
13599 
 
13600 
  def __init__(self, banner=None,):
13601 
    self.banner = banner
13602 
 
13603 
  def read(self, iprot):
13604 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13605 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13606 
      return
13607 
    iprot.readStructBegin()
13608 
    while True:
13609 
      (fname, ftype, fid) = iprot.readFieldBegin()
13610 
      if ftype == TType.STOP:
13611 
        break
13612 
      if fid == 1:
13613 
        if ftype == TType.STRUCT:
13614 
          self.banner = Banner()
13615 
          self.banner.read(iprot)
6850 kshitij.so 13616 
        else:
13617 
          iprot.skip(ftype)
13618 
      else:
13619 
        iprot.skip(ftype)
13620 
      iprot.readFieldEnd()
13621 
    iprot.readStructEnd()
13622 
 
13623 
  def write(self, oprot):
13624 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13625 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13626 
      return
8579 kshitij.so 13627 
    oprot.writeStructBegin('updateBanner_args')
13628 
    if self.banner is not None:
13629 
      oprot.writeFieldBegin('banner', TType.STRUCT, 1)
13630 
      self.banner.write(oprot)
6850 kshitij.so 13631 
      oprot.writeFieldEnd()
13632 
    oprot.writeFieldStop()
13633 
    oprot.writeStructEnd()
13634 
 
13635 
  def validate(self):
13636 
    return
13637 
 
13638 
 
13639 
  def __repr__(self):
13640 
    L = ['%s=%r' % (key, value)
13641 
      for key, value in self.__dict__.iteritems()]
13642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13643 
 
13644 
  def __eq__(self, other):
13645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13646 
 
13647 
  def __ne__(self, other):
13648 
    return not (self == other)
13649 
 
8579 kshitij.so 13650 
class updateBanner_result:
6850 kshitij.so 13651 
  """
13652 
  Attributes:
13653 
   - success
13654 
  """
13655 
 
13656 
  thrift_spec = (
13657 
    (0, TType.BOOL, 'success', None, None, ), # 0
13658 
  )
13659 
 
13660 
  def __init__(self, success=None,):
13661 
    self.success = success
13662 
 
13663 
  def read(self, iprot):
13664 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13665 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13666 
      return
13667 
    iprot.readStructBegin()
13668 
    while True:
13669 
      (fname, ftype, fid) = iprot.readFieldBegin()
13670 
      if ftype == TType.STOP:
13671 
        break
13672 
      if fid == 0:
13673 
        if ftype == TType.BOOL:
13674 
          self.success = iprot.readBool();
13675 
        else:
13676 
          iprot.skip(ftype)
13677 
      else:
13678 
        iprot.skip(ftype)
13679 
      iprot.readFieldEnd()
13680 
    iprot.readStructEnd()
13681 
 
13682 
  def write(self, oprot):
13683 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13684 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13685 
      return
8579 kshitij.so 13686 
    oprot.writeStructBegin('updateBanner_result')
6850 kshitij.so 13687 
    if self.success is not None:
13688 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13689 
      oprot.writeBool(self.success)
13690 
      oprot.writeFieldEnd()
13691 
    oprot.writeFieldStop()
13692 
    oprot.writeStructEnd()
13693 
 
13694 
  def validate(self):
13695 
    return
13696 
 
13697 
 
13698 
  def __repr__(self):
13699 
    L = ['%s=%r' % (key, value)
13700 
      for key, value in self.__dict__.iteritems()]
13701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13702 
 
13703 
  def __eq__(self, other):
13704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13705 
 
13706 
  def __ne__(self, other):
13707 
    return not (self == other)
13708 
 
13709 
class getAllBanners_args:
13710 
 
13711 
  thrift_spec = (
13712 
  )
13713 
 
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
13723 
      else:
13724 
        iprot.skip(ftype)
13725 
      iprot.readFieldEnd()
13726 
    iprot.readStructEnd()
13727 
 
13728 
  def write(self, oprot):
13729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13731 
      return
13732 
    oprot.writeStructBegin('getAllBanners_args')
13733 
    oprot.writeFieldStop()
13734 
    oprot.writeStructEnd()
13735 
 
13736 
  def validate(self):
13737 
    return
13738 
 
13739 
 
13740 
  def __repr__(self):
13741 
    L = ['%s=%r' % (key, value)
13742 
      for key, value in self.__dict__.iteritems()]
13743 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13744 
 
13745 
  def __eq__(self, other):
13746 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13747 
 
13748 
  def __ne__(self, other):
13749 
    return not (self == other)
13750 
 
13751 
class getAllBanners_result:
13752 
  """
13753 
  Attributes:
13754 
   - success
13755 
  """
13756 
 
13757 
  thrift_spec = (
8579 kshitij.so 13758 
    (0, TType.LIST, 'success', (TType.STRUCT,(Banner, Banner.thrift_spec)), None, ), # 0
6850 kshitij.so 13759 
  )
13760 
 
13761 
  def __init__(self, success=None,):
13762 
    self.success = success
13763 
 
13764 
  def read(self, iprot):
13765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13767 
      return
13768 
    iprot.readStructBegin()
13769 
    while True:
13770 
      (fname, ftype, fid) = iprot.readFieldBegin()
13771 
      if ftype == TType.STOP:
13772 
        break
13773 
      if fid == 0:
13774 
        if ftype == TType.LIST:
13775 
          self.success = []
8590 kshitij.so 13776 
          (_etype198, _size195) = iprot.readListBegin()
13777 
          for _i199 in xrange(_size195):
13778 
            _elem200 = Banner()
13779 
            _elem200.read(iprot)
13780 
            self.success.append(_elem200)
6850 kshitij.so 13781 
          iprot.readListEnd()
13782 
        else:
13783 
          iprot.skip(ftype)
13784 
      else:
13785 
        iprot.skip(ftype)
13786 
      iprot.readFieldEnd()
13787 
    iprot.readStructEnd()
13788 
 
13789 
  def write(self, oprot):
13790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13792 
      return
13793 
    oprot.writeStructBegin('getAllBanners_result')
13794 
    if self.success is not None:
13795 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8579 kshitij.so 13796 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 13797 
      for iter201 in self.success:
13798 
        iter201.write(oprot)
6850 kshitij.so 13799 
      oprot.writeListEnd()
13800 
      oprot.writeFieldEnd()
13801 
    oprot.writeFieldStop()
13802 
    oprot.writeStructEnd()
13803 
 
13804 
  def validate(self):
13805 
    return
13806 
 
13807 
 
13808 
  def __repr__(self):
13809 
    L = ['%s=%r' % (key, value)
13810 
      for key, value in self.__dict__.iteritems()]
13811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13812 
 
13813 
  def __eq__(self, other):
13814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13815 
 
13816 
  def __ne__(self, other):
13817 
    return not (self == other)
13818 
 
13819 
class deleteBanner_args:
13820 
  """
13821 
  Attributes:
13822 
   - bannerName
9155 kshitij.so 13823 
   - bannerType
6850 kshitij.so 13824 
  """
13825 
 
13826 
  thrift_spec = (
13827 
    None, # 0
13828 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 13829 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6850 kshitij.so 13830 
  )
13831 
 
9155 kshitij.so 13832 
  def __init__(self, bannerName=None, bannerType=None,):
6850 kshitij.so 13833 
    self.bannerName = bannerName
9155 kshitij.so 13834 
    self.bannerType = bannerType
6850 kshitij.so 13835 
 
13836 
  def read(self, iprot):
13837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13839 
      return
13840 
    iprot.readStructBegin()
13841 
    while True:
13842 
      (fname, ftype, fid) = iprot.readFieldBegin()
13843 
      if ftype == TType.STOP:
13844 
        break
13845 
      if fid == 1:
13846 
        if ftype == TType.STRING:
13847 
          self.bannerName = iprot.readString();
13848 
        else:
13849 
          iprot.skip(ftype)
9155 kshitij.so 13850 
      elif fid == 2:
13851 
        if ftype == TType.I32:
13852 
          self.bannerType = iprot.readI32();
13853 
        else:
13854 
          iprot.skip(ftype)
6850 kshitij.so 13855 
      else:
13856 
        iprot.skip(ftype)
13857 
      iprot.readFieldEnd()
13858 
    iprot.readStructEnd()
13859 
 
13860 
  def write(self, oprot):
13861 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13862 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13863 
      return
13864 
    oprot.writeStructBegin('deleteBanner_args')
13865 
    if self.bannerName is not None:
13866 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
13867 
      oprot.writeString(self.bannerName)
13868 
      oprot.writeFieldEnd()
9155 kshitij.so 13869 
    if self.bannerType is not None:
13870 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
13871 
      oprot.writeI32(self.bannerType)
13872 
      oprot.writeFieldEnd()
6850 kshitij.so 13873 
    oprot.writeFieldStop()
13874 
    oprot.writeStructEnd()
13875 
 
13876 
  def validate(self):
13877 
    return
13878 
 
13879 
 
13880 
  def __repr__(self):
13881 
    L = ['%s=%r' % (key, value)
13882 
      for key, value in self.__dict__.iteritems()]
13883 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13884 
 
13885 
  def __eq__(self, other):
13886 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13887 
 
13888 
  def __ne__(self, other):
13889 
    return not (self == other)
13890 
 
13891 
class deleteBanner_result:
13892 
  """
13893 
  Attributes:
13894 
   - success
13895 
  """
13896 
 
13897 
  thrift_spec = (
13898 
    (0, TType.BOOL, 'success', None, None, ), # 0
13899 
  )
13900 
 
13901 
  def __init__(self, success=None,):
13902 
    self.success = success
13903 
 
13904 
  def read(self, iprot):
13905 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13906 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13907 
      return
13908 
    iprot.readStructBegin()
13909 
    while True:
13910 
      (fname, ftype, fid) = iprot.readFieldBegin()
13911 
      if ftype == TType.STOP:
13912 
        break
13913 
      if fid == 0:
13914 
        if ftype == TType.BOOL:
13915 
          self.success = iprot.readBool();
13916 
        else:
13917 
          iprot.skip(ftype)
13918 
      else:
13919 
        iprot.skip(ftype)
13920 
      iprot.readFieldEnd()
13921 
    iprot.readStructEnd()
13922 
 
13923 
  def write(self, oprot):
13924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13926 
      return
13927 
    oprot.writeStructBegin('deleteBanner_result')
13928 
    if self.success is not None:
13929 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13930 
      oprot.writeBool(self.success)
13931 
      oprot.writeFieldEnd()
13932 
    oprot.writeFieldStop()
13933 
    oprot.writeStructEnd()
13934 
 
13935 
  def validate(self):
13936 
    return
13937 
 
13938 
 
13939 
  def __repr__(self):
13940 
    L = ['%s=%r' % (key, value)
13941 
      for key, value in self.__dict__.iteritems()]
13942 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13943 
 
13944 
  def __eq__(self, other):
13945 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13946 
 
13947 
  def __ne__(self, other):
13948 
    return not (self == other)
13949 
 
13950 
class getBannerDetails_args:
13951 
  """
13952 
  Attributes:
13953 
   - bannerName
9155 kshitij.so 13954 
   - bannerType
6850 kshitij.so 13955 
  """
13956 
 
13957 
  thrift_spec = (
13958 
    None, # 0
13959 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 13960 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6850 kshitij.so 13961 
  )
13962 
 
9155 kshitij.so 13963 
  def __init__(self, bannerName=None, bannerType=None,):
6850 kshitij.so 13964 
    self.bannerName = bannerName
9155 kshitij.so 13965 
    self.bannerType = bannerType
6850 kshitij.so 13966 
 
13967 
  def read(self, iprot):
13968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13970 
      return
13971 
    iprot.readStructBegin()
13972 
    while True:
13973 
      (fname, ftype, fid) = iprot.readFieldBegin()
13974 
      if ftype == TType.STOP:
13975 
        break
13976 
      if fid == 1:
13977 
        if ftype == TType.STRING:
13978 
          self.bannerName = iprot.readString();
13979 
        else:
13980 
          iprot.skip(ftype)
9155 kshitij.so 13981 
      elif fid == 2:
13982 
        if ftype == TType.I32:
13983 
          self.bannerType = iprot.readI32();
13984 
        else:
13985 
          iprot.skip(ftype)
6850 kshitij.so 13986 
      else:
13987 
        iprot.skip(ftype)
13988 
      iprot.readFieldEnd()
13989 
    iprot.readStructEnd()
13990 
 
13991 
  def write(self, oprot):
13992 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13993 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13994 
      return
13995 
    oprot.writeStructBegin('getBannerDetails_args')
13996 
    if self.bannerName is not None:
13997 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
13998 
      oprot.writeString(self.bannerName)
13999 
      oprot.writeFieldEnd()
9155 kshitij.so 14000 
    if self.bannerType is not None:
14001 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
14002 
      oprot.writeI32(self.bannerType)
14003 
      oprot.writeFieldEnd()
6850 kshitij.so 14004 
    oprot.writeFieldStop()
14005 
    oprot.writeStructEnd()
14006 
 
14007 
  def validate(self):
14008 
    return
14009 
 
14010 
 
14011 
  def __repr__(self):
14012 
    L = ['%s=%r' % (key, value)
14013 
      for key, value in self.__dict__.iteritems()]
14014 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14015 
 
14016 
  def __eq__(self, other):
14017 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14018 
 
14019 
  def __ne__(self, other):
14020 
    return not (self == other)
14021 
 
14022 
class getBannerDetails_result:
14023 
  """
14024 
  Attributes:
14025 
   - success
14026 
  """
14027 
 
14028 
  thrift_spec = (
14029 
    (0, TType.STRUCT, 'success', (Banner, Banner.thrift_spec), None, ), # 0
14030 
  )
14031 
 
14032 
  def __init__(self, success=None,):
14033 
    self.success = success
14034 
 
14035 
  def read(self, iprot):
14036 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14037 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14038 
      return
14039 
    iprot.readStructBegin()
14040 
    while True:
14041 
      (fname, ftype, fid) = iprot.readFieldBegin()
14042 
      if ftype == TType.STOP:
14043 
        break
14044 
      if fid == 0:
14045 
        if ftype == TType.STRUCT:
14046 
          self.success = Banner()
14047 
          self.success.read(iprot)
14048 
        else:
14049 
          iprot.skip(ftype)
14050 
      else:
14051 
        iprot.skip(ftype)
14052 
      iprot.readFieldEnd()
14053 
    iprot.readStructEnd()
14054 
 
14055 
  def write(self, oprot):
14056 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14057 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14058 
      return
14059 
    oprot.writeStructBegin('getBannerDetails_result')
14060 
    if self.success is not None:
14061 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14062 
      self.success.write(oprot)
14063 
      oprot.writeFieldEnd()
14064 
    oprot.writeFieldStop()
14065 
    oprot.writeStructEnd()
14066 
 
14067 
  def validate(self):
14068 
    return
14069 
 
14070 
 
14071 
  def __repr__(self):
14072 
    L = ['%s=%r' % (key, value)
14073 
      for key, value in self.__dict__.iteritems()]
14074 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14075 
 
14076 
  def __eq__(self, other):
14077 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14078 
 
14079 
  def __ne__(self, other):
14080 
    return not (self == other)
14081 
 
14082 
class getActiveBanners_args:
14083 
 
14084 
  thrift_spec = (
14085 
  )
14086 
 
14087 
  def read(self, iprot):
14088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14090 
      return
14091 
    iprot.readStructBegin()
14092 
    while True:
14093 
      (fname, ftype, fid) = iprot.readFieldBegin()
14094 
      if ftype == TType.STOP:
14095 
        break
14096 
      else:
14097 
        iprot.skip(ftype)
14098 
      iprot.readFieldEnd()
14099 
    iprot.readStructEnd()
14100 
 
14101 
  def write(self, oprot):
14102 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14103 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14104 
      return
14105 
    oprot.writeStructBegin('getActiveBanners_args')
14106 
    oprot.writeFieldStop()
14107 
    oprot.writeStructEnd()
14108 
 
14109 
  def validate(self):
14110 
    return
14111 
 
14112 
 
14113 
  def __repr__(self):
14114 
    L = ['%s=%r' % (key, value)
14115 
      for key, value in self.__dict__.iteritems()]
14116 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14117 
 
14118 
  def __eq__(self, other):
14119 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14120 
 
14121 
  def __ne__(self, other):
14122 
    return not (self == other)
14123 
 
14124 
class getActiveBanners_result:
14125 
  """
14126 
  Attributes:
14127 
   - success
14128 
  """
14129 
 
14130 
  thrift_spec = (
8579 kshitij.so 14131 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
6850 kshitij.so 14132 
  )
14133 
 
14134 
  def __init__(self, success=None,):
14135 
    self.success = success
14136 
 
14137 
  def read(self, iprot):
14138 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14139 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14140 
      return
14141 
    iprot.readStructBegin()
14142 
    while True:
14143 
      (fname, ftype, fid) = iprot.readFieldBegin()
14144 
      if ftype == TType.STOP:
14145 
        break
14146 
      if fid == 0:
8579 kshitij.so 14147 
        if ftype == TType.MAP:
14148 
          self.success = {}
8590 kshitij.so 14149 
          (_ktype203, _vtype204, _size202 ) = iprot.readMapBegin()
14150 
          for _i206 in xrange(_size202):
14151 
            _key207 = iprot.readString();
14152 
            _val208 = []
14153 
            (_etype212, _size209) = iprot.readListBegin()
14154 
            for _i213 in xrange(_size209):
14155 
              _elem214 = Banner()
14156 
              _elem214.read(iprot)
14157 
              _val208.append(_elem214)
8579 kshitij.so 14158 
            iprot.readListEnd()
8590 kshitij.so 14159 
            self.success[_key207] = _val208
8579 kshitij.so 14160 
          iprot.readMapEnd()
6850 kshitij.so 14161 
        else:
14162 
          iprot.skip(ftype)
14163 
      else:
14164 
        iprot.skip(ftype)
14165 
      iprot.readFieldEnd()
14166 
    iprot.readStructEnd()
14167 
 
14168 
  def write(self, oprot):
14169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14171 
      return
14172 
    oprot.writeStructBegin('getActiveBanners_result')
14173 
    if self.success is not None:
8579 kshitij.so 14174 
      oprot.writeFieldBegin('success', TType.MAP, 0)
14175 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
8590 kshitij.so 14176 
      for kiter215,viter216 in self.success.items():
14177 
        oprot.writeString(kiter215)
14178 
        oprot.writeListBegin(TType.STRUCT, len(viter216))
14179 
        for iter217 in viter216:
14180 
          iter217.write(oprot)
8579 kshitij.so 14181 
        oprot.writeListEnd()
14182 
      oprot.writeMapEnd()
6850 kshitij.so 14183 
      oprot.writeFieldEnd()
14184 
    oprot.writeFieldStop()
14185 
    oprot.writeStructEnd()
14186 
 
14187 
  def validate(self):
14188 
    return
14189 
 
14190 
 
14191 
  def __repr__(self):
14192 
    L = ['%s=%r' % (key, value)
14193 
      for key, value in self.__dict__.iteritems()]
14194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14195 
 
14196 
  def __eq__(self, other):
14197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14198 
 
14199 
  def __ne__(self, other):
14200 
    return not (self == other)
14201 
 
6849 kshitij.so 14202 
class addBannerMap_args:
14203 
  """
14204 
  Attributes:
8579 kshitij.so 14205 
   - bannerMaps
6849 kshitij.so 14206 
  """
14207 
 
14208 
  thrift_spec = (
14209 
    None, # 0
8579 kshitij.so 14210 
    (1, TType.LIST, 'bannerMaps', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 1
6849 kshitij.so 14211 
  )
14212 
 
8579 kshitij.so 14213 
  def __init__(self, bannerMaps=None,):
14214 
    self.bannerMaps = bannerMaps
6849 kshitij.so 14215 
 
14216 
  def read(self, iprot):
14217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14219 
      return
14220 
    iprot.readStructBegin()
14221 
    while True:
14222 
      (fname, ftype, fid) = iprot.readFieldBegin()
14223 
      if ftype == TType.STOP:
14224 
        break
14225 
      if fid == 1:
8579 kshitij.so 14226 
        if ftype == TType.LIST:
14227 
          self.bannerMaps = []
8590 kshitij.so 14228 
          (_etype221, _size218) = iprot.readListBegin()
14229 
          for _i222 in xrange(_size218):
14230 
            _elem223 = BannerMap()
14231 
            _elem223.read(iprot)
14232 
            self.bannerMaps.append(_elem223)
8579 kshitij.so 14233 
          iprot.readListEnd()
6849 kshitij.so 14234 
        else:
14235 
          iprot.skip(ftype)
8579 kshitij.so 14236 
      else:
14237 
        iprot.skip(ftype)
14238 
      iprot.readFieldEnd()
14239 
    iprot.readStructEnd()
14240 
 
14241 
  def write(self, oprot):
14242 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14243 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14244 
      return
14245 
    oprot.writeStructBegin('addBannerMap_args')
14246 
    if self.bannerMaps is not None:
14247 
      oprot.writeFieldBegin('bannerMaps', TType.LIST, 1)
14248 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerMaps))
8590 kshitij.so 14249 
      for iter224 in self.bannerMaps:
14250 
        iter224.write(oprot)
8579 kshitij.so 14251 
      oprot.writeListEnd()
14252 
      oprot.writeFieldEnd()
14253 
    oprot.writeFieldStop()
14254 
    oprot.writeStructEnd()
14255 
 
14256 
  def validate(self):
14257 
    return
14258 
 
14259 
 
14260 
  def __repr__(self):
14261 
    L = ['%s=%r' % (key, value)
14262 
      for key, value in self.__dict__.iteritems()]
14263 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14264 
 
14265 
  def __eq__(self, other):
14266 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14267 
 
14268 
  def __ne__(self, other):
14269 
    return not (self == other)
14270 
 
14271 
class addBannerMap_result:
14272 
  """
14273 
  Attributes:
14274 
   - success
14275 
  """
14276 
 
14277 
  thrift_spec = (
14278 
    (0, TType.BOOL, 'success', None, None, ), # 0
14279 
  )
14280 
 
14281 
  def __init__(self, success=None,):
14282 
    self.success = success
14283 
 
14284 
  def read(self, iprot):
14285 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14286 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14287 
      return
14288 
    iprot.readStructBegin()
14289 
    while True:
14290 
      (fname, ftype, fid) = iprot.readFieldBegin()
14291 
      if ftype == TType.STOP:
14292 
        break
14293 
      if fid == 0:
14294 
        if ftype == TType.BOOL:
14295 
          self.success = iprot.readBool();
6849 kshitij.so 14296 
        else:
14297 
          iprot.skip(ftype)
8579 kshitij.so 14298 
      else:
14299 
        iprot.skip(ftype)
14300 
      iprot.readFieldEnd()
14301 
    iprot.readStructEnd()
14302 
 
14303 
  def write(self, oprot):
14304 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14305 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14306 
      return
14307 
    oprot.writeStructBegin('addBannerMap_result')
14308 
    if self.success is not None:
14309 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14310 
      oprot.writeBool(self.success)
14311 
      oprot.writeFieldEnd()
14312 
    oprot.writeFieldStop()
14313 
    oprot.writeStructEnd()
14314 
 
14315 
  def validate(self):
14316 
    return
14317 
 
14318 
 
14319 
  def __repr__(self):
14320 
    L = ['%s=%r' % (key, value)
14321 
      for key, value in self.__dict__.iteritems()]
14322 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14323 
 
14324 
  def __eq__(self, other):
14325 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14326 
 
14327 
  def __ne__(self, other):
14328 
    return not (self == other)
14329 
 
14330 
class updateBannerMap_args:
14331 
  """
14332 
  Attributes:
14333 
   - bannerMap
14334 
  """
14335 
 
14336 
  thrift_spec = (
14337 
    None, # 0
14338 
    (1, TType.STRUCT, 'bannerMap', (BannerMap, BannerMap.thrift_spec), None, ), # 1
14339 
  )
14340 
 
14341 
  def __init__(self, bannerMap=None,):
14342 
    self.bannerMap = bannerMap
14343 
 
14344 
  def read(self, iprot):
14345 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14346 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14347 
      return
14348 
    iprot.readStructBegin()
14349 
    while True:
14350 
      (fname, ftype, fid) = iprot.readFieldBegin()
14351 
      if ftype == TType.STOP:
14352 
        break
14353 
      if fid == 1:
14354 
        if ftype == TType.STRUCT:
14355 
          self.bannerMap = BannerMap()
14356 
          self.bannerMap.read(iprot)
6849 kshitij.so 14357 
        else:
14358 
          iprot.skip(ftype)
14359 
      else:
14360 
        iprot.skip(ftype)
14361 
      iprot.readFieldEnd()
14362 
    iprot.readStructEnd()
14363 
 
14364 
  def write(self, oprot):
14365 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14366 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14367 
      return
8579 kshitij.so 14368 
    oprot.writeStructBegin('updateBannerMap_args')
14369 
    if self.bannerMap is not None:
14370 
      oprot.writeFieldBegin('bannerMap', TType.STRUCT, 1)
14371 
      self.bannerMap.write(oprot)
6849 kshitij.so 14372 
      oprot.writeFieldEnd()
14373 
    oprot.writeFieldStop()
14374 
    oprot.writeStructEnd()
14375 
 
14376 
  def validate(self):
14377 
    return
14378 
 
14379 
 
14380 
  def __repr__(self):
14381 
    L = ['%s=%r' % (key, value)
14382 
      for key, value in self.__dict__.iteritems()]
14383 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14384 
 
14385 
  def __eq__(self, other):
14386 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14387 
 
14388 
  def __ne__(self, other):
14389 
    return not (self == other)
14390 
 
8579 kshitij.so 14391 
class updateBannerMap_result:
6849 kshitij.so 14392 
  """
14393 
  Attributes:
14394 
   - success
14395 
  """
14396 
 
14397 
  thrift_spec = (
14398 
    (0, TType.BOOL, 'success', None, None, ), # 0
14399 
  )
14400 
 
14401 
  def __init__(self, success=None,):
14402 
    self.success = success
14403 
 
14404 
  def read(self, iprot):
14405 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14406 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14407 
      return
14408 
    iprot.readStructBegin()
14409 
    while True:
14410 
      (fname, ftype, fid) = iprot.readFieldBegin()
14411 
      if ftype == TType.STOP:
14412 
        break
14413 
      if fid == 0:
14414 
        if ftype == TType.BOOL:
14415 
          self.success = iprot.readBool();
14416 
        else:
14417 
          iprot.skip(ftype)
14418 
      else:
14419 
        iprot.skip(ftype)
14420 
      iprot.readFieldEnd()
14421 
    iprot.readStructEnd()
14422 
 
14423 
  def write(self, oprot):
14424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14426 
      return
8579 kshitij.so 14427 
    oprot.writeStructBegin('updateBannerMap_result')
6849 kshitij.so 14428 
    if self.success is not None:
14429 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14430 
      oprot.writeBool(self.success)
14431 
      oprot.writeFieldEnd()
14432 
    oprot.writeFieldStop()
14433 
    oprot.writeStructEnd()
14434 
 
14435 
  def validate(self):
14436 
    return
14437 
 
14438 
 
14439 
  def __repr__(self):
14440 
    L = ['%s=%r' % (key, value)
14441 
      for key, value in self.__dict__.iteritems()]
14442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14443 
 
14444 
  def __eq__(self, other):
14445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14446 
 
14447 
  def __ne__(self, other):
14448 
    return not (self == other)
14449 
 
14450 
class deleteBannerMap_args:
14451 
  """
14452 
  Attributes:
14453 
   - bannerName
14454 
  """
14455 
 
14456 
  thrift_spec = (
14457 
    None, # 0
14458 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
14459 
  )
14460 
 
14461 
  def __init__(self, bannerName=None,):
14462 
    self.bannerName = bannerName
14463 
 
14464 
  def read(self, iprot):
14465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14467 
      return
14468 
    iprot.readStructBegin()
14469 
    while True:
14470 
      (fname, ftype, fid) = iprot.readFieldBegin()
14471 
      if ftype == TType.STOP:
14472 
        break
14473 
      if fid == 1:
14474 
        if ftype == TType.STRING:
14475 
          self.bannerName = iprot.readString();
14476 
        else:
14477 
          iprot.skip(ftype)
14478 
      else:
14479 
        iprot.skip(ftype)
14480 
      iprot.readFieldEnd()
14481 
    iprot.readStructEnd()
14482 
 
14483 
  def write(self, oprot):
14484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14486 
      return
14487 
    oprot.writeStructBegin('deleteBannerMap_args')
14488 
    if self.bannerName is not None:
14489 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
14490 
      oprot.writeString(self.bannerName)
14491 
      oprot.writeFieldEnd()
14492 
    oprot.writeFieldStop()
14493 
    oprot.writeStructEnd()
14494 
 
14495 
  def validate(self):
14496 
    return
14497 
 
14498 
 
14499 
  def __repr__(self):
14500 
    L = ['%s=%r' % (key, value)
14501 
      for key, value in self.__dict__.iteritems()]
14502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14503 
 
14504 
  def __eq__(self, other):
14505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14506 
 
14507 
  def __ne__(self, other):
14508 
    return not (self == other)
14509 
 
14510 
class deleteBannerMap_result:
14511 
  """
14512 
  Attributes:
14513 
   - success
14514 
  """
14515 
 
14516 
  thrift_spec = (
14517 
    (0, TType.BOOL, 'success', None, None, ), # 0
14518 
  )
14519 
 
14520 
  def __init__(self, success=None,):
14521 
    self.success = success
14522 
 
14523 
  def read(self, iprot):
14524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14526 
      return
14527 
    iprot.readStructBegin()
14528 
    while True:
14529 
      (fname, ftype, fid) = iprot.readFieldBegin()
14530 
      if ftype == TType.STOP:
14531 
        break
14532 
      if fid == 0:
14533 
        if ftype == TType.BOOL:
14534 
          self.success = iprot.readBool();
14535 
        else:
14536 
          iprot.skip(ftype)
14537 
      else:
14538 
        iprot.skip(ftype)
14539 
      iprot.readFieldEnd()
14540 
    iprot.readStructEnd()
14541 
 
14542 
  def write(self, oprot):
14543 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14544 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14545 
      return
14546 
    oprot.writeStructBegin('deleteBannerMap_result')
14547 
    if self.success is not None:
14548 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14549 
      oprot.writeBool(self.success)
14550 
      oprot.writeFieldEnd()
14551 
    oprot.writeFieldStop()
14552 
    oprot.writeStructEnd()
14553 
 
14554 
  def validate(self):
14555 
    return
14556 
 
14557 
 
14558 
  def __repr__(self):
14559 
    L = ['%s=%r' % (key, value)
14560 
      for key, value in self.__dict__.iteritems()]
14561 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14562 
 
14563 
  def __eq__(self, other):
14564 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14565 
 
14566 
  def __ne__(self, other):
14567 
    return not (self == other)
14568 
 
14569 
class getBannerMapDetails_args:
14570 
  """
14571 
  Attributes:
14572 
   - bannerName
9155 kshitij.so 14573 
   - bannerType
6849 kshitij.so 14574 
  """
14575 
 
14576 
  thrift_spec = (
14577 
    None, # 0
14578 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 14579 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6849 kshitij.so 14580 
  )
14581 
 
9155 kshitij.so 14582 
  def __init__(self, bannerName=None, bannerType=None,):
6849 kshitij.so 14583 
    self.bannerName = bannerName
9155 kshitij.so 14584 
    self.bannerType = bannerType
6849 kshitij.so 14585 
 
14586 
  def read(self, iprot):
14587 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14588 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14589 
      return
14590 
    iprot.readStructBegin()
14591 
    while True:
14592 
      (fname, ftype, fid) = iprot.readFieldBegin()
14593 
      if ftype == TType.STOP:
14594 
        break
14595 
      if fid == 1:
14596 
        if ftype == TType.STRING:
14597 
          self.bannerName = iprot.readString();
14598 
        else:
14599 
          iprot.skip(ftype)
9155 kshitij.so 14600 
      elif fid == 2:
14601 
        if ftype == TType.I32:
14602 
          self.bannerType = iprot.readI32();
14603 
        else:
14604 
          iprot.skip(ftype)
6849 kshitij.so 14605 
      else:
14606 
        iprot.skip(ftype)
14607 
      iprot.readFieldEnd()
14608 
    iprot.readStructEnd()
14609 
 
14610 
  def write(self, oprot):
14611 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14612 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14613 
      return
14614 
    oprot.writeStructBegin('getBannerMapDetails_args')
14615 
    if self.bannerName is not None:
14616 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
14617 
      oprot.writeString(self.bannerName)
14618 
      oprot.writeFieldEnd()
9155 kshitij.so 14619 
    if self.bannerType is not None:
14620 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
14621 
      oprot.writeI32(self.bannerType)
14622 
      oprot.writeFieldEnd()
6849 kshitij.so 14623 
    oprot.writeFieldStop()
14624 
    oprot.writeStructEnd()
14625 
 
14626 
  def validate(self):
14627 
    return
14628 
 
14629 
 
14630 
  def __repr__(self):
14631 
    L = ['%s=%r' % (key, value)
14632 
      for key, value in self.__dict__.iteritems()]
14633 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14634 
 
14635 
  def __eq__(self, other):
14636 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14637 
 
14638 
  def __ne__(self, other):
14639 
    return not (self == other)
14640 
 
14641 
class getBannerMapDetails_result:
14642 
  """
14643 
  Attributes:
14644 
   - success
14645 
  """
14646 
 
14647 
  thrift_spec = (
14648 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 0
14649 
  )
14650 
 
14651 
  def __init__(self, success=None,):
14652 
    self.success = success
14653 
 
14654 
  def read(self, iprot):
14655 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14656 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14657 
      return
14658 
    iprot.readStructBegin()
14659 
    while True:
14660 
      (fname, ftype, fid) = iprot.readFieldBegin()
14661 
      if ftype == TType.STOP:
14662 
        break
14663 
      if fid == 0:
14664 
        if ftype == TType.LIST:
14665 
          self.success = []
8590 kshitij.so 14666 
          (_etype228, _size225) = iprot.readListBegin()
14667 
          for _i229 in xrange(_size225):
14668 
            _elem230 = BannerMap()
14669 
            _elem230.read(iprot)
14670 
            self.success.append(_elem230)
6849 kshitij.so 14671 
          iprot.readListEnd()
14672 
        else:
14673 
          iprot.skip(ftype)
14674 
      else:
14675 
        iprot.skip(ftype)
14676 
      iprot.readFieldEnd()
14677 
    iprot.readStructEnd()
14678 
 
14679 
  def write(self, oprot):
14680 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14681 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14682 
      return
14683 
    oprot.writeStructBegin('getBannerMapDetails_result')
14684 
    if self.success is not None:
14685 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14686 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 14687 
      for iter231 in self.success:
14688 
        iter231.write(oprot)
6849 kshitij.so 14689 
      oprot.writeListEnd()
14690 
      oprot.writeFieldEnd()
14691 
    oprot.writeFieldStop()
14692 
    oprot.writeStructEnd()
14693 
 
14694 
  def validate(self):
14695 
    return
14696 
 
14697 
 
14698 
  def __repr__(self):
14699 
    L = ['%s=%r' % (key, value)
14700 
      for key, value in self.__dict__.iteritems()]
14701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14702 
 
14703 
  def __eq__(self, other):
14704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14705 
 
14706 
  def __ne__(self, other):
14707 
    return not (self == other)
14708 
 
8579 kshitij.so 14709 
class addBannerUri_args:
14710 
  """
14711 
  Attributes:
14712 
   - bannerUriMappings
14713 
  """
14714 
 
14715 
  thrift_spec = (
14716 
    None, # 0
14717 
    (1, TType.LIST, 'bannerUriMappings', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 1
14718 
  )
14719 
 
14720 
  def __init__(self, bannerUriMappings=None,):
14721 
    self.bannerUriMappings = bannerUriMappings
14722 
 
14723 
  def read(self, iprot):
14724 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14725 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14726 
      return
14727 
    iprot.readStructBegin()
14728 
    while True:
14729 
      (fname, ftype, fid) = iprot.readFieldBegin()
14730 
      if ftype == TType.STOP:
14731 
        break
14732 
      if fid == 1:
14733 
        if ftype == TType.LIST:
14734 
          self.bannerUriMappings = []
8590 kshitij.so 14735 
          (_etype235, _size232) = iprot.readListBegin()
14736 
          for _i236 in xrange(_size232):
14737 
            _elem237 = BannerUriMapping()
14738 
            _elem237.read(iprot)
14739 
            self.bannerUriMappings.append(_elem237)
8579 kshitij.so 14740 
          iprot.readListEnd()
14741 
        else:
14742 
          iprot.skip(ftype)
14743 
      else:
14744 
        iprot.skip(ftype)
14745 
      iprot.readFieldEnd()
14746 
    iprot.readStructEnd()
14747 
 
14748 
  def write(self, oprot):
14749 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14750 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14751 
      return
14752 
    oprot.writeStructBegin('addBannerUri_args')
14753 
    if self.bannerUriMappings is not None:
14754 
      oprot.writeFieldBegin('bannerUriMappings', TType.LIST, 1)
14755 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerUriMappings))
8590 kshitij.so 14756 
      for iter238 in self.bannerUriMappings:
14757 
        iter238.write(oprot)
8579 kshitij.so 14758 
      oprot.writeListEnd()
14759 
      oprot.writeFieldEnd()
14760 
    oprot.writeFieldStop()
14761 
    oprot.writeStructEnd()
14762 
 
14763 
  def validate(self):
14764 
    return
14765 
 
14766 
 
14767 
  def __repr__(self):
14768 
    L = ['%s=%r' % (key, value)
14769 
      for key, value in self.__dict__.iteritems()]
14770 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14771 
 
14772 
  def __eq__(self, other):
14773 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14774 
 
14775 
  def __ne__(self, other):
14776 
    return not (self == other)
14777 
 
14778 
class addBannerUri_result:
14779 
 
14780 
  thrift_spec = (
14781 
  )
14782 
 
14783 
  def read(self, iprot):
14784 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14785 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14786 
      return
14787 
    iprot.readStructBegin()
14788 
    while True:
14789 
      (fname, ftype, fid) = iprot.readFieldBegin()
14790 
      if ftype == TType.STOP:
14791 
        break
14792 
      else:
14793 
        iprot.skip(ftype)
14794 
      iprot.readFieldEnd()
14795 
    iprot.readStructEnd()
14796 
 
14797 
  def write(self, oprot):
14798 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14799 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14800 
      return
14801 
    oprot.writeStructBegin('addBannerUri_result')
14802 
    oprot.writeFieldStop()
14803 
    oprot.writeStructEnd()
14804 
 
14805 
  def validate(self):
14806 
    return
14807 
 
14808 
 
14809 
  def __repr__(self):
14810 
    L = ['%s=%r' % (key, value)
14811 
      for key, value in self.__dict__.iteritems()]
14812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14813 
 
14814 
  def __eq__(self, other):
14815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14816 
 
14817 
  def __ne__(self, other):
14818 
    return not (self == other)
14819 
 
14820 
class getUriMapping_args:
14821 
  """
14822 
  Attributes:
14823 
   - bannerName
9155 kshitij.so 14824 
   - bannerType
8579 kshitij.so 14825 
  """
14826 
 
14827 
  thrift_spec = (
14828 
    None, # 0
14829 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 14830 
    (2, TType.I32, 'bannerType', None, None, ), # 2
8579 kshitij.so 14831 
  )
14832 
 
9155 kshitij.so 14833 
  def __init__(self, bannerName=None, bannerType=None,):
8579 kshitij.so 14834 
    self.bannerName = bannerName
9155 kshitij.so 14835 
    self.bannerType = bannerType
8579 kshitij.so 14836 
 
14837 
  def read(self, iprot):
14838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14840 
      return
14841 
    iprot.readStructBegin()
14842 
    while True:
14843 
      (fname, ftype, fid) = iprot.readFieldBegin()
14844 
      if ftype == TType.STOP:
14845 
        break
14846 
      if fid == 1:
14847 
        if ftype == TType.STRING:
14848 
          self.bannerName = iprot.readString();
14849 
        else:
14850 
          iprot.skip(ftype)
9155 kshitij.so 14851 
      elif fid == 2:
14852 
        if ftype == TType.I32:
14853 
          self.bannerType = iprot.readI32();
14854 
        else:
14855 
          iprot.skip(ftype)
8579 kshitij.so 14856 
      else:
14857 
        iprot.skip(ftype)
14858 
      iprot.readFieldEnd()
14859 
    iprot.readStructEnd()
14860 
 
14861 
  def write(self, oprot):
14862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14864 
      return
14865 
    oprot.writeStructBegin('getUriMapping_args')
14866 
    if self.bannerName is not None:
14867 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
14868 
      oprot.writeString(self.bannerName)
14869 
      oprot.writeFieldEnd()
9155 kshitij.so 14870 
    if self.bannerType is not None:
14871 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
14872 
      oprot.writeI32(self.bannerType)
14873 
      oprot.writeFieldEnd()
8579 kshitij.so 14874 
    oprot.writeFieldStop()
14875 
    oprot.writeStructEnd()
14876 
 
14877 
  def validate(self):
14878 
    return
14879 
 
14880 
 
14881 
  def __repr__(self):
14882 
    L = ['%s=%r' % (key, value)
14883 
      for key, value in self.__dict__.iteritems()]
14884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14885 
 
14886 
  def __eq__(self, other):
14887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14888 
 
14889 
  def __ne__(self, other):
14890 
    return not (self == other)
14891 
 
14892 
class getUriMapping_result:
14893 
  """
14894 
  Attributes:
14895 
   - success
14896 
  """
14897 
 
14898 
  thrift_spec = (
14899 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 0
14900 
  )
14901 
 
14902 
  def __init__(self, success=None,):
14903 
    self.success = success
14904 
 
14905 
  def read(self, iprot):
14906 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14907 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14908 
      return
14909 
    iprot.readStructBegin()
14910 
    while True:
14911 
      (fname, ftype, fid) = iprot.readFieldBegin()
14912 
      if ftype == TType.STOP:
14913 
        break
14914 
      if fid == 0:
14915 
        if ftype == TType.LIST:
14916 
          self.success = []
8590 kshitij.so 14917 
          (_etype242, _size239) = iprot.readListBegin()
14918 
          for _i243 in xrange(_size239):
14919 
            _elem244 = BannerUriMapping()
14920 
            _elem244.read(iprot)
14921 
            self.success.append(_elem244)
8579 kshitij.so 14922 
          iprot.readListEnd()
14923 
        else:
14924 
          iprot.skip(ftype)
14925 
      else:
14926 
        iprot.skip(ftype)
14927 
      iprot.readFieldEnd()
14928 
    iprot.readStructEnd()
14929 
 
14930 
  def write(self, oprot):
14931 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14932 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14933 
      return
14934 
    oprot.writeStructBegin('getUriMapping_result')
14935 
    if self.success is not None:
14936 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14937 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 14938 
      for iter245 in self.success:
14939 
        iter245.write(oprot)
8579 kshitij.so 14940 
      oprot.writeListEnd()
14941 
      oprot.writeFieldEnd()
14942 
    oprot.writeFieldStop()
14943 
    oprot.writeStructEnd()
14944 
 
14945 
  def validate(self):
14946 
    return
14947 
 
14948 
 
14949 
  def __repr__(self):
14950 
    L = ['%s=%r' % (key, value)
14951 
      for key, value in self.__dict__.iteritems()]
14952 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14953 
 
14954 
  def __eq__(self, other):
14955 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14956 
 
14957 
  def __ne__(self, other):
14958 
    return not (self == other)
14959 
 
14960 
class addCampaign_args:
14961 
  """
14962 
  Attributes:
14963 
   - campaign
14964 
  """
14965 
 
14966 
  thrift_spec = (
14967 
    None, # 0
14968 
    (1, TType.STRUCT, 'campaign', (Campaign, Campaign.thrift_spec), None, ), # 1
14969 
  )
14970 
 
14971 
  def __init__(self, campaign=None,):
14972 
    self.campaign = campaign
14973 
 
14974 
  def read(self, iprot):
14975 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14976 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14977 
      return
14978 
    iprot.readStructBegin()
14979 
    while True:
14980 
      (fname, ftype, fid) = iprot.readFieldBegin()
14981 
      if ftype == TType.STOP:
14982 
        break
14983 
      if fid == 1:
14984 
        if ftype == TType.STRUCT:
14985 
          self.campaign = Campaign()
14986 
          self.campaign.read(iprot)
14987 
        else:
14988 
          iprot.skip(ftype)
14989 
      else:
14990 
        iprot.skip(ftype)
14991 
      iprot.readFieldEnd()
14992 
    iprot.readStructEnd()
14993 
 
14994 
  def write(self, oprot):
14995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14997 
      return
14998 
    oprot.writeStructBegin('addCampaign_args')
14999 
    if self.campaign is not None:
15000 
      oprot.writeFieldBegin('campaign', TType.STRUCT, 1)
15001 
      self.campaign.write(oprot)
15002 
      oprot.writeFieldEnd()
15003 
    oprot.writeFieldStop()
15004 
    oprot.writeStructEnd()
15005 
 
15006 
  def validate(self):
15007 
    return
15008 
 
15009 
 
15010 
  def __repr__(self):
15011 
    L = ['%s=%r' % (key, value)
15012 
      for key, value in self.__dict__.iteritems()]
15013 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15014 
 
15015 
  def __eq__(self, other):
15016 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15017 
 
15018 
  def __ne__(self, other):
15019 
    return not (self == other)
15020 
 
15021 
class addCampaign_result:
15022 
 
15023 
  thrift_spec = (
15024 
  )
15025 
 
15026 
  def read(self, iprot):
15027 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15028 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15029 
      return
15030 
    iprot.readStructBegin()
15031 
    while True:
15032 
      (fname, ftype, fid) = iprot.readFieldBegin()
15033 
      if ftype == TType.STOP:
15034 
        break
15035 
      else:
15036 
        iprot.skip(ftype)
15037 
      iprot.readFieldEnd()
15038 
    iprot.readStructEnd()
15039 
 
15040 
  def write(self, oprot):
15041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15043 
      return
15044 
    oprot.writeStructBegin('addCampaign_result')
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 getCampaigns_args:
15064 
  """
15065 
  Attributes:
15066 
   - campaignName
15067 
  """
15068 
 
15069 
  thrift_spec = (
15070 
    None, # 0
15071 
    (1, TType.STRING, 'campaignName', None, None, ), # 1
15072 
  )
15073 
 
15074 
  def __init__(self, campaignName=None,):
15075 
    self.campaignName = campaignName
15076 
 
15077 
  def read(self, iprot):
15078 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15079 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15080 
      return
15081 
    iprot.readStructBegin()
15082 
    while True:
15083 
      (fname, ftype, fid) = iprot.readFieldBegin()
15084 
      if ftype == TType.STOP:
15085 
        break
15086 
      if fid == 1:
15087 
        if ftype == TType.STRING:
15088 
          self.campaignName = iprot.readString();
15089 
        else:
15090 
          iprot.skip(ftype)
15091 
      else:
15092 
        iprot.skip(ftype)
15093 
      iprot.readFieldEnd()
15094 
    iprot.readStructEnd()
15095 
 
15096 
  def write(self, oprot):
15097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15099 
      return
15100 
    oprot.writeStructBegin('getCampaigns_args')
15101 
    if self.campaignName is not None:
15102 
      oprot.writeFieldBegin('campaignName', TType.STRING, 1)
15103 
      oprot.writeString(self.campaignName)
15104 
      oprot.writeFieldEnd()
15105 
    oprot.writeFieldStop()
15106 
    oprot.writeStructEnd()
15107 
 
15108 
  def validate(self):
15109 
    return
15110 
 
15111 
 
15112 
  def __repr__(self):
15113 
    L = ['%s=%r' % (key, value)
15114 
      for key, value in self.__dict__.iteritems()]
15115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15116 
 
15117 
  def __eq__(self, other):
15118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15119 
 
15120 
  def __ne__(self, other):
15121 
    return not (self == other)
15122 
 
15123 
class getCampaigns_result:
15124 
  """
15125 
  Attributes:
15126 
   - success
15127 
  """
15128 
 
15129 
  thrift_spec = (
15130 
    (0, TType.LIST, 'success', (TType.STRUCT,(Campaign, Campaign.thrift_spec)), None, ), # 0
15131 
  )
15132 
 
15133 
  def __init__(self, success=None,):
15134 
    self.success = success
15135 
 
15136 
  def read(self, iprot):
15137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15139 
      return
15140 
    iprot.readStructBegin()
15141 
    while True:
15142 
      (fname, ftype, fid) = iprot.readFieldBegin()
15143 
      if ftype == TType.STOP:
15144 
        break
15145 
      if fid == 0:
15146 
        if ftype == TType.LIST:
15147 
          self.success = []
8590 kshitij.so 15148 
          (_etype249, _size246) = iprot.readListBegin()
15149 
          for _i250 in xrange(_size246):
15150 
            _elem251 = Campaign()
15151 
            _elem251.read(iprot)
15152 
            self.success.append(_elem251)
8579 kshitij.so 15153 
          iprot.readListEnd()
15154 
        else:
15155 
          iprot.skip(ftype)
15156 
      else:
15157 
        iprot.skip(ftype)
15158 
      iprot.readFieldEnd()
15159 
    iprot.readStructEnd()
15160 
 
15161 
  def write(self, oprot):
15162 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15163 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15164 
      return
15165 
    oprot.writeStructBegin('getCampaigns_result')
15166 
    if self.success is not None:
15167 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15168 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 15169 
      for iter252 in self.success:
15170 
        iter252.write(oprot)
8579 kshitij.so 15171 
      oprot.writeListEnd()
15172 
      oprot.writeFieldEnd()
15173 
    oprot.writeFieldStop()
15174 
    oprot.writeStructEnd()
15175 
 
15176 
  def validate(self):
15177 
    return
15178 
 
15179 
 
15180 
  def __repr__(self):
15181 
    L = ['%s=%r' % (key, value)
15182 
      for key, value in self.__dict__.iteritems()]
15183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15184 
 
15185 
  def __eq__(self, other):
15186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15187 
 
15188 
  def __ne__(self, other):
15189 
    return not (self == other)
15190 
 
15191 
class deleteCampaign_args:
15192 
  """
15193 
  Attributes:
15194 
   - campaignId
15195 
  """
15196 
 
15197 
  thrift_spec = (
15198 
    None, # 0
15199 
    (1, TType.I64, 'campaignId', None, None, ), # 1
15200 
  )
15201 
 
15202 
  def __init__(self, campaignId=None,):
15203 
    self.campaignId = campaignId
15204 
 
15205 
  def read(self, iprot):
15206 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15207 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15208 
      return
15209 
    iprot.readStructBegin()
15210 
    while True:
15211 
      (fname, ftype, fid) = iprot.readFieldBegin()
15212 
      if ftype == TType.STOP:
15213 
        break
15214 
      if fid == 1:
15215 
        if ftype == TType.I64:
15216 
          self.campaignId = iprot.readI64();
15217 
        else:
15218 
          iprot.skip(ftype)
15219 
      else:
15220 
        iprot.skip(ftype)
15221 
      iprot.readFieldEnd()
15222 
    iprot.readStructEnd()
15223 
 
15224 
  def write(self, oprot):
15225 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15226 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15227 
      return
15228 
    oprot.writeStructBegin('deleteCampaign_args')
15229 
    if self.campaignId is not None:
15230 
      oprot.writeFieldBegin('campaignId', TType.I64, 1)
15231 
      oprot.writeI64(self.campaignId)
15232 
      oprot.writeFieldEnd()
15233 
    oprot.writeFieldStop()
15234 
    oprot.writeStructEnd()
15235 
 
15236 
  def validate(self):
15237 
    return
15238 
 
15239 
 
15240 
  def __repr__(self):
15241 
    L = ['%s=%r' % (key, value)
15242 
      for key, value in self.__dict__.iteritems()]
15243 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15244 
 
15245 
  def __eq__(self, other):
15246 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15247 
 
15248 
  def __ne__(self, other):
15249 
    return not (self == other)
15250 
 
15251 
class deleteCampaign_result:
15252 
 
15253 
  thrift_spec = (
15254 
  )
15255 
 
15256 
  def read(self, iprot):
15257 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15258 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15259 
      return
15260 
    iprot.readStructBegin()
15261 
    while True:
15262 
      (fname, ftype, fid) = iprot.readFieldBegin()
15263 
      if ftype == TType.STOP:
15264 
        break
15265 
      else:
15266 
        iprot.skip(ftype)
15267 
      iprot.readFieldEnd()
15268 
    iprot.readStructEnd()
15269 
 
15270 
  def write(self, oprot):
15271 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15272 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15273 
      return
15274 
    oprot.writeStructBegin('deleteCampaign_result')
15275 
    oprot.writeFieldStop()
15276 
    oprot.writeStructEnd()
15277 
 
15278 
  def validate(self):
15279 
    return
15280 
 
15281 
 
15282 
  def __repr__(self):
15283 
    L = ['%s=%r' % (key, value)
15284 
      for key, value in self.__dict__.iteritems()]
15285 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15286 
 
15287 
  def __eq__(self, other):
15288 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15289 
 
15290 
  def __ne__(self, other):
15291 
    return not (self == other)
15292 
 
15293 
class getAllCampaigns_args:
15294 
 
15295 
  thrift_spec = (
15296 
  )
15297 
 
15298 
  def read(self, iprot):
15299 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15300 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15301 
      return
15302 
    iprot.readStructBegin()
15303 
    while True:
15304 
      (fname, ftype, fid) = iprot.readFieldBegin()
15305 
      if ftype == TType.STOP:
15306 
        break
15307 
      else:
15308 
        iprot.skip(ftype)
15309 
      iprot.readFieldEnd()
15310 
    iprot.readStructEnd()
15311 
 
15312 
  def write(self, oprot):
15313 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15314 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15315 
      return
15316 
    oprot.writeStructBegin('getAllCampaigns_args')
15317 
    oprot.writeFieldStop()
15318 
    oprot.writeStructEnd()
15319 
 
15320 
  def validate(self):
15321 
    return
15322 
 
15323 
 
15324 
  def __repr__(self):
15325 
    L = ['%s=%r' % (key, value)
15326 
      for key, value in self.__dict__.iteritems()]
15327 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15328 
 
15329 
  def __eq__(self, other):
15330 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15331 
 
15332 
  def __ne__(self, other):
15333 
    return not (self == other)
15334 
 
15335 
class getAllCampaigns_result:
15336 
  """
15337 
  Attributes:
15338 
   - success
15339 
  """
15340 
 
15341 
  thrift_spec = (
15342 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
15343 
  )
15344 
 
15345 
  def __init__(self, success=None,):
15346 
    self.success = success
15347 
 
15348 
  def read(self, iprot):
15349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15351 
      return
15352 
    iprot.readStructBegin()
15353 
    while True:
15354 
      (fname, ftype, fid) = iprot.readFieldBegin()
15355 
      if ftype == TType.STOP:
15356 
        break
15357 
      if fid == 0:
15358 
        if ftype == TType.LIST:
15359 
          self.success = []
8590 kshitij.so 15360 
          (_etype256, _size253) = iprot.readListBegin()
15361 
          for _i257 in xrange(_size253):
15362 
            _elem258 = iprot.readString();
15363 
            self.success.append(_elem258)
8579 kshitij.so 15364 
          iprot.readListEnd()
15365 
        else:
15366 
          iprot.skip(ftype)
15367 
      else:
15368 
        iprot.skip(ftype)
15369 
      iprot.readFieldEnd()
15370 
    iprot.readStructEnd()
15371 
 
15372 
  def write(self, oprot):
15373 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15374 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15375 
      return
15376 
    oprot.writeStructBegin('getAllCampaigns_result')
15377 
    if self.success is not None:
15378 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15379 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 15380 
      for iter259 in self.success:
15381 
        oprot.writeString(iter259)
8579 kshitij.so 15382 
      oprot.writeListEnd()
15383 
      oprot.writeFieldEnd()
15384 
    oprot.writeFieldStop()
15385 
    oprot.writeStructEnd()
15386 
 
15387 
  def validate(self):
15388 
    return
15389 
 
15390 
 
15391 
  def __repr__(self):
15392 
    L = ['%s=%r' % (key, value)
15393 
      for key, value in self.__dict__.iteritems()]
15394 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15395 
 
15396 
  def __eq__(self, other):
15397 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15398 
 
15399 
  def __ne__(self, other):
15400 
    return not (self == other)
15401 
 
9155 kshitij.so 15402 
class getActiveBannersForMobileSite_args:
15403 
 
15404 
  thrift_spec = (
15405 
  )
15406 
 
15407 
  def read(self, iprot):
15408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15410 
      return
15411 
    iprot.readStructBegin()
15412 
    while True:
15413 
      (fname, ftype, fid) = iprot.readFieldBegin()
15414 
      if ftype == TType.STOP:
15415 
        break
15416 
      else:
15417 
        iprot.skip(ftype)
15418 
      iprot.readFieldEnd()
15419 
    iprot.readStructEnd()
15420 
 
15421 
  def write(self, oprot):
15422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15424 
      return
15425 
    oprot.writeStructBegin('getActiveBannersForMobileSite_args')
15426 
    oprot.writeFieldStop()
15427 
    oprot.writeStructEnd()
15428 
 
15429 
  def validate(self):
15430 
    return
15431 
 
15432 
 
15433 
  def __repr__(self):
15434 
    L = ['%s=%r' % (key, value)
15435 
      for key, value in self.__dict__.iteritems()]
15436 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15437 
 
15438 
  def __eq__(self, other):
15439 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15440 
 
15441 
  def __ne__(self, other):
15442 
    return not (self == other)
15443 
 
15444 
class getActiveBannersForMobileSite_result:
15445 
  """
15446 
  Attributes:
15447 
   - success
15448 
  """
15449 
 
15450 
  thrift_spec = (
15451 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
15452 
  )
15453 
 
15454 
  def __init__(self, success=None,):
15455 
    self.success = success
15456 
 
15457 
  def read(self, iprot):
15458 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15459 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15460 
      return
15461 
    iprot.readStructBegin()
15462 
    while True:
15463 
      (fname, ftype, fid) = iprot.readFieldBegin()
15464 
      if ftype == TType.STOP:
15465 
        break
15466 
      if fid == 0:
15467 
        if ftype == TType.MAP:
15468 
          self.success = {}
15469 
          (_ktype261, _vtype262, _size260 ) = iprot.readMapBegin()
15470 
          for _i264 in xrange(_size260):
15471 
            _key265 = iprot.readString();
15472 
            _val266 = []
15473 
            (_etype270, _size267) = iprot.readListBegin()
15474 
            for _i271 in xrange(_size267):
15475 
              _elem272 = Banner()
15476 
              _elem272.read(iprot)
15477 
              _val266.append(_elem272)
15478 
            iprot.readListEnd()
15479 
            self.success[_key265] = _val266
15480 
          iprot.readMapEnd()
15481 
        else:
15482 
          iprot.skip(ftype)
15483 
      else:
15484 
        iprot.skip(ftype)
15485 
      iprot.readFieldEnd()
15486 
    iprot.readStructEnd()
15487 
 
15488 
  def write(self, oprot):
15489 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15490 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15491 
      return
15492 
    oprot.writeStructBegin('getActiveBannersForMobileSite_result')
15493 
    if self.success is not None:
15494 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15495 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
15496 
      for kiter273,viter274 in self.success.items():
15497 
        oprot.writeString(kiter273)
15498 
        oprot.writeListBegin(TType.STRUCT, len(viter274))
15499 
        for iter275 in viter274:
15500 
          iter275.write(oprot)
15501 
        oprot.writeListEnd()
15502 
      oprot.writeMapEnd()
15503 
      oprot.writeFieldEnd()
15504 
    oprot.writeFieldStop()
15505 
    oprot.writeStructEnd()
15506 
 
15507 
  def validate(self):
15508 
    return
15509 
 
15510 
 
15511 
  def __repr__(self):
15512 
    L = ['%s=%r' % (key, value)
15513 
      for key, value in self.__dict__.iteritems()]
15514 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15515 
 
15516 
  def __eq__(self, other):
15517 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15518 
 
15519 
  def __ne__(self, other):
15520 
    return not (self == other)
15521 
 
5944 mandeep.dh 15522 
class deleteSimilarItem_args:
15523 
  """
15524 
  Attributes:
15525 
   - itemId
15526 
   - catalogItemId
15527 
  """
15528 
 
15529 
  thrift_spec = (
15530 
    None, # 0
15531 
    (1, TType.I64, 'itemId', None, None, ), # 1
15532 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
15533 
  )
15534 
 
15535 
  def __init__(self, itemId=None, catalogItemId=None,):
15536 
    self.itemId = itemId
15537 
    self.catalogItemId = catalogItemId
15538 
 
15539 
  def read(self, iprot):
15540 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15541 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15542 
      return
15543 
    iprot.readStructBegin()
15544 
    while True:
15545 
      (fname, ftype, fid) = iprot.readFieldBegin()
15546 
      if ftype == TType.STOP:
15547 
        break
15548 
      if fid == 1:
15549 
        if ftype == TType.I64:
15550 
          self.itemId = iprot.readI64();
15551 
        else:
15552 
          iprot.skip(ftype)
15553 
      elif fid == 2:
15554 
        if ftype == TType.I64:
15555 
          self.catalogItemId = iprot.readI64();
15556 
        else:
15557 
          iprot.skip(ftype)
15558 
      else:
15559 
        iprot.skip(ftype)
15560 
      iprot.readFieldEnd()
15561 
    iprot.readStructEnd()
15562 
 
15563 
  def write(self, oprot):
15564 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15565 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15566 
      return
15567 
    oprot.writeStructBegin('deleteSimilarItem_args')
15568 
    if self.itemId is not None:
15569 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15570 
      oprot.writeI64(self.itemId)
15571 
      oprot.writeFieldEnd()
15572 
    if self.catalogItemId is not None:
15573 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
15574 
      oprot.writeI64(self.catalogItemId)
15575 
      oprot.writeFieldEnd()
15576 
    oprot.writeFieldStop()
15577 
    oprot.writeStructEnd()
15578 
 
15579 
  def validate(self):
15580 
    return
15581 
 
15582 
 
15583 
  def __repr__(self):
15584 
    L = ['%s=%r' % (key, value)
15585 
      for key, value in self.__dict__.iteritems()]
15586 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15587 
 
15588 
  def __eq__(self, other):
15589 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15590 
 
15591 
  def __ne__(self, other):
15592 
    return not (self == other)
15593 
 
15594 
class deleteSimilarItem_result:
15595 
  """
15596 
  Attributes:
15597 
   - success
15598 
   - cex
15599 
  """
15600 
 
15601 
  thrift_spec = (
15602 
    (0, TType.BOOL, 'success', None, None, ), # 0
15603 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
15604 
  )
15605 
 
15606 
  def __init__(self, success=None, cex=None,):
15607 
    self.success = success
15608 
    self.cex = cex
15609 
 
15610 
  def read(self, iprot):
15611 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15612 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15613 
      return
15614 
    iprot.readStructBegin()
15615 
    while True:
15616 
      (fname, ftype, fid) = iprot.readFieldBegin()
15617 
      if ftype == TType.STOP:
15618 
        break
15619 
      if fid == 0:
15620 
        if ftype == TType.BOOL:
15621 
          self.success = iprot.readBool();
15622 
        else:
15623 
          iprot.skip(ftype)
15624 
      elif fid == 1:
15625 
        if ftype == TType.STRUCT:
15626 
          self.cex = CatalogServiceException()
15627 
          self.cex.read(iprot)
15628 
        else:
15629 
          iprot.skip(ftype)
15630 
      else:
15631 
        iprot.skip(ftype)
15632 
      iprot.readFieldEnd()
15633 
    iprot.readStructEnd()
15634 
 
15635 
  def write(self, oprot):
15636 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15637 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15638 
      return
15639 
    oprot.writeStructBegin('deleteSimilarItem_result')
15640 
    if self.success is not None:
15641 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15642 
      oprot.writeBool(self.success)
15643 
      oprot.writeFieldEnd()
15644 
    if self.cex is not None:
15645 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15646 
      self.cex.write(oprot)
15647 
      oprot.writeFieldEnd()
15648 
    oprot.writeFieldStop()
15649 
    oprot.writeStructEnd()
15650 
 
15651 
  def validate(self):
15652 
    return
15653 
 
15654 
 
15655 
  def __repr__(self):
15656 
    L = ['%s=%r' % (key, value)
15657 
      for key, value in self.__dict__.iteritems()]
15658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15659 
 
15660 
  def __eq__(self, other):
15661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15662 
 
15663 
  def __ne__(self, other):
15664 
    return not (self == other)
15665 
 
15666 
class checkSimilarItem_args:
15667 
  """
15668 
  Attributes:
15669 
   - brand
15670 
   - modelNumber
15671 
   - modelName
15672 
   - color
15673 
  """
15674 
 
15675 
  thrift_spec = (
15676 
    None, # 0
15677 
    (1, TType.STRING, 'brand', None, None, ), # 1
15678 
    (2, TType.STRING, 'modelNumber', None, None, ), # 2
15679 
    (3, TType.STRING, 'modelName', None, None, ), # 3
15680 
    (4, TType.STRING, 'color', None, None, ), # 4
15681 
  )
15682 
 
15683 
  def __init__(self, brand=None, modelNumber=None, modelName=None, color=None,):
15684 
    self.brand = brand
15685 
    self.modelNumber = modelNumber
15686 
    self.modelName = modelName
15687 
    self.color = color
15688 
 
15689 
  def read(self, iprot):
15690 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15691 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15692 
      return
15693 
    iprot.readStructBegin()
15694 
    while True:
15695 
      (fname, ftype, fid) = iprot.readFieldBegin()
15696 
      if ftype == TType.STOP:
15697 
        break
15698 
      if fid == 1:
15699 
        if ftype == TType.STRING:
15700 
          self.brand = iprot.readString();
15701 
        else:
15702 
          iprot.skip(ftype)
15703 
      elif fid == 2:
15704 
        if ftype == TType.STRING:
15705 
          self.modelNumber = iprot.readString();
15706 
        else:
15707 
          iprot.skip(ftype)
15708 
      elif fid == 3:
15709 
        if ftype == TType.STRING:
15710 
          self.modelName = iprot.readString();
15711 
        else:
15712 
          iprot.skip(ftype)
15713 
      elif fid == 4:
15714 
        if ftype == TType.STRING:
15715 
          self.color = iprot.readString();
15716 
        else:
15717 
          iprot.skip(ftype)
15718 
      else:
15719 
        iprot.skip(ftype)
15720 
      iprot.readFieldEnd()
15721 
    iprot.readStructEnd()
15722 
 
15723 
  def write(self, oprot):
15724 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15725 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15726 
      return
15727 
    oprot.writeStructBegin('checkSimilarItem_args')
15728 
    if self.brand is not None:
15729 
      oprot.writeFieldBegin('brand', TType.STRING, 1)
15730 
      oprot.writeString(self.brand)
15731 
      oprot.writeFieldEnd()
15732 
    if self.modelNumber is not None:
15733 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 2)
15734 
      oprot.writeString(self.modelNumber)
15735 
      oprot.writeFieldEnd()
15736 
    if self.modelName is not None:
15737 
      oprot.writeFieldBegin('modelName', TType.STRING, 3)
15738 
      oprot.writeString(self.modelName)
15739 
      oprot.writeFieldEnd()
15740 
    if self.color is not None:
15741 
      oprot.writeFieldBegin('color', TType.STRING, 4)
15742 
      oprot.writeString(self.color)
15743 
      oprot.writeFieldEnd()
15744 
    oprot.writeFieldStop()
15745 
    oprot.writeStructEnd()
15746 
 
15747 
  def validate(self):
15748 
    return
15749 
 
15750 
 
15751 
  def __repr__(self):
15752 
    L = ['%s=%r' % (key, value)
15753 
      for key, value in self.__dict__.iteritems()]
15754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15755 
 
15756 
  def __eq__(self, other):
15757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15758 
 
15759 
  def __ne__(self, other):
15760 
    return not (self == other)
15761 
 
15762 
class checkSimilarItem_result:
15763 
  """
15764 
  Attributes:
15765 
   - success
15766 
  """
15767 
 
15768 
  thrift_spec = (
15769 
    (0, TType.I64, 'success', None, None, ), # 0
15770 
  )
15771 
 
15772 
  def __init__(self, success=None,):
15773 
    self.success = success
15774 
 
15775 
  def read(self, iprot):
15776 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15777 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15778 
      return
15779 
    iprot.readStructBegin()
15780 
    while True:
15781 
      (fname, ftype, fid) = iprot.readFieldBegin()
15782 
      if ftype == TType.STOP:
15783 
        break
15784 
      if fid == 0:
15785 
        if ftype == TType.I64:
15786 
          self.success = iprot.readI64();
15787 
        else:
15788 
          iprot.skip(ftype)
15789 
      else:
15790 
        iprot.skip(ftype)
15791 
      iprot.readFieldEnd()
15792 
    iprot.readStructEnd()
15793 
 
15794 
  def write(self, oprot):
15795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15797 
      return
15798 
    oprot.writeStructBegin('checkSimilarItem_result')
15799 
    if self.success is not None:
15800 
      oprot.writeFieldBegin('success', TType.I64, 0)
15801 
      oprot.writeI64(self.success)
15802 
      oprot.writeFieldEnd()
15803 
    oprot.writeFieldStop()
15804 
    oprot.writeStructEnd()
15805 
 
15806 
  def validate(self):
15807 
    return
15808 
 
15809 
 
15810 
  def __repr__(self):
15811 
    L = ['%s=%r' % (key, value)
15812 
      for key, value in self.__dict__.iteritems()]
15813 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15814 
 
15815 
  def __eq__(self, other):
15816 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15817 
 
15818 
  def __ne__(self, other):
15819 
    return not (self == other)
15820 
 
15821 
class validateRiskyStatus_args:
15822 
  """
15823 
  Attributes:
15824 
   - itemId
15825 
  """
15826 
 
15827 
  thrift_spec = (
15828 
    None, # 0
15829 
    (1, TType.I64, 'itemId', None, None, ), # 1
15830 
  )
15831 
 
15832 
  def __init__(self, itemId=None,):
15833 
    self.itemId = itemId
15834 
 
15835 
  def read(self, iprot):
15836 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15837 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15838 
      return
15839 
    iprot.readStructBegin()
15840 
    while True:
15841 
      (fname, ftype, fid) = iprot.readFieldBegin()
15842 
      if ftype == TType.STOP:
15843 
        break
15844 
      if fid == 1:
15845 
        if ftype == TType.I64:
15846 
          self.itemId = iprot.readI64();
15847 
        else:
15848 
          iprot.skip(ftype)
15849 
      else:
15850 
        iprot.skip(ftype)
15851 
      iprot.readFieldEnd()
15852 
    iprot.readStructEnd()
15853 
 
15854 
  def write(self, oprot):
15855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15857 
      return
15858 
    oprot.writeStructBegin('validateRiskyStatus_args')
15859 
    if self.itemId is not None:
15860 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15861 
      oprot.writeI64(self.itemId)
15862 
      oprot.writeFieldEnd()
15863 
    oprot.writeFieldStop()
15864 
    oprot.writeStructEnd()
15865 
 
15866 
  def validate(self):
15867 
    return
15868 
 
15869 
 
15870 
  def __repr__(self):
15871 
    L = ['%s=%r' % (key, value)
15872 
      for key, value in self.__dict__.iteritems()]
15873 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15874 
 
15875 
  def __eq__(self, other):
15876 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15877 
 
15878 
  def __ne__(self, other):
15879 
    return not (self == other)
15880 
 
15881 
class validateRiskyStatus_result:
15882 
 
15883 
  thrift_spec = (
15884 
  )
15885 
 
15886 
  def read(self, iprot):
15887 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15888 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15889 
      return
15890 
    iprot.readStructBegin()
15891 
    while True:
15892 
      (fname, ftype, fid) = iprot.readFieldBegin()
15893 
      if ftype == TType.STOP:
15894 
        break
15895 
      else:
15896 
        iprot.skip(ftype)
15897 
      iprot.readFieldEnd()
15898 
    iprot.readStructEnd()
15899 
 
15900 
  def write(self, oprot):
15901 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15902 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15903 
      return
15904 
    oprot.writeStructBegin('validateRiskyStatus_result')
15905 
    oprot.writeFieldStop()
15906 
    oprot.writeStructEnd()
15907 
 
15908 
  def validate(self):
15909 
    return
15910 
 
15911 
 
15912 
  def __repr__(self):
15913 
    L = ['%s=%r' % (key, value)
15914 
      for key, value in self.__dict__.iteritems()]
15915 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15916 
 
15917 
  def __eq__(self, other):
15918 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15919 
 
15920 
  def __ne__(self, other):
15921 
    return not (self == other)
15922 
 
15923 
class changeItemRiskyFlag_args:
15924 
  """
15925 
  Attributes:
15926 
   - itemId
15927 
   - risky
15928 
  """
15929 
 
15930 
  thrift_spec = (
15931 
    None, # 0
15932 
    (1, TType.I64, 'itemId', None, None, ), # 1
15933 
    (2, TType.BOOL, 'risky', None, None, ), # 2
15934 
  )
15935 
 
15936 
  def __init__(self, itemId=None, risky=None,):
15937 
    self.itemId = itemId
15938 
    self.risky = risky
15939 
 
15940 
  def read(self, iprot):
15941 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15942 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15943 
      return
15944 
    iprot.readStructBegin()
15945 
    while True:
15946 
      (fname, ftype, fid) = iprot.readFieldBegin()
15947 
      if ftype == TType.STOP:
15948 
        break
15949 
      if fid == 1:
15950 
        if ftype == TType.I64:
15951 
          self.itemId = iprot.readI64();
15952 
        else:
15953 
          iprot.skip(ftype)
15954 
      elif fid == 2:
15955 
        if ftype == TType.BOOL:
15956 
          self.risky = iprot.readBool();
15957 
        else:
15958 
          iprot.skip(ftype)
15959 
      else:
15960 
        iprot.skip(ftype)
15961 
      iprot.readFieldEnd()
15962 
    iprot.readStructEnd()
15963 
 
15964 
  def write(self, oprot):
15965 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15966 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15967 
      return
15968 
    oprot.writeStructBegin('changeItemRiskyFlag_args')
15969 
    if self.itemId is not None:
15970 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15971 
      oprot.writeI64(self.itemId)
15972 
      oprot.writeFieldEnd()
15973 
    if self.risky is not None:
15974 
      oprot.writeFieldBegin('risky', TType.BOOL, 2)
15975 
      oprot.writeBool(self.risky)
15976 
      oprot.writeFieldEnd()
15977 
    oprot.writeFieldStop()
15978 
    oprot.writeStructEnd()
15979 
 
15980 
  def validate(self):
15981 
    return
15982 
 
15983 
 
15984 
  def __repr__(self):
15985 
    L = ['%s=%r' % (key, value)
15986 
      for key, value in self.__dict__.iteritems()]
15987 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15988 
 
15989 
  def __eq__(self, other):
15990 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15991 
 
15992 
  def __ne__(self, other):
15993 
    return not (self == other)
15994 
 
15995 
class changeItemRiskyFlag_result:
15996 
 
15997 
  thrift_spec = (
15998 
  )
15999 
 
16000 
  def read(self, iprot):
16001 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16002 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16003 
      return
16004 
    iprot.readStructBegin()
16005 
    while True:
16006 
      (fname, ftype, fid) = iprot.readFieldBegin()
16007 
      if ftype == TType.STOP:
16008 
        break
16009 
      else:
16010 
        iprot.skip(ftype)
16011 
      iprot.readFieldEnd()
16012 
    iprot.readStructEnd()
16013 
 
16014 
  def write(self, oprot):
16015 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16016 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16017 
      return
16018 
    oprot.writeStructBegin('changeItemRiskyFlag_result')
16019 
    oprot.writeFieldStop()
16020 
    oprot.writeStructEnd()
16021 
 
16022 
  def validate(self):
16023 
    return
16024 
 
16025 
 
16026 
  def __repr__(self):
16027 
    L = ['%s=%r' % (key, value)
16028 
      for key, value in self.__dict__.iteritems()]
16029 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16030 
 
16031 
  def __eq__(self, other):
16032 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16033 
 
16034 
  def __ne__(self, other):
16035 
    return not (self == other)
16036 
 
16037 
class getItemsByRiskyFlag_args:
16038 
 
16039 
  thrift_spec = (
16040 
  )
16041 
 
16042 
  def read(self, iprot):
16043 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16044 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16045 
      return
16046 
    iprot.readStructBegin()
16047 
    while True:
16048 
      (fname, ftype, fid) = iprot.readFieldBegin()
16049 
      if ftype == TType.STOP:
16050 
        break
16051 
      else:
16052 
        iprot.skip(ftype)
16053 
      iprot.readFieldEnd()
16054 
    iprot.readStructEnd()
16055 
 
16056 
  def write(self, oprot):
16057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16059 
      return
16060 
    oprot.writeStructBegin('getItemsByRiskyFlag_args')
16061 
    oprot.writeFieldStop()
16062 
    oprot.writeStructEnd()
16063 
 
16064 
  def validate(self):
16065 
    return
16066 
 
16067 
 
16068 
  def __repr__(self):
16069 
    L = ['%s=%r' % (key, value)
16070 
      for key, value in self.__dict__.iteritems()]
16071 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16072 
 
16073 
  def __eq__(self, other):
16074 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16075 
 
16076 
  def __ne__(self, other):
16077 
    return not (self == other)
16078 
 
16079 
class getItemsByRiskyFlag_result:
16080 
  """
16081 
  Attributes:
16082 
   - success
16083 
  """
16084 
 
16085 
  thrift_spec = (
16086 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
16087 
  )
16088 
 
16089 
  def __init__(self, success=None,):
16090 
    self.success = success
16091 
 
16092 
  def read(self, iprot):
16093 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16094 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16095 
      return
16096 
    iprot.readStructBegin()
16097 
    while True:
16098 
      (fname, ftype, fid) = iprot.readFieldBegin()
16099 
      if ftype == TType.STOP:
16100 
        break
16101 
      if fid == 0:
16102 
        if ftype == TType.LIST:
16103 
          self.success = []
9155 kshitij.so 16104 
          (_etype279, _size276) = iprot.readListBegin()
16105 
          for _i280 in xrange(_size276):
16106 
            _elem281 = Item()
16107 
            _elem281.read(iprot)
16108 
            self.success.append(_elem281)
5944 mandeep.dh 16109 
          iprot.readListEnd()
16110 
        else:
16111 
          iprot.skip(ftype)
16112 
      else:
16113 
        iprot.skip(ftype)
16114 
      iprot.readFieldEnd()
16115 
    iprot.readStructEnd()
16116 
 
16117 
  def write(self, oprot):
16118 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16119 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16120 
      return
16121 
    oprot.writeStructBegin('getItemsByRiskyFlag_result')
16122 
    if self.success is not None:
16123 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16124 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16125 
      for iter282 in self.success:
16126 
        iter282.write(oprot)
5944 mandeep.dh 16127 
      oprot.writeListEnd()
16128 
      oprot.writeFieldEnd()
16129 
    oprot.writeFieldStop()
16130 
    oprot.writeStructEnd()
16131 
 
16132 
  def validate(self):
16133 
    return
16134 
 
16135 
 
16136 
  def __repr__(self):
16137 
    L = ['%s=%r' % (key, value)
16138 
      for key, value in self.__dict__.iteritems()]
16139 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16140 
 
16141 
  def __eq__(self, other):
16142 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16143 
 
16144 
  def __ne__(self, other):
16145 
    return not (self == other)
16146 
 
16147 
class getItemsForMasterSheet_args:
16148 
  """
16149 
  Attributes:
16150 
   - category
16151 
   - brand
16152 
  """
16153 
 
16154 
  thrift_spec = (
16155 
    None, # 0
16156 
    (1, TType.STRING, 'category', None, None, ), # 1
16157 
    (2, TType.STRING, 'brand', None, None, ), # 2
16158 
  )
16159 
 
16160 
  def __init__(self, category=None, brand=None,):
16161 
    self.category = category
16162 
    self.brand = brand
16163 
 
16164 
  def read(self, iprot):
16165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16167 
      return
16168 
    iprot.readStructBegin()
16169 
    while True:
16170 
      (fname, ftype, fid) = iprot.readFieldBegin()
16171 
      if ftype == TType.STOP:
16172 
        break
16173 
      if fid == 1:
16174 
        if ftype == TType.STRING:
16175 
          self.category = iprot.readString();
16176 
        else:
16177 
          iprot.skip(ftype)
16178 
      elif fid == 2:
16179 
        if ftype == TType.STRING:
16180 
          self.brand = iprot.readString();
16181 
        else:
16182 
          iprot.skip(ftype)
16183 
      else:
16184 
        iprot.skip(ftype)
16185 
      iprot.readFieldEnd()
16186 
    iprot.readStructEnd()
16187 
 
16188 
  def write(self, oprot):
16189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16191 
      return
16192 
    oprot.writeStructBegin('getItemsForMasterSheet_args')
16193 
    if self.category is not None:
16194 
      oprot.writeFieldBegin('category', TType.STRING, 1)
16195 
      oprot.writeString(self.category)
16196 
      oprot.writeFieldEnd()
16197 
    if self.brand is not None:
16198 
      oprot.writeFieldBegin('brand', TType.STRING, 2)
16199 
      oprot.writeString(self.brand)
16200 
      oprot.writeFieldEnd()
16201 
    oprot.writeFieldStop()
16202 
    oprot.writeStructEnd()
16203 
 
16204 
  def validate(self):
16205 
    return
16206 
 
16207 
 
16208 
  def __repr__(self):
16209 
    L = ['%s=%r' % (key, value)
16210 
      for key, value in self.__dict__.iteritems()]
16211 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16212 
 
16213 
  def __eq__(self, other):
16214 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16215 
 
16216 
  def __ne__(self, other):
16217 
    return not (self == other)
16218 
 
16219 
class getItemsForMasterSheet_result:
16220 
  """
16221 
  Attributes:
16222 
   - success
16223 
  """
16224 
 
16225 
  thrift_spec = (
16226 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
16227 
  )
16228 
 
16229 
  def __init__(self, success=None,):
16230 
    self.success = success
16231 
 
16232 
  def read(self, iprot):
16233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16235 
      return
16236 
    iprot.readStructBegin()
16237 
    while True:
16238 
      (fname, ftype, fid) = iprot.readFieldBegin()
16239 
      if ftype == TType.STOP:
16240 
        break
16241 
      if fid == 0:
16242 
        if ftype == TType.LIST:
16243 
          self.success = []
9155 kshitij.so 16244 
          (_etype286, _size283) = iprot.readListBegin()
16245 
          for _i287 in xrange(_size283):
16246 
            _elem288 = Item()
16247 
            _elem288.read(iprot)
16248 
            self.success.append(_elem288)
5944 mandeep.dh 16249 
          iprot.readListEnd()
16250 
        else:
16251 
          iprot.skip(ftype)
16252 
      else:
16253 
        iprot.skip(ftype)
16254 
      iprot.readFieldEnd()
16255 
    iprot.readStructEnd()
16256 
 
16257 
  def write(self, oprot):
16258 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16259 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16260 
      return
16261 
    oprot.writeStructBegin('getItemsForMasterSheet_result')
16262 
    if self.success is not None:
16263 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16264 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16265 
      for iter289 in self.success:
16266 
        iter289.write(oprot)
5944 mandeep.dh 16267 
      oprot.writeListEnd()
16268 
      oprot.writeFieldEnd()
16269 
    oprot.writeFieldStop()
16270 
    oprot.writeStructEnd()
16271 
 
16272 
  def validate(self):
16273 
    return
16274 
 
16275 
 
16276 
  def __repr__(self):
16277 
    L = ['%s=%r' % (key, value)
16278 
      for key, value in self.__dict__.iteritems()]
16279 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16280 
 
16281 
  def __eq__(self, other):
16282 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16283 
 
16284 
  def __ne__(self, other):
16285 
    return not (self == other)
16286 
 
16287 
class getSimilarItemsCatalogIds_args:
16288 
  """
16289 
  Attributes:
16290 
   - beginIndex
16291 
   - totalItems
16292 
   - itemId
16293 
  """
16294 
 
16295 
  thrift_spec = (
16296 
    None, # 0
16297 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
16298 
    (2, TType.I64, 'totalItems', None, None, ), # 2
16299 
    (3, TType.I64, 'itemId', None, None, ), # 3
16300 
  )
16301 
 
16302 
  def __init__(self, beginIndex=None, totalItems=None, itemId=None,):
16303 
    self.beginIndex = beginIndex
16304 
    self.totalItems = totalItems
16305 
    self.itemId = itemId
16306 
 
16307 
  def read(self, iprot):
16308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16310 
      return
16311 
    iprot.readStructBegin()
16312 
    while True:
16313 
      (fname, ftype, fid) = iprot.readFieldBegin()
16314 
      if ftype == TType.STOP:
16315 
        break
16316 
      if fid == 1:
16317 
        if ftype == TType.I64:
16318 
          self.beginIndex = iprot.readI64();
16319 
        else:
16320 
          iprot.skip(ftype)
16321 
      elif fid == 2:
16322 
        if ftype == TType.I64:
16323 
          self.totalItems = iprot.readI64();
16324 
        else:
16325 
          iprot.skip(ftype)
16326 
      elif fid == 3:
16327 
        if ftype == TType.I64:
16328 
          self.itemId = iprot.readI64();
16329 
        else:
16330 
          iprot.skip(ftype)
16331 
      else:
16332 
        iprot.skip(ftype)
16333 
      iprot.readFieldEnd()
16334 
    iprot.readStructEnd()
16335 
 
16336 
  def write(self, oprot):
16337 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16338 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16339 
      return
16340 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_args')
16341 
    if self.beginIndex is not None:
16342 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
16343 
      oprot.writeI64(self.beginIndex)
16344 
      oprot.writeFieldEnd()
16345 
    if self.totalItems is not None:
16346 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
16347 
      oprot.writeI64(self.totalItems)
16348 
      oprot.writeFieldEnd()
16349 
    if self.itemId is not None:
16350 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
16351 
      oprot.writeI64(self.itemId)
16352 
      oprot.writeFieldEnd()
16353 
    oprot.writeFieldStop()
16354 
    oprot.writeStructEnd()
16355 
 
16356 
  def validate(self):
16357 
    return
16358 
 
16359 
 
16360 
  def __repr__(self):
16361 
    L = ['%s=%r' % (key, value)
16362 
      for key, value in self.__dict__.iteritems()]
16363 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16364 
 
16365 
  def __eq__(self, other):
16366 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16367 
 
16368 
  def __ne__(self, other):
16369 
    return not (self == other)
16370 
 
16371 
class getSimilarItemsCatalogIds_result:
16372 
  """
16373 
  Attributes:
16374 
   - success
16375 
  """
16376 
 
16377 
  thrift_spec = (
16378 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
16379 
  )
16380 
 
16381 
  def __init__(self, success=None,):
16382 
    self.success = success
16383 
 
16384 
  def read(self, iprot):
16385 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16386 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16387 
      return
16388 
    iprot.readStructBegin()
16389 
    while True:
16390 
      (fname, ftype, fid) = iprot.readFieldBegin()
16391 
      if ftype == TType.STOP:
16392 
        break
16393 
      if fid == 0:
16394 
        if ftype == TType.LIST:
16395 
          self.success = []
9155 kshitij.so 16396 
          (_etype293, _size290) = iprot.readListBegin()
16397 
          for _i294 in xrange(_size290):
16398 
            _elem295 = iprot.readI64();
16399 
            self.success.append(_elem295)
5944 mandeep.dh 16400 
          iprot.readListEnd()
16401 
        else:
16402 
          iprot.skip(ftype)
16403 
      else:
16404 
        iprot.skip(ftype)
16405 
      iprot.readFieldEnd()
16406 
    iprot.readStructEnd()
16407 
 
16408 
  def write(self, oprot):
16409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16411 
      return
16412 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_result')
16413 
    if self.success is not None:
16414 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16415 
      oprot.writeListBegin(TType.I64, len(self.success))
9155 kshitij.so 16416 
      for iter296 in self.success:
16417 
        oprot.writeI64(iter296)
5944 mandeep.dh 16418 
      oprot.writeListEnd()
16419 
      oprot.writeFieldEnd()
16420 
    oprot.writeFieldStop()
16421 
    oprot.writeStructEnd()
16422 
 
16423 
  def validate(self):
16424 
    return
16425 
 
16426 
 
16427 
  def __repr__(self):
16428 
    L = ['%s=%r' % (key, value)
16429 
      for key, value in self.__dict__.iteritems()]
16430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16431 
 
16432 
  def __eq__(self, other):
16433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16434 
 
16435 
  def __ne__(self, other):
16436 
    return not (self == other)
16437 
 
16438 
class addProductNotification_args:
16439 
  """
16440 
  Attributes:
16441 
   - itemId
16442 
   - email
16443 
  """
16444 
 
16445 
  thrift_spec = None
16446 
  def __init__(self, itemId=None, email=None,):
16447 
    self.itemId = itemId
16448 
    self.email = email
16449 
 
16450 
  def read(self, iprot):
16451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16453 
      return
16454 
    iprot.readStructBegin()
16455 
    while True:
16456 
      (fname, ftype, fid) = iprot.readFieldBegin()
16457 
      if ftype == TType.STOP:
16458 
        break
16459 
      if fid == -1:
16460 
        if ftype == TType.I64:
16461 
          self.itemId = iprot.readI64();
16462 
        else:
16463 
          iprot.skip(ftype)
16464 
      elif fid == -2:
16465 
        if ftype == TType.STRING:
16466 
          self.email = iprot.readString();
16467 
        else:
16468 
          iprot.skip(ftype)
16469 
      else:
16470 
        iprot.skip(ftype)
16471 
      iprot.readFieldEnd()
16472 
    iprot.readStructEnd()
16473 
 
16474 
  def write(self, oprot):
16475 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16476 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16477 
      return
16478 
    oprot.writeStructBegin('addProductNotification_args')
16479 
    if self.email is not None:
16480 
      oprot.writeFieldBegin('email', TType.STRING, -2)
16481 
      oprot.writeString(self.email)
16482 
      oprot.writeFieldEnd()
16483 
    if self.itemId is not None:
16484 
      oprot.writeFieldBegin('itemId', TType.I64, -1)
16485 
      oprot.writeI64(self.itemId)
16486 
      oprot.writeFieldEnd()
16487 
    oprot.writeFieldStop()
16488 
    oprot.writeStructEnd()
16489 
 
16490 
  def validate(self):
16491 
    return
16492 
 
16493 
 
16494 
  def __repr__(self):
16495 
    L = ['%s=%r' % (key, value)
16496 
      for key, value in self.__dict__.iteritems()]
16497 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16498 
 
16499 
  def __eq__(self, other):
16500 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16501 
 
16502 
  def __ne__(self, other):
16503 
    return not (self == other)
16504 
 
16505 
class addProductNotification_result:
16506 
  """
16507 
  Attributes:
16508 
   - success
16509 
  """
16510 
 
16511 
  thrift_spec = (
16512 
    (0, TType.BOOL, 'success', None, None, ), # 0
16513 
  )
16514 
 
16515 
  def __init__(self, success=None,):
16516 
    self.success = success
16517 
 
16518 
  def read(self, iprot):
16519 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16520 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16521 
      return
16522 
    iprot.readStructBegin()
16523 
    while True:
16524 
      (fname, ftype, fid) = iprot.readFieldBegin()
16525 
      if ftype == TType.STOP:
16526 
        break
16527 
      if fid == 0:
16528 
        if ftype == TType.BOOL:
16529 
          self.success = iprot.readBool();
16530 
        else:
16531 
          iprot.skip(ftype)
16532 
      else:
16533 
        iprot.skip(ftype)
16534 
      iprot.readFieldEnd()
16535 
    iprot.readStructEnd()
16536 
 
16537 
  def write(self, oprot):
16538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16540 
      return
16541 
    oprot.writeStructBegin('addProductNotification_result')
16542 
    if self.success is not None:
16543 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16544 
      oprot.writeBool(self.success)
16545 
      oprot.writeFieldEnd()
16546 
    oprot.writeFieldStop()
16547 
    oprot.writeStructEnd()
16548 
 
16549 
  def validate(self):
16550 
    return
16551 
 
16552 
 
16553 
  def __repr__(self):
16554 
    L = ['%s=%r' % (key, value)
16555 
      for key, value in self.__dict__.iteritems()]
16556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16557 
 
16558 
  def __eq__(self, other):
16559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16560 
 
16561 
  def __ne__(self, other):
16562 
    return not (self == other)
16563 
 
16564 
class sendProductNotifications_args:
16565 
 
16566 
  thrift_spec = (
16567 
  )
16568 
 
16569 
  def read(self, iprot):
16570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16572 
      return
16573 
    iprot.readStructBegin()
16574 
    while True:
16575 
      (fname, ftype, fid) = iprot.readFieldBegin()
16576 
      if ftype == TType.STOP:
16577 
        break
16578 
      else:
16579 
        iprot.skip(ftype)
16580 
      iprot.readFieldEnd()
16581 
    iprot.readStructEnd()
16582 
 
16583 
  def write(self, oprot):
16584 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16585 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16586 
      return
16587 
    oprot.writeStructBegin('sendProductNotifications_args')
16588 
    oprot.writeFieldStop()
16589 
    oprot.writeStructEnd()
16590 
 
16591 
  def validate(self):
16592 
    return
16593 
 
16594 
 
16595 
  def __repr__(self):
16596 
    L = ['%s=%r' % (key, value)
16597 
      for key, value in self.__dict__.iteritems()]
16598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16599 
 
16600 
  def __eq__(self, other):
16601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16602 
 
16603 
  def __ne__(self, other):
16604 
    return not (self == other)
16605 
 
16606 
class sendProductNotifications_result:
16607 
  """
16608 
  Attributes:
16609 
   - success
16610 
  """
16611 
 
16612 
  thrift_spec = (
16613 
    (0, TType.BOOL, 'success', None, None, ), # 0
16614 
  )
16615 
 
16616 
  def __init__(self, success=None,):
16617 
    self.success = success
16618 
 
16619 
  def read(self, iprot):
16620 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16621 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16622 
      return
16623 
    iprot.readStructBegin()
16624 
    while True:
16625 
      (fname, ftype, fid) = iprot.readFieldBegin()
16626 
      if ftype == TType.STOP:
16627 
        break
16628 
      if fid == 0:
16629 
        if ftype == TType.BOOL:
16630 
          self.success = iprot.readBool();
16631 
        else:
16632 
          iprot.skip(ftype)
16633 
      else:
16634 
        iprot.skip(ftype)
16635 
      iprot.readFieldEnd()
16636 
    iprot.readStructEnd()
16637 
 
16638 
  def write(self, oprot):
16639 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16640 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16641 
      return
16642 
    oprot.writeStructBegin('sendProductNotifications_result')
16643 
    if self.success is not None:
16644 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16645 
      oprot.writeBool(self.success)
16646 
      oprot.writeFieldEnd()
16647 
    oprot.writeFieldStop()
16648 
    oprot.writeStructEnd()
16649 
 
16650 
  def validate(self):
16651 
    return
16652 
 
16653 
 
16654 
  def __repr__(self):
16655 
    L = ['%s=%r' % (key, value)
16656 
      for key, value in self.__dict__.iteritems()]
16657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16658 
 
16659 
  def __eq__(self, other):
16660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16661 
 
16662 
  def __ne__(self, other):
16663 
    return not (self == other)
16664 
 
16665 
class getAllBrandsByCategory_args:
16666 
  """
16667 
  Attributes:
16668 
   - categoryId
16669 
  """
16670 
 
16671 
  thrift_spec = (
16672 
    None, # 0
16673 
    (1, TType.I64, 'categoryId', None, None, ), # 1
16674 
  )
16675 
 
16676 
  def __init__(self, categoryId=None,):
16677 
    self.categoryId = categoryId
16678 
 
16679 
  def read(self, iprot):
16680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16682 
      return
16683 
    iprot.readStructBegin()
16684 
    while True:
16685 
      (fname, ftype, fid) = iprot.readFieldBegin()
16686 
      if ftype == TType.STOP:
16687 
        break
16688 
      if fid == 1:
16689 
        if ftype == TType.I64:
16690 
          self.categoryId = iprot.readI64();
16691 
        else:
16692 
          iprot.skip(ftype)
16693 
      else:
16694 
        iprot.skip(ftype)
16695 
      iprot.readFieldEnd()
16696 
    iprot.readStructEnd()
16697 
 
16698 
  def write(self, oprot):
16699 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16700 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16701 
      return
16702 
    oprot.writeStructBegin('getAllBrandsByCategory_args')
16703 
    if self.categoryId is not None:
16704 
      oprot.writeFieldBegin('categoryId', TType.I64, 1)
16705 
      oprot.writeI64(self.categoryId)
16706 
      oprot.writeFieldEnd()
16707 
    oprot.writeFieldStop()
16708 
    oprot.writeStructEnd()
16709 
 
16710 
  def validate(self):
16711 
    return
16712 
 
16713 
 
16714 
  def __repr__(self):
16715 
    L = ['%s=%r' % (key, value)
16716 
      for key, value in self.__dict__.iteritems()]
16717 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16718 
 
16719 
  def __eq__(self, other):
16720 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16721 
 
16722 
  def __ne__(self, other):
16723 
    return not (self == other)
16724 
 
16725 
class getAllBrandsByCategory_result:
16726 
  """
16727 
  Attributes:
16728 
   - success
16729 
  """
16730 
 
16731 
  thrift_spec = (
16732 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
16733 
  )
16734 
 
16735 
  def __init__(self, success=None,):
16736 
    self.success = success
16737 
 
16738 
  def read(self, iprot):
16739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16741 
      return
16742 
    iprot.readStructBegin()
16743 
    while True:
16744 
      (fname, ftype, fid) = iprot.readFieldBegin()
16745 
      if ftype == TType.STOP:
16746 
        break
16747 
      if fid == 0:
16748 
        if ftype == TType.LIST:
16749 
          self.success = []
9155 kshitij.so 16750 
          (_etype300, _size297) = iprot.readListBegin()
16751 
          for _i301 in xrange(_size297):
16752 
            _elem302 = iprot.readString();
16753 
            self.success.append(_elem302)
5944 mandeep.dh 16754 
          iprot.readListEnd()
16755 
        else:
16756 
          iprot.skip(ftype)
16757 
      else:
16758 
        iprot.skip(ftype)
16759 
      iprot.readFieldEnd()
16760 
    iprot.readStructEnd()
16761 
 
16762 
  def write(self, oprot):
16763 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16764 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16765 
      return
16766 
    oprot.writeStructBegin('getAllBrandsByCategory_result')
16767 
    if self.success is not None:
16768 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16769 
      oprot.writeListBegin(TType.STRING, len(self.success))
9155 kshitij.so 16770 
      for iter303 in self.success:
16771 
        oprot.writeString(iter303)
5944 mandeep.dh 16772 
      oprot.writeListEnd()
16773 
      oprot.writeFieldEnd()
16774 
    oprot.writeFieldStop()
16775 
    oprot.writeStructEnd()
16776 
 
16777 
  def validate(self):
16778 
    return
16779 
 
16780 
 
16781 
  def __repr__(self):
16782 
    L = ['%s=%r' % (key, value)
16783 
      for key, value in self.__dict__.iteritems()]
16784 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16785 
 
16786 
  def __eq__(self, other):
16787 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16788 
 
16789 
  def __ne__(self, other):
16790 
    return not (self == other)
16791 
 
16792 
class getAllBrands_args:
16793 
 
16794 
  thrift_spec = (
16795 
  )
16796 
 
16797 
  def read(self, iprot):
16798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16800 
      return
16801 
    iprot.readStructBegin()
16802 
    while True:
16803 
      (fname, ftype, fid) = iprot.readFieldBegin()
16804 
      if ftype == TType.STOP:
16805 
        break
16806 
      else:
16807 
        iprot.skip(ftype)
16808 
      iprot.readFieldEnd()
16809 
    iprot.readStructEnd()
16810 
 
16811 
  def write(self, oprot):
16812 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16813 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16814 
      return
16815 
    oprot.writeStructBegin('getAllBrands_args')
16816 
    oprot.writeFieldStop()
16817 
    oprot.writeStructEnd()
16818 
 
16819 
  def validate(self):
16820 
    return
16821 
 
16822 
 
16823 
  def __repr__(self):
16824 
    L = ['%s=%r' % (key, value)
16825 
      for key, value in self.__dict__.iteritems()]
16826 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16827 
 
16828 
  def __eq__(self, other):
16829 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16830 
 
16831 
  def __ne__(self, other):
16832 
    return not (self == other)
16833 
 
16834 
class getAllBrands_result:
16835 
  """
16836 
  Attributes:
16837 
   - success
16838 
  """
16839 
 
16840 
  thrift_spec = (
16841 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
16842 
  )
16843 
 
16844 
  def __init__(self, success=None,):
16845 
    self.success = success
16846 
 
16847 
  def read(self, iprot):
16848 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16849 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16850 
      return
16851 
    iprot.readStructBegin()
16852 
    while True:
16853 
      (fname, ftype, fid) = iprot.readFieldBegin()
16854 
      if ftype == TType.STOP:
16855 
        break
16856 
      if fid == 0:
16857 
        if ftype == TType.LIST:
16858 
          self.success = []
9155 kshitij.so 16859 
          (_etype307, _size304) = iprot.readListBegin()
16860 
          for _i308 in xrange(_size304):
16861 
            _elem309 = iprot.readString();
16862 
            self.success.append(_elem309)
5944 mandeep.dh 16863 
          iprot.readListEnd()
16864 
        else:
16865 
          iprot.skip(ftype)
16866 
      else:
16867 
        iprot.skip(ftype)
16868 
      iprot.readFieldEnd()
16869 
    iprot.readStructEnd()
16870 
 
16871 
  def write(self, oprot):
16872 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16873 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16874 
      return
16875 
    oprot.writeStructBegin('getAllBrands_result')
16876 
    if self.success is not None:
16877 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16878 
      oprot.writeListBegin(TType.STRING, len(self.success))
9155 kshitij.so 16879 
      for iter310 in self.success:
16880 
        oprot.writeString(iter310)
5944 mandeep.dh 16881 
      oprot.writeListEnd()
16882 
      oprot.writeFieldEnd()
16883 
    oprot.writeFieldStop()
16884 
    oprot.writeStructEnd()
16885 
 
16886 
  def validate(self):
16887 
    return
16888 
 
16889 
 
16890 
  def __repr__(self):
16891 
    L = ['%s=%r' % (key, value)
16892 
      for key, value in self.__dict__.iteritems()]
16893 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16894 
 
16895 
  def __eq__(self, other):
16896 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16897 
 
16898 
  def __ne__(self, other):
16899 
    return not (self == other)
16900 
 
16901 
class getAllSources_args:
16902 
 
16903 
  thrift_spec = (
16904 
  )
16905 
 
16906 
  def read(self, iprot):
16907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16909 
      return
16910 
    iprot.readStructBegin()
16911 
    while True:
16912 
      (fname, ftype, fid) = iprot.readFieldBegin()
16913 
      if ftype == TType.STOP:
16914 
        break
16915 
      else:
16916 
        iprot.skip(ftype)
16917 
      iprot.readFieldEnd()
16918 
    iprot.readStructEnd()
16919 
 
16920 
  def write(self, oprot):
16921 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16922 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16923 
      return
16924 
    oprot.writeStructBegin('getAllSources_args')
16925 
    oprot.writeFieldStop()
16926 
    oprot.writeStructEnd()
16927 
 
16928 
  def validate(self):
16929 
    return
16930 
 
16931 
 
16932 
  def __repr__(self):
16933 
    L = ['%s=%r' % (key, value)
16934 
      for key, value in self.__dict__.iteritems()]
16935 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16936 
 
16937 
  def __eq__(self, other):
16938 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16939 
 
16940 
  def __ne__(self, other):
16941 
    return not (self == other)
16942 
 
16943 
class getAllSources_result:
16944 
  """
16945 
  Attributes:
16946 
   - success
16947 
  """
16948 
 
16949 
  thrift_spec = (
16950 
    (0, TType.LIST, 'success', (TType.STRUCT,(Source, Source.thrift_spec)), None, ), # 0
16951 
  )
16952 
 
16953 
  def __init__(self, success=None,):
16954 
    self.success = success
16955 
 
16956 
  def read(self, iprot):
16957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16959 
      return
16960 
    iprot.readStructBegin()
16961 
    while True:
16962 
      (fname, ftype, fid) = iprot.readFieldBegin()
16963 
      if ftype == TType.STOP:
16964 
        break
16965 
      if fid == 0:
16966 
        if ftype == TType.LIST:
16967 
          self.success = []
9155 kshitij.so 16968 
          (_etype314, _size311) = iprot.readListBegin()
16969 
          for _i315 in xrange(_size311):
16970 
            _elem316 = Source()
16971 
            _elem316.read(iprot)
16972 
            self.success.append(_elem316)
5944 mandeep.dh 16973 
          iprot.readListEnd()
16974 
        else:
16975 
          iprot.skip(ftype)
16976 
      else:
16977 
        iprot.skip(ftype)
16978 
      iprot.readFieldEnd()
16979 
    iprot.readStructEnd()
16980 
 
16981 
  def write(self, oprot):
16982 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16983 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16984 
      return
16985 
    oprot.writeStructBegin('getAllSources_result')
16986 
    if self.success is not None:
16987 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16988 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16989 
      for iter317 in self.success:
16990 
        iter317.write(oprot)
5944 mandeep.dh 16991 
      oprot.writeListEnd()
16992 
      oprot.writeFieldEnd()
16993 
    oprot.writeFieldStop()
16994 
    oprot.writeStructEnd()
16995 
 
16996 
  def validate(self):
16997 
    return
16998 
 
16999 
 
17000 
  def __repr__(self):
17001 
    L = ['%s=%r' % (key, value)
17002 
      for key, value in self.__dict__.iteritems()]
17003 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17004 
 
17005 
  def __eq__(self, other):
17006 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17007 
 
17008 
  def __ne__(self, other):
17009 
    return not (self == other)
17010 
 
17011 
class getItemPricingBySource_args:
17012 
  """
17013 
  Attributes:
17014 
   - itemId
17015 
   - sourceId
17016 
  """
17017 
 
17018 
  thrift_spec = (
17019 
    None, # 0
17020 
    (1, TType.I64, 'itemId', None, None, ), # 1
17021 
    (2, TType.I64, 'sourceId', None, None, ), # 2
17022 
  )
17023 
 
17024 
  def __init__(self, itemId=None, sourceId=None,):
17025 
    self.itemId = itemId
17026 
    self.sourceId = sourceId
17027 
 
17028 
  def read(self, iprot):
17029 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17030 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17031 
      return
17032 
    iprot.readStructBegin()
17033 
    while True:
17034 
      (fname, ftype, fid) = iprot.readFieldBegin()
17035 
      if ftype == TType.STOP:
17036 
        break
17037 
      if fid == 1:
17038 
        if ftype == TType.I64:
17039 
          self.itemId = iprot.readI64();
17040 
        else:
17041 
          iprot.skip(ftype)
17042 
      elif fid == 2:
17043 
        if ftype == TType.I64:
17044 
          self.sourceId = iprot.readI64();
17045 
        else:
17046 
          iprot.skip(ftype)
17047 
      else:
17048 
        iprot.skip(ftype)
17049 
      iprot.readFieldEnd()
17050 
    iprot.readStructEnd()
17051 
 
17052 
  def write(self, oprot):
17053 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17054 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17055 
      return
17056 
    oprot.writeStructBegin('getItemPricingBySource_args')
17057 
    if self.itemId is not None:
17058 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17059 
      oprot.writeI64(self.itemId)
17060 
      oprot.writeFieldEnd()
17061 
    if self.sourceId is not None:
17062 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
17063 
      oprot.writeI64(self.sourceId)
17064 
      oprot.writeFieldEnd()
17065 
    oprot.writeFieldStop()
17066 
    oprot.writeStructEnd()
17067 
 
17068 
  def validate(self):
17069 
    return
17070 
 
17071 
 
17072 
  def __repr__(self):
17073 
    L = ['%s=%r' % (key, value)
17074 
      for key, value in self.__dict__.iteritems()]
17075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17076 
 
17077 
  def __eq__(self, other):
17078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17079 
 
17080 
  def __ne__(self, other):
17081 
    return not (self == other)
17082 
 
17083 
class getItemPricingBySource_result:
17084 
  """
17085 
  Attributes:
17086 
   - success
17087 
   - cex
17088 
  """
17089 
 
17090 
  thrift_spec = (
17091 
    (0, TType.STRUCT, 'success', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 0
17092 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17093 
  )
17094 
 
17095 
  def __init__(self, success=None, cex=None,):
17096 
    self.success = success
17097 
    self.cex = cex
17098 
 
17099 
  def read(self, iprot):
17100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17102 
      return
17103 
    iprot.readStructBegin()
17104 
    while True:
17105 
      (fname, ftype, fid) = iprot.readFieldBegin()
17106 
      if ftype == TType.STOP:
17107 
        break
17108 
      if fid == 0:
17109 
        if ftype == TType.STRUCT:
17110 
          self.success = SourceItemPricing()
17111 
          self.success.read(iprot)
17112 
        else:
17113 
          iprot.skip(ftype)
17114 
      elif fid == 1:
17115 
        if ftype == TType.STRUCT:
17116 
          self.cex = CatalogServiceException()
17117 
          self.cex.read(iprot)
17118 
        else:
17119 
          iprot.skip(ftype)
17120 
      else:
17121 
        iprot.skip(ftype)
17122 
      iprot.readFieldEnd()
17123 
    iprot.readStructEnd()
17124 
 
17125 
  def write(self, oprot):
17126 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17127 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17128 
      return
17129 
    oprot.writeStructBegin('getItemPricingBySource_result')
17130 
    if self.success is not None:
17131 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17132 
      self.success.write(oprot)
17133 
      oprot.writeFieldEnd()
17134 
    if self.cex is not None:
17135 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17136 
      self.cex.write(oprot)
17137 
      oprot.writeFieldEnd()
17138 
    oprot.writeFieldStop()
17139 
    oprot.writeStructEnd()
17140 
 
17141 
  def validate(self):
17142 
    return
17143 
 
17144 
 
17145 
  def __repr__(self):
17146 
    L = ['%s=%r' % (key, value)
17147 
      for key, value in self.__dict__.iteritems()]
17148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17149 
 
17150 
  def __eq__(self, other):
17151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17152 
 
17153 
  def __ne__(self, other):
17154 
    return not (self == other)
17155 
 
17156 
class addSourceItemPricing_args:
17157 
  """
17158 
  Attributes:
17159 
   - sourceItemPricing
17160 
  """
17161 
 
17162 
  thrift_spec = (
17163 
    None, # 0
17164 
    (1, TType.STRUCT, 'sourceItemPricing', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 1
17165 
  )
17166 
 
17167 
  def __init__(self, sourceItemPricing=None,):
17168 
    self.sourceItemPricing = sourceItemPricing
17169 
 
17170 
  def read(self, iprot):
17171 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17172 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17173 
      return
17174 
    iprot.readStructBegin()
17175 
    while True:
17176 
      (fname, ftype, fid) = iprot.readFieldBegin()
17177 
      if ftype == TType.STOP:
17178 
        break
17179 
      if fid == 1:
17180 
        if ftype == TType.STRUCT:
17181 
          self.sourceItemPricing = SourceItemPricing()
17182 
          self.sourceItemPricing.read(iprot)
17183 
        else:
17184 
          iprot.skip(ftype)
17185 
      else:
17186 
        iprot.skip(ftype)
17187 
      iprot.readFieldEnd()
17188 
    iprot.readStructEnd()
17189 
 
17190 
  def write(self, oprot):
17191 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17192 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17193 
      return
17194 
    oprot.writeStructBegin('addSourceItemPricing_args')
17195 
    if self.sourceItemPricing is not None:
17196 
      oprot.writeFieldBegin('sourceItemPricing', TType.STRUCT, 1)
17197 
      self.sourceItemPricing.write(oprot)
17198 
      oprot.writeFieldEnd()
17199 
    oprot.writeFieldStop()
17200 
    oprot.writeStructEnd()
17201 
 
17202 
  def validate(self):
17203 
    return
17204 
 
17205 
 
17206 
  def __repr__(self):
17207 
    L = ['%s=%r' % (key, value)
17208 
      for key, value in self.__dict__.iteritems()]
17209 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17210 
 
17211 
  def __eq__(self, other):
17212 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17213 
 
17214 
  def __ne__(self, other):
17215 
    return not (self == other)
17216 
 
17217 
class addSourceItemPricing_result:
17218 
  """
17219 
  Attributes:
17220 
   - cex
17221 
  """
17222 
 
17223 
  thrift_spec = (
17224 
    None, # 0
17225 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17226 
  )
17227 
 
17228 
  def __init__(self, cex=None,):
17229 
    self.cex = cex
17230 
 
17231 
  def read(self, iprot):
17232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17234 
      return
17235 
    iprot.readStructBegin()
17236 
    while True:
17237 
      (fname, ftype, fid) = iprot.readFieldBegin()
17238 
      if ftype == TType.STOP:
17239 
        break
17240 
      if fid == 1:
17241 
        if ftype == TType.STRUCT:
17242 
          self.cex = CatalogServiceException()
17243 
          self.cex.read(iprot)
17244 
        else:
17245 
          iprot.skip(ftype)
17246 
      else:
17247 
        iprot.skip(ftype)
17248 
      iprot.readFieldEnd()
17249 
    iprot.readStructEnd()
17250 
 
17251 
  def write(self, oprot):
17252 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17253 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17254 
      return
17255 
    oprot.writeStructBegin('addSourceItemPricing_result')
17256 
    if self.cex is not None:
17257 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17258 
      self.cex.write(oprot)
17259 
      oprot.writeFieldEnd()
17260 
    oprot.writeFieldStop()
17261 
    oprot.writeStructEnd()
17262 
 
17263 
  def validate(self):
17264 
    return
17265 
 
17266 
 
17267 
  def __repr__(self):
17268 
    L = ['%s=%r' % (key, value)
17269 
      for key, value in self.__dict__.iteritems()]
17270 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17271 
 
17272 
  def __eq__(self, other):
17273 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17274 
 
17275 
  def __ne__(self, other):
17276 
    return not (self == other)
17277 
 
17278 
class getAllSourcePricing_args:
17279 
  """
17280 
  Attributes:
17281 
   - itemId
17282 
  """
17283 
 
17284 
  thrift_spec = (
17285 
    None, # 0
17286 
    (1, TType.I64, 'itemId', None, None, ), # 1
17287 
  )
17288 
 
17289 
  def __init__(self, itemId=None,):
17290 
    self.itemId = itemId
17291 
 
17292 
  def read(self, iprot):
17293 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17294 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17295 
      return
17296 
    iprot.readStructBegin()
17297 
    while True:
17298 
      (fname, ftype, fid) = iprot.readFieldBegin()
17299 
      if ftype == TType.STOP:
17300 
        break
17301 
      if fid == 1:
17302 
        if ftype == TType.I64:
17303 
          self.itemId = iprot.readI64();
17304 
        else:
17305 
          iprot.skip(ftype)
17306 
      else:
17307 
        iprot.skip(ftype)
17308 
      iprot.readFieldEnd()
17309 
    iprot.readStructEnd()
17310 
 
17311 
  def write(self, oprot):
17312 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17313 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17314 
      return
17315 
    oprot.writeStructBegin('getAllSourcePricing_args')
17316 
    if self.itemId is not None:
17317 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17318 
      oprot.writeI64(self.itemId)
17319 
      oprot.writeFieldEnd()
17320 
    oprot.writeFieldStop()
17321 
    oprot.writeStructEnd()
17322 
 
17323 
  def validate(self):
17324 
    return
17325 
 
17326 
 
17327 
  def __repr__(self):
17328 
    L = ['%s=%r' % (key, value)
17329 
      for key, value in self.__dict__.iteritems()]
17330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17331 
 
17332 
  def __eq__(self, other):
17333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17334 
 
17335 
  def __ne__(self, other):
17336 
    return not (self == other)
17337 
 
17338 
class getAllSourcePricing_result:
17339 
  """
17340 
  Attributes:
17341 
   - success
17342 
   - cex
17343 
  """
17344 
 
17345 
  thrift_spec = (
17346 
    (0, TType.LIST, 'success', (TType.STRUCT,(SourceItemPricing, SourceItemPricing.thrift_spec)), None, ), # 0
17347 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17348 
  )
17349 
 
17350 
  def __init__(self, success=None, cex=None,):
17351 
    self.success = success
17352 
    self.cex = cex
17353 
 
17354 
  def read(self, iprot):
17355 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17356 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17357 
      return
17358 
    iprot.readStructBegin()
17359 
    while True:
17360 
      (fname, ftype, fid) = iprot.readFieldBegin()
17361 
      if ftype == TType.STOP:
17362 
        break
17363 
      if fid == 0:
17364 
        if ftype == TType.LIST:
17365 
          self.success = []
9155 kshitij.so 17366 
          (_etype321, _size318) = iprot.readListBegin()
17367 
          for _i322 in xrange(_size318):
17368 
            _elem323 = SourceItemPricing()
17369 
            _elem323.read(iprot)
17370 
            self.success.append(_elem323)
5944 mandeep.dh 17371 
          iprot.readListEnd()
17372 
        else:
17373 
          iprot.skip(ftype)
17374 
      elif fid == 1:
17375 
        if ftype == TType.STRUCT:
17376 
          self.cex = CatalogServiceException()
17377 
          self.cex.read(iprot)
17378 
        else:
17379 
          iprot.skip(ftype)
17380 
      else:
17381 
        iprot.skip(ftype)
17382 
      iprot.readFieldEnd()
17383 
    iprot.readStructEnd()
17384 
 
17385 
  def write(self, oprot):
17386 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17387 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17388 
      return
17389 
    oprot.writeStructBegin('getAllSourcePricing_result')
17390 
    if self.success is not None:
17391 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17392 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 17393 
      for iter324 in self.success:
17394 
        iter324.write(oprot)
5944 mandeep.dh 17395 
      oprot.writeListEnd()
17396 
      oprot.writeFieldEnd()
17397 
    if self.cex is not None:
17398 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17399 
      self.cex.write(oprot)
17400 
      oprot.writeFieldEnd()
17401 
    oprot.writeFieldStop()
17402 
    oprot.writeStructEnd()
17403 
 
17404 
  def validate(self):
17405 
    return
17406 
 
17407 
 
17408 
  def __repr__(self):
17409 
    L = ['%s=%r' % (key, value)
17410 
      for key, value in self.__dict__.iteritems()]
17411 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17412 
 
17413 
  def __eq__(self, other):
17414 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17415 
 
17416 
  def __ne__(self, other):
17417 
    return not (self == other)
17418 
 
17419 
class getItemForSource_args:
17420 
  """
17421 
  Attributes:
17422 
   - item_id
17423 
   - sourceId
17424 
  """
17425 
 
17426 
  thrift_spec = (
17427 
    None, # 0
17428 
    (1, TType.I64, 'item_id', None, None, ), # 1
17429 
    (2, TType.I64, 'sourceId', None, None, ), # 2
17430 
  )
17431 
 
17432 
  def __init__(self, item_id=None, sourceId=None,):
17433 
    self.item_id = item_id
17434 
    self.sourceId = sourceId
17435 
 
17436 
  def read(self, iprot):
17437 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17438 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17439 
      return
17440 
    iprot.readStructBegin()
17441 
    while True:
17442 
      (fname, ftype, fid) = iprot.readFieldBegin()
17443 
      if ftype == TType.STOP:
17444 
        break
17445 
      if fid == 1:
17446 
        if ftype == TType.I64:
17447 
          self.item_id = iprot.readI64();
17448 
        else:
17449 
          iprot.skip(ftype)
17450 
      elif fid == 2:
17451 
        if ftype == TType.I64:
17452 
          self.sourceId = iprot.readI64();
17453 
        else:
17454 
          iprot.skip(ftype)
17455 
      else:
17456 
        iprot.skip(ftype)
17457 
      iprot.readFieldEnd()
17458 
    iprot.readStructEnd()
17459 
 
17460 
  def write(self, oprot):
17461 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17462 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17463 
      return
17464 
    oprot.writeStructBegin('getItemForSource_args')
17465 
    if self.item_id is not None:
17466 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
17467 
      oprot.writeI64(self.item_id)
17468 
      oprot.writeFieldEnd()
17469 
    if self.sourceId is not None:
17470 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
17471 
      oprot.writeI64(self.sourceId)
17472 
      oprot.writeFieldEnd()
17473 
    oprot.writeFieldStop()
17474 
    oprot.writeStructEnd()
17475 
 
17476 
  def validate(self):
17477 
    return
17478 
 
17479 
 
17480 
  def __repr__(self):
17481 
    L = ['%s=%r' % (key, value)
17482 
      for key, value in self.__dict__.iteritems()]
17483 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17484 
 
17485 
  def __eq__(self, other):
17486 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17487 
 
17488 
  def __ne__(self, other):
17489 
    return not (self == other)
17490 
 
17491 
class getItemForSource_result:
17492 
  """
17493 
  Attributes:
17494 
   - success
17495 
   - cex
17496 
  """
17497 
 
17498 
  thrift_spec = (
17499 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
17500 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17501 
  )
17502 
 
17503 
  def __init__(self, success=None, cex=None,):
17504 
    self.success = success
17505 
    self.cex = cex
17506 
 
17507 
  def read(self, iprot):
17508 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17509 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17510 
      return
17511 
    iprot.readStructBegin()
17512 
    while True:
17513 
      (fname, ftype, fid) = iprot.readFieldBegin()
17514 
      if ftype == TType.STOP:
17515 
        break
17516 
      if fid == 0:
17517 
        if ftype == TType.STRUCT:
17518 
          self.success = Item()
17519 
          self.success.read(iprot)
17520 
        else:
17521 
          iprot.skip(ftype)
17522 
      elif fid == 1:
17523 
        if ftype == TType.STRUCT:
17524 
          self.cex = CatalogServiceException()
17525 
          self.cex.read(iprot)
17526 
        else:
17527 
          iprot.skip(ftype)
17528 
      else:
17529 
        iprot.skip(ftype)
17530 
      iprot.readFieldEnd()
17531 
    iprot.readStructEnd()
17532 
 
17533 
  def write(self, oprot):
17534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17536 
      return
17537 
    oprot.writeStructBegin('getItemForSource_result')
17538 
    if self.success is not None:
17539 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17540 
      self.success.write(oprot)
17541 
      oprot.writeFieldEnd()
17542 
    if self.cex is not None:
17543 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17544 
      self.cex.write(oprot)
17545 
      oprot.writeFieldEnd()
17546 
    oprot.writeFieldStop()
17547 
    oprot.writeStructEnd()
17548 
 
17549 
  def validate(self):
17550 
    return
17551 
 
17552 
 
17553 
  def __repr__(self):
17554 
    L = ['%s=%r' % (key, value)
17555 
      for key, value in self.__dict__.iteritems()]
17556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17557 
 
17558 
  def __eq__(self, other):
17559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17560 
 
17561 
  def __ne__(self, other):
17562 
    return not (self == other)
17563 
 
17564 
class searchItemsInRange_args:
17565 
  """
17566 
  Attributes:
17567 
   - searchTerms
17568 
   - offset
17569 
   - limit
17570 
  """
17571 
 
17572 
  thrift_spec = (
17573 
    None, # 0
17574 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
17575 
    (2, TType.I64, 'offset', None, None, ), # 2
17576 
    (3, TType.I64, 'limit', None, None, ), # 3
17577 
  )
17578 
 
17579 
  def __init__(self, searchTerms=None, offset=None, limit=None,):
17580 
    self.searchTerms = searchTerms
17581 
    self.offset = offset
17582 
    self.limit = limit
17583 
 
17584 
  def read(self, iprot):
17585 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17586 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17587 
      return
17588 
    iprot.readStructBegin()
17589 
    while True:
17590 
      (fname, ftype, fid) = iprot.readFieldBegin()
17591 
      if ftype == TType.STOP:
17592 
        break
17593 
      if fid == 1:
17594 
        if ftype == TType.LIST:
17595 
          self.searchTerms = []
9155 kshitij.so 17596 
          (_etype328, _size325) = iprot.readListBegin()
17597 
          for _i329 in xrange(_size325):
17598 
            _elem330 = iprot.readString();
17599 
            self.searchTerms.append(_elem330)
5944 mandeep.dh 17600 
          iprot.readListEnd()
17601 
        else:
17602 
          iprot.skip(ftype)
17603 
      elif fid == 2:
17604 
        if ftype == TType.I64:
17605 
          self.offset = iprot.readI64();
17606 
        else:
17607 
          iprot.skip(ftype)
17608 
      elif fid == 3:
17609 
        if ftype == TType.I64:
17610 
          self.limit = iprot.readI64();
17611 
        else:
17612 
          iprot.skip(ftype)
17613 
      else:
17614 
        iprot.skip(ftype)
17615 
      iprot.readFieldEnd()
17616 
    iprot.readStructEnd()
17617 
 
17618 
  def write(self, oprot):
17619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17621 
      return
17622 
    oprot.writeStructBegin('searchItemsInRange_args')
17623 
    if self.searchTerms is not None:
17624 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
17625 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
9155 kshitij.so 17626 
      for iter331 in self.searchTerms:
17627 
        oprot.writeString(iter331)
5944 mandeep.dh 17628 
      oprot.writeListEnd()
17629 
      oprot.writeFieldEnd()
17630 
    if self.offset is not None:
17631 
      oprot.writeFieldBegin('offset', TType.I64, 2)
17632 
      oprot.writeI64(self.offset)
17633 
      oprot.writeFieldEnd()
17634 
    if self.limit is not None:
17635 
      oprot.writeFieldBegin('limit', TType.I64, 3)
17636 
      oprot.writeI64(self.limit)
17637 
      oprot.writeFieldEnd()
17638 
    oprot.writeFieldStop()
17639 
    oprot.writeStructEnd()
17640 
 
17641 
  def validate(self):
17642 
    return
17643 
 
17644 
 
17645 
  def __repr__(self):
17646 
    L = ['%s=%r' % (key, value)
17647 
      for key, value in self.__dict__.iteritems()]
17648 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17649 
 
17650 
  def __eq__(self, other):
17651 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17652 
 
17653 
  def __ne__(self, other):
17654 
    return not (self == other)
17655 
 
17656 
class searchItemsInRange_result:
17657 
  """
17658 
  Attributes:
17659 
   - success
17660 
  """
17661 
 
17662 
  thrift_spec = (
17663 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
17664 
  )
17665 
 
17666 
  def __init__(self, success=None,):
17667 
    self.success = success
17668 
 
17669 
  def read(self, iprot):
17670 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17671 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17672 
      return
17673 
    iprot.readStructBegin()
17674 
    while True:
17675 
      (fname, ftype, fid) = iprot.readFieldBegin()
17676 
      if ftype == TType.STOP:
17677 
        break
17678 
      if fid == 0:
17679 
        if ftype == TType.LIST:
17680 
          self.success = []
9155 kshitij.so 17681 
          (_etype335, _size332) = iprot.readListBegin()
17682 
          for _i336 in xrange(_size332):
17683 
            _elem337 = Item()
17684 
            _elem337.read(iprot)
17685 
            self.success.append(_elem337)
5944 mandeep.dh 17686 
          iprot.readListEnd()
17687 
        else:
17688 
          iprot.skip(ftype)
17689 
      else:
17690 
        iprot.skip(ftype)
17691 
      iprot.readFieldEnd()
17692 
    iprot.readStructEnd()
17693 
 
17694 
  def write(self, oprot):
17695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17697 
      return
17698 
    oprot.writeStructBegin('searchItemsInRange_result')
17699 
    if self.success is not None:
17700 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17701 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 17702 
      for iter338 in self.success:
17703 
        iter338.write(oprot)
5944 mandeep.dh 17704 
      oprot.writeListEnd()
17705 
      oprot.writeFieldEnd()
17706 
    oprot.writeFieldStop()
17707 
    oprot.writeStructEnd()
17708 
 
17709 
  def validate(self):
17710 
    return
17711 
 
17712 
 
17713 
  def __repr__(self):
17714 
    L = ['%s=%r' % (key, value)
17715 
      for key, value in self.__dict__.iteritems()]
17716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17717 
 
17718 
  def __eq__(self, other):
17719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17720 
 
17721 
  def __ne__(self, other):
17722 
    return not (self == other)
17723 
 
17724 
class getSearchResultCount_args:
17725 
  """
17726 
  Attributes:
17727 
   - searchTerms
17728 
  """
17729 
 
17730 
  thrift_spec = (
17731 
    None, # 0
17732 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
17733 
  )
17734 
 
17735 
  def __init__(self, searchTerms=None,):
17736 
    self.searchTerms = searchTerms
17737 
 
17738 
  def read(self, iprot):
17739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17741 
      return
17742 
    iprot.readStructBegin()
17743 
    while True:
17744 
      (fname, ftype, fid) = iprot.readFieldBegin()
17745 
      if ftype == TType.STOP:
17746 
        break
17747 
      if fid == 1:
17748 
        if ftype == TType.LIST:
17749 
          self.searchTerms = []
9155 kshitij.so 17750 
          (_etype342, _size339) = iprot.readListBegin()
17751 
          for _i343 in xrange(_size339):
17752 
            _elem344 = iprot.readString();
17753 
            self.searchTerms.append(_elem344)
5944 mandeep.dh 17754 
          iprot.readListEnd()
17755 
        else:
17756 
          iprot.skip(ftype)
17757 
      else:
17758 
        iprot.skip(ftype)
17759 
      iprot.readFieldEnd()
17760 
    iprot.readStructEnd()
17761 
 
17762 
  def write(self, oprot):
17763 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17764 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17765 
      return
17766 
    oprot.writeStructBegin('getSearchResultCount_args')
17767 
    if self.searchTerms is not None:
17768 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
17769 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
9155 kshitij.so 17770 
      for iter345 in self.searchTerms:
17771 
        oprot.writeString(iter345)
5944 mandeep.dh 17772 
      oprot.writeListEnd()
17773 
      oprot.writeFieldEnd()
17774 
    oprot.writeFieldStop()
17775 
    oprot.writeStructEnd()
17776 
 
17777 
  def validate(self):
17778 
    return
17779 
 
17780 
 
17781 
  def __repr__(self):
17782 
    L = ['%s=%r' % (key, value)
17783 
      for key, value in self.__dict__.iteritems()]
17784 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17785 
 
17786 
  def __eq__(self, other):
17787 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17788 
 
17789 
  def __ne__(self, other):
17790 
    return not (self == other)
17791 
 
17792 
class getSearchResultCount_result:
17793 
  """
17794 
  Attributes:
17795 
   - success
17796 
  """
17797 
 
17798 
  thrift_spec = (
17799 
    (0, TType.I32, 'success', None, None, ), # 0
17800 
  )
17801 
 
17802 
  def __init__(self, success=None,):
17803 
    self.success = success
17804 
 
17805 
  def read(self, iprot):
17806 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17807 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17808 
      return
17809 
    iprot.readStructBegin()
17810 
    while True:
17811 
      (fname, ftype, fid) = iprot.readFieldBegin()
17812 
      if ftype == TType.STOP:
17813 
        break
17814 
      if fid == 0:
17815 
        if ftype == TType.I32:
17816 
          self.success = iprot.readI32();
17817 
        else:
17818 
          iprot.skip(ftype)
17819 
      else:
17820 
        iprot.skip(ftype)
17821 
      iprot.readFieldEnd()
17822 
    iprot.readStructEnd()
17823 
 
17824 
  def write(self, oprot):
17825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17827 
      return
17828 
    oprot.writeStructBegin('getSearchResultCount_result')
17829 
    if self.success is not None:
17830 
      oprot.writeFieldBegin('success', TType.I32, 0)
17831 
      oprot.writeI32(self.success)
17832 
      oprot.writeFieldEnd()
17833 
    oprot.writeFieldStop()
17834 
    oprot.writeStructEnd()
17835 
 
17836 
  def validate(self):
17837 
    return
17838 
 
17839 
 
17840 
  def __repr__(self):
17841 
    L = ['%s=%r' % (key, value)
17842 
      for key, value in self.__dict__.iteritems()]
17843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17844 
 
17845 
  def __eq__(self, other):
17846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17847 
 
17848 
  def __ne__(self, other):
17849 
    return not (self == other)
17850 
 
17851 
class getProductNotifications_args:
17852 
  """
17853 
  Attributes:
17854 
   - startDateTime
17855 
  """
17856 
 
17857 
  thrift_spec = (
17858 
    None, # 0
17859 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
17860 
  )
17861 
 
17862 
  def __init__(self, startDateTime=None,):
17863 
    self.startDateTime = startDateTime
17864 
 
17865 
  def read(self, iprot):
17866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17868 
      return
17869 
    iprot.readStructBegin()
17870 
    while True:
17871 
      (fname, ftype, fid) = iprot.readFieldBegin()
17872 
      if ftype == TType.STOP:
17873 
        break
17874 
      if fid == 1:
17875 
        if ftype == TType.I64:
17876 
          self.startDateTime = iprot.readI64();
17877 
        else:
17878 
          iprot.skip(ftype)
17879 
      else:
17880 
        iprot.skip(ftype)
17881 
      iprot.readFieldEnd()
17882 
    iprot.readStructEnd()
17883 
 
17884 
  def write(self, oprot):
17885 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17886 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17887 
      return
17888 
    oprot.writeStructBegin('getProductNotifications_args')
17889 
    if self.startDateTime is not None:
17890 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
17891 
      oprot.writeI64(self.startDateTime)
17892 
      oprot.writeFieldEnd()
17893 
    oprot.writeFieldStop()
17894 
    oprot.writeStructEnd()
17895 
 
17896 
  def validate(self):
17897 
    return
17898 
 
17899 
 
17900 
  def __repr__(self):
17901 
    L = ['%s=%r' % (key, value)
17902 
      for key, value in self.__dict__.iteritems()]
17903 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17904 
 
17905 
  def __eq__(self, other):
17906 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17907 
 
17908 
  def __ne__(self, other):
17909 
    return not (self == other)
17910 
 
17911 
class getProductNotifications_result:
17912 
  """
17913 
  Attributes:
17914 
   - success
17915 
  """
17916 
 
17917 
  thrift_spec = (
17918 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequest, ProductNotificationRequest.thrift_spec)), None, ), # 0
17919 
  )
17920 
 
17921 
  def __init__(self, success=None,):
17922 
    self.success = success
17923 
 
17924 
  def read(self, iprot):
17925 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17926 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17927 
      return
17928 
    iprot.readStructBegin()
17929 
    while True:
17930 
      (fname, ftype, fid) = iprot.readFieldBegin()
17931 
      if ftype == TType.STOP:
17932 
        break
17933 
      if fid == 0:
17934 
        if ftype == TType.LIST:
17935 
          self.success = []
9155 kshitij.so 17936 
          (_etype349, _size346) = iprot.readListBegin()
17937 
          for _i350 in xrange(_size346):
17938 
            _elem351 = ProductNotificationRequest()
17939 
            _elem351.read(iprot)
17940 
            self.success.append(_elem351)
5944 mandeep.dh 17941 
          iprot.readListEnd()
17942 
        else:
17943 
          iprot.skip(ftype)
17944 
      else:
17945 
        iprot.skip(ftype)
17946 
      iprot.readFieldEnd()
17947 
    iprot.readStructEnd()
17948 
 
17949 
  def write(self, oprot):
17950 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17951 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17952 
      return
17953 
    oprot.writeStructBegin('getProductNotifications_result')
17954 
    if self.success is not None:
17955 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17956 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 17957 
      for iter352 in self.success:
17958 
        iter352.write(oprot)
5944 mandeep.dh 17959 
      oprot.writeListEnd()
17960 
      oprot.writeFieldEnd()
17961 
    oprot.writeFieldStop()
17962 
    oprot.writeStructEnd()
17963 
 
17964 
  def validate(self):
17965 
    return
17966 
 
17967 
 
17968 
  def __repr__(self):
17969 
    L = ['%s=%r' % (key, value)
17970 
      for key, value in self.__dict__.iteritems()]
17971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17972 
 
17973 
  def __eq__(self, other):
17974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17975 
 
17976 
  def __ne__(self, other):
17977 
    return not (self == other)
17978 
 
17979 
class getProductNotificationRequestCount_args:
17980 
  """
17981 
  Attributes:
17982 
   - startDateTime
7897 amar.kumar 17983 
   - categoryId
5944 mandeep.dh 17984 
  """
17985 
 
17986 
  thrift_spec = (
17987 
    None, # 0
17988 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
7897 amar.kumar 17989 
    (2, TType.I64, 'categoryId', None, None, ), # 2
5944 mandeep.dh 17990 
  )
17991 
 
7897 amar.kumar 17992 
  def __init__(self, startDateTime=None, categoryId=None,):
5944 mandeep.dh 17993 
    self.startDateTime = startDateTime
7897 amar.kumar 17994 
    self.categoryId = categoryId
5944 mandeep.dh 17995 
 
17996 
  def read(self, iprot):
17997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17999 
      return
18000 
    iprot.readStructBegin()
18001 
    while True:
18002 
      (fname, ftype, fid) = iprot.readFieldBegin()
18003 
      if ftype == TType.STOP:
18004 
        break
18005 
      if fid == 1:
18006 
        if ftype == TType.I64:
18007 
          self.startDateTime = iprot.readI64();
18008 
        else:
18009 
          iprot.skip(ftype)
7897 amar.kumar 18010 
      elif fid == 2:
18011 
        if ftype == TType.I64:
18012 
          self.categoryId = iprot.readI64();
18013 
        else:
18014 
          iprot.skip(ftype)
5944 mandeep.dh 18015 
      else:
18016 
        iprot.skip(ftype)
18017 
      iprot.readFieldEnd()
18018 
    iprot.readStructEnd()
18019 
 
18020 
  def write(self, oprot):
18021 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18022 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18023 
      return
18024 
    oprot.writeStructBegin('getProductNotificationRequestCount_args')
18025 
    if self.startDateTime is not None:
18026 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
18027 
      oprot.writeI64(self.startDateTime)
18028 
      oprot.writeFieldEnd()
7897 amar.kumar 18029 
    if self.categoryId is not None:
18030 
      oprot.writeFieldBegin('categoryId', TType.I64, 2)
18031 
      oprot.writeI64(self.categoryId)
18032 
      oprot.writeFieldEnd()
5944 mandeep.dh 18033 
    oprot.writeFieldStop()
18034 
    oprot.writeStructEnd()
18035 
 
18036 
  def validate(self):
18037 
    return
18038 
 
18039 
 
18040 
  def __repr__(self):
18041 
    L = ['%s=%r' % (key, value)
18042 
      for key, value in self.__dict__.iteritems()]
18043 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18044 
 
18045 
  def __eq__(self, other):
18046 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18047 
 
18048 
  def __ne__(self, other):
18049 
    return not (self == other)
18050 
 
18051 
class getProductNotificationRequestCount_result:
18052 
  """
18053 
  Attributes:
18054 
   - success
18055 
  """
18056 
 
18057 
  thrift_spec = (
18058 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequestCount, ProductNotificationRequestCount.thrift_spec)), None, ), # 0
18059 
  )
18060 
 
18061 
  def __init__(self, success=None,):
18062 
    self.success = success
18063 
 
18064 
  def read(self, iprot):
18065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18067 
      return
18068 
    iprot.readStructBegin()
18069 
    while True:
18070 
      (fname, ftype, fid) = iprot.readFieldBegin()
18071 
      if ftype == TType.STOP:
18072 
        break
18073 
      if fid == 0:
18074 
        if ftype == TType.LIST:
18075 
          self.success = []
9155 kshitij.so 18076 
          (_etype356, _size353) = iprot.readListBegin()
18077 
          for _i357 in xrange(_size353):
18078 
            _elem358 = ProductNotificationRequestCount()
18079 
            _elem358.read(iprot)
18080 
            self.success.append(_elem358)
5944 mandeep.dh 18081 
          iprot.readListEnd()
18082 
        else:
18083 
          iprot.skip(ftype)
18084 
      else:
18085 
        iprot.skip(ftype)
18086 
      iprot.readFieldEnd()
18087 
    iprot.readStructEnd()
18088 
 
18089 
  def write(self, oprot):
18090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18092 
      return
18093 
    oprot.writeStructBegin('getProductNotificationRequestCount_result')
18094 
    if self.success is not None:
18095 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18096 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18097 
      for iter359 in self.success:
18098 
        iter359.write(oprot)
5944 mandeep.dh 18099 
      oprot.writeListEnd()
18100 
      oprot.writeFieldEnd()
18101 
    oprot.writeFieldStop()
18102 
    oprot.writeStructEnd()
18103 
 
18104 
  def validate(self):
18105 
    return
18106 
 
18107 
 
18108 
  def __repr__(self):
18109 
    L = ['%s=%r' % (key, value)
18110 
      for key, value in self.__dict__.iteritems()]
18111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18112 
 
18113 
  def __eq__(self, other):
18114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18115 
 
18116 
  def __ne__(self, other):
18117 
    return not (self == other)
18118 
 
18119 
class addAuthorizationLog_args:
18120 
  """
18121 
  Attributes:
18122 
   - itemId
18123 
   - username
18124 
   - reason
18125 
  """
18126 
 
18127 
  thrift_spec = (
18128 
    None, # 0
18129 
    (1, TType.I64, 'itemId', None, None, ), # 1
18130 
    (2, TType.STRING, 'username', None, None, ), # 2
18131 
    (3, TType.STRING, 'reason', None, None, ), # 3
18132 
  )
18133 
 
18134 
  def __init__(self, itemId=None, username=None, reason=None,):
18135 
    self.itemId = itemId
18136 
    self.username = username
18137 
    self.reason = reason
18138 
 
18139 
  def read(self, iprot):
18140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18142 
      return
18143 
    iprot.readStructBegin()
18144 
    while True:
18145 
      (fname, ftype, fid) = iprot.readFieldBegin()
18146 
      if ftype == TType.STOP:
18147 
        break
18148 
      if fid == 1:
18149 
        if ftype == TType.I64:
18150 
          self.itemId = iprot.readI64();
18151 
        else:
18152 
          iprot.skip(ftype)
18153 
      elif fid == 2:
18154 
        if ftype == TType.STRING:
18155 
          self.username = iprot.readString();
18156 
        else:
18157 
          iprot.skip(ftype)
18158 
      elif fid == 3:
18159 
        if ftype == TType.STRING:
18160 
          self.reason = iprot.readString();
18161 
        else:
18162 
          iprot.skip(ftype)
18163 
      else:
18164 
        iprot.skip(ftype)
18165 
      iprot.readFieldEnd()
18166 
    iprot.readStructEnd()
18167 
 
18168 
  def write(self, oprot):
18169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18171 
      return
18172 
    oprot.writeStructBegin('addAuthorizationLog_args')
18173 
    if self.itemId is not None:
18174 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18175 
      oprot.writeI64(self.itemId)
18176 
      oprot.writeFieldEnd()
18177 
    if self.username is not None:
18178 
      oprot.writeFieldBegin('username', TType.STRING, 2)
18179 
      oprot.writeString(self.username)
18180 
      oprot.writeFieldEnd()
18181 
    if self.reason is not None:
18182 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
18183 
      oprot.writeString(self.reason)
18184 
      oprot.writeFieldEnd()
18185 
    oprot.writeFieldStop()
18186 
    oprot.writeStructEnd()
18187 
 
18188 
  def validate(self):
18189 
    return
18190 
 
18191 
 
18192 
  def __repr__(self):
18193 
    L = ['%s=%r' % (key, value)
18194 
      for key, value in self.__dict__.iteritems()]
18195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18196 
 
18197 
  def __eq__(self, other):
18198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18199 
 
18200 
  def __ne__(self, other):
18201 
    return not (self == other)
18202 
 
18203 
class addAuthorizationLog_result:
18204 
  """
18205 
  Attributes:
18206 
   - success
18207 
   - cex
18208 
  """
18209 
 
18210 
  thrift_spec = (
18211 
    (0, TType.BOOL, 'success', None, None, ), # 0
18212 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
18213 
  )
18214 
 
18215 
  def __init__(self, success=None, cex=None,):
18216 
    self.success = success
18217 
    self.cex = cex
18218 
 
18219 
  def read(self, iprot):
18220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18222 
      return
18223 
    iprot.readStructBegin()
18224 
    while True:
18225 
      (fname, ftype, fid) = iprot.readFieldBegin()
18226 
      if ftype == TType.STOP:
18227 
        break
18228 
      if fid == 0:
18229 
        if ftype == TType.BOOL:
18230 
          self.success = iprot.readBool();
18231 
        else:
18232 
          iprot.skip(ftype)
18233 
      elif fid == 1:
18234 
        if ftype == TType.STRUCT:
18235 
          self.cex = CatalogServiceException()
18236 
          self.cex.read(iprot)
18237 
        else:
18238 
          iprot.skip(ftype)
18239 
      else:
18240 
        iprot.skip(ftype)
18241 
      iprot.readFieldEnd()
18242 
    iprot.readStructEnd()
18243 
 
18244 
  def write(self, oprot):
18245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18247 
      return
18248 
    oprot.writeStructBegin('addAuthorizationLog_result')
18249 
    if self.success is not None:
18250 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18251 
      oprot.writeBool(self.success)
18252 
      oprot.writeFieldEnd()
18253 
    if self.cex is not None:
18254 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
18255 
      self.cex.write(oprot)
18256 
      oprot.writeFieldEnd()
18257 
    oprot.writeFieldStop()
18258 
    oprot.writeStructEnd()
18259 
 
18260 
  def validate(self):
18261 
    return
18262 
 
18263 
 
18264 
  def __repr__(self):
18265 
    L = ['%s=%r' % (key, value)
18266 
      for key, value in self.__dict__.iteritems()]
18267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18268 
 
18269 
  def __eq__(self, other):
18270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18271 
 
18272 
  def __ne__(self, other):
18273 
    return not (self == other)
18274 
 
18275 
class addupdateVoucherForItem_args:
18276 
  """
18277 
  Attributes:
18278 
   - catalog_item_id
18279 
   - voucherType
18280 
   - voucherAmount
18281 
  """
18282 
 
18283 
  thrift_spec = (
18284 
    None, # 0
18285 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
18286 
    (2, TType.I64, 'voucherType', None, None, ), # 2
18287 
    (3, TType.I64, 'voucherAmount', None, None, ), # 3
18288 
  )
18289 
 
18290 
  def __init__(self, catalog_item_id=None, voucherType=None, voucherAmount=None,):
18291 
    self.catalog_item_id = catalog_item_id
18292 
    self.voucherType = voucherType
18293 
    self.voucherAmount = voucherAmount
18294 
 
18295 
  def read(self, iprot):
18296 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18297 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18298 
      return
18299 
    iprot.readStructBegin()
18300 
    while True:
18301 
      (fname, ftype, fid) = iprot.readFieldBegin()
18302 
      if ftype == TType.STOP:
18303 
        break
18304 
      if fid == 1:
18305 
        if ftype == TType.I64:
18306 
          self.catalog_item_id = iprot.readI64();
18307 
        else:
18308 
          iprot.skip(ftype)
18309 
      elif fid == 2:
18310 
        if ftype == TType.I64:
18311 
          self.voucherType = iprot.readI64();
18312 
        else:
18313 
          iprot.skip(ftype)
18314 
      elif fid == 3:
18315 
        if ftype == TType.I64:
18316 
          self.voucherAmount = iprot.readI64();
18317 
        else:
18318 
          iprot.skip(ftype)
18319 
      else:
18320 
        iprot.skip(ftype)
18321 
      iprot.readFieldEnd()
18322 
    iprot.readStructEnd()
18323 
 
18324 
  def write(self, oprot):
18325 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18326 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18327 
      return
18328 
    oprot.writeStructBegin('addupdateVoucherForItem_args')
18329 
    if self.catalog_item_id is not None:
18330 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
18331 
      oprot.writeI64(self.catalog_item_id)
18332 
      oprot.writeFieldEnd()
18333 
    if self.voucherType is not None:
18334 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
18335 
      oprot.writeI64(self.voucherType)
18336 
      oprot.writeFieldEnd()
18337 
    if self.voucherAmount is not None:
18338 
      oprot.writeFieldBegin('voucherAmount', TType.I64, 3)
18339 
      oprot.writeI64(self.voucherAmount)
18340 
      oprot.writeFieldEnd()
18341 
    oprot.writeFieldStop()
18342 
    oprot.writeStructEnd()
18343 
 
18344 
  def validate(self):
18345 
    return
18346 
 
18347 
 
18348 
  def __repr__(self):
18349 
    L = ['%s=%r' % (key, value)
18350 
      for key, value in self.__dict__.iteritems()]
18351 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18352 
 
18353 
  def __eq__(self, other):
18354 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18355 
 
18356 
  def __ne__(self, other):
18357 
    return not (self == other)
18358 
 
18359 
class addupdateVoucherForItem_result:
18360 
  """
18361 
  Attributes:
18362 
   - success
18363 
   - cex
18364 
  """
18365 
 
18366 
  thrift_spec = (
18367 
    (0, TType.BOOL, 'success', None, None, ), # 0
18368 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
18369 
  )
18370 
 
18371 
  def __init__(self, success=None, cex=None,):
18372 
    self.success = success
18373 
    self.cex = cex
18374 
 
18375 
  def read(self, iprot):
18376 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18377 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18378 
      return
18379 
    iprot.readStructBegin()
18380 
    while True:
18381 
      (fname, ftype, fid) = iprot.readFieldBegin()
18382 
      if ftype == TType.STOP:
18383 
        break
18384 
      if fid == 0:
18385 
        if ftype == TType.BOOL:
18386 
          self.success = iprot.readBool();
18387 
        else:
18388 
          iprot.skip(ftype)
18389 
      elif fid == 1:
18390 
        if ftype == TType.STRUCT:
18391 
          self.cex = CatalogServiceException()
18392 
          self.cex.read(iprot)
18393 
        else:
18394 
          iprot.skip(ftype)
18395 
      else:
18396 
        iprot.skip(ftype)
18397 
      iprot.readFieldEnd()
18398 
    iprot.readStructEnd()
18399 
 
18400 
  def write(self, oprot):
18401 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18402 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18403 
      return
18404 
    oprot.writeStructBegin('addupdateVoucherForItem_result')
18405 
    if self.success is not None:
18406 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18407 
      oprot.writeBool(self.success)
18408 
      oprot.writeFieldEnd()
18409 
    if self.cex is not None:
18410 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
18411 
      self.cex.write(oprot)
18412 
      oprot.writeFieldEnd()
18413 
    oprot.writeFieldStop()
18414 
    oprot.writeStructEnd()
18415 
 
18416 
  def validate(self):
18417 
    return
18418 
 
18419 
 
18420 
  def __repr__(self):
18421 
    L = ['%s=%r' % (key, value)
18422 
      for key, value in self.__dict__.iteritems()]
18423 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18424 
 
18425 
  def __eq__(self, other):
18426 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18427 
 
18428 
  def __ne__(self, other):
18429 
    return not (self == other)
18430 
 
18431 
class deleteVoucherForItem_args:
18432 
  """
18433 
  Attributes:
18434 
   - catalog_item_id
18435 
   - voucherType
18436 
  """
18437 
 
18438 
  thrift_spec = (
18439 
    None, # 0
18440 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
18441 
    (2, TType.I64, 'voucherType', None, None, ), # 2
18442 
  )
18443 
 
18444 
  def __init__(self, catalog_item_id=None, voucherType=None,):
18445 
    self.catalog_item_id = catalog_item_id
18446 
    self.voucherType = voucherType
18447 
 
18448 
  def read(self, iprot):
18449 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18450 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18451 
      return
18452 
    iprot.readStructBegin()
18453 
    while True:
18454 
      (fname, ftype, fid) = iprot.readFieldBegin()
18455 
      if ftype == TType.STOP:
18456 
        break
18457 
      if fid == 1:
18458 
        if ftype == TType.I64:
18459 
          self.catalog_item_id = iprot.readI64();
18460 
        else:
18461 
          iprot.skip(ftype)
18462 
      elif fid == 2:
18463 
        if ftype == TType.I64:
18464 
          self.voucherType = iprot.readI64();
18465 
        else:
18466 
          iprot.skip(ftype)
18467 
      else:
18468 
        iprot.skip(ftype)
18469 
      iprot.readFieldEnd()
18470 
    iprot.readStructEnd()
18471 
 
18472 
  def write(self, oprot):
18473 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18474 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18475 
      return
18476 
    oprot.writeStructBegin('deleteVoucherForItem_args')
18477 
    if self.catalog_item_id is not None:
18478 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
18479 
      oprot.writeI64(self.catalog_item_id)
18480 
      oprot.writeFieldEnd()
18481 
    if self.voucherType is not None:
18482 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
18483 
      oprot.writeI64(self.voucherType)
18484 
      oprot.writeFieldEnd()
18485 
    oprot.writeFieldStop()
18486 
    oprot.writeStructEnd()
18487 
 
18488 
  def validate(self):
18489 
    return
18490 
 
18491 
 
18492 
  def __repr__(self):
18493 
    L = ['%s=%r' % (key, value)
18494 
      for key, value in self.__dict__.iteritems()]
18495 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18496 
 
18497 
  def __eq__(self, other):
18498 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18499 
 
18500 
  def __ne__(self, other):
18501 
    return not (self == other)
18502 
 
18503 
class deleteVoucherForItem_result:
18504 
  """
18505 
  Attributes:
18506 
   - success
18507 
   - cex
18508 
  """
18509 
 
18510 
  thrift_spec = (
18511 
    (0, TType.BOOL, 'success', None, None, ), # 0
18512 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
18513 
  )
18514 
 
18515 
  def __init__(self, success=None, cex=None,):
18516 
    self.success = success
18517 
    self.cex = cex
18518 
 
18519 
  def read(self, iprot):
18520 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18521 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18522 
      return
18523 
    iprot.readStructBegin()
18524 
    while True:
18525 
      (fname, ftype, fid) = iprot.readFieldBegin()
18526 
      if ftype == TType.STOP:
18527 
        break
18528 
      if fid == 0:
18529 
        if ftype == TType.BOOL:
18530 
          self.success = iprot.readBool();
18531 
        else:
18532 
          iprot.skip(ftype)
18533 
      elif fid == 1:
18534 
        if ftype == TType.STRUCT:
18535 
          self.cex = CatalogServiceException()
18536 
          self.cex.read(iprot)
18537 
        else:
18538 
          iprot.skip(ftype)
18539 
      else:
18540 
        iprot.skip(ftype)
18541 
      iprot.readFieldEnd()
18542 
    iprot.readStructEnd()
18543 
 
18544 
  def write(self, oprot):
18545 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18546 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18547 
      return
18548 
    oprot.writeStructBegin('deleteVoucherForItem_result')
18549 
    if self.success is not None:
18550 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18551 
      oprot.writeBool(self.success)
18552 
      oprot.writeFieldEnd()
18553 
    if self.cex is not None:
18554 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
18555 
      self.cex.write(oprot)
18556 
      oprot.writeFieldEnd()
18557 
    oprot.writeFieldStop()
18558 
    oprot.writeStructEnd()
18559 
 
18560 
  def validate(self):
18561 
    return
18562 
 
18563 
 
18564 
  def __repr__(self):
18565 
    L = ['%s=%r' % (key, value)
18566 
      for key, value in self.__dict__.iteritems()]
18567 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18568 
 
18569 
  def __eq__(self, other):
18570 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18571 
 
18572 
  def __ne__(self, other):
18573 
    return not (self == other)
18574 
 
18575 
class getVoucherAmount_args:
18576 
  """
18577 
  Attributes:
18578 
   - itemId
18579 
   - voucherType
18580 
  """
18581 
 
18582 
  thrift_spec = (
18583 
    None, # 0
18584 
    (1, TType.I64, 'itemId', None, None, ), # 1
18585 
    (2, TType.I64, 'voucherType', None, None, ), # 2
18586 
  )
18587 
 
18588 
  def __init__(self, itemId=None, voucherType=None,):
18589 
    self.itemId = itemId
18590 
    self.voucherType = voucherType
18591 
 
18592 
  def read(self, iprot):
18593 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18594 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18595 
      return
18596 
    iprot.readStructBegin()
18597 
    while True:
18598 
      (fname, ftype, fid) = iprot.readFieldBegin()
18599 
      if ftype == TType.STOP:
18600 
        break
18601 
      if fid == 1:
18602 
        if ftype == TType.I64:
18603 
          self.itemId = iprot.readI64();
18604 
        else:
18605 
          iprot.skip(ftype)
18606 
      elif fid == 2:
18607 
        if ftype == TType.I64:
18608 
          self.voucherType = iprot.readI64();
18609 
        else:
18610 
          iprot.skip(ftype)
18611 
      else:
18612 
        iprot.skip(ftype)
18613 
      iprot.readFieldEnd()
18614 
    iprot.readStructEnd()
18615 
 
18616 
  def write(self, oprot):
18617 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18618 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18619 
      return
18620 
    oprot.writeStructBegin('getVoucherAmount_args')
18621 
    if self.itemId is not None:
18622 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18623 
      oprot.writeI64(self.itemId)
18624 
      oprot.writeFieldEnd()
18625 
    if self.voucherType is not None:
18626 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
18627 
      oprot.writeI64(self.voucherType)
18628 
      oprot.writeFieldEnd()
18629 
    oprot.writeFieldStop()
18630 
    oprot.writeStructEnd()
18631 
 
18632 
  def validate(self):
18633 
    return
18634 
 
18635 
 
18636 
  def __repr__(self):
18637 
    L = ['%s=%r' % (key, value)
18638 
      for key, value in self.__dict__.iteritems()]
18639 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18640 
 
18641 
  def __eq__(self, other):
18642 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18643 
 
18644 
  def __ne__(self, other):
18645 
    return not (self == other)
18646 
 
18647 
class getVoucherAmount_result:
18648 
  """
18649 
  Attributes:
18650 
   - success
18651 
  """
18652 
 
18653 
  thrift_spec = (
18654 
    (0, TType.I64, 'success', None, None, ), # 0
18655 
  )
18656 
 
18657 
  def __init__(self, success=None,):
18658 
    self.success = success
18659 
 
18660 
  def read(self, iprot):
18661 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18662 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18663 
      return
18664 
    iprot.readStructBegin()
18665 
    while True:
18666 
      (fname, ftype, fid) = iprot.readFieldBegin()
18667 
      if ftype == TType.STOP:
18668 
        break
18669 
      if fid == 0:
18670 
        if ftype == TType.I64:
18671 
          self.success = iprot.readI64();
18672 
        else:
18673 
          iprot.skip(ftype)
18674 
      else:
18675 
        iprot.skip(ftype)
18676 
      iprot.readFieldEnd()
18677 
    iprot.readStructEnd()
18678 
 
18679 
  def write(self, oprot):
18680 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18681 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18682 
      return
18683 
    oprot.writeStructBegin('getVoucherAmount_result')
18684 
    if self.success is not None:
18685 
      oprot.writeFieldBegin('success', TType.I64, 0)
18686 
      oprot.writeI64(self.success)
18687 
      oprot.writeFieldEnd()
18688 
    oprot.writeFieldStop()
18689 
    oprot.writeStructEnd()
18690 
 
18691 
  def validate(self):
18692 
    return
18693 
 
18694 
 
18695 
  def __repr__(self):
18696 
    L = ['%s=%r' % (key, value)
18697 
      for key, value in self.__dict__.iteritems()]
18698 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18699 
 
18700 
  def __eq__(self, other):
18701 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18702 
 
18703 
  def __ne__(self, other):
18704 
    return not (self == other)
18705 
 
18706 
class getAllItemVouchers_args:
18707 
  """
18708 
  Attributes:
18709 
   - itemId
18710 
  """
18711 
 
18712 
  thrift_spec = (
18713 
    None, # 0
18714 
    (1, TType.I64, 'itemId', None, None, ), # 1
18715 
  )
18716 
 
18717 
  def __init__(self, itemId=None,):
18718 
    self.itemId = itemId
18719 
 
18720 
  def read(self, iprot):
18721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18723 
      return
18724 
    iprot.readStructBegin()
18725 
    while True:
18726 
      (fname, ftype, fid) = iprot.readFieldBegin()
18727 
      if ftype == TType.STOP:
18728 
        break
18729 
      if fid == 1:
18730 
        if ftype == TType.I64:
18731 
          self.itemId = iprot.readI64();
18732 
        else:
18733 
          iprot.skip(ftype)
18734 
      else:
18735 
        iprot.skip(ftype)
18736 
      iprot.readFieldEnd()
18737 
    iprot.readStructEnd()
18738 
 
18739 
  def write(self, oprot):
18740 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18741 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18742 
      return
18743 
    oprot.writeStructBegin('getAllItemVouchers_args')
18744 
    if self.itemId is not None:
18745 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18746 
      oprot.writeI64(self.itemId)
18747 
      oprot.writeFieldEnd()
18748 
    oprot.writeFieldStop()
18749 
    oprot.writeStructEnd()
18750 
 
18751 
  def validate(self):
18752 
    return
18753 
 
18754 
 
18755 
  def __repr__(self):
18756 
    L = ['%s=%r' % (key, value)
18757 
      for key, value in self.__dict__.iteritems()]
18758 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18759 
 
18760 
  def __eq__(self, other):
18761 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18762 
 
18763 
  def __ne__(self, other):
18764 
    return not (self == other)
18765 
 
18766 
class getAllItemVouchers_result:
18767 
  """
18768 
  Attributes:
18769 
   - success
18770 
  """
18771 
 
18772 
  thrift_spec = (
18773 
    (0, TType.LIST, 'success', (TType.STRUCT,(VoucherItemMapping, VoucherItemMapping.thrift_spec)), None, ), # 0
18774 
  )
18775 
 
18776 
  def __init__(self, success=None,):
18777 
    self.success = success
18778 
 
18779 
  def read(self, iprot):
18780 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18781 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18782 
      return
18783 
    iprot.readStructBegin()
18784 
    while True:
18785 
      (fname, ftype, fid) = iprot.readFieldBegin()
18786 
      if ftype == TType.STOP:
18787 
        break
18788 
      if fid == 0:
18789 
        if ftype == TType.LIST:
18790 
          self.success = []
9155 kshitij.so 18791 
          (_etype363, _size360) = iprot.readListBegin()
18792 
          for _i364 in xrange(_size360):
18793 
            _elem365 = VoucherItemMapping()
18794 
            _elem365.read(iprot)
18795 
            self.success.append(_elem365)
5944 mandeep.dh 18796 
          iprot.readListEnd()
18797 
        else:
18798 
          iprot.skip(ftype)
18799 
      else:
18800 
        iprot.skip(ftype)
18801 
      iprot.readFieldEnd()
18802 
    iprot.readStructEnd()
18803 
 
18804 
  def write(self, oprot):
18805 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18806 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18807 
      return
18808 
    oprot.writeStructBegin('getAllItemVouchers_result')
18809 
    if self.success is not None:
18810 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18811 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18812 
      for iter366 in self.success:
18813 
        iter366.write(oprot)
5944 mandeep.dh 18814 
      oprot.writeListEnd()
18815 
      oprot.writeFieldEnd()
18816 
    oprot.writeFieldStop()
18817 
    oprot.writeStructEnd()
18818 
 
18819 
  def validate(self):
18820 
    return
18821 
 
18822 
 
18823 
  def __repr__(self):
18824 
    L = ['%s=%r' % (key, value)
18825 
      for key, value in self.__dict__.iteritems()]
18826 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18827 
 
18828 
  def __eq__(self, other):
18829 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18830 
 
18831 
  def __ne__(self, other):
18832 
    return not (self == other)
18833 
 
18834 
class isValidCatalogItemId_args:
18835 
  """
18836 
  Attributes:
18837 
   - catalog_item_id
18838 
  """
18839 
 
18840 
  thrift_spec = (
18841 
    None, # 0
18842 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
18843 
  )
18844 
 
18845 
  def __init__(self, catalog_item_id=None,):
18846 
    self.catalog_item_id = catalog_item_id
18847 
 
18848 
  def read(self, iprot):
18849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18851 
      return
18852 
    iprot.readStructBegin()
18853 
    while True:
18854 
      (fname, ftype, fid) = iprot.readFieldBegin()
18855 
      if ftype == TType.STOP:
18856 
        break
18857 
      if fid == 1:
18858 
        if ftype == TType.I64:
18859 
          self.catalog_item_id = iprot.readI64();
18860 
        else:
18861 
          iprot.skip(ftype)
18862 
      else:
18863 
        iprot.skip(ftype)
18864 
      iprot.readFieldEnd()
18865 
    iprot.readStructEnd()
18866 
 
18867 
  def write(self, oprot):
18868 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18869 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18870 
      return
18871 
    oprot.writeStructBegin('isValidCatalogItemId_args')
18872 
    if self.catalog_item_id is not None:
18873 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
18874 
      oprot.writeI64(self.catalog_item_id)
18875 
      oprot.writeFieldEnd()
18876 
    oprot.writeFieldStop()
18877 
    oprot.writeStructEnd()
18878 
 
18879 
  def validate(self):
18880 
    return
18881 
 
18882 
 
18883 
  def __repr__(self):
18884 
    L = ['%s=%r' % (key, value)
18885 
      for key, value in self.__dict__.iteritems()]
18886 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18887 
 
18888 
  def __eq__(self, other):
18889 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18890 
 
18891 
  def __ne__(self, other):
18892 
    return not (self == other)
18893 
 
18894 
class isValidCatalogItemId_result:
18895 
  """
18896 
  Attributes:
18897 
   - success
18898 
  """
18899 
 
18900 
  thrift_spec = (
18901 
    (0, TType.BOOL, 'success', None, None, ), # 0
18902 
  )
18903 
 
18904 
  def __init__(self, success=None,):
18905 
    self.success = success
18906 
 
18907 
  def read(self, iprot):
18908 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18909 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18910 
      return
18911 
    iprot.readStructBegin()
18912 
    while True:
18913 
      (fname, ftype, fid) = iprot.readFieldBegin()
18914 
      if ftype == TType.STOP:
18915 
        break
18916 
      if fid == 0:
18917 
        if ftype == TType.BOOL:
18918 
          self.success = iprot.readBool();
18919 
        else:
18920 
          iprot.skip(ftype)
18921 
      else:
18922 
        iprot.skip(ftype)
18923 
      iprot.readFieldEnd()
18924 
    iprot.readStructEnd()
18925 
 
18926 
  def write(self, oprot):
18927 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18928 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18929 
      return
18930 
    oprot.writeStructBegin('isValidCatalogItemId_result')
18931 
    if self.success is not None:
18932 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18933 
      oprot.writeBool(self.success)
18934 
      oprot.writeFieldEnd()
18935 
    oprot.writeFieldStop()
18936 
    oprot.writeStructEnd()
18937 
 
18938 
  def validate(self):
18939 
    return
18940 
 
18941 
 
18942 
  def __repr__(self):
18943 
    L = ['%s=%r' % (key, value)
18944 
      for key, value in self.__dict__.iteritems()]
18945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18946 
 
18947 
  def __eq__(self, other):
18948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18949 
 
18950 
  def __ne__(self, other):
18951 
    return not (self == other)
6039 amit.gupta 18952 
 
18953 
class getVatPercentageForItem_args:
18954 
  """
18955 
  Attributes:
18956 
   - itemId
7330 amit.gupta 18957 
   - stateId
6039 amit.gupta 18958 
   - price
18959 
  """
18960 
 
18961 
  thrift_spec = (
18962 
    None, # 0
18963 
    (1, TType.I64, 'itemId', None, None, ), # 1
7330 amit.gupta 18964 
    (2, TType.I64, 'stateId', None, None, ), # 2
18965 
    (3, TType.DOUBLE, 'price', None, None, ), # 3
6039 amit.gupta 18966 
  )
18967 
 
7330 amit.gupta 18968 
  def __init__(self, itemId=None, stateId=None, price=None,):
6039 amit.gupta 18969 
    self.itemId = itemId
7330 amit.gupta 18970 
    self.stateId = stateId
6039 amit.gupta 18971 
    self.price = price
18972 
 
18973 
  def read(self, iprot):
18974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18976 
      return
18977 
    iprot.readStructBegin()
18978 
    while True:
18979 
      (fname, ftype, fid) = iprot.readFieldBegin()
18980 
      if ftype == TType.STOP:
18981 
        break
18982 
      if fid == 1:
18983 
        if ftype == TType.I64:
18984 
          self.itemId = iprot.readI64();
18985 
        else:
18986 
          iprot.skip(ftype)
18987 
      elif fid == 2:
7330 amit.gupta 18988 
        if ftype == TType.I64:
18989 
          self.stateId = iprot.readI64();
18990 
        else:
18991 
          iprot.skip(ftype)
18992 
      elif fid == 3:
6039 amit.gupta 18993 
        if ftype == TType.DOUBLE:
18994 
          self.price = iprot.readDouble();
18995 
        else:
18996 
          iprot.skip(ftype)
18997 
      else:
18998 
        iprot.skip(ftype)
18999 
      iprot.readFieldEnd()
19000 
    iprot.readStructEnd()
19001 
 
19002 
  def write(self, oprot):
19003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19005 
      return
19006 
    oprot.writeStructBegin('getVatPercentageForItem_args')
19007 
    if self.itemId is not None:
19008 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19009 
      oprot.writeI64(self.itemId)
19010 
      oprot.writeFieldEnd()
7330 amit.gupta 19011 
    if self.stateId is not None:
19012 
      oprot.writeFieldBegin('stateId', TType.I64, 2)
19013 
      oprot.writeI64(self.stateId)
19014 
      oprot.writeFieldEnd()
6039 amit.gupta 19015 
    if self.price is not None:
7330 amit.gupta 19016 
      oprot.writeFieldBegin('price', TType.DOUBLE, 3)
6039 amit.gupta 19017 
      oprot.writeDouble(self.price)
19018 
      oprot.writeFieldEnd()
19019 
    oprot.writeFieldStop()
19020 
    oprot.writeStructEnd()
19021 
 
19022 
  def validate(self):
19023 
    return
19024 
 
19025 
 
19026 
  def __repr__(self):
19027 
    L = ['%s=%r' % (key, value)
19028 
      for key, value in self.__dict__.iteritems()]
19029 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19030 
 
19031 
  def __eq__(self, other):
19032 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19033 
 
19034 
  def __ne__(self, other):
19035 
    return not (self == other)
19036 
 
19037 
class getVatPercentageForItem_result:
19038 
  """
19039 
  Attributes:
19040 
   - success
7340 amit.gupta 19041 
   - cex
6039 amit.gupta 19042 
  """
19043 
 
19044 
  thrift_spec = (
19045 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
7340 amit.gupta 19046 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6039 amit.gupta 19047 
  )
19048 
 
7340 amit.gupta 19049 
  def __init__(self, success=None, cex=None,):
6039 amit.gupta 19050 
    self.success = success
7340 amit.gupta 19051 
    self.cex = cex
6039 amit.gupta 19052 
 
19053 
  def read(self, iprot):
19054 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19055 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19056 
      return
19057 
    iprot.readStructBegin()
19058 
    while True:
19059 
      (fname, ftype, fid) = iprot.readFieldBegin()
19060 
      if ftype == TType.STOP:
19061 
        break
19062 
      if fid == 0:
19063 
        if ftype == TType.DOUBLE:
19064 
          self.success = iprot.readDouble();
19065 
        else:
19066 
          iprot.skip(ftype)
7340 amit.gupta 19067 
      elif fid == 1:
19068 
        if ftype == TType.STRUCT:
19069 
          self.cex = CatalogServiceException()
19070 
          self.cex.read(iprot)
19071 
        else:
19072 
          iprot.skip(ftype)
6039 amit.gupta 19073 
      else:
19074 
        iprot.skip(ftype)
19075 
      iprot.readFieldEnd()
19076 
    iprot.readStructEnd()
19077 
 
19078 
  def write(self, oprot):
19079 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19080 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19081 
      return
19082 
    oprot.writeStructBegin('getVatPercentageForItem_result')
19083 
    if self.success is not None:
19084 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
19085 
      oprot.writeDouble(self.success)
19086 
      oprot.writeFieldEnd()
7340 amit.gupta 19087 
    if self.cex is not None:
19088 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
19089 
      self.cex.write(oprot)
19090 
      oprot.writeFieldEnd()
6039 amit.gupta 19091 
    oprot.writeFieldStop()
19092 
    oprot.writeStructEnd()
19093 
 
19094 
  def validate(self):
19095 
    return
19096 
 
19097 
 
19098 
  def __repr__(self):
19099 
    L = ['%s=%r' % (key, value)
19100 
      for key, value in self.__dict__.iteritems()]
19101 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19102 
 
19103 
  def __eq__(self, other):
19104 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19105 
 
19106 
  def __ne__(self, other):
19107 
    return not (self == other)
19108 
 
19109 
class getVatAmountForItem_args:
19110 
  """
19111 
  Attributes:
19112 
   - itemId
19113 
   - price
19114 
  """
19115 
 
19116 
  thrift_spec = (
19117 
    None, # 0
19118 
    (1, TType.I64, 'itemId', None, None, ), # 1
19119 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
19120 
  )
19121 
 
19122 
  def __init__(self, itemId=None, price=None,):
19123 
    self.itemId = itemId
19124 
    self.price = price
19125 
 
19126 
  def read(self, iprot):
19127 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19128 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19129 
      return
19130 
    iprot.readStructBegin()
19131 
    while True:
19132 
      (fname, ftype, fid) = iprot.readFieldBegin()
19133 
      if ftype == TType.STOP:
19134 
        break
19135 
      if fid == 1:
19136 
        if ftype == TType.I64:
19137 
          self.itemId = iprot.readI64();
19138 
        else:
19139 
          iprot.skip(ftype)
19140 
      elif fid == 2:
19141 
        if ftype == TType.DOUBLE:
19142 
          self.price = iprot.readDouble();
19143 
        else:
19144 
          iprot.skip(ftype)
19145 
      else:
19146 
        iprot.skip(ftype)
19147 
      iprot.readFieldEnd()
19148 
    iprot.readStructEnd()
19149 
 
19150 
  def write(self, oprot):
19151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19153 
      return
19154 
    oprot.writeStructBegin('getVatAmountForItem_args')
19155 
    if self.itemId is not None:
19156 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19157 
      oprot.writeI64(self.itemId)
19158 
      oprot.writeFieldEnd()
19159 
    if self.price is not None:
19160 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
19161 
      oprot.writeDouble(self.price)
19162 
      oprot.writeFieldEnd()
19163 
    oprot.writeFieldStop()
19164 
    oprot.writeStructEnd()
19165 
 
19166 
  def validate(self):
19167 
    return
19168 
 
19169 
 
19170 
  def __repr__(self):
19171 
    L = ['%s=%r' % (key, value)
19172 
      for key, value in self.__dict__.iteritems()]
19173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19174 
 
19175 
  def __eq__(self, other):
19176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19177 
 
19178 
  def __ne__(self, other):
19179 
    return not (self == other)
19180 
 
19181 
class getVatAmountForItem_result:
19182 
  """
19183 
  Attributes:
19184 
   - success
19185 
  """
19186 
 
19187 
  thrift_spec = (
19188 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
19189 
  )
19190 
 
19191 
  def __init__(self, success=None,):
19192 
    self.success = success
19193 
 
19194 
  def read(self, iprot):
19195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19197 
      return
19198 
    iprot.readStructBegin()
19199 
    while True:
19200 
      (fname, ftype, fid) = iprot.readFieldBegin()
19201 
      if ftype == TType.STOP:
19202 
        break
19203 
      if fid == 0:
19204 
        if ftype == TType.DOUBLE:
19205 
          self.success = iprot.readDouble();
19206 
        else:
19207 
          iprot.skip(ftype)
19208 
      else:
19209 
        iprot.skip(ftype)
19210 
      iprot.readFieldEnd()
19211 
    iprot.readStructEnd()
19212 
 
19213 
  def write(self, oprot):
19214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19216 
      return
19217 
    oprot.writeStructBegin('getVatAmountForItem_result')
19218 
    if self.success is not None:
19219 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
19220 
      oprot.writeDouble(self.success)
19221 
      oprot.writeFieldEnd()
19222 
    oprot.writeFieldStop()
19223 
    oprot.writeStructEnd()
19224 
 
19225 
  def validate(self):
19226 
    return
19227 
 
19228 
 
19229 
  def __repr__(self):
19230 
    L = ['%s=%r' % (key, value)
19231 
      for key, value in self.__dict__.iteritems()]
19232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19233 
 
19234 
  def __eq__(self, other):
19235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19236 
 
19237 
  def __ne__(self, other):
19238 
    return not (self == other)
6531 vikram.rag 19239 
 
19240 
class getAllIgnoredInventoryUpdateItemsList_args:
19241 
  """
19242 
  Attributes:
19243 
   - offset
19244 
   - limit
19245 
  """
19246 
 
19247 
  thrift_spec = (
19248 
    None, # 0
19249 
    (1, TType.I32, 'offset', None, None, ), # 1
19250 
    (2, TType.I32, 'limit', None, None, ), # 2
19251 
  )
19252 
 
19253 
  def __init__(self, offset=None, limit=None,):
19254 
    self.offset = offset
19255 
    self.limit = limit
19256 
 
19257 
  def read(self, iprot):
19258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19260 
      return
19261 
    iprot.readStructBegin()
19262 
    while True:
19263 
      (fname, ftype, fid) = iprot.readFieldBegin()
19264 
      if ftype == TType.STOP:
19265 
        break
19266 
      if fid == 1:
19267 
        if ftype == TType.I32:
19268 
          self.offset = iprot.readI32();
19269 
        else:
19270 
          iprot.skip(ftype)
19271 
      elif fid == 2:
19272 
        if ftype == TType.I32:
19273 
          self.limit = iprot.readI32();
19274 
        else:
19275 
          iprot.skip(ftype)
19276 
      else:
19277 
        iprot.skip(ftype)
19278 
      iprot.readFieldEnd()
19279 
    iprot.readStructEnd()
19280 
 
19281 
  def write(self, oprot):
19282 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19283 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19284 
      return
19285 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_args')
19286 
    if self.offset is not None:
19287 
      oprot.writeFieldBegin('offset', TType.I32, 1)
19288 
      oprot.writeI32(self.offset)
19289 
      oprot.writeFieldEnd()
19290 
    if self.limit is not None:
19291 
      oprot.writeFieldBegin('limit', TType.I32, 2)
19292 
      oprot.writeI32(self.limit)
19293 
      oprot.writeFieldEnd()
19294 
    oprot.writeFieldStop()
19295 
    oprot.writeStructEnd()
19296 
 
19297 
  def validate(self):
19298 
    return
19299 
 
19300 
 
19301 
  def __repr__(self):
19302 
    L = ['%s=%r' % (key, value)
19303 
      for key, value in self.__dict__.iteritems()]
19304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19305 
 
19306 
  def __eq__(self, other):
19307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19308 
 
19309 
  def __ne__(self, other):
19310 
    return not (self == other)
19311 
 
19312 
class getAllIgnoredInventoryUpdateItemsList_result:
19313 
  """
19314 
  Attributes:
19315 
   - success
19316 
  """
19317 
 
19318 
  thrift_spec = (
19319 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
19320 
  )
19321 
 
19322 
  def __init__(self, success=None,):
19323 
    self.success = success
19324 
 
19325 
  def read(self, iprot):
19326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19328 
      return
19329 
    iprot.readStructBegin()
19330 
    while True:
19331 
      (fname, ftype, fid) = iprot.readFieldBegin()
19332 
      if ftype == TType.STOP:
19333 
        break
19334 
      if fid == 0:
19335 
        if ftype == TType.LIST:
19336 
          self.success = []
9155 kshitij.so 19337 
          (_etype370, _size367) = iprot.readListBegin()
19338 
          for _i371 in xrange(_size367):
19339 
            _elem372 = Item()
19340 
            _elem372.read(iprot)
19341 
            self.success.append(_elem372)
6531 vikram.rag 19342 
          iprot.readListEnd()
19343 
        else:
19344 
          iprot.skip(ftype)
19345 
      else:
19346 
        iprot.skip(ftype)
19347 
      iprot.readFieldEnd()
19348 
    iprot.readStructEnd()
19349 
 
19350 
  def write(self, oprot):
19351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19353 
      return
19354 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_result')
19355 
    if self.success is not None:
19356 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19357 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 19358 
      for iter373 in self.success:
19359 
        iter373.write(oprot)
6531 vikram.rag 19360 
      oprot.writeListEnd()
19361 
      oprot.writeFieldEnd()
19362 
    oprot.writeFieldStop()
19363 
    oprot.writeStructEnd()
19364 
 
19365 
  def validate(self):
19366 
    return
19367 
 
19368 
 
19369 
  def __repr__(self):
19370 
    L = ['%s=%r' % (key, value)
19371 
      for key, value in self.__dict__.iteritems()]
19372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19373 
 
19374 
  def __eq__(self, other):
19375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19376 
 
19377 
  def __ne__(self, other):
19378 
    return not (self == other)
6805 anupam.sin 19379 
 
6821 amar.kumar 19380 
class getAllAliveItems_args:
19381 
 
19382 
  thrift_spec = (
19383 
  )
19384 
 
19385 
  def read(self, iprot):
19386 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19387 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19388 
      return
19389 
    iprot.readStructBegin()
19390 
    while True:
19391 
      (fname, ftype, fid) = iprot.readFieldBegin()
19392 
      if ftype == TType.STOP:
19393 
        break
19394 
      else:
19395 
        iprot.skip(ftype)
19396 
      iprot.readFieldEnd()
19397 
    iprot.readStructEnd()
19398 
 
19399 
  def write(self, oprot):
19400 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19401 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19402 
      return
19403 
    oprot.writeStructBegin('getAllAliveItems_args')
19404 
    oprot.writeFieldStop()
19405 
    oprot.writeStructEnd()
19406 
 
19407 
  def validate(self):
19408 
    return
19409 
 
19410 
 
19411 
  def __repr__(self):
19412 
    L = ['%s=%r' % (key, value)
19413 
      for key, value in self.__dict__.iteritems()]
19414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19415 
 
19416 
  def __eq__(self, other):
19417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19418 
 
19419 
  def __ne__(self, other):
19420 
    return not (self == other)
19421 
 
19422 
class getAllAliveItems_result:
19423 
  """
19424 
  Attributes:
19425 
   - success
19426 
  """
19427 
 
19428 
  thrift_spec = (
19429 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
19430 
  )
19431 
 
19432 
  def __init__(self, success=None,):
19433 
    self.success = success
19434 
 
19435 
  def read(self, iprot):
19436 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19437 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19438 
      return
19439 
    iprot.readStructBegin()
19440 
    while True:
19441 
      (fname, ftype, fid) = iprot.readFieldBegin()
19442 
      if ftype == TType.STOP:
19443 
        break
19444 
      if fid == 0:
19445 
        if ftype == TType.LIST:
19446 
          self.success = []
9155 kshitij.so 19447 
          (_etype377, _size374) = iprot.readListBegin()
19448 
          for _i378 in xrange(_size374):
19449 
            _elem379 = Item()
19450 
            _elem379.read(iprot)
19451 
            self.success.append(_elem379)
6821 amar.kumar 19452 
          iprot.readListEnd()
19453 
        else:
19454 
          iprot.skip(ftype)
19455 
      else:
19456 
        iprot.skip(ftype)
19457 
      iprot.readFieldEnd()
19458 
    iprot.readStructEnd()
19459 
 
19460 
  def write(self, oprot):
19461 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19462 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19463 
      return
19464 
    oprot.writeStructBegin('getAllAliveItems_result')
19465 
    if self.success is not None:
19466 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19467 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 19468 
      for iter380 in self.success:
19469 
        iter380.write(oprot)
6821 amar.kumar 19470 
      oprot.writeListEnd()
19471 
      oprot.writeFieldEnd()
19472 
    oprot.writeFieldStop()
19473 
    oprot.writeStructEnd()
19474 
 
19475 
  def validate(self):
19476 
    return
19477 
 
19478 
 
19479 
  def __repr__(self):
19480 
    L = ['%s=%r' % (key, value)
19481 
      for key, value in self.__dict__.iteritems()]
19482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19483 
 
19484 
  def __eq__(self, other):
19485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19486 
 
19487 
  def __ne__(self, other):
19488 
    return not (self == other)
19489 
 
6805 anupam.sin 19490 
class getInsuranceAmount_args:
19491 
  """
19492 
  Attributes:
19493 
   - itemId
6921 anupam.sin 19494 
   - price
6805 anupam.sin 19495 
   - insurerId
19496 
   - quantity
19497 
  """
19498 
 
19499 
  thrift_spec = (
19500 
    None, # 0
19501 
    (1, TType.I64, 'itemId', None, None, ), # 1
6921 anupam.sin 19502 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
19503 
    (3, TType.I64, 'insurerId', None, None, ), # 3
19504 
    (4, TType.I64, 'quantity', None, None, ), # 4
6805 anupam.sin 19505 
  )
19506 
 
6921 anupam.sin 19507 
  def __init__(self, itemId=None, price=None, insurerId=None, quantity=None,):
6805 anupam.sin 19508 
    self.itemId = itemId
6921 anupam.sin 19509 
    self.price = price
6805 anupam.sin 19510 
    self.insurerId = insurerId
19511 
    self.quantity = quantity
19512 
 
19513 
  def read(self, iprot):
19514 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19515 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19516 
      return
19517 
    iprot.readStructBegin()
19518 
    while True:
19519 
      (fname, ftype, fid) = iprot.readFieldBegin()
19520 
      if ftype == TType.STOP:
19521 
        break
19522 
      if fid == 1:
19523 
        if ftype == TType.I64:
19524 
          self.itemId = iprot.readI64();
19525 
        else:
19526 
          iprot.skip(ftype)
19527 
      elif fid == 2:
6921 anupam.sin 19528 
        if ftype == TType.DOUBLE:
19529 
          self.price = iprot.readDouble();
19530 
        else:
19531 
          iprot.skip(ftype)
19532 
      elif fid == 3:
6805 anupam.sin 19533 
        if ftype == TType.I64:
19534 
          self.insurerId = iprot.readI64();
19535 
        else:
19536 
          iprot.skip(ftype)
6921 anupam.sin 19537 
      elif fid == 4:
6805 anupam.sin 19538 
        if ftype == TType.I64:
19539 
          self.quantity = iprot.readI64();
19540 
        else:
19541 
          iprot.skip(ftype)
19542 
      else:
19543 
        iprot.skip(ftype)
19544 
      iprot.readFieldEnd()
19545 
    iprot.readStructEnd()
19546 
 
19547 
  def write(self, oprot):
19548 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19549 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19550 
      return
19551 
    oprot.writeStructBegin('getInsuranceAmount_args')
19552 
    if self.itemId is not None:
19553 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19554 
      oprot.writeI64(self.itemId)
19555 
      oprot.writeFieldEnd()
6921 anupam.sin 19556 
    if self.price is not None:
19557 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
19558 
      oprot.writeDouble(self.price)
19559 
      oprot.writeFieldEnd()
6805 anupam.sin 19560 
    if self.insurerId is not None:
6921 anupam.sin 19561 
      oprot.writeFieldBegin('insurerId', TType.I64, 3)
6805 anupam.sin 19562 
      oprot.writeI64(self.insurerId)
19563 
      oprot.writeFieldEnd()
19564 
    if self.quantity is not None:
6921 anupam.sin 19565 
      oprot.writeFieldBegin('quantity', TType.I64, 4)
6805 anupam.sin 19566 
      oprot.writeI64(self.quantity)
19567 
      oprot.writeFieldEnd()
19568 
    oprot.writeFieldStop()
19569 
    oprot.writeStructEnd()
19570 
 
19571 
  def validate(self):
19572 
    return
19573 
 
19574 
 
19575 
  def __repr__(self):
19576 
    L = ['%s=%r' % (key, value)
19577 
      for key, value in self.__dict__.iteritems()]
19578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19579 
 
19580 
  def __eq__(self, other):
19581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19582 
 
19583 
  def __ne__(self, other):
19584 
    return not (self == other)
19585 
 
19586 
class getInsuranceAmount_result:
19587 
  """
19588 
  Attributes:
19589 
   - success
19590 
  """
19591 
 
19592 
  thrift_spec = (
19593 
    (0, TType.I64, 'success', None, None, ), # 0
19594 
  )
19595 
 
19596 
  def __init__(self, success=None,):
19597 
    self.success = success
19598 
 
19599 
  def read(self, iprot):
19600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19602 
      return
19603 
    iprot.readStructBegin()
19604 
    while True:
19605 
      (fname, ftype, fid) = iprot.readFieldBegin()
19606 
      if ftype == TType.STOP:
19607 
        break
19608 
      if fid == 0:
19609 
        if ftype == TType.I64:
19610 
          self.success = iprot.readI64();
19611 
        else:
19612 
          iprot.skip(ftype)
19613 
      else:
19614 
        iprot.skip(ftype)
19615 
      iprot.readFieldEnd()
19616 
    iprot.readStructEnd()
19617 
 
19618 
  def write(self, oprot):
19619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19621 
      return
19622 
    oprot.writeStructBegin('getInsuranceAmount_result')
19623 
    if self.success is not None:
19624 
      oprot.writeFieldBegin('success', TType.I64, 0)
19625 
      oprot.writeI64(self.success)
19626 
      oprot.writeFieldEnd()
19627 
    oprot.writeFieldStop()
19628 
    oprot.writeStructEnd()
19629 
 
19630 
  def validate(self):
19631 
    return
19632 
 
19633 
 
19634 
  def __repr__(self):
19635 
    L = ['%s=%r' % (key, value)
19636 
      for key, value in self.__dict__.iteritems()]
19637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19638 
 
19639 
  def __eq__(self, other):
19640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19641 
 
19642 
  def __ne__(self, other):
19643 
    return not (self == other)
19644 
 
19645 
class getInsurer_args:
19646 
  """
19647 
  Attributes:
19648 
   - insurerId
19649 
  """
19650 
 
19651 
  thrift_spec = (
19652 
    None, # 0
19653 
    (1, TType.I64, 'insurerId', None, None, ), # 1
19654 
  )
19655 
 
19656 
  def __init__(self, insurerId=None,):
19657 
    self.insurerId = insurerId
19658 
 
19659 
  def read(self, iprot):
19660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19662 
      return
19663 
    iprot.readStructBegin()
19664 
    while True:
19665 
      (fname, ftype, fid) = iprot.readFieldBegin()
19666 
      if ftype == TType.STOP:
19667 
        break
19668 
      if fid == 1:
19669 
        if ftype == TType.I64:
19670 
          self.insurerId = iprot.readI64();
19671 
        else:
19672 
          iprot.skip(ftype)
19673 
      else:
19674 
        iprot.skip(ftype)
19675 
      iprot.readFieldEnd()
19676 
    iprot.readStructEnd()
19677 
 
19678 
  def write(self, oprot):
19679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19681 
      return
19682 
    oprot.writeStructBegin('getInsurer_args')
19683 
    if self.insurerId is not None:
19684 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
19685 
      oprot.writeI64(self.insurerId)
19686 
      oprot.writeFieldEnd()
19687 
    oprot.writeFieldStop()
19688 
    oprot.writeStructEnd()
19689 
 
19690 
  def validate(self):
19691 
    return
19692 
 
19693 
 
19694 
  def __repr__(self):
19695 
    L = ['%s=%r' % (key, value)
19696 
      for key, value in self.__dict__.iteritems()]
19697 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19698 
 
19699 
  def __eq__(self, other):
19700 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19701 
 
19702 
  def __ne__(self, other):
19703 
    return not (self == other)
19704 
 
19705 
class getInsurer_result:
19706 
  """
19707 
  Attributes:
19708 
   - success
19709 
  """
19710 
 
19711 
  thrift_spec = (
19712 
    (0, TType.STRUCT, 'success', (Insurer, Insurer.thrift_spec), None, ), # 0
19713 
  )
19714 
 
19715 
  def __init__(self, success=None,):
19716 
    self.success = success
19717 
 
19718 
  def read(self, iprot):
19719 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19720 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19721 
      return
19722 
    iprot.readStructBegin()
19723 
    while True:
19724 
      (fname, ftype, fid) = iprot.readFieldBegin()
19725 
      if ftype == TType.STOP:
19726 
        break
19727 
      if fid == 0:
19728 
        if ftype == TType.STRUCT:
19729 
          self.success = Insurer()
19730 
          self.success.read(iprot)
19731 
        else:
19732 
          iprot.skip(ftype)
19733 
      else:
19734 
        iprot.skip(ftype)
19735 
      iprot.readFieldEnd()
19736 
    iprot.readStructEnd()
19737 
 
19738 
  def write(self, oprot):
19739 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19740 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19741 
      return
19742 
    oprot.writeStructBegin('getInsurer_result')
19743 
    if self.success is not None:
19744 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19745 
      self.success.write(oprot)
19746 
      oprot.writeFieldEnd()
19747 
    oprot.writeFieldStop()
19748 
    oprot.writeStructEnd()
19749 
 
19750 
  def validate(self):
19751 
    return
19752 
 
19753 
 
19754 
  def __repr__(self):
19755 
    L = ['%s=%r' % (key, value)
19756 
      for key, value in self.__dict__.iteritems()]
19757 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19758 
 
19759 
  def __eq__(self, other):
19760 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19761 
 
19762 
  def __ne__(self, other):
19763 
    return not (self == other)
6838 vikram.rag 19764 
 
19765 
class getAllInsurers_args:
19766 
 
19767 
  thrift_spec = (
19768 
  )
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 
      else:
19780 
        iprot.skip(ftype)
19781 
      iprot.readFieldEnd()
19782 
    iprot.readStructEnd()
19783 
 
19784 
  def write(self, oprot):
19785 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19786 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19787 
      return
19788 
    oprot.writeStructBegin('getAllInsurers_args')
19789 
    oprot.writeFieldStop()
19790 
    oprot.writeStructEnd()
19791 
 
19792 
  def validate(self):
19793 
    return
19794 
 
19795 
 
19796 
  def __repr__(self):
19797 
    L = ['%s=%r' % (key, value)
19798 
      for key, value in self.__dict__.iteritems()]
19799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19800 
 
19801 
  def __eq__(self, other):
19802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19803 
 
19804 
  def __ne__(self, other):
19805 
    return not (self == other)
19806 
 
19807 
class getAllInsurers_result:
19808 
  """
19809 
  Attributes:
19810 
   - success
19811 
  """
19812 
 
19813 
  thrift_spec = (
19814 
    (0, TType.LIST, 'success', (TType.STRUCT,(Insurer, Insurer.thrift_spec)), None, ), # 0
19815 
  )
19816 
 
19817 
  def __init__(self, success=None,):
19818 
    self.success = success
19819 
 
19820 
  def read(self, iprot):
19821 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19822 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19823 
      return
19824 
    iprot.readStructBegin()
19825 
    while True:
19826 
      (fname, ftype, fid) = iprot.readFieldBegin()
19827 
      if ftype == TType.STOP:
19828 
        break
19829 
      if fid == 0:
19830 
        if ftype == TType.LIST:
19831 
          self.success = []
9155 kshitij.so 19832 
          (_etype384, _size381) = iprot.readListBegin()
19833 
          for _i385 in xrange(_size381):
19834 
            _elem386 = Insurer()
19835 
            _elem386.read(iprot)
19836 
            self.success.append(_elem386)
6838 vikram.rag 19837 
          iprot.readListEnd()
19838 
        else:
19839 
          iprot.skip(ftype)
19840 
      else:
19841 
        iprot.skip(ftype)
19842 
      iprot.readFieldEnd()
19843 
    iprot.readStructEnd()
19844 
 
19845 
  def write(self, oprot):
19846 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19847 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19848 
      return
19849 
    oprot.writeStructBegin('getAllInsurers_result')
19850 
    if self.success is not None:
19851 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19852 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 19853 
      for iter387 in self.success:
19854 
        iter387.write(oprot)
6838 vikram.rag 19855 
      oprot.writeListEnd()
19856 
      oprot.writeFieldEnd()
19857 
    oprot.writeFieldStop()
19858 
    oprot.writeStructEnd()
19859 
 
19860 
  def validate(self):
19861 
    return
19862 
 
19863 
 
19864 
  def __repr__(self):
19865 
    L = ['%s=%r' % (key, value)
19866 
      for key, value in self.__dict__.iteritems()]
19867 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19868 
 
19869 
  def __eq__(self, other):
19870 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19871 
 
19872 
  def __ne__(self, other):
19873 
    return not (self == other)
6962 rajveer 19874 
 
19875 
class updateInsuranceDeclaredAmount_args:
19876 
  """
19877 
  Attributes:
19878 
   - insurerId
19879 
   - amount
19880 
  """
19881 
 
19882 
  thrift_spec = (
19883 
    None, # 0
19884 
    (1, TType.I64, 'insurerId', None, None, ), # 1
19885 
    (2, TType.DOUBLE, 'amount', None, None, ), # 2
19886 
  )
19887 
 
19888 
  def __init__(self, insurerId=None, amount=None,):
19889 
    self.insurerId = insurerId
19890 
    self.amount = amount
19891 
 
19892 
  def read(self, iprot):
19893 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19894 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19895 
      return
19896 
    iprot.readStructBegin()
19897 
    while True:
19898 
      (fname, ftype, fid) = iprot.readFieldBegin()
19899 
      if ftype == TType.STOP:
19900 
        break
19901 
      if fid == 1:
19902 
        if ftype == TType.I64:
19903 
          self.insurerId = iprot.readI64();
19904 
        else:
19905 
          iprot.skip(ftype)
19906 
      elif fid == 2:
19907 
        if ftype == TType.DOUBLE:
19908 
          self.amount = iprot.readDouble();
19909 
        else:
19910 
          iprot.skip(ftype)
19911 
      else:
19912 
        iprot.skip(ftype)
19913 
      iprot.readFieldEnd()
19914 
    iprot.readStructEnd()
19915 
 
19916 
  def write(self, oprot):
19917 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19918 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19919 
      return
19920 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_args')
19921 
    if self.insurerId is not None:
19922 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
19923 
      oprot.writeI64(self.insurerId)
19924 
      oprot.writeFieldEnd()
19925 
    if self.amount is not None:
19926 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 2)
19927 
      oprot.writeDouble(self.amount)
19928 
      oprot.writeFieldEnd()
19929 
    oprot.writeFieldStop()
19930 
    oprot.writeStructEnd()
19931 
 
19932 
  def validate(self):
19933 
    return
19934 
 
19935 
 
19936 
  def __repr__(self):
19937 
    L = ['%s=%r' % (key, value)
19938 
      for key, value in self.__dict__.iteritems()]
19939 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19940 
 
19941 
  def __eq__(self, other):
19942 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19943 
 
19944 
  def __ne__(self, other):
19945 
    return not (self == other)
19946 
 
19947 
class updateInsuranceDeclaredAmount_result:
19948 
 
19949 
  thrift_spec = (
19950 
  )
19951 
 
19952 
  def read(self, iprot):
19953 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19954 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19955 
      return
19956 
    iprot.readStructBegin()
19957 
    while True:
19958 
      (fname, ftype, fid) = iprot.readFieldBegin()
19959 
      if ftype == TType.STOP:
19960 
        break
19961 
      else:
19962 
        iprot.skip(ftype)
19963 
      iprot.readFieldEnd()
19964 
    iprot.readStructEnd()
19965 
 
19966 
  def write(self, oprot):
19967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19969 
      return
19970 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_result')
19971 
    oprot.writeFieldStop()
19972 
    oprot.writeStructEnd()
19973 
 
19974 
  def validate(self):
19975 
    return
19976 
 
19977 
 
19978 
  def __repr__(self):
19979 
    L = ['%s=%r' % (key, value)
19980 
      for key, value in self.__dict__.iteritems()]
19981 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19982 
 
19983 
  def __eq__(self, other):
19984 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19985 
 
19986 
  def __ne__(self, other):
19987 
    return not (self == other)
7190 amar.kumar 19988 
 
19989 
class getFreebieForItem_args:
19990 
  """
19991 
  Attributes:
19992 
   - itemId
19993 
  """
19994 
 
19995 
  thrift_spec = (
19996 
    None, # 0
19997 
    (1, TType.I64, 'itemId', None, None, ), # 1
19998 
  )
19999 
 
20000 
  def __init__(self, itemId=None,):
20001 
    self.itemId = itemId
20002 
 
20003 
  def read(self, iprot):
20004 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20005 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20006 
      return
20007 
    iprot.readStructBegin()
20008 
    while True:
20009 
      (fname, ftype, fid) = iprot.readFieldBegin()
20010 
      if ftype == TType.STOP:
20011 
        break
20012 
      if fid == 1:
20013 
        if ftype == TType.I64:
20014 
          self.itemId = iprot.readI64();
20015 
        else:
20016 
          iprot.skip(ftype)
20017 
      else:
20018 
        iprot.skip(ftype)
20019 
      iprot.readFieldEnd()
20020 
    iprot.readStructEnd()
20021 
 
20022 
  def write(self, oprot):
20023 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20024 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20025 
      return
20026 
    oprot.writeStructBegin('getFreebieForItem_args')
20027 
    if self.itemId is not None:
20028 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20029 
      oprot.writeI64(self.itemId)
20030 
      oprot.writeFieldEnd()
20031 
    oprot.writeFieldStop()
20032 
    oprot.writeStructEnd()
20033 
 
20034 
  def validate(self):
20035 
    return
20036 
 
20037 
 
20038 
  def __repr__(self):
20039 
    L = ['%s=%r' % (key, value)
20040 
      for key, value in self.__dict__.iteritems()]
20041 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20042 
 
20043 
  def __eq__(self, other):
20044 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20045 
 
20046 
  def __ne__(self, other):
20047 
    return not (self == other)
20048 
 
20049 
class getFreebieForItem_result:
20050 
  """
20051 
  Attributes:
20052 
   - success
20053 
  """
20054 
 
20055 
  thrift_spec = (
20056 
    (0, TType.I64, 'success', None, None, ), # 0
20057 
  )
20058 
 
20059 
  def __init__(self, success=None,):
20060 
    self.success = success
20061 
 
20062 
  def read(self, iprot):
20063 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20064 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20065 
      return
20066 
    iprot.readStructBegin()
20067 
    while True:
20068 
      (fname, ftype, fid) = iprot.readFieldBegin()
20069 
      if ftype == TType.STOP:
20070 
        break
20071 
      if fid == 0:
20072 
        if ftype == TType.I64:
20073 
          self.success = iprot.readI64();
20074 
        else:
20075 
          iprot.skip(ftype)
20076 
      else:
20077 
        iprot.skip(ftype)
20078 
      iprot.readFieldEnd()
20079 
    iprot.readStructEnd()
20080 
 
20081 
  def write(self, oprot):
20082 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20083 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20084 
      return
20085 
    oprot.writeStructBegin('getFreebieForItem_result')
20086 
    if self.success is not None:
20087 
      oprot.writeFieldBegin('success', TType.I64, 0)
20088 
      oprot.writeI64(self.success)
20089 
      oprot.writeFieldEnd()
20090 
    oprot.writeFieldStop()
20091 
    oprot.writeStructEnd()
20092 
 
20093 
  def validate(self):
20094 
    return
20095 
 
20096 
 
20097 
  def __repr__(self):
20098 
    L = ['%s=%r' % (key, value)
20099 
      for key, value in self.__dict__.iteritems()]
20100 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20101 
 
20102 
  def __eq__(self, other):
20103 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20104 
 
20105 
  def __ne__(self, other):
20106 
    return not (self == other)
20107 
 
20108 
class addOrUpdateFreebieForItem_args:
20109 
  """
20110 
  Attributes:
20111 
   - freebieItem
20112 
  """
20113 
 
20114 
  thrift_spec = (
20115 
    None, # 0
20116 
    (1, TType.STRUCT, 'freebieItem', (FreebieItem, FreebieItem.thrift_spec), None, ), # 1
20117 
  )
20118 
 
20119 
  def __init__(self, freebieItem=None,):
20120 
    self.freebieItem = freebieItem
20121 
 
20122 
  def read(self, iprot):
20123 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20124 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20125 
      return
20126 
    iprot.readStructBegin()
20127 
    while True:
20128 
      (fname, ftype, fid) = iprot.readFieldBegin()
20129 
      if ftype == TType.STOP:
20130 
        break
20131 
      if fid == 1:
20132 
        if ftype == TType.STRUCT:
20133 
          self.freebieItem = FreebieItem()
20134 
          self.freebieItem.read(iprot)
20135 
        else:
20136 
          iprot.skip(ftype)
20137 
      else:
20138 
        iprot.skip(ftype)
20139 
      iprot.readFieldEnd()
20140 
    iprot.readStructEnd()
20141 
 
20142 
  def write(self, oprot):
20143 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20144 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20145 
      return
20146 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_args')
20147 
    if self.freebieItem is not None:
20148 
      oprot.writeFieldBegin('freebieItem', TType.STRUCT, 1)
20149 
      self.freebieItem.write(oprot)
20150 
      oprot.writeFieldEnd()
20151 
    oprot.writeFieldStop()
20152 
    oprot.writeStructEnd()
20153 
 
20154 
  def validate(self):
20155 
    return
20156 
 
20157 
 
20158 
  def __repr__(self):
20159 
    L = ['%s=%r' % (key, value)
20160 
      for key, value in self.__dict__.iteritems()]
20161 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20162 
 
20163 
  def __eq__(self, other):
20164 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20165 
 
20166 
  def __ne__(self, other):
20167 
    return not (self == other)
20168 
 
20169 
class addOrUpdateFreebieForItem_result:
20170 
 
20171 
  thrift_spec = (
20172 
  )
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 
      else:
20184 
        iprot.skip(ftype)
20185 
      iprot.readFieldEnd()
20186 
    iprot.readStructEnd()
20187 
 
20188 
  def write(self, oprot):
20189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20191 
      return
20192 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_result')
20193 
    oprot.writeFieldStop()
20194 
    oprot.writeStructEnd()
20195 
 
20196 
  def validate(self):
20197 
    return
20198 
 
20199 
 
20200 
  def __repr__(self):
20201 
    L = ['%s=%r' % (key, value)
20202 
      for key, value in self.__dict__.iteritems()]
20203 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20204 
 
20205 
  def __eq__(self, other):
20206 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20207 
 
20208 
  def __ne__(self, other):
20209 
    return not (self == other)
7256 rajveer 20210 
 
7272 amit.gupta 20211 
class addOrUpdateBrandInfo_args:
20212 
  """
20213 
  Attributes:
20214 
   - brandInfo
20215 
  """
20216 
 
20217 
  thrift_spec = (
20218 
    None, # 0
20219 
    (1, TType.STRUCT, 'brandInfo', (BrandInfo, BrandInfo.thrift_spec), None, ), # 1
20220 
  )
20221 
 
20222 
  def __init__(self, brandInfo=None,):
20223 
    self.brandInfo = brandInfo
20224 
 
20225 
  def read(self, iprot):
20226 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20227 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20228 
      return
20229 
    iprot.readStructBegin()
20230 
    while True:
20231 
      (fname, ftype, fid) = iprot.readFieldBegin()
20232 
      if ftype == TType.STOP:
20233 
        break
20234 
      if fid == 1:
20235 
        if ftype == TType.STRUCT:
20236 
          self.brandInfo = BrandInfo()
20237 
          self.brandInfo.read(iprot)
20238 
        else:
20239 
          iprot.skip(ftype)
20240 
      else:
20241 
        iprot.skip(ftype)
20242 
      iprot.readFieldEnd()
20243 
    iprot.readStructEnd()
20244 
 
20245 
  def write(self, oprot):
20246 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20247 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20248 
      return
20249 
    oprot.writeStructBegin('addOrUpdateBrandInfo_args')
20250 
    if self.brandInfo is not None:
20251 
      oprot.writeFieldBegin('brandInfo', TType.STRUCT, 1)
20252 
      self.brandInfo.write(oprot)
20253 
      oprot.writeFieldEnd()
20254 
    oprot.writeFieldStop()
20255 
    oprot.writeStructEnd()
20256 
 
20257 
  def validate(self):
20258 
    return
20259 
 
20260 
 
20261 
  def __repr__(self):
20262 
    L = ['%s=%r' % (key, value)
20263 
      for key, value in self.__dict__.iteritems()]
20264 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20265 
 
20266 
  def __eq__(self, other):
20267 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20268 
 
20269 
  def __ne__(self, other):
20270 
    return not (self == other)
20271 
 
20272 
class addOrUpdateBrandInfo_result:
20273 
 
20274 
  thrift_spec = (
20275 
  )
20276 
 
20277 
  def read(self, iprot):
20278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20280 
      return
20281 
    iprot.readStructBegin()
20282 
    while True:
20283 
      (fname, ftype, fid) = iprot.readFieldBegin()
20284 
      if ftype == TType.STOP:
20285 
        break
20286 
      else:
20287 
        iprot.skip(ftype)
20288 
      iprot.readFieldEnd()
20289 
    iprot.readStructEnd()
20290 
 
20291 
  def write(self, oprot):
20292 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20293 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20294 
      return
20295 
    oprot.writeStructBegin('addOrUpdateBrandInfo_result')
20296 
    oprot.writeFieldStop()
20297 
    oprot.writeStructEnd()
20298 
 
20299 
  def validate(self):
20300 
    return
20301 
 
20302 
 
20303 
  def __repr__(self):
20304 
    L = ['%s=%r' % (key, value)
20305 
      for key, value in self.__dict__.iteritems()]
20306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20307 
 
20308 
  def __eq__(self, other):
20309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20310 
 
20311 
  def __ne__(self, other):
20312 
    return not (self == other)
20313 
 
20314 
class getBrandInfo_args:
20315 
 
20316 
  thrift_spec = (
20317 
  )
20318 
 
20319 
  def read(self, iprot):
20320 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20321 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20322 
      return
20323 
    iprot.readStructBegin()
20324 
    while True:
20325 
      (fname, ftype, fid) = iprot.readFieldBegin()
20326 
      if ftype == TType.STOP:
20327 
        break
20328 
      else:
20329 
        iprot.skip(ftype)
20330 
      iprot.readFieldEnd()
20331 
    iprot.readStructEnd()
20332 
 
20333 
  def write(self, oprot):
20334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20336 
      return
20337 
    oprot.writeStructBegin('getBrandInfo_args')
20338 
    oprot.writeFieldStop()
20339 
    oprot.writeStructEnd()
20340 
 
20341 
  def validate(self):
20342 
    return
20343 
 
20344 
 
20345 
  def __repr__(self):
20346 
    L = ['%s=%r' % (key, value)
20347 
      for key, value in self.__dict__.iteritems()]
20348 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20349 
 
20350 
  def __eq__(self, other):
20351 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20352 
 
20353 
  def __ne__(self, other):
20354 
    return not (self == other)
20355 
 
20356 
class getBrandInfo_result:
20357 
  """
20358 
  Attributes:
20359 
   - success
20360 
  """
20361 
 
20362 
  thrift_spec = (
20363 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(BrandInfo, BrandInfo.thrift_spec)), None, ), # 0
20364 
  )
20365 
 
20366 
  def __init__(self, success=None,):
20367 
    self.success = success
20368 
 
20369 
  def read(self, iprot):
20370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20372 
      return
20373 
    iprot.readStructBegin()
20374 
    while True:
20375 
      (fname, ftype, fid) = iprot.readFieldBegin()
20376 
      if ftype == TType.STOP:
20377 
        break
20378 
      if fid == 0:
20379 
        if ftype == TType.MAP:
20380 
          self.success = {}
9155 kshitij.so 20381 
          (_ktype389, _vtype390, _size388 ) = iprot.readMapBegin()
20382 
          for _i392 in xrange(_size388):
20383 
            _key393 = iprot.readString();
20384 
            _val394 = BrandInfo()
20385 
            _val394.read(iprot)
20386 
            self.success[_key393] = _val394
7272 amit.gupta 20387 
          iprot.readMapEnd()
20388 
        else:
20389 
          iprot.skip(ftype)
20390 
      else:
20391 
        iprot.skip(ftype)
20392 
      iprot.readFieldEnd()
20393 
    iprot.readStructEnd()
20394 
 
20395 
  def write(self, oprot):
20396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20398 
      return
20399 
    oprot.writeStructBegin('getBrandInfo_result')
20400 
    if self.success is not None:
20401 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20402 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
9155 kshitij.so 20403 
      for kiter395,viter396 in self.success.items():
20404 
        oprot.writeString(kiter395)
20405 
        viter396.write(oprot)
7272 amit.gupta 20406 
      oprot.writeMapEnd()
20407 
      oprot.writeFieldEnd()
20408 
    oprot.writeFieldStop()
20409 
    oprot.writeStructEnd()
20410 
 
20411 
  def validate(self):
20412 
    return
20413 
 
20414 
 
20415 
  def __repr__(self):
20416 
    L = ['%s=%r' % (key, value)
20417 
      for key, value in self.__dict__.iteritems()]
20418 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20419 
 
20420 
  def __eq__(self, other):
20421 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20422 
 
20423 
  def __ne__(self, other):
20424 
    return not (self == other)
20425 
 
7256 rajveer 20426 
class getStorePricing_args:
20427 
  """
20428 
  Attributes:
20429 
   - itemId
20430 
  """
20431 
 
20432 
  thrift_spec = (
20433 
    None, # 0
20434 
    (1, TType.I64, 'itemId', None, None, ), # 1
20435 
  )
20436 
 
20437 
  def __init__(self, itemId=None,):
20438 
    self.itemId = itemId
20439 
 
20440 
  def read(self, iprot):
20441 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20442 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20443 
      return
20444 
    iprot.readStructBegin()
20445 
    while True:
20446 
      (fname, ftype, fid) = iprot.readFieldBegin()
20447 
      if ftype == TType.STOP:
20448 
        break
20449 
      if fid == 1:
20450 
        if ftype == TType.I64:
20451 
          self.itemId = iprot.readI64();
20452 
        else:
20453 
          iprot.skip(ftype)
20454 
      else:
20455 
        iprot.skip(ftype)
20456 
      iprot.readFieldEnd()
20457 
    iprot.readStructEnd()
20458 
 
20459 
  def write(self, oprot):
20460 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20461 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20462 
      return
20463 
    oprot.writeStructBegin('getStorePricing_args')
20464 
    if self.itemId is not None:
20465 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20466 
      oprot.writeI64(self.itemId)
20467 
      oprot.writeFieldEnd()
20468 
    oprot.writeFieldStop()
20469 
    oprot.writeStructEnd()
20470 
 
20471 
  def validate(self):
20472 
    return
20473 
 
20474 
 
20475 
  def __repr__(self):
20476 
    L = ['%s=%r' % (key, value)
20477 
      for key, value in self.__dict__.iteritems()]
20478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20479 
 
20480 
  def __eq__(self, other):
20481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20482 
 
20483 
  def __ne__(self, other):
20484 
    return not (self == other)
20485 
 
20486 
class getStorePricing_result:
20487 
  """
20488 
  Attributes:
20489 
   - success
20490 
  """
20491 
 
20492 
  thrift_spec = (
20493 
    (0, TType.STRUCT, 'success', (StorePricing, StorePricing.thrift_spec), None, ), # 0
20494 
  )
20495 
 
20496 
  def __init__(self, success=None,):
20497 
    self.success = success
20498 
 
20499 
  def read(self, iprot):
20500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20502 
      return
20503 
    iprot.readStructBegin()
20504 
    while True:
20505 
      (fname, ftype, fid) = iprot.readFieldBegin()
20506 
      if ftype == TType.STOP:
20507 
        break
20508 
      if fid == 0:
20509 
        if ftype == TType.STRUCT:
20510 
          self.success = StorePricing()
20511 
          self.success.read(iprot)
20512 
        else:
20513 
          iprot.skip(ftype)
20514 
      else:
20515 
        iprot.skip(ftype)
20516 
      iprot.readFieldEnd()
20517 
    iprot.readStructEnd()
20518 
 
20519 
  def write(self, oprot):
20520 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20521 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20522 
      return
20523 
    oprot.writeStructBegin('getStorePricing_result')
20524 
    if self.success is not None:
20525 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20526 
      self.success.write(oprot)
20527 
      oprot.writeFieldEnd()
20528 
    oprot.writeFieldStop()
20529 
    oprot.writeStructEnd()
20530 
 
20531 
  def validate(self):
20532 
    return
20533 
 
20534 
 
20535 
  def __repr__(self):
20536 
    L = ['%s=%r' % (key, value)
20537 
      for key, value in self.__dict__.iteritems()]
20538 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20539 
 
20540 
  def __eq__(self, other):
20541 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20542 
 
20543 
  def __ne__(self, other):
20544 
    return not (self == other)
7265 rajveer 20545 
 
7306 rajveer 20546 
class getStorePricings_args:
20547 
  """
20548 
  Attributes:
20549 
   - itemIds
20550 
  """
20551 
 
20552 
  thrift_spec = (
20553 
    None, # 0
20554 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
20555 
  )
20556 
 
20557 
  def __init__(self, itemIds=None,):
20558 
    self.itemIds = itemIds
20559 
 
20560 
  def read(self, iprot):
20561 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20562 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20563 
      return
20564 
    iprot.readStructBegin()
20565 
    while True:
20566 
      (fname, ftype, fid) = iprot.readFieldBegin()
20567 
      if ftype == TType.STOP:
20568 
        break
20569 
      if fid == 1:
20570 
        if ftype == TType.LIST:
20571 
          self.itemIds = []
9155 kshitij.so 20572 
          (_etype400, _size397) = iprot.readListBegin()
20573 
          for _i401 in xrange(_size397):
20574 
            _elem402 = iprot.readI64();
20575 
            self.itemIds.append(_elem402)
7306 rajveer 20576 
          iprot.readListEnd()
20577 
        else:
20578 
          iprot.skip(ftype)
20579 
      else:
20580 
        iprot.skip(ftype)
20581 
      iprot.readFieldEnd()
20582 
    iprot.readStructEnd()
20583 
 
20584 
  def write(self, oprot):
20585 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20586 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20587 
      return
20588 
    oprot.writeStructBegin('getStorePricings_args')
20589 
    if self.itemIds is not None:
20590 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
20591 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
9155 kshitij.so 20592 
      for iter403 in self.itemIds:
20593 
        oprot.writeI64(iter403)
7306 rajveer 20594 
      oprot.writeListEnd()
20595 
      oprot.writeFieldEnd()
20596 
    oprot.writeFieldStop()
20597 
    oprot.writeStructEnd()
20598 
 
20599 
  def validate(self):
20600 
    return
20601 
 
20602 
 
20603 
  def __repr__(self):
20604 
    L = ['%s=%r' % (key, value)
20605 
      for key, value in self.__dict__.iteritems()]
20606 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20607 
 
20608 
  def __eq__(self, other):
20609 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20610 
 
20611 
  def __ne__(self, other):
20612 
    return not (self == other)
20613 
 
20614 
class getStorePricings_result:
20615 
  """
20616 
  Attributes:
20617 
   - success
20618 
  """
20619 
 
20620 
  thrift_spec = (
20621 
    (0, TType.LIST, 'success', (TType.STRUCT,(StorePricing, StorePricing.thrift_spec)), None, ), # 0
20622 
  )
20623 
 
20624 
  def __init__(self, success=None,):
20625 
    self.success = success
20626 
 
20627 
  def read(self, iprot):
20628 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20629 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20630 
      return
20631 
    iprot.readStructBegin()
20632 
    while True:
20633 
      (fname, ftype, fid) = iprot.readFieldBegin()
20634 
      if ftype == TType.STOP:
20635 
        break
20636 
      if fid == 0:
20637 
        if ftype == TType.LIST:
20638 
          self.success = []
9155 kshitij.so 20639 
          (_etype407, _size404) = iprot.readListBegin()
20640 
          for _i408 in xrange(_size404):
20641 
            _elem409 = StorePricing()
20642 
            _elem409.read(iprot)
20643 
            self.success.append(_elem409)
7306 rajveer 20644 
          iprot.readListEnd()
20645 
        else:
20646 
          iprot.skip(ftype)
20647 
      else:
20648 
        iprot.skip(ftype)
20649 
      iprot.readFieldEnd()
20650 
    iprot.readStructEnd()
20651 
 
20652 
  def write(self, oprot):
20653 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20654 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20655 
      return
20656 
    oprot.writeStructBegin('getStorePricings_result')
20657 
    if self.success is not None:
20658 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20659 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 20660 
      for iter410 in self.success:
20661 
        iter410.write(oprot)
7306 rajveer 20662 
      oprot.writeListEnd()
20663 
      oprot.writeFieldEnd()
20664 
    oprot.writeFieldStop()
20665 
    oprot.writeStructEnd()
20666 
 
20667 
  def validate(self):
20668 
    return
20669 
 
20670 
 
20671 
  def __repr__(self):
20672 
    L = ['%s=%r' % (key, value)
20673 
      for key, value in self.__dict__.iteritems()]
20674 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20675 
 
20676 
  def __eq__(self, other):
20677 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20678 
 
20679 
  def __ne__(self, other):
20680 
    return not (self == other)
20681 
 
7265 rajveer 20682 
class updateStorePricing_args:
20683 
  """
20684 
  Attributes:
20685 
   - sp
7382 rajveer 20686 
   - allColors
7265 rajveer 20687 
  """
20688 
 
20689 
  thrift_spec = (
20690 
    None, # 0
20691 
    (1, TType.STRUCT, 'sp', (StorePricing, StorePricing.thrift_spec), None, ), # 1
7382 rajveer 20692 
    (2, TType.BOOL, 'allColors', None, None, ), # 2
7265 rajveer 20693 
  )
20694 
 
7382 rajveer 20695 
  def __init__(self, sp=None, allColors=None,):
7265 rajveer 20696 
    self.sp = sp
7382 rajveer 20697 
    self.allColors = allColors
7265 rajveer 20698 
 
20699 
  def read(self, iprot):
20700 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20701 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20702 
      return
20703 
    iprot.readStructBegin()
20704 
    while True:
20705 
      (fname, ftype, fid) = iprot.readFieldBegin()
20706 
      if ftype == TType.STOP:
20707 
        break
20708 
      if fid == 1:
20709 
        if ftype == TType.STRUCT:
20710 
          self.sp = StorePricing()
20711 
          self.sp.read(iprot)
20712 
        else:
20713 
          iprot.skip(ftype)
7382 rajveer 20714 
      elif fid == 2:
20715 
        if ftype == TType.BOOL:
20716 
          self.allColors = iprot.readBool();
20717 
        else:
20718 
          iprot.skip(ftype)
7265 rajveer 20719 
      else:
20720 
        iprot.skip(ftype)
20721 
      iprot.readFieldEnd()
20722 
    iprot.readStructEnd()
20723 
 
20724 
  def write(self, oprot):
20725 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20726 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20727 
      return
20728 
    oprot.writeStructBegin('updateStorePricing_args')
20729 
    if self.sp is not None:
20730 
      oprot.writeFieldBegin('sp', TType.STRUCT, 1)
20731 
      self.sp.write(oprot)
20732 
      oprot.writeFieldEnd()
7382 rajveer 20733 
    if self.allColors is not None:
20734 
      oprot.writeFieldBegin('allColors', TType.BOOL, 2)
20735 
      oprot.writeBool(self.allColors)
20736 
      oprot.writeFieldEnd()
7265 rajveer 20737 
    oprot.writeFieldStop()
20738 
    oprot.writeStructEnd()
20739 
 
20740 
  def validate(self):
20741 
    return
20742 
 
20743 
 
20744 
  def __repr__(self):
20745 
    L = ['%s=%r' % (key, value)
20746 
      for key, value in self.__dict__.iteritems()]
20747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20748 
 
20749 
  def __eq__(self, other):
20750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20751 
 
20752 
  def __ne__(self, other):
20753 
    return not (self == other)
20754 
 
20755 
class updateStorePricing_result:
20756 
 
20757 
  thrift_spec = (
20758 
  )
20759 
 
20760 
  def read(self, iprot):
20761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20763 
      return
20764 
    iprot.readStructBegin()
20765 
    while True:
20766 
      (fname, ftype, fid) = iprot.readFieldBegin()
20767 
      if ftype == TType.STOP:
20768 
        break
20769 
      else:
20770 
        iprot.skip(ftype)
20771 
      iprot.readFieldEnd()
20772 
    iprot.readStructEnd()
20773 
 
20774 
  def write(self, oprot):
20775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20777 
      return
20778 
    oprot.writeStructBegin('updateStorePricing_result')
20779 
    oprot.writeFieldStop()
20780 
    oprot.writeStructEnd()
20781 
 
20782 
  def validate(self):
20783 
    return
20784 
 
20785 
 
20786 
  def __repr__(self):
20787 
    L = ['%s=%r' % (key, value)
20788 
      for key, value in self.__dict__.iteritems()]
20789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20790 
 
20791 
  def __eq__(self, other):
20792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20793 
 
20794 
  def __ne__(self, other):
20795 
    return not (self == other)
7281 kshitij.so 20796 
 
20797 
class getAllAmazonListedItems_args:
20798 
 
20799 
  thrift_spec = (
20800 
  )
20801 
 
20802 
  def read(self, iprot):
20803 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20804 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20805 
      return
20806 
    iprot.readStructBegin()
20807 
    while True:
20808 
      (fname, ftype, fid) = iprot.readFieldBegin()
20809 
      if ftype == TType.STOP:
20810 
        break
20811 
      else:
20812 
        iprot.skip(ftype)
20813 
      iprot.readFieldEnd()
20814 
    iprot.readStructEnd()
20815 
 
20816 
  def write(self, oprot):
20817 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20818 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20819 
      return
20820 
    oprot.writeStructBegin('getAllAmazonListedItems_args')
20821 
    oprot.writeFieldStop()
20822 
    oprot.writeStructEnd()
20823 
 
20824 
  def validate(self):
20825 
    return
20826 
 
20827 
 
20828 
  def __repr__(self):
20829 
    L = ['%s=%r' % (key, value)
20830 
      for key, value in self.__dict__.iteritems()]
20831 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20832 
 
20833 
  def __eq__(self, other):
20834 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20835 
 
20836 
  def __ne__(self, other):
20837 
    return not (self == other)
20838 
 
20839 
class getAllAmazonListedItems_result:
20840 
  """
20841 
  Attributes:
20842 
   - success
20843 
  """
20844 
 
20845 
  thrift_spec = (
20846 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
20847 
  )
20848 
 
20849 
  def __init__(self, success=None,):
20850 
    self.success = success
20851 
 
20852 
  def read(self, iprot):
20853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20855 
      return
20856 
    iprot.readStructBegin()
20857 
    while True:
20858 
      (fname, ftype, fid) = iprot.readFieldBegin()
20859 
      if ftype == TType.STOP:
20860 
        break
20861 
      if fid == 0:
20862 
        if ftype == TType.LIST:
20863 
          self.success = []
9155 kshitij.so 20864 
          (_etype414, _size411) = iprot.readListBegin()
20865 
          for _i415 in xrange(_size411):
20866 
            _elem416 = Amazonlisted()
20867 
            _elem416.read(iprot)
20868 
            self.success.append(_elem416)
7281 kshitij.so 20869 
          iprot.readListEnd()
20870 
        else:
20871 
          iprot.skip(ftype)
20872 
      else:
20873 
        iprot.skip(ftype)
20874 
      iprot.readFieldEnd()
20875 
    iprot.readStructEnd()
20876 
 
20877 
  def write(self, oprot):
20878 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20879 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20880 
      return
20881 
    oprot.writeStructBegin('getAllAmazonListedItems_result')
20882 
    if self.success is not None:
20883 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20884 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 20885 
      for iter417 in self.success:
20886 
        iter417.write(oprot)
7281 kshitij.so 20887 
      oprot.writeListEnd()
20888 
      oprot.writeFieldEnd()
20889 
    oprot.writeFieldStop()
20890 
    oprot.writeStructEnd()
20891 
 
20892 
  def validate(self):
20893 
    return
20894 
 
20895 
 
20896 
  def __repr__(self):
20897 
    L = ['%s=%r' % (key, value)
20898 
      for key, value in self.__dict__.iteritems()]
20899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20900 
 
20901 
  def __eq__(self, other):
20902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20903 
 
20904 
  def __ne__(self, other):
20905 
    return not (self == other)
20906 
 
8619 kshitij.so 20907 
class searchAmazonItems_args:
20908 
  """
20909 
  Attributes:
20910 
   - searchTerm
20911 
   - offset
20912 
   - limit
20913 
  """
20914 
 
20915 
  thrift_spec = (
20916 
    None, # 0
20917 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
20918 
    (2, TType.I64, 'offset', None, None, ), # 2
20919 
    (3, TType.I64, 'limit', None, None, ), # 3
20920 
  )
20921 
 
20922 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
20923 
    self.searchTerm = searchTerm
20924 
    self.offset = offset
20925 
    self.limit = limit
20926 
 
20927 
  def read(self, iprot):
20928 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20929 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20930 
      return
20931 
    iprot.readStructBegin()
20932 
    while True:
20933 
      (fname, ftype, fid) = iprot.readFieldBegin()
20934 
      if ftype == TType.STOP:
20935 
        break
20936 
      if fid == 1:
20937 
        if ftype == TType.LIST:
20938 
          self.searchTerm = []
9155 kshitij.so 20939 
          (_etype421, _size418) = iprot.readListBegin()
20940 
          for _i422 in xrange(_size418):
20941 
            _elem423 = iprot.readString();
20942 
            self.searchTerm.append(_elem423)
8619 kshitij.so 20943 
          iprot.readListEnd()
20944 
        else:
20945 
          iprot.skip(ftype)
20946 
      elif fid == 2:
20947 
        if ftype == TType.I64:
20948 
          self.offset = iprot.readI64();
20949 
        else:
20950 
          iprot.skip(ftype)
20951 
      elif fid == 3:
20952 
        if ftype == TType.I64:
20953 
          self.limit = iprot.readI64();
20954 
        else:
20955 
          iprot.skip(ftype)
20956 
      else:
20957 
        iprot.skip(ftype)
20958 
      iprot.readFieldEnd()
20959 
    iprot.readStructEnd()
20960 
 
20961 
  def write(self, oprot):
20962 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20963 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20964 
      return
20965 
    oprot.writeStructBegin('searchAmazonItems_args')
20966 
    if self.searchTerm is not None:
20967 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
20968 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
9155 kshitij.so 20969 
      for iter424 in self.searchTerm:
20970 
        oprot.writeString(iter424)
8619 kshitij.so 20971 
      oprot.writeListEnd()
20972 
      oprot.writeFieldEnd()
20973 
    if self.offset is not None:
20974 
      oprot.writeFieldBegin('offset', TType.I64, 2)
20975 
      oprot.writeI64(self.offset)
20976 
      oprot.writeFieldEnd()
20977 
    if self.limit is not None:
20978 
      oprot.writeFieldBegin('limit', TType.I64, 3)
20979 
      oprot.writeI64(self.limit)
20980 
      oprot.writeFieldEnd()
20981 
    oprot.writeFieldStop()
20982 
    oprot.writeStructEnd()
20983 
 
20984 
  def validate(self):
20985 
    return
20986 
 
20987 
 
20988 
  def __repr__(self):
20989 
    L = ['%s=%r' % (key, value)
20990 
      for key, value in self.__dict__.iteritems()]
20991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20992 
 
20993 
  def __eq__(self, other):
20994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20995 
 
20996 
  def __ne__(self, other):
20997 
    return not (self == other)
20998 
 
20999 
class searchAmazonItems_result:
21000 
  """
21001 
  Attributes:
21002 
   - success
21003 
  """
21004 
 
21005 
  thrift_spec = (
21006 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
21007 
  )
21008 
 
21009 
  def __init__(self, success=None,):
21010 
    self.success = success
21011 
 
21012 
  def read(self, iprot):
21013 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21014 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21015 
      return
21016 
    iprot.readStructBegin()
21017 
    while True:
21018 
      (fname, ftype, fid) = iprot.readFieldBegin()
21019 
      if ftype == TType.STOP:
21020 
        break
21021 
      if fid == 0:
21022 
        if ftype == TType.LIST:
21023 
          self.success = []
9155 kshitij.so 21024 
          (_etype428, _size425) = iprot.readListBegin()
21025 
          for _i429 in xrange(_size425):
21026 
            _elem430 = Amazonlisted()
21027 
            _elem430.read(iprot)
21028 
            self.success.append(_elem430)
8619 kshitij.so 21029 
          iprot.readListEnd()
21030 
        else:
21031 
          iprot.skip(ftype)
21032 
      else:
21033 
        iprot.skip(ftype)
21034 
      iprot.readFieldEnd()
21035 
    iprot.readStructEnd()
21036 
 
21037 
  def write(self, oprot):
21038 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21039 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21040 
      return
21041 
    oprot.writeStructBegin('searchAmazonItems_result')
21042 
    if self.success is not None:
21043 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21044 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21045 
      for iter431 in self.success:
21046 
        iter431.write(oprot)
8619 kshitij.so 21047 
      oprot.writeListEnd()
21048 
      oprot.writeFieldEnd()
21049 
    oprot.writeFieldStop()
21050 
    oprot.writeStructEnd()
21051 
 
21052 
  def validate(self):
21053 
    return
21054 
 
21055 
 
21056 
  def __repr__(self):
21057 
    L = ['%s=%r' % (key, value)
21058 
      for key, value in self.__dict__.iteritems()]
21059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21060 
 
21061 
  def __eq__(self, other):
21062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21063 
 
21064 
  def __ne__(self, other):
21065 
    return not (self == other)
21066 
 
21067 
class getAmazonSearchResultCount_args:
21068 
  """
21069 
  Attributes:
21070 
   - searchTerm
21071 
  """
21072 
 
21073 
  thrift_spec = (
21074 
    None, # 0
21075 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
21076 
  )
21077 
 
21078 
  def __init__(self, searchTerm=None,):
21079 
    self.searchTerm = searchTerm
21080 
 
21081 
  def read(self, iprot):
21082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21084 
      return
21085 
    iprot.readStructBegin()
21086 
    while True:
21087 
      (fname, ftype, fid) = iprot.readFieldBegin()
21088 
      if ftype == TType.STOP:
21089 
        break
21090 
      if fid == 1:
21091 
        if ftype == TType.LIST:
21092 
          self.searchTerm = []
9155 kshitij.so 21093 
          (_etype435, _size432) = iprot.readListBegin()
21094 
          for _i436 in xrange(_size432):
21095 
            _elem437 = iprot.readString();
21096 
            self.searchTerm.append(_elem437)
8619 kshitij.so 21097 
          iprot.readListEnd()
21098 
        else:
21099 
          iprot.skip(ftype)
21100 
      else:
21101 
        iprot.skip(ftype)
21102 
      iprot.readFieldEnd()
21103 
    iprot.readStructEnd()
21104 
 
21105 
  def write(self, oprot):
21106 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21107 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21108 
      return
21109 
    oprot.writeStructBegin('getAmazonSearchResultCount_args')
21110 
    if self.searchTerm is not None:
21111 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
21112 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
9155 kshitij.so 21113 
      for iter438 in self.searchTerm:
21114 
        oprot.writeString(iter438)
8619 kshitij.so 21115 
      oprot.writeListEnd()
21116 
      oprot.writeFieldEnd()
21117 
    oprot.writeFieldStop()
21118 
    oprot.writeStructEnd()
21119 
 
21120 
  def validate(self):
21121 
    return
21122 
 
21123 
 
21124 
  def __repr__(self):
21125 
    L = ['%s=%r' % (key, value)
21126 
      for key, value in self.__dict__.iteritems()]
21127 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21128 
 
21129 
  def __eq__(self, other):
21130 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21131 
 
21132 
  def __ne__(self, other):
21133 
    return not (self == other)
21134 
 
21135 
class getAmazonSearchResultCount_result:
21136 
  """
21137 
  Attributes:
21138 
   - success
21139 
  """
21140 
 
21141 
  thrift_spec = (
21142 
    (0, TType.I64, 'success', None, None, ), # 0
21143 
  )
21144 
 
21145 
  def __init__(self, success=None,):
21146 
    self.success = success
21147 
 
21148 
  def read(self, iprot):
21149 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21150 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21151 
      return
21152 
    iprot.readStructBegin()
21153 
    while True:
21154 
      (fname, ftype, fid) = iprot.readFieldBegin()
21155 
      if ftype == TType.STOP:
21156 
        break
21157 
      if fid == 0:
21158 
        if ftype == TType.I64:
21159 
          self.success = iprot.readI64();
21160 
        else:
21161 
          iprot.skip(ftype)
21162 
      else:
21163 
        iprot.skip(ftype)
21164 
      iprot.readFieldEnd()
21165 
    iprot.readStructEnd()
21166 
 
21167 
  def write(self, oprot):
21168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21170 
      return
21171 
    oprot.writeStructBegin('getAmazonSearchResultCount_result')
21172 
    if self.success is not None:
21173 
      oprot.writeFieldBegin('success', TType.I64, 0)
21174 
      oprot.writeI64(self.success)
21175 
      oprot.writeFieldEnd()
21176 
    oprot.writeFieldStop()
21177 
    oprot.writeStructEnd()
21178 
 
21179 
  def validate(self):
21180 
    return
21181 
 
21182 
 
21183 
  def __repr__(self):
21184 
    L = ['%s=%r' % (key, value)
21185 
      for key, value in self.__dict__.iteritems()]
21186 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21187 
 
21188 
  def __eq__(self, other):
21189 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21190 
 
21191 
  def __ne__(self, other):
21192 
    return not (self == other)
21193 
 
21194 
class getCountForAmazonlistedItems_args:
21195 
 
21196 
  thrift_spec = (
21197 
  )
21198 
 
21199 
  def read(self, iprot):
21200 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21201 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21202 
      return
21203 
    iprot.readStructBegin()
21204 
    while True:
21205 
      (fname, ftype, fid) = iprot.readFieldBegin()
21206 
      if ftype == TType.STOP:
21207 
        break
21208 
      else:
21209 
        iprot.skip(ftype)
21210 
      iprot.readFieldEnd()
21211 
    iprot.readStructEnd()
21212 
 
21213 
  def write(self, oprot):
21214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21216 
      return
21217 
    oprot.writeStructBegin('getCountForAmazonlistedItems_args')
21218 
    oprot.writeFieldStop()
21219 
    oprot.writeStructEnd()
21220 
 
21221 
  def validate(self):
21222 
    return
21223 
 
21224 
 
21225 
  def __repr__(self):
21226 
    L = ['%s=%r' % (key, value)
21227 
      for key, value in self.__dict__.iteritems()]
21228 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21229 
 
21230 
  def __eq__(self, other):
21231 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21232 
 
21233 
  def __ne__(self, other):
21234 
    return not (self == other)
21235 
 
21236 
class getCountForAmazonlistedItems_result:
21237 
  """
21238 
  Attributes:
21239 
   - success
21240 
  """
21241 
 
21242 
  thrift_spec = (
21243 
    (0, TType.I64, 'success', None, None, ), # 0
21244 
  )
21245 
 
21246 
  def __init__(self, success=None,):
21247 
    self.success = success
21248 
 
21249 
  def read(self, iprot):
21250 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21251 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21252 
      return
21253 
    iprot.readStructBegin()
21254 
    while True:
21255 
      (fname, ftype, fid) = iprot.readFieldBegin()
21256 
      if ftype == TType.STOP:
21257 
        break
21258 
      if fid == 0:
21259 
        if ftype == TType.I64:
21260 
          self.success = iprot.readI64();
21261 
        else:
21262 
          iprot.skip(ftype)
21263 
      else:
21264 
        iprot.skip(ftype)
21265 
      iprot.readFieldEnd()
21266 
    iprot.readStructEnd()
21267 
 
21268 
  def write(self, oprot):
21269 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21270 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21271 
      return
21272 
    oprot.writeStructBegin('getCountForAmazonlistedItems_result')
21273 
    if self.success is not None:
21274 
      oprot.writeFieldBegin('success', TType.I64, 0)
21275 
      oprot.writeI64(self.success)
21276 
      oprot.writeFieldEnd()
21277 
    oprot.writeFieldStop()
21278 
    oprot.writeStructEnd()
21279 
 
21280 
  def validate(self):
21281 
    return
21282 
 
21283 
 
21284 
  def __repr__(self):
21285 
    L = ['%s=%r' % (key, value)
21286 
      for key, value in self.__dict__.iteritems()]
21287 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21288 
 
21289 
  def __eq__(self, other):
21290 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21291 
 
21292 
  def __ne__(self, other):
21293 
    return not (self == other)
21294 
 
7281 kshitij.so 21295 
class getAmazonItemDetails_args:
21296 
  """
21297 
  Attributes:
21298 
   - itemId
21299 
  """
21300 
 
21301 
  thrift_spec = (
21302 
    None, # 0
21303 
    (1, TType.I64, 'itemId', None, None, ), # 1
21304 
  )
21305 
 
21306 
  def __init__(self, itemId=None,):
21307 
    self.itemId = itemId
21308 
 
21309 
  def read(self, iprot):
21310 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21311 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21312 
      return
21313 
    iprot.readStructBegin()
21314 
    while True:
21315 
      (fname, ftype, fid) = iprot.readFieldBegin()
21316 
      if ftype == TType.STOP:
21317 
        break
21318 
      if fid == 1:
21319 
        if ftype == TType.I64:
21320 
          self.itemId = iprot.readI64();
21321 
        else:
21322 
          iprot.skip(ftype)
21323 
      else:
21324 
        iprot.skip(ftype)
21325 
      iprot.readFieldEnd()
21326 
    iprot.readStructEnd()
21327 
 
21328 
  def write(self, oprot):
21329 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21330 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21331 
      return
21332 
    oprot.writeStructBegin('getAmazonItemDetails_args')
21333 
    if self.itemId is not None:
21334 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
21335 
      oprot.writeI64(self.itemId)
21336 
      oprot.writeFieldEnd()
21337 
    oprot.writeFieldStop()
21338 
    oprot.writeStructEnd()
21339 
 
21340 
  def validate(self):
21341 
    return
21342 
 
21343 
 
21344 
  def __repr__(self):
21345 
    L = ['%s=%r' % (key, value)
21346 
      for key, value in self.__dict__.iteritems()]
21347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21348 
 
21349 
  def __eq__(self, other):
21350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21351 
 
21352 
  def __ne__(self, other):
21353 
    return not (self == other)
21354 
 
21355 
class getAmazonItemDetails_result:
21356 
  """
21357 
  Attributes:
21358 
   - success
21359 
  """
21360 
 
21361 
  thrift_spec = (
21362 
    (0, TType.STRUCT, 'success', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 0
21363 
  )
21364 
 
21365 
  def __init__(self, success=None,):
21366 
    self.success = success
21367 
 
21368 
  def read(self, iprot):
21369 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21370 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21371 
      return
21372 
    iprot.readStructBegin()
21373 
    while True:
21374 
      (fname, ftype, fid) = iprot.readFieldBegin()
21375 
      if ftype == TType.STOP:
21376 
        break
21377 
      if fid == 0:
21378 
        if ftype == TType.STRUCT:
21379 
          self.success = Amazonlisted()
21380 
          self.success.read(iprot)
21381 
        else:
21382 
          iprot.skip(ftype)
21383 
      else:
21384 
        iprot.skip(ftype)
21385 
      iprot.readFieldEnd()
21386 
    iprot.readStructEnd()
21387 
 
21388 
  def write(self, oprot):
21389 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21390 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21391 
      return
21392 
    oprot.writeStructBegin('getAmazonItemDetails_result')
21393 
    if self.success is not None:
21394 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21395 
      self.success.write(oprot)
21396 
      oprot.writeFieldEnd()
21397 
    oprot.writeFieldStop()
21398 
    oprot.writeStructEnd()
21399 
 
21400 
  def validate(self):
21401 
    return
21402 
 
21403 
 
21404 
  def __repr__(self):
21405 
    L = ['%s=%r' % (key, value)
21406 
      for key, value in self.__dict__.iteritems()]
21407 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21408 
 
21409 
  def __eq__(self, other):
21410 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21411 
 
21412 
  def __ne__(self, other):
21413 
    return not (self == other)
21414 
 
21415 
class updateAmazonItemDetails_args:
21416 
  """
21417 
  Attributes:
8168 kshitij.so 21418 
   - amazonlisted
7281 kshitij.so 21419 
  """
21420 
 
21421 
  thrift_spec = (
21422 
    None, # 0
8168 kshitij.so 21423 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
7281 kshitij.so 21424 
  )
21425 
 
8168 kshitij.so 21426 
  def __init__(self, amazonlisted=None,):
21427 
    self.amazonlisted = amazonlisted
7281 kshitij.so 21428 
 
21429 
  def read(self, iprot):
21430 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21431 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21432 
      return
21433 
    iprot.readStructBegin()
21434 
    while True:
21435 
      (fname, ftype, fid) = iprot.readFieldBegin()
21436 
      if ftype == TType.STOP:
21437 
        break
21438 
      if fid == 1:
8168 kshitij.so 21439 
        if ftype == TType.STRUCT:
21440 
          self.amazonlisted = Amazonlisted()
21441 
          self.amazonlisted.read(iprot)
7281 kshitij.so 21442 
        else:
21443 
          iprot.skip(ftype)
21444 
      else:
21445 
        iprot.skip(ftype)
21446 
      iprot.readFieldEnd()
21447 
    iprot.readStructEnd()
21448 
 
21449 
  def write(self, oprot):
21450 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21451 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21452 
      return
21453 
    oprot.writeStructBegin('updateAmazonItemDetails_args')
8168 kshitij.so 21454 
    if self.amazonlisted is not None:
21455 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
21456 
      self.amazonlisted.write(oprot)
7281 kshitij.so 21457 
      oprot.writeFieldEnd()
21458 
    oprot.writeFieldStop()
21459 
    oprot.writeStructEnd()
21460 
 
21461 
  def validate(self):
21462 
    return
21463 
 
21464 
 
21465 
  def __repr__(self):
21466 
    L = ['%s=%r' % (key, value)
21467 
      for key, value in self.__dict__.iteritems()]
21468 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21469 
 
21470 
  def __eq__(self, other):
21471 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21472 
 
21473 
  def __ne__(self, other):
21474 
    return not (self == other)
21475 
 
21476 
class updateAmazonItemDetails_result:
21477 
 
21478 
  thrift_spec = (
21479 
  )
21480 
 
21481 
  def read(self, iprot):
21482 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21483 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21484 
      return
21485 
    iprot.readStructBegin()
21486 
    while True:
21487 
      (fname, ftype, fid) = iprot.readFieldBegin()
21488 
      if ftype == TType.STOP:
21489 
        break
21490 
      else:
21491 
        iprot.skip(ftype)
21492 
      iprot.readFieldEnd()
21493 
    iprot.readStructEnd()
21494 
 
21495 
  def write(self, oprot):
21496 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21497 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21498 
      return
21499 
    oprot.writeStructBegin('updateAmazonItemDetails_result')
21500 
    oprot.writeFieldStop()
21501 
    oprot.writeStructEnd()
21502 
 
21503 
  def validate(self):
21504 
    return
21505 
 
21506 
 
21507 
  def __repr__(self):
21508 
    L = ['%s=%r' % (key, value)
21509 
      for key, value in self.__dict__.iteritems()]
21510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21511 
 
21512 
  def __eq__(self, other):
21513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21514 
 
21515 
  def __ne__(self, other):
21516 
    return not (self == other)
21517 
 
21518 
class addAmazonItem_args:
21519 
  """
21520 
  Attributes:
21521 
   - amazonlisted
21522 
  """
21523 
 
21524 
  thrift_spec = (
21525 
    None, # 0
21526 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
21527 
  )
21528 
 
21529 
  def __init__(self, amazonlisted=None,):
21530 
    self.amazonlisted = amazonlisted
21531 
 
21532 
  def read(self, iprot):
21533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21535 
      return
21536 
    iprot.readStructBegin()
21537 
    while True:
21538 
      (fname, ftype, fid) = iprot.readFieldBegin()
21539 
      if ftype == TType.STOP:
21540 
        break
21541 
      if fid == 1:
21542 
        if ftype == TType.STRUCT:
21543 
          self.amazonlisted = Amazonlisted()
21544 
          self.amazonlisted.read(iprot)
21545 
        else:
21546 
          iprot.skip(ftype)
21547 
      else:
21548 
        iprot.skip(ftype)
21549 
      iprot.readFieldEnd()
21550 
    iprot.readStructEnd()
21551 
 
21552 
  def write(self, oprot):
21553 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21554 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21555 
      return
21556 
    oprot.writeStructBegin('addAmazonItem_args')
21557 
    if self.amazonlisted is not None:
21558 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
21559 
      self.amazonlisted.write(oprot)
21560 
      oprot.writeFieldEnd()
21561 
    oprot.writeFieldStop()
21562 
    oprot.writeStructEnd()
21563 
 
21564 
  def validate(self):
21565 
    return
21566 
 
21567 
 
21568 
  def __repr__(self):
21569 
    L = ['%s=%r' % (key, value)
21570 
      for key, value in self.__dict__.iteritems()]
21571 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21572 
 
21573 
  def __eq__(self, other):
21574 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21575 
 
21576 
  def __ne__(self, other):
21577 
    return not (self == other)
21578 
 
21579 
class addAmazonItem_result:
21580 
 
21581 
  thrift_spec = (
21582 
  )
21583 
 
21584 
  def read(self, iprot):
21585 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21586 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21587 
      return
21588 
    iprot.readStructBegin()
21589 
    while True:
21590 
      (fname, ftype, fid) = iprot.readFieldBegin()
21591 
      if ftype == TType.STOP:
21592 
        break
21593 
      else:
21594 
        iprot.skip(ftype)
21595 
      iprot.readFieldEnd()
21596 
    iprot.readStructEnd()
21597 
 
21598 
  def write(self, oprot):
21599 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21600 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21601 
      return
21602 
    oprot.writeStructBegin('addAmazonItem_result')
21603 
    oprot.writeFieldStop()
21604 
    oprot.writeStructEnd()
21605 
 
21606 
  def validate(self):
21607 
    return
21608 
 
21609 
 
21610 
  def __repr__(self):
21611 
    L = ['%s=%r' % (key, value)
21612 
      for key, value in self.__dict__.iteritems()]
21613 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21614 
 
21615 
  def __eq__(self, other):
21616 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21617 
 
21618 
  def __ne__(self, other):
21619 
    return not (self == other)
7291 vikram.rag 21620 
 
21621 
class getAsinItems_args:
21622 
 
21623 
  thrift_spec = (
21624 
  )
21625 
 
21626 
  def read(self, iprot):
21627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21629 
      return
21630 
    iprot.readStructBegin()
21631 
    while True:
21632 
      (fname, ftype, fid) = iprot.readFieldBegin()
21633 
      if ftype == TType.STOP:
21634 
        break
21635 
      else:
21636 
        iprot.skip(ftype)
21637 
      iprot.readFieldEnd()
21638 
    iprot.readStructEnd()
21639 
 
21640 
  def write(self, oprot):
21641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21643 
      return
21644 
    oprot.writeStructBegin('getAsinItems_args')
21645 
    oprot.writeFieldStop()
21646 
    oprot.writeStructEnd()
21647 
 
21648 
  def validate(self):
21649 
    return
21650 
 
21651 
 
21652 
  def __repr__(self):
21653 
    L = ['%s=%r' % (key, value)
21654 
      for key, value in self.__dict__.iteritems()]
21655 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21656 
 
21657 
  def __eq__(self, other):
21658 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21659 
 
21660 
  def __ne__(self, other):
21661 
    return not (self == other)
21662 
 
21663 
class getAsinItems_result:
21664 
  """
21665 
  Attributes:
21666 
   - success
21667 
  """
21668 
 
21669 
  thrift_spec = (
21670 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
21671 
  )
21672 
 
21673 
  def __init__(self, success=None,):
21674 
    self.success = success
21675 
 
21676 
  def read(self, iprot):
21677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21679 
      return
21680 
    iprot.readStructBegin()
21681 
    while True:
21682 
      (fname, ftype, fid) = iprot.readFieldBegin()
21683 
      if ftype == TType.STOP:
21684 
        break
21685 
      if fid == 0:
21686 
        if ftype == TType.LIST:
21687 
          self.success = []
9155 kshitij.so 21688 
          (_etype442, _size439) = iprot.readListBegin()
21689 
          for _i443 in xrange(_size439):
21690 
            _elem444 = Item()
21691 
            _elem444.read(iprot)
21692 
            self.success.append(_elem444)
7291 vikram.rag 21693 
          iprot.readListEnd()
21694 
        else:
21695 
          iprot.skip(ftype)
21696 
      else:
21697 
        iprot.skip(ftype)
21698 
      iprot.readFieldEnd()
21699 
    iprot.readStructEnd()
21700 
 
21701 
  def write(self, oprot):
21702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21704 
      return
21705 
    oprot.writeStructBegin('getAsinItems_result')
21706 
    if self.success is not None:
21707 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21708 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21709 
      for iter445 in self.success:
21710 
        iter445.write(oprot)
7291 vikram.rag 21711 
      oprot.writeListEnd()
21712 
      oprot.writeFieldEnd()
21713 
    oprot.writeFieldStop()
21714 
    oprot.writeStructEnd()
21715 
 
21716 
  def validate(self):
21717 
    return
21718 
 
21719 
 
21720 
  def __repr__(self):
21721 
    L = ['%s=%r' % (key, value)
21722 
      for key, value in self.__dict__.iteritems()]
21723 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21724 
 
21725 
  def __eq__(self, other):
21726 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21727 
 
21728 
  def __ne__(self, other):
21729 
    return not (self == other)
21730 
 
21731 
class getAllFbaListedItems_args:
21732 
 
21733 
  thrift_spec = (
21734 
  )
21735 
 
21736 
  def read(self, iprot):
21737 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21738 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21739 
      return
21740 
    iprot.readStructBegin()
21741 
    while True:
21742 
      (fname, ftype, fid) = iprot.readFieldBegin()
21743 
      if ftype == TType.STOP:
21744 
        break
21745 
      else:
21746 
        iprot.skip(ftype)
21747 
      iprot.readFieldEnd()
21748 
    iprot.readStructEnd()
21749 
 
21750 
  def write(self, oprot):
21751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21753 
      return
21754 
    oprot.writeStructBegin('getAllFbaListedItems_args')
21755 
    oprot.writeFieldStop()
21756 
    oprot.writeStructEnd()
21757 
 
21758 
  def validate(self):
21759 
    return
21760 
 
21761 
 
21762 
  def __repr__(self):
21763 
    L = ['%s=%r' % (key, value)
21764 
      for key, value in self.__dict__.iteritems()]
21765 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21766 
 
21767 
  def __eq__(self, other):
21768 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21769 
 
21770 
  def __ne__(self, other):
21771 
    return not (self == other)
21772 
 
21773 
class getAllFbaListedItems_result:
21774 
  """
21775 
  Attributes:
21776 
   - success
21777 
  """
21778 
 
21779 
  thrift_spec = (
21780 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
21781 
  )
21782 
 
21783 
  def __init__(self, success=None,):
21784 
    self.success = success
21785 
 
21786 
  def read(self, iprot):
21787 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21788 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21789 
      return
21790 
    iprot.readStructBegin()
21791 
    while True:
21792 
      (fname, ftype, fid) = iprot.readFieldBegin()
21793 
      if ftype == TType.STOP:
21794 
        break
21795 
      if fid == 0:
21796 
        if ftype == TType.LIST:
21797 
          self.success = []
9155 kshitij.so 21798 
          (_etype449, _size446) = iprot.readListBegin()
21799 
          for _i450 in xrange(_size446):
21800 
            _elem451 = Amazonlisted()
21801 
            _elem451.read(iprot)
21802 
            self.success.append(_elem451)
7291 vikram.rag 21803 
          iprot.readListEnd()
21804 
        else:
21805 
          iprot.skip(ftype)
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('getAllFbaListedItems_result')
21816 
    if self.success is not None:
21817 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21818 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21819 
      for iter452 in self.success:
21820 
        iter452.write(oprot)
7291 vikram.rag 21821 
      oprot.writeListEnd()
21822 
      oprot.writeFieldEnd()
21823 
    oprot.writeFieldStop()
21824 
    oprot.writeStructEnd()
21825 
 
21826 
  def validate(self):
21827 
    return
21828 
 
21829 
 
21830 
  def __repr__(self):
21831 
    L = ['%s=%r' % (key, value)
21832 
      for key, value in self.__dict__.iteritems()]
21833 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21834 
 
21835 
  def __eq__(self, other):
21836 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21837 
 
21838 
  def __ne__(self, other):
21839 
    return not (self == other)
21840 
 
21841 
class getAllNonFbaListedItems_args:
21842 
 
21843 
  thrift_spec = (
21844 
  )
21845 
 
21846 
  def read(self, iprot):
21847 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21848 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21849 
      return
21850 
    iprot.readStructBegin()
21851 
    while True:
21852 
      (fname, ftype, fid) = iprot.readFieldBegin()
21853 
      if ftype == TType.STOP:
21854 
        break
21855 
      else:
21856 
        iprot.skip(ftype)
21857 
      iprot.readFieldEnd()
21858 
    iprot.readStructEnd()
21859 
 
21860 
  def write(self, oprot):
21861 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21862 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21863 
      return
21864 
    oprot.writeStructBegin('getAllNonFbaListedItems_args')
21865 
    oprot.writeFieldStop()
21866 
    oprot.writeStructEnd()
21867 
 
21868 
  def validate(self):
21869 
    return
21870 
 
21871 
 
21872 
  def __repr__(self):
21873 
    L = ['%s=%r' % (key, value)
21874 
      for key, value in self.__dict__.iteritems()]
21875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21876 
 
21877 
  def __eq__(self, other):
21878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21879 
 
21880 
  def __ne__(self, other):
21881 
    return not (self == other)
21882 
 
21883 
class getAllNonFbaListedItems_result:
21884 
  """
21885 
  Attributes:
21886 
   - success
21887 
  """
21888 
 
21889 
  thrift_spec = (
21890 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
21891 
  )
21892 
 
21893 
  def __init__(self, success=None,):
21894 
    self.success = success
21895 
 
21896 
  def read(self, iprot):
21897 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21898 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21899 
      return
21900 
    iprot.readStructBegin()
21901 
    while True:
21902 
      (fname, ftype, fid) = iprot.readFieldBegin()
21903 
      if ftype == TType.STOP:
21904 
        break
21905 
      if fid == 0:
21906 
        if ftype == TType.LIST:
21907 
          self.success = []
9155 kshitij.so 21908 
          (_etype456, _size453) = iprot.readListBegin()
21909 
          for _i457 in xrange(_size453):
21910 
            _elem458 = Amazonlisted()
21911 
            _elem458.read(iprot)
21912 
            self.success.append(_elem458)
7291 vikram.rag 21913 
          iprot.readListEnd()
21914 
        else:
21915 
          iprot.skip(ftype)
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('getAllNonFbaListedItems_result')
21926 
    if self.success is not None:
21927 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21928 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21929 
      for iter459 in self.success:
21930 
        iter459.write(oprot)
7291 vikram.rag 21931 
      oprot.writeListEnd()
21932 
      oprot.writeFieldEnd()
21933 
    oprot.writeFieldStop()
21934 
    oprot.writeStructEnd()
21935 
 
21936 
  def validate(self):
21937 
    return
21938 
 
21939 
 
21940 
  def __repr__(self):
21941 
    L = ['%s=%r' % (key, value)
21942 
      for key, value in self.__dict__.iteritems()]
21943 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21944 
 
21945 
  def __eq__(self, other):
21946 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21947 
 
21948 
  def __ne__(self, other):
21949 
    return not (self == other)
7460 kshitij.so 21950 
 
21951 
class updateItemInventory_args:
21952 
  """
21953 
  Attributes:
21954 
   - itemId
21955 
   - holdInventory
21956 
   - defaultInventory
21957 
  """
21958 
 
21959 
  thrift_spec = (
21960 
    None, # 0
21961 
    (1, TType.I64, 'itemId', None, None, ), # 1
21962 
    (2, TType.I64, 'holdInventory', None, None, ), # 2
21963 
    (3, TType.I64, 'defaultInventory', None, None, ), # 3
21964 
  )
21965 
 
21966 
  def __init__(self, itemId=None, holdInventory=None, defaultInventory=None,):
21967 
    self.itemId = itemId
21968 
    self.holdInventory = holdInventory
21969 
    self.defaultInventory = defaultInventory
21970 
 
21971 
  def read(self, iprot):
21972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21974 
      return
21975 
    iprot.readStructBegin()
21976 
    while True:
21977 
      (fname, ftype, fid) = iprot.readFieldBegin()
21978 
      if ftype == TType.STOP:
21979 
        break
21980 
      if fid == 1:
21981 
        if ftype == TType.I64:
21982 
          self.itemId = iprot.readI64();
21983 
        else:
21984 
          iprot.skip(ftype)
21985 
      elif fid == 2:
21986 
        if ftype == TType.I64:
21987 
          self.holdInventory = iprot.readI64();
21988 
        else:
21989 
          iprot.skip(ftype)
21990 
      elif fid == 3:
21991 
        if ftype == TType.I64:
21992 
          self.defaultInventory = iprot.readI64();
21993 
        else:
21994 
          iprot.skip(ftype)
21995 
      else:
21996 
        iprot.skip(ftype)
21997 
      iprot.readFieldEnd()
21998 
    iprot.readStructEnd()
21999 
 
22000 
  def write(self, oprot):
22001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22003 
      return
22004 
    oprot.writeStructBegin('updateItemInventory_args')
22005 
    if self.itemId is not None:
22006 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
22007 
      oprot.writeI64(self.itemId)
22008 
      oprot.writeFieldEnd()
22009 
    if self.holdInventory is not None:
22010 
      oprot.writeFieldBegin('holdInventory', TType.I64, 2)
22011 
      oprot.writeI64(self.holdInventory)
22012 
      oprot.writeFieldEnd()
22013 
    if self.defaultInventory is not None:
22014 
      oprot.writeFieldBegin('defaultInventory', TType.I64, 3)
22015 
      oprot.writeI64(self.defaultInventory)
22016 
      oprot.writeFieldEnd()
22017 
    oprot.writeFieldStop()
22018 
    oprot.writeStructEnd()
22019 
 
22020 
  def validate(self):
22021 
    return
22022 
 
22023 
 
22024 
  def __repr__(self):
22025 
    L = ['%s=%r' % (key, value)
22026 
      for key, value in self.__dict__.iteritems()]
22027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22028 
 
22029 
  def __eq__(self, other):
22030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22031 
 
22032 
  def __ne__(self, other):
22033 
    return not (self == other)
22034 
 
22035 
class updateItemInventory_result:
22036 
  """
22037 
  Attributes:
22038 
   - success
22039 
  """
22040 
 
22041 
  thrift_spec = (
22042 
    (0, TType.BOOL, 'success', None, None, ), # 0
22043 
  )
22044 
 
22045 
  def __init__(self, success=None,):
22046 
    self.success = success
22047 
 
22048 
  def read(self, iprot):
22049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22051 
      return
22052 
    iprot.readStructBegin()
22053 
    while True:
22054 
      (fname, ftype, fid) = iprot.readFieldBegin()
22055 
      if ftype == TType.STOP:
22056 
        break
22057 
      if fid == 0:
22058 
        if ftype == TType.BOOL:
22059 
          self.success = iprot.readBool();
22060 
        else:
22061 
          iprot.skip(ftype)
22062 
      else:
22063 
        iprot.skip(ftype)
22064 
      iprot.readFieldEnd()
22065 
    iprot.readStructEnd()
22066 
 
22067 
  def write(self, oprot):
22068 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22069 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22070 
      return
22071 
    oprot.writeStructBegin('updateItemInventory_result')
22072 
    if self.success is not None:
22073 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22074 
      oprot.writeBool(self.success)
22075 
      oprot.writeFieldEnd()
22076 
    oprot.writeFieldStop()
22077 
    oprot.writeStructEnd()
22078 
 
22079 
  def validate(self):
22080 
    return
22081 
 
22082 
 
22083 
  def __repr__(self):
22084 
    L = ['%s=%r' % (key, value)
22085 
      for key, value in self.__dict__.iteritems()]
22086 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22087 
 
22088 
  def __eq__(self, other):
22089 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22090 
 
22091 
  def __ne__(self, other):
22092 
    return not (self == other)
7770 kshitij.so 22093 
 
22094 
class updateTimestampForAmazonFeeds_args:
22095 
  """
22096 
  Attributes:
22097 
   - type
22098 
   - sku
22099 
   - timestamp
22100 
  """
22101 
 
22102 
  thrift_spec = (
22103 
    None, # 0
22104 
    (1, TType.STRING, 'type', None, None, ), # 1
22105 
    (2, TType.LIST, 'sku', (TType.I64,None), None, ), # 2
22106 
    (3, TType.I64, 'timestamp', None, None, ), # 3
22107 
  )
22108 
 
22109 
  def __init__(self, type=None, sku=None, timestamp=None,):
22110 
    self.type = type
22111 
    self.sku = sku
22112 
    self.timestamp = timestamp
22113 
 
22114 
  def read(self, iprot):
22115 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22116 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22117 
      return
22118 
    iprot.readStructBegin()
22119 
    while True:
22120 
      (fname, ftype, fid) = iprot.readFieldBegin()
22121 
      if ftype == TType.STOP:
22122 
        break
22123 
      if fid == 1:
22124 
        if ftype == TType.STRING:
22125 
          self.type = iprot.readString();
22126 
        else:
22127 
          iprot.skip(ftype)
22128 
      elif fid == 2:
22129 
        if ftype == TType.LIST:
22130 
          self.sku = []
9155 kshitij.so 22131 
          (_etype463, _size460) = iprot.readListBegin()
22132 
          for _i464 in xrange(_size460):
22133 
            _elem465 = iprot.readI64();
22134 
            self.sku.append(_elem465)
7770 kshitij.so 22135 
          iprot.readListEnd()
22136 
        else:
22137 
          iprot.skip(ftype)
22138 
      elif fid == 3:
22139 
        if ftype == TType.I64:
22140 
          self.timestamp = iprot.readI64();
22141 
        else:
22142 
          iprot.skip(ftype)
22143 
      else:
22144 
        iprot.skip(ftype)
22145 
      iprot.readFieldEnd()
22146 
    iprot.readStructEnd()
22147 
 
22148 
  def write(self, oprot):
22149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22151 
      return
22152 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_args')
22153 
    if self.type is not None:
22154 
      oprot.writeFieldBegin('type', TType.STRING, 1)
22155 
      oprot.writeString(self.type)
22156 
      oprot.writeFieldEnd()
22157 
    if self.sku is not None:
22158 
      oprot.writeFieldBegin('sku', TType.LIST, 2)
22159 
      oprot.writeListBegin(TType.I64, len(self.sku))
9155 kshitij.so 22160 
      for iter466 in self.sku:
22161 
        oprot.writeI64(iter466)
7770 kshitij.so 22162 
      oprot.writeListEnd()
22163 
      oprot.writeFieldEnd()
22164 
    if self.timestamp is not None:
22165 
      oprot.writeFieldBegin('timestamp', TType.I64, 3)
22166 
      oprot.writeI64(self.timestamp)
22167 
      oprot.writeFieldEnd()
22168 
    oprot.writeFieldStop()
22169 
    oprot.writeStructEnd()
22170 
 
22171 
  def validate(self):
22172 
    return
22173 
 
22174 
 
22175 
  def __repr__(self):
22176 
    L = ['%s=%r' % (key, value)
22177 
      for key, value in self.__dict__.iteritems()]
22178 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22179 
 
22180 
  def __eq__(self, other):
22181 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22182 
 
22183 
  def __ne__(self, other):
22184 
    return not (self == other)
22185 
 
22186 
class updateTimestampForAmazonFeeds_result:
22187 
  """
22188 
  Attributes:
22189 
   - success
22190 
  """
22191 
 
22192 
  thrift_spec = (
22193 
    (0, TType.BOOL, 'success', None, None, ), # 0
22194 
  )
22195 
 
22196 
  def __init__(self, success=None,):
22197 
    self.success = success
22198 
 
22199 
  def read(self, iprot):
22200 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22201 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22202 
      return
22203 
    iprot.readStructBegin()
22204 
    while True:
22205 
      (fname, ftype, fid) = iprot.readFieldBegin()
22206 
      if ftype == TType.STOP:
22207 
        break
22208 
      if fid == 0:
22209 
        if ftype == TType.BOOL:
22210 
          self.success = iprot.readBool();
22211 
        else:
22212 
          iprot.skip(ftype)
22213 
      else:
22214 
        iprot.skip(ftype)
22215 
      iprot.readFieldEnd()
22216 
    iprot.readStructEnd()
22217 
 
22218 
  def write(self, oprot):
22219 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22220 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22221 
      return
22222 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_result')
22223 
    if self.success is not None:
22224 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22225 
      oprot.writeBool(self.success)
22226 
      oprot.writeFieldEnd()
22227 
    oprot.writeFieldStop()
22228 
    oprot.writeStructEnd()
22229 
 
22230 
  def validate(self):
22231 
    return
22232 
 
22233 
 
22234 
  def __repr__(self):
22235 
    L = ['%s=%r' % (key, value)
22236 
      for key, value in self.__dict__.iteritems()]
22237 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22238 
 
22239 
  def __eq__(self, other):
22240 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22241 
 
22242 
  def __ne__(self, other):
22243 
    return not (self == other)
7897 amar.kumar 22244 
 
22245 
class getAllParentCategories_args:
22246 
 
22247 
  thrift_spec = (
22248 
  )
22249 
 
22250 
  def read(self, iprot):
22251 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22252 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22253 
      return
22254 
    iprot.readStructBegin()
22255 
    while True:
22256 
      (fname, ftype, fid) = iprot.readFieldBegin()
22257 
      if ftype == TType.STOP:
22258 
        break
22259 
      else:
22260 
        iprot.skip(ftype)
22261 
      iprot.readFieldEnd()
22262 
    iprot.readStructEnd()
22263 
 
22264 
  def write(self, oprot):
22265 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22266 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22267 
      return
22268 
    oprot.writeStructBegin('getAllParentCategories_args')
22269 
    oprot.writeFieldStop()
22270 
    oprot.writeStructEnd()
22271 
 
22272 
  def validate(self):
22273 
    return
22274 
 
22275 
 
22276 
  def __repr__(self):
22277 
    L = ['%s=%r' % (key, value)
22278 
      for key, value in self.__dict__.iteritems()]
22279 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22280 
 
22281 
  def __eq__(self, other):
22282 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22283 
 
22284 
  def __ne__(self, other):
22285 
    return not (self == other)
22286 
 
22287 
class getAllParentCategories_result:
22288 
  """
22289 
  Attributes:
22290 
   - success
22291 
  """
22292 
 
22293 
  thrift_spec = (
22294 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
22295 
  )
22296 
 
22297 
  def __init__(self, success=None,):
22298 
    self.success = success
22299 
 
22300 
  def read(self, iprot):
22301 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22302 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22303 
      return
22304 
    iprot.readStructBegin()
22305 
    while True:
22306 
      (fname, ftype, fid) = iprot.readFieldBegin()
22307 
      if ftype == TType.STOP:
22308 
        break
22309 
      if fid == 0:
22310 
        if ftype == TType.LIST:
22311 
          self.success = []
9155 kshitij.so 22312 
          (_etype470, _size467) = iprot.readListBegin()
22313 
          for _i471 in xrange(_size467):
22314 
            _elem472 = Category()
22315 
            _elem472.read(iprot)
22316 
            self.success.append(_elem472)
7897 amar.kumar 22317 
          iprot.readListEnd()
22318 
        else:
22319 
          iprot.skip(ftype)
22320 
      else:
22321 
        iprot.skip(ftype)
22322 
      iprot.readFieldEnd()
22323 
    iprot.readStructEnd()
22324 
 
22325 
  def write(self, oprot):
22326 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22327 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22328 
      return
22329 
    oprot.writeStructBegin('getAllParentCategories_result')
22330 
    if self.success is not None:
22331 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22332 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22333 
      for iter473 in self.success:
22334 
        iter473.write(oprot)
7897 amar.kumar 22335 
      oprot.writeListEnd()
22336 
      oprot.writeFieldEnd()
22337 
    oprot.writeFieldStop()
22338 
    oprot.writeStructEnd()
22339 
 
22340 
  def validate(self):
22341 
    return
22342 
 
22343 
 
22344 
  def __repr__(self):
22345 
    L = ['%s=%r' % (key, value)
22346 
      for key, value in self.__dict__.iteritems()]
22347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22348 
 
22349 
  def __eq__(self, other):
22350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22351 
 
22352 
  def __ne__(self, other):
22353 
    return not (self == other)
7977 kshitij.so 22354 
 
22355 
class addPageViewEvent_args:
22356 
  """
22357 
  Attributes:
22358 
   - pageViewEvents
22359 
  """
22360 
 
22361 
  thrift_spec = (
22362 
    None, # 0
22363 
    (1, TType.STRUCT, 'pageViewEvents', (PageViewEvents, PageViewEvents.thrift_spec), None, ), # 1
22364 
  )
22365 
 
22366 
  def __init__(self, pageViewEvents=None,):
22367 
    self.pageViewEvents = pageViewEvents
22368 
 
22369 
  def read(self, iprot):
22370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22372 
      return
22373 
    iprot.readStructBegin()
22374 
    while True:
22375 
      (fname, ftype, fid) = iprot.readFieldBegin()
22376 
      if ftype == TType.STOP:
22377 
        break
22378 
      if fid == 1:
22379 
        if ftype == TType.STRUCT:
22380 
          self.pageViewEvents = PageViewEvents()
22381 
          self.pageViewEvents.read(iprot)
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('addPageViewEvent_args')
22394 
    if self.pageViewEvents is not None:
22395 
      oprot.writeFieldBegin('pageViewEvents', TType.STRUCT, 1)
22396 
      self.pageViewEvents.write(oprot)
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)
22415 
 
22416 
class addPageViewEvent_result:
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('addPageViewEvent_result')
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 addCartEvent_args:
22459 
  """
22460 
  Attributes:
22461 
   - cartEvents
22462 
  """
22463 
 
22464 
  thrift_spec = (
22465 
    None, # 0
22466 
    (1, TType.STRUCT, 'cartEvents', (CartEvents, CartEvents.thrift_spec), None, ), # 1
22467 
  )
22468 
 
22469 
  def __init__(self, cartEvents=None,):
22470 
    self.cartEvents = cartEvents
22471 
 
22472 
  def read(self, iprot):
22473 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22474 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22475 
      return
22476 
    iprot.readStructBegin()
22477 
    while True:
22478 
      (fname, ftype, fid) = iprot.readFieldBegin()
22479 
      if ftype == TType.STOP:
22480 
        break
22481 
      if fid == 1:
22482 
        if ftype == TType.STRUCT:
22483 
          self.cartEvents = CartEvents()
22484 
          self.cartEvents.read(iprot)
22485 
        else:
22486 
          iprot.skip(ftype)
22487 
      else:
22488 
        iprot.skip(ftype)
22489 
      iprot.readFieldEnd()
22490 
    iprot.readStructEnd()
22491 
 
22492 
  def write(self, oprot):
22493 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22494 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22495 
      return
22496 
    oprot.writeStructBegin('addCartEvent_args')
22497 
    if self.cartEvents is not None:
22498 
      oprot.writeFieldBegin('cartEvents', TType.STRUCT, 1)
22499 
      self.cartEvents.write(oprot)
22500 
      oprot.writeFieldEnd()
22501 
    oprot.writeFieldStop()
22502 
    oprot.writeStructEnd()
22503 
 
22504 
  def validate(self):
22505 
    return
22506 
 
22507 
 
22508 
  def __repr__(self):
22509 
    L = ['%s=%r' % (key, value)
22510 
      for key, value in self.__dict__.iteritems()]
22511 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22512 
 
22513 
  def __eq__(self, other):
22514 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22515 
 
22516 
  def __ne__(self, other):
22517 
    return not (self == other)
22518 
 
22519 
class addCartEvent_result:
22520 
 
22521 
  thrift_spec = (
22522 
  )
22523 
 
22524 
  def read(self, iprot):
22525 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22526 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22527 
      return
22528 
    iprot.readStructBegin()
22529 
    while True:
22530 
      (fname, ftype, fid) = iprot.readFieldBegin()
22531 
      if ftype == TType.STOP:
22532 
        break
22533 
      else:
22534 
        iprot.skip(ftype)
22535 
      iprot.readFieldEnd()
22536 
    iprot.readStructEnd()
22537 
 
22538 
  def write(self, oprot):
22539 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22540 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22541 
      return
22542 
    oprot.writeStructBegin('addCartEvent_result')
22543 
    oprot.writeFieldStop()
22544 
    oprot.writeStructEnd()
22545 
 
22546 
  def validate(self):
22547 
    return
22548 
 
22549 
 
22550 
  def __repr__(self):
22551 
    L = ['%s=%r' % (key, value)
22552 
      for key, value in self.__dict__.iteritems()]
22553 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22554 
 
22555 
  def __eq__(self, other):
22556 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22557 
 
22558 
  def __ne__(self, other):
22559 
    return not (self == other)
8139 kshitij.so 22560 
 
8182 amar.kumar 22561 
class addEbayItem_args:
22562 
  """
22563 
  Attributes:
22564 
   - ebayItem
22565 
  """
22566 
 
22567 
  thrift_spec = (
22568 
    None, # 0
22569 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
22570 
  )
22571 
 
22572 
  def __init__(self, ebayItem=None,):
22573 
    self.ebayItem = ebayItem
22574 
 
22575 
  def read(self, iprot):
22576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22578 
      return
22579 
    iprot.readStructBegin()
22580 
    while True:
22581 
      (fname, ftype, fid) = iprot.readFieldBegin()
22582 
      if ftype == TType.STOP:
22583 
        break
22584 
      if fid == 1:
22585 
        if ftype == TType.STRUCT:
22586 
          self.ebayItem = EbayItem()
22587 
          self.ebayItem.read(iprot)
22588 
        else:
22589 
          iprot.skip(ftype)
22590 
      else:
22591 
        iprot.skip(ftype)
22592 
      iprot.readFieldEnd()
22593 
    iprot.readStructEnd()
22594 
 
22595 
  def write(self, oprot):
22596 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22597 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22598 
      return
22599 
    oprot.writeStructBegin('addEbayItem_args')
22600 
    if self.ebayItem is not None:
22601 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
22602 
      self.ebayItem.write(oprot)
22603 
      oprot.writeFieldEnd()
22604 
    oprot.writeFieldStop()
22605 
    oprot.writeStructEnd()
22606 
 
22607 
  def validate(self):
22608 
    return
22609 
 
22610 
 
22611 
  def __repr__(self):
22612 
    L = ['%s=%r' % (key, value)
22613 
      for key, value in self.__dict__.iteritems()]
22614 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22615 
 
22616 
  def __eq__(self, other):
22617 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22618 
 
22619 
  def __ne__(self, other):
22620 
    return not (self == other)
22621 
 
22622 
class addEbayItem_result:
22623 
 
22624 
  thrift_spec = (
22625 
  )
22626 
 
22627 
  def read(self, iprot):
22628 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22629 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22630 
      return
22631 
    iprot.readStructBegin()
22632 
    while True:
22633 
      (fname, ftype, fid) = iprot.readFieldBegin()
22634 
      if ftype == TType.STOP:
22635 
        break
22636 
      else:
22637 
        iprot.skip(ftype)
22638 
      iprot.readFieldEnd()
22639 
    iprot.readStructEnd()
22640 
 
22641 
  def write(self, oprot):
22642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22644 
      return
22645 
    oprot.writeStructBegin('addEbayItem_result')
22646 
    oprot.writeFieldStop()
22647 
    oprot.writeStructEnd()
22648 
 
22649 
  def validate(self):
22650 
    return
22651 
 
22652 
 
22653 
  def __repr__(self):
22654 
    L = ['%s=%r' % (key, value)
22655 
      for key, value in self.__dict__.iteritems()]
22656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22657 
 
22658 
  def __eq__(self, other):
22659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22660 
 
22661 
  def __ne__(self, other):
22662 
    return not (self == other)
22663 
 
22664 
class getEbayItem_args:
22665 
  """
22666 
  Attributes:
22667 
   - listingId
22668 
  """
22669 
 
22670 
  thrift_spec = (
22671 
    None, # 0
22672 
    (1, TType.STRING, 'listingId', None, None, ), # 1
22673 
  )
22674 
 
22675 
  def __init__(self, listingId=None,):
22676 
    self.listingId = listingId
22677 
 
22678 
  def read(self, iprot):
22679 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22680 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22681 
      return
22682 
    iprot.readStructBegin()
22683 
    while True:
22684 
      (fname, ftype, fid) = iprot.readFieldBegin()
22685 
      if ftype == TType.STOP:
22686 
        break
22687 
      if fid == 1:
22688 
        if ftype == TType.STRING:
22689 
          self.listingId = iprot.readString();
22690 
        else:
22691 
          iprot.skip(ftype)
22692 
      else:
22693 
        iprot.skip(ftype)
22694 
      iprot.readFieldEnd()
22695 
    iprot.readStructEnd()
22696 
 
22697 
  def write(self, oprot):
22698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22700 
      return
22701 
    oprot.writeStructBegin('getEbayItem_args')
22702 
    if self.listingId is not None:
22703 
      oprot.writeFieldBegin('listingId', TType.STRING, 1)
22704 
      oprot.writeString(self.listingId)
22705 
      oprot.writeFieldEnd()
22706 
    oprot.writeFieldStop()
22707 
    oprot.writeStructEnd()
22708 
 
22709 
  def validate(self):
22710 
    return
22711 
 
22712 
 
22713 
  def __repr__(self):
22714 
    L = ['%s=%r' % (key, value)
22715 
      for key, value in self.__dict__.iteritems()]
22716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22717 
 
22718 
  def __eq__(self, other):
22719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22720 
 
22721 
  def __ne__(self, other):
22722 
    return not (self == other)
22723 
 
22724 
class getEbayItem_result:
22725 
  """
22726 
  Attributes:
22727 
   - success
22728 
  """
22729 
 
22730 
  thrift_spec = (
22731 
    (0, TType.STRUCT, 'success', (EbayItem, EbayItem.thrift_spec), None, ), # 0
22732 
  )
22733 
 
22734 
  def __init__(self, success=None,):
22735 
    self.success = success
22736 
 
22737 
  def read(self, iprot):
22738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22740 
      return
22741 
    iprot.readStructBegin()
22742 
    while True:
22743 
      (fname, ftype, fid) = iprot.readFieldBegin()
22744 
      if ftype == TType.STOP:
22745 
        break
22746 
      if fid == 0:
22747 
        if ftype == TType.STRUCT:
22748 
          self.success = EbayItem()
22749 
          self.success.read(iprot)
22750 
        else:
22751 
          iprot.skip(ftype)
22752 
      else:
22753 
        iprot.skip(ftype)
22754 
      iprot.readFieldEnd()
22755 
    iprot.readStructEnd()
22756 
 
22757 
  def write(self, oprot):
22758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22760 
      return
22761 
    oprot.writeStructBegin('getEbayItem_result')
22762 
    if self.success is not None:
22763 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22764 
      self.success.write(oprot)
22765 
      oprot.writeFieldEnd()
22766 
    oprot.writeFieldStop()
22767 
    oprot.writeStructEnd()
22768 
 
22769 
  def validate(self):
22770 
    return
22771 
 
22772 
 
22773 
  def __repr__(self):
22774 
    L = ['%s=%r' % (key, value)
22775 
      for key, value in self.__dict__.iteritems()]
22776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22777 
 
22778 
  def __eq__(self, other):
22779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22780 
 
22781 
  def __ne__(self, other):
22782 
    return not (self == other)
22783 
 
22784 
class updateEbayItem_args:
22785 
  """
22786 
  Attributes:
22787 
   - ebayItem
22788 
  """
22789 
 
22790 
  thrift_spec = (
22791 
    None, # 0
22792 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
22793 
  )
22794 
 
22795 
  def __init__(self, ebayItem=None,):
22796 
    self.ebayItem = ebayItem
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 
      if fid == 1:
22808 
        if ftype == TType.STRUCT:
22809 
          self.ebayItem = EbayItem()
22810 
          self.ebayItem.read(iprot)
22811 
        else:
22812 
          iprot.skip(ftype)
22813 
      else:
22814 
        iprot.skip(ftype)
22815 
      iprot.readFieldEnd()
22816 
    iprot.readStructEnd()
22817 
 
22818 
  def write(self, oprot):
22819 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22820 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22821 
      return
22822 
    oprot.writeStructBegin('updateEbayItem_args')
22823 
    if self.ebayItem is not None:
22824 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
22825 
      self.ebayItem.write(oprot)
22826 
      oprot.writeFieldEnd()
22827 
    oprot.writeFieldStop()
22828 
    oprot.writeStructEnd()
22829 
 
22830 
  def validate(self):
22831 
    return
22832 
 
22833 
 
22834 
  def __repr__(self):
22835 
    L = ['%s=%r' % (key, value)
22836 
      for key, value in self.__dict__.iteritems()]
22837 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22838 
 
22839 
  def __eq__(self, other):
22840 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22841 
 
22842 
  def __ne__(self, other):
22843 
    return not (self == other)
22844 
 
22845 
class updateEbayItem_result:
22846 
 
22847 
  thrift_spec = (
22848 
  )
22849 
 
22850 
  def read(self, iprot):
22851 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22852 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22853 
      return
22854 
    iprot.readStructBegin()
22855 
    while True:
22856 
      (fname, ftype, fid) = iprot.readFieldBegin()
22857 
      if ftype == TType.STOP:
22858 
        break
22859 
      else:
22860 
        iprot.skip(ftype)
22861 
      iprot.readFieldEnd()
22862 
    iprot.readStructEnd()
22863 
 
22864 
  def write(self, oprot):
22865 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22866 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22867 
      return
22868 
    oprot.writeStructBegin('updateEbayItem_result')
22869 
    oprot.writeFieldStop()
22870 
    oprot.writeStructEnd()
22871 
 
22872 
  def validate(self):
22873 
    return
22874 
 
22875 
 
22876 
  def __repr__(self):
22877 
    L = ['%s=%r' % (key, value)
22878 
      for key, value in self.__dict__.iteritems()]
22879 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22880 
 
22881 
  def __eq__(self, other):
22882 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22883 
 
22884 
  def __ne__(self, other):
22885 
    return not (self == other)
22886 
 
8139 kshitij.so 22887 
class getAmazonListedItems_args:
22888 
  """
22889 
  Attributes:
22890 
   - offset
22891 
   - limit
22892 
  """
22893 
 
22894 
  thrift_spec = (
22895 
    None, # 0
22896 
    (1, TType.I64, 'offset', None, None, ), # 1
22897 
    (2, TType.I64, 'limit', None, None, ), # 2
22898 
  )
22899 
 
22900 
  def __init__(self, offset=None, limit=None,):
22901 
    self.offset = offset
22902 
    self.limit = limit
22903 
 
22904 
  def read(self, iprot):
22905 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22906 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22907 
      return
22908 
    iprot.readStructBegin()
22909 
    while True:
22910 
      (fname, ftype, fid) = iprot.readFieldBegin()
22911 
      if ftype == TType.STOP:
22912 
        break
22913 
      if fid == 1:
22914 
        if ftype == TType.I64:
22915 
          self.offset = iprot.readI64();
22916 
        else:
22917 
          iprot.skip(ftype)
22918 
      elif fid == 2:
22919 
        if ftype == TType.I64:
22920 
          self.limit = iprot.readI64();
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('getAmazonListedItems_args')
22933 
    if self.offset is not None:
22934 
      oprot.writeFieldBegin('offset', TType.I64, 1)
22935 
      oprot.writeI64(self.offset)
22936 
      oprot.writeFieldEnd()
22937 
    if self.limit is not None:
22938 
      oprot.writeFieldBegin('limit', TType.I64, 2)
22939 
      oprot.writeI64(self.limit)
22940 
      oprot.writeFieldEnd()
22941 
    oprot.writeFieldStop()
22942 
    oprot.writeStructEnd()
22943 
 
22944 
  def validate(self):
22945 
    return
22946 
 
22947 
 
22948 
  def __repr__(self):
22949 
    L = ['%s=%r' % (key, value)
22950 
      for key, value in self.__dict__.iteritems()]
22951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22952 
 
22953 
  def __eq__(self, other):
22954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22955 
 
22956 
  def __ne__(self, other):
22957 
    return not (self == other)
22958 
 
22959 
class getAmazonListedItems_result:
22960 
  """
22961 
  Attributes:
22962 
   - success
22963 
  """
22964 
 
22965 
  thrift_spec = (
22966 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
22967 
  )
22968 
 
22969 
  def __init__(self, success=None,):
22970 
    self.success = success
22971 
 
22972 
  def read(self, iprot):
22973 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22974 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22975 
      return
22976 
    iprot.readStructBegin()
22977 
    while True:
22978 
      (fname, ftype, fid) = iprot.readFieldBegin()
22979 
      if ftype == TType.STOP:
22980 
        break
22981 
      if fid == 0:
22982 
        if ftype == TType.LIST:
22983 
          self.success = []
9155 kshitij.so 22984 
          (_etype477, _size474) = iprot.readListBegin()
22985 
          for _i478 in xrange(_size474):
22986 
            _elem479 = Amazonlisted()
22987 
            _elem479.read(iprot)
22988 
            self.success.append(_elem479)
8139 kshitij.so 22989 
          iprot.readListEnd()
22990 
        else:
22991 
          iprot.skip(ftype)
22992 
      else:
22993 
        iprot.skip(ftype)
22994 
      iprot.readFieldEnd()
22995 
    iprot.readStructEnd()
22996 
 
22997 
  def write(self, oprot):
22998 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22999 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23000 
      return
23001 
    oprot.writeStructBegin('getAmazonListedItems_result')
23002 
    if self.success is not None:
23003 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23004 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 23005 
      for iter480 in self.success:
23006 
        iter480.write(oprot)
8139 kshitij.so 23007 
      oprot.writeListEnd()
23008 
      oprot.writeFieldEnd()
23009 
    oprot.writeFieldStop()
23010 
    oprot.writeStructEnd()
23011 
 
23012 
  def validate(self):
23013 
    return
23014 
 
23015 
 
23016 
  def __repr__(self):
23017 
    L = ['%s=%r' % (key, value)
23018 
      for key, value in self.__dict__.iteritems()]
23019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23020 
 
23021 
  def __eq__(self, other):
23022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23023 
 
23024 
  def __ne__(self, other):
23025 
    return not (self == other)
8168 kshitij.so 23026 
 
23027 
class updateAmazonAttributesInBulk_args:
23028 
  """
23029 
  Attributes:
23030 
   - amazonlisted
23031 
  """
23032 
 
23033 
  thrift_spec = (
23034 
    None, # 0
23035 
    (1, TType.MAP, 'amazonlisted', (TType.I64,None,TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 1
23036 
  )
23037 
 
23038 
  def __init__(self, amazonlisted=None,):
23039 
    self.amazonlisted = amazonlisted
23040 
 
23041 
  def read(self, iprot):
23042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23044 
      return
23045 
    iprot.readStructBegin()
23046 
    while True:
23047 
      (fname, ftype, fid) = iprot.readFieldBegin()
23048 
      if ftype == TType.STOP:
23049 
        break
23050 
      if fid == 1:
23051 
        if ftype == TType.MAP:
23052 
          self.amazonlisted = {}
9155 kshitij.so 23053 
          (_ktype482, _vtype483, _size481 ) = iprot.readMapBegin()
23054 
          for _i485 in xrange(_size481):
23055 
            _key486 = iprot.readI64();
23056 
            _val487 = Amazonlisted()
23057 
            _val487.read(iprot)
23058 
            self.amazonlisted[_key486] = _val487
8168 kshitij.so 23059 
          iprot.readMapEnd()
23060 
        else:
23061 
          iprot.skip(ftype)
23062 
      else:
23063 
        iprot.skip(ftype)
23064 
      iprot.readFieldEnd()
23065 
    iprot.readStructEnd()
23066 
 
23067 
  def write(self, oprot):
23068 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23069 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23070 
      return
23071 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_args')
23072 
    if self.amazonlisted is not None:
23073 
      oprot.writeFieldBegin('amazonlisted', TType.MAP, 1)
23074 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.amazonlisted))
9155 kshitij.so 23075 
      for kiter488,viter489 in self.amazonlisted.items():
23076 
        oprot.writeI64(kiter488)
23077 
        viter489.write(oprot)
8168 kshitij.so 23078 
      oprot.writeMapEnd()
23079 
      oprot.writeFieldEnd()
23080 
    oprot.writeFieldStop()
23081 
    oprot.writeStructEnd()
23082 
 
23083 
  def validate(self):
23084 
    return
23085 
 
23086 
 
23087 
  def __repr__(self):
23088 
    L = ['%s=%r' % (key, value)
23089 
      for key, value in self.__dict__.iteritems()]
23090 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23091 
 
23092 
  def __eq__(self, other):
23093 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23094 
 
23095 
  def __ne__(self, other):
23096 
    return not (self == other)
23097 
 
23098 
class updateAmazonAttributesInBulk_result:
23099 
  """
23100 
  Attributes:
23101 
   - success
23102 
  """
23103 
 
23104 
  thrift_spec = (
23105 
    (0, TType.BOOL, 'success', None, None, ), # 0
23106 
  )
23107 
 
23108 
  def __init__(self, success=None,):
23109 
    self.success = success
23110 
 
23111 
  def read(self, iprot):
23112 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23113 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23114 
      return
23115 
    iprot.readStructBegin()
23116 
    while True:
23117 
      (fname, ftype, fid) = iprot.readFieldBegin()
23118 
      if ftype == TType.STOP:
23119 
        break
23120 
      if fid == 0:
23121 
        if ftype == TType.BOOL:
23122 
          self.success = iprot.readBool();
23123 
        else:
23124 
          iprot.skip(ftype)
23125 
      else:
23126 
        iprot.skip(ftype)
23127 
      iprot.readFieldEnd()
23128 
    iprot.readStructEnd()
23129 
 
23130 
  def write(self, oprot):
23131 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23132 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23133 
      return
23134 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_result')
23135 
    if self.success is not None:
23136 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
23137 
      oprot.writeBool(self.success)
23138 
      oprot.writeFieldEnd()
23139 
    oprot.writeFieldStop()
23140 
    oprot.writeStructEnd()
23141 
 
23142 
  def validate(self):
23143 
    return
23144 
 
23145 
 
23146 
  def __repr__(self):
23147 
    L = ['%s=%r' % (key, value)
23148 
      for key, value in self.__dict__.iteritems()]
23149 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23150 
 
23151 
  def __eq__(self, other):
23152 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23153 
 
23154 
  def __ne__(self, other):
23155 
    return not (self == other)
8379 vikram.rag 23156 
 
23157 
class getAllItemstoListOnFba_args:
23158 
 
23159 
  thrift_spec = (
23160 
  )
23161 
 
23162 
  def read(self, iprot):
23163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23165 
      return
23166 
    iprot.readStructBegin()
23167 
    while True:
23168 
      (fname, ftype, fid) = iprot.readFieldBegin()
23169 
      if ftype == TType.STOP:
23170 
        break
23171 
      else:
23172 
        iprot.skip(ftype)
23173 
      iprot.readFieldEnd()
23174 
    iprot.readStructEnd()
23175 
 
23176 
  def write(self, oprot):
23177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23179 
      return
23180 
    oprot.writeStructBegin('getAllItemstoListOnFba_args')
23181 
    oprot.writeFieldStop()
23182 
    oprot.writeStructEnd()
23183 
 
23184 
  def validate(self):
23185 
    return
23186 
 
23187 
 
23188 
  def __repr__(self):
23189 
    L = ['%s=%r' % (key, value)
23190 
      for key, value in self.__dict__.iteritems()]
23191 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23192 
 
23193 
  def __eq__(self, other):
23194 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23195 
 
23196 
  def __ne__(self, other):
23197 
    return not (self == other)
23198 
 
23199 
class getAllItemstoListOnFba_result:
23200 
  """
23201 
  Attributes:
23202 
   - success
23203 
  """
23204 
 
23205 
  thrift_spec = (
23206 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
23207 
  )
23208 
 
23209 
  def __init__(self, success=None,):
23210 
    self.success = success
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 == 0:
23222 
        if ftype == TType.LIST:
23223 
          self.success = []
9155 kshitij.so 23224 
          (_etype493, _size490) = iprot.readListBegin()
23225 
          for _i494 in xrange(_size490):
23226 
            _elem495 = Amazonlisted()
23227 
            _elem495.read(iprot)
23228 
            self.success.append(_elem495)
8379 vikram.rag 23229 
          iprot.readListEnd()
23230 
        else:
23231 
          iprot.skip(ftype)
23232 
      else:
23233 
        iprot.skip(ftype)
23234 
      iprot.readFieldEnd()
23235 
    iprot.readStructEnd()
23236 
 
23237 
  def write(self, oprot):
23238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23240 
      return
23241 
    oprot.writeStructBegin('getAllItemstoListOnFba_result')
23242 
    if self.success is not None:
23243 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23244 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 23245 
      for iter496 in self.success:
23246 
        iter496.write(oprot)
8379 vikram.rag 23247 
      oprot.writeListEnd()
23248 
      oprot.writeFieldEnd()
23249 
    oprot.writeFieldStop()
23250 
    oprot.writeStructEnd()
23251 
 
23252 
  def validate(self):
23253 
    return
23254 
 
23255 
 
23256 
  def __repr__(self):
23257 
    L = ['%s=%r' % (key, value)
23258 
      for key, value in self.__dict__.iteritems()]
23259 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23260 
 
23261 
  def __eq__(self, other):
23262 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23263 
 
23264 
  def __ne__(self, other):
23265 
    return not (self == other)
23266 
 
23267 
class getAllItemstoListOnNonFba_args:
23268 
 
23269 
  thrift_spec = (
23270 
  )
23271 
 
23272 
  def read(self, iprot):
23273 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23274 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23275 
      return
23276 
    iprot.readStructBegin()
23277 
    while True:
23278 
      (fname, ftype, fid) = iprot.readFieldBegin()
23279 
      if ftype == TType.STOP:
23280 
        break
23281 
      else:
23282 
        iprot.skip(ftype)
23283 
      iprot.readFieldEnd()
23284 
    iprot.readStructEnd()
23285 
 
23286 
  def write(self, oprot):
23287 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23288 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23289 
      return
23290 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_args')
23291 
    oprot.writeFieldStop()
23292 
    oprot.writeStructEnd()
23293 
 
23294 
  def validate(self):
23295 
    return
23296 
 
23297 
 
23298 
  def __repr__(self):
23299 
    L = ['%s=%r' % (key, value)
23300 
      for key, value in self.__dict__.iteritems()]
23301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23302 
 
23303 
  def __eq__(self, other):
23304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23305 
 
23306 
  def __ne__(self, other):
23307 
    return not (self == other)
23308 
 
23309 
class getAllItemstoListOnNonFba_result:
23310 
  """
23311 
  Attributes:
23312 
   - success
23313 
  """
23314 
 
23315 
  thrift_spec = (
23316 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
23317 
  )
23318 
 
23319 
  def __init__(self, success=None,):
23320 
    self.success = success
23321 
 
23322 
  def read(self, iprot):
23323 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23324 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23325 
      return
23326 
    iprot.readStructBegin()
23327 
    while True:
23328 
      (fname, ftype, fid) = iprot.readFieldBegin()
23329 
      if ftype == TType.STOP:
23330 
        break
23331 
      if fid == 0:
23332 
        if ftype == TType.LIST:
23333 
          self.success = []
9155 kshitij.so 23334 
          (_etype500, _size497) = iprot.readListBegin()
23335 
          for _i501 in xrange(_size497):
23336 
            _elem502 = Amazonlisted()
23337 
            _elem502.read(iprot)
23338 
            self.success.append(_elem502)
8379 vikram.rag 23339 
          iprot.readListEnd()
23340 
        else:
23341 
          iprot.skip(ftype)
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('getAllItemstoListOnNonFba_result')
23352 
    if self.success is not None:
23353 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23354 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 23355 
      for iter503 in self.success:
23356 
        iter503.write(oprot)
8379 vikram.rag 23357 
      oprot.writeListEnd()
23358 
      oprot.writeFieldEnd()
23359 
    oprot.writeFieldStop()
23360 
    oprot.writeStructEnd()
23361 
 
23362 
  def validate(self):
23363 
    return
23364 
 
23365 
 
23366 
  def __repr__(self):
23367 
    L = ['%s=%r' % (key, value)
23368 
      for key, value in self.__dict__.iteritems()]
23369 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23370 
 
23371 
  def __eq__(self, other):
23372 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23373 
 
23374 
  def __ne__(self, other):
23375 
    return not (self == other)
8616 vikram.rag 23376 
 
9242 kshitij.so 23377 
class updateAsin_args:
23378 
  """
23379 
  Attributes:
23380 
   - item
23381 
  """
8616 vikram.rag 23382 
 
23383 
  thrift_spec = (
9242 kshitij.so 23384 
    None, # 0
23385 
    (1, TType.MAP, 'item', (TType.I64,None,TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 1
8616 vikram.rag 23386 
  )
23387 
 
9242 kshitij.so 23388 
  def __init__(self, item=None,):
23389 
    self.item = item
23390 
 
8616 vikram.rag 23391 
  def read(self, iprot):
23392 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23393 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23394 
      return
23395 
    iprot.readStructBegin()
23396 
    while True:
23397 
      (fname, ftype, fid) = iprot.readFieldBegin()
23398 
      if ftype == TType.STOP:
23399 
        break
9242 kshitij.so 23400 
      if fid == 1:
23401 
        if ftype == TType.MAP:
23402 
          self.item = {}
23403 
          (_ktype505, _vtype506, _size504 ) = iprot.readMapBegin()
23404 
          for _i508 in xrange(_size504):
23405 
            _key509 = iprot.readI64();
23406 
            _val510 = Item()
23407 
            _val510.read(iprot)
23408 
            self.item[_key509] = _val510
23409 
          iprot.readMapEnd()
23410 
        else:
23411 
          iprot.skip(ftype)
8616 vikram.rag 23412 
      else:
23413 
        iprot.skip(ftype)
23414 
      iprot.readFieldEnd()
23415 
    iprot.readStructEnd()
23416 
 
23417 
  def write(self, oprot):
23418 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23419 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23420 
      return
9242 kshitij.so 23421 
    oprot.writeStructBegin('updateAsin_args')
23422 
    if self.item is not None:
23423 
      oprot.writeFieldBegin('item', TType.MAP, 1)
23424 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.item))
23425 
      for kiter511,viter512 in self.item.items():
23426 
        oprot.writeI64(kiter511)
23427 
        viter512.write(oprot)
23428 
      oprot.writeMapEnd()
23429 
      oprot.writeFieldEnd()
8616 vikram.rag 23430 
    oprot.writeFieldStop()
23431 
    oprot.writeStructEnd()
23432 
 
23433 
  def validate(self):
23434 
    return
23435 
 
23436 
 
23437 
  def __repr__(self):
23438 
    L = ['%s=%r' % (key, value)
23439 
      for key, value in self.__dict__.iteritems()]
23440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23441 
 
23442 
  def __eq__(self, other):
23443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23444 
 
23445 
  def __ne__(self, other):
23446 
    return not (self == other)
23447 
 
9242 kshitij.so 23448 
class updateAsin_result:
8616 vikram.rag 23449 
 
23450 
  thrift_spec = (
23451 
  )
23452 
 
23453 
  def read(self, iprot):
23454 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23455 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23456 
      return
23457 
    iprot.readStructBegin()
23458 
    while True:
23459 
      (fname, ftype, fid) = iprot.readFieldBegin()
23460 
      if ftype == TType.STOP:
23461 
        break
23462 
      else:
23463 
        iprot.skip(ftype)
23464 
      iprot.readFieldEnd()
23465 
    iprot.readStructEnd()
23466 
 
23467 
  def write(self, oprot):
23468 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23469 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23470 
      return
9242 kshitij.so 23471 
    oprot.writeStructBegin('updateAsin_result')
8616 vikram.rag 23472 
    oprot.writeFieldStop()
23473 
    oprot.writeStructEnd()
23474 
 
23475 
  def validate(self):
23476 
    return
23477 
 
23478 
 
23479 
  def __repr__(self):
23480 
    L = ['%s=%r' % (key, value)
23481 
      for key, value in self.__dict__.iteritems()]
23482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23483 
 
23484 
  def __eq__(self, other):
23485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23486 
 
23487 
  def __ne__(self, other):
23488 
    return not (self == other)
8619 kshitij.so 23489 
 
9242 kshitij.so 23490 
class addOrUpdateSnapdealItem_args:
8619 kshitij.so 23491 
  """
23492 
  Attributes:
9242 kshitij.so 23493 
   - snapdealitem
8619 kshitij.so 23494 
  """
23495 
 
9242 kshitij.so 23496 
  thrift_spec = None
23497 
  def __init__(self, snapdealitem=None,):
23498 
    self.snapdealitem = snapdealitem
8619 kshitij.so 23499 
 
23500 
  def read(self, iprot):
23501 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23502 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23503 
      return
23504 
    iprot.readStructBegin()
23505 
    while True:
23506 
      (fname, ftype, fid) = iprot.readFieldBegin()
23507 
      if ftype == TType.STOP:
23508 
        break
9242 kshitij.so 23509 
      if fid == -1:
23510 
        if ftype == TType.STRUCT:
23511 
          self.snapdealitem = SnapdealItem()
23512 
          self.snapdealitem.read(iprot)
8619 kshitij.so 23513 
        else:
23514 
          iprot.skip(ftype)
23515 
      else:
23516 
        iprot.skip(ftype)
23517 
      iprot.readFieldEnd()
23518 
    iprot.readStructEnd()
23519 
 
23520 
  def write(self, oprot):
23521 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23522 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23523 
      return
9242 kshitij.so 23524 
    oprot.writeStructBegin('addOrUpdateSnapdealItem_args')
23525 
    if self.snapdealitem is not None:
23526 
      oprot.writeFieldBegin('snapdealitem', TType.STRUCT, -1)
23527 
      self.snapdealitem.write(oprot)
8619 kshitij.so 23528 
      oprot.writeFieldEnd()
23529 
    oprot.writeFieldStop()
23530 
    oprot.writeStructEnd()
23531 
 
23532 
  def validate(self):
23533 
    return
23534 
 
23535 
 
23536 
  def __repr__(self):
23537 
    L = ['%s=%r' % (key, value)
23538 
      for key, value in self.__dict__.iteritems()]
23539 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23540 
 
23541 
  def __eq__(self, other):
23542 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23543 
 
23544 
  def __ne__(self, other):
23545 
    return not (self == other)
23546 
 
9242 kshitij.so 23547 
class addOrUpdateSnapdealItem_result:
23548 
  """
23549 
  Attributes:
23550 
   - success
23551 
  """
8619 kshitij.so 23552 
 
23553 
  thrift_spec = (
9242 kshitij.so 23554 
    (0, TType.BOOL, 'success', None, None, ), # 0
8619 kshitij.so 23555 
  )
23556 
 
9242 kshitij.so 23557 
  def __init__(self, success=None,):
23558 
    self.success = success
23559 
 
8619 kshitij.so 23560 
  def read(self, iprot):
23561 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23562 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23563 
      return
23564 
    iprot.readStructBegin()
23565 
    while True:
23566 
      (fname, ftype, fid) = iprot.readFieldBegin()
23567 
      if ftype == TType.STOP:
23568 
        break
9242 kshitij.so 23569 
      if fid == 0:
23570 
        if ftype == TType.BOOL:
23571 
          self.success = iprot.readBool();
23572 
        else:
23573 
          iprot.skip(ftype)
8619 kshitij.so 23574 
      else:
23575 
        iprot.skip(ftype)
23576 
      iprot.readFieldEnd()
23577 
    iprot.readStructEnd()
23578 
 
23579 
  def write(self, oprot):
23580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23582 
      return
9242 kshitij.so 23583 
    oprot.writeStructBegin('addOrUpdateSnapdealItem_result')
23584 
    if self.success is not None:
23585 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
23586 
      oprot.writeBool(self.success)
23587 
      oprot.writeFieldEnd()
8619 kshitij.so 23588 
    oprot.writeFieldStop()
23589 
    oprot.writeStructEnd()
23590 
 
23591 
  def validate(self):
23592 
    return
23593 
 
23594 
 
23595 
  def __repr__(self):
23596 
    L = ['%s=%r' % (key, value)
23597 
      for key, value in self.__dict__.iteritems()]
23598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23599 
 
23600 
  def __eq__(self, other):
23601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23602 
 
23603 
  def __ne__(self, other):
23604 
    return not (self == other)
8739 vikram.rag 23605 
 
9242 kshitij.so 23606 
class getSnapdealItem_args:
8739 vikram.rag 23607 
  """
23608 
  Attributes:
9242 kshitij.so 23609 
   - item_id
8739 vikram.rag 23610 
  """
23611 
 
9242 kshitij.so 23612 
  thrift_spec = (
23613 
    None, # 0
23614 
    (1, TType.I64, 'item_id', None, None, ), # 1
23615 
  )
8739 vikram.rag 23616 
 
9242 kshitij.so 23617 
  def __init__(self, item_id=None,):
23618 
    self.item_id = item_id
23619 
 
8739 vikram.rag 23620 
  def read(self, iprot):
23621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23623 
      return
23624 
    iprot.readStructBegin()
23625 
    while True:
23626 
      (fname, ftype, fid) = iprot.readFieldBegin()
23627 
      if ftype == TType.STOP:
23628 
        break
9242 kshitij.so 23629 
      if fid == 1:
23630 
        if ftype == TType.I64:
23631 
          self.item_id = iprot.readI64();
8739 vikram.rag 23632 
        else:
23633 
          iprot.skip(ftype)
23634 
      else:
23635 
        iprot.skip(ftype)
23636 
      iprot.readFieldEnd()
23637 
    iprot.readStructEnd()
23638 
 
23639 
  def write(self, oprot):
23640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23642 
      return
9242 kshitij.so 23643 
    oprot.writeStructBegin('getSnapdealItem_args')
23644 
    if self.item_id is not None:
23645 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
23646 
      oprot.writeI64(self.item_id)
8739 vikram.rag 23647 
      oprot.writeFieldEnd()
23648 
    oprot.writeFieldStop()
23649 
    oprot.writeStructEnd()
23650 
 
23651 
  def validate(self):
23652 
    return
23653 
 
23654 
 
23655 
  def __repr__(self):
23656 
    L = ['%s=%r' % (key, value)
23657 
      for key, value in self.__dict__.iteritems()]
23658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23659 
 
23660 
  def __eq__(self, other):
23661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23662 
 
23663 
  def __ne__(self, other):
23664 
    return not (self == other)
23665 
 
9242 kshitij.so 23666 
class getSnapdealItem_result:
8739 vikram.rag 23667 
  """
23668 
  Attributes:
23669 
   - success
23670 
  """
23671 
 
23672 
  thrift_spec = (
9242 kshitij.so 23673 
    (0, TType.STRUCT, 'success', (SnapdealItem, SnapdealItem.thrift_spec), None, ), # 0
8739 vikram.rag 23674 
  )
23675 
 
23676 
  def __init__(self, success=None,):
23677 
    self.success = success
23678 
 
23679 
  def read(self, iprot):
23680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23682 
      return
23683 
    iprot.readStructBegin()
23684 
    while True:
23685 
      (fname, ftype, fid) = iprot.readFieldBegin()
23686 
      if ftype == TType.STOP:
23687 
        break
23688 
      if fid == 0:
9242 kshitij.so 23689 
        if ftype == TType.STRUCT:
23690 
          self.success = SnapdealItem()
23691 
          self.success.read(iprot)
8739 vikram.rag 23692 
        else:
23693 
          iprot.skip(ftype)
23694 
      else:
23695 
        iprot.skip(ftype)
23696 
      iprot.readFieldEnd()
23697 
    iprot.readStructEnd()
23698 
 
23699 
  def write(self, oprot):
23700 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23701 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23702 
      return
9242 kshitij.so 23703 
    oprot.writeStructBegin('getSnapdealItem_result')
8739 vikram.rag 23704 
    if self.success is not None:
9242 kshitij.so 23705 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23706 
      self.success.write(oprot)
8739 vikram.rag 23707 
      oprot.writeFieldEnd()
23708 
    oprot.writeFieldStop()
23709 
    oprot.writeStructEnd()
23710 
 
23711 
  def validate(self):
23712 
    return
23713 
 
23714 
 
23715 
  def __repr__(self):
23716 
    L = ['%s=%r' % (key, value)
23717 
      for key, value in self.__dict__.iteritems()]
23718 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23719 
 
23720 
  def __eq__(self, other):
23721 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23722 
 
23723 
  def __ne__(self, other):
23724 
    return not (self == other)
23725 
 
9242 kshitij.so 23726 
class getSnapdealItemDetails_args:
8739 vikram.rag 23727 
  """
23728 
  Attributes:
23729 
   - item_id
23730 
  """
23731 
 
23732 
  thrift_spec = (
23733 
    None, # 0
23734 
    (1, TType.I64, 'item_id', None, None, ), # 1
23735 
  )
23736 
 
23737 
  def __init__(self, item_id=None,):
23738 
    self.item_id = item_id
23739 
 
23740 
  def read(self, iprot):
23741 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23742 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23743 
      return
23744 
    iprot.readStructBegin()
23745 
    while True:
23746 
      (fname, ftype, fid) = iprot.readFieldBegin()
23747 
      if ftype == TType.STOP:
23748 
        break
23749 
      if fid == 1:
23750 
        if ftype == TType.I64:
23751 
          self.item_id = iprot.readI64();
23752 
        else:
23753 
          iprot.skip(ftype)
23754 
      else:
23755 
        iprot.skip(ftype)
23756 
      iprot.readFieldEnd()
23757 
    iprot.readStructEnd()
23758 
 
23759 
  def write(self, oprot):
23760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23762 
      return
9242 kshitij.so 23763 
    oprot.writeStructBegin('getSnapdealItemDetails_args')
8739 vikram.rag 23764 
    if self.item_id is not None:
23765 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
23766 
      oprot.writeI64(self.item_id)
23767 
      oprot.writeFieldEnd()
23768 
    oprot.writeFieldStop()
23769 
    oprot.writeStructEnd()
23770 
 
23771 
  def validate(self):
23772 
    return
23773 
 
23774 
 
23775 
  def __repr__(self):
23776 
    L = ['%s=%r' % (key, value)
23777 
      for key, value in self.__dict__.iteritems()]
23778 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23779 
 
23780 
  def __eq__(self, other):
23781 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23782 
 
23783 
  def __ne__(self, other):
23784 
    return not (self == other)
23785 
 
9242 kshitij.so 23786 
class getSnapdealItemDetails_result:
8739 vikram.rag 23787 
  """
23788 
  Attributes:
23789 
   - success
23790 
  """
23791 
 
23792 
  thrift_spec = (
9242 kshitij.so 23793 
    (0, TType.STRUCT, 'success', (SnapdealItemDetails, SnapdealItemDetails.thrift_spec), None, ), # 0
8739 vikram.rag 23794 
  )
23795 
 
23796 
  def __init__(self, success=None,):
23797 
    self.success = success
23798 
 
23799 
  def read(self, iprot):
23800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23802 
      return
23803 
    iprot.readStructBegin()
23804 
    while True:
23805 
      (fname, ftype, fid) = iprot.readFieldBegin()
23806 
      if ftype == TType.STOP:
23807 
        break
23808 
      if fid == 0:
23809 
        if ftype == TType.STRUCT:
9242 kshitij.so 23810 
          self.success = SnapdealItemDetails()
8739 vikram.rag 23811 
          self.success.read(iprot)
23812 
        else:
23813 
          iprot.skip(ftype)
23814 
      else:
23815 
        iprot.skip(ftype)
23816 
      iprot.readFieldEnd()
23817 
    iprot.readStructEnd()
23818 
 
23819 
  def write(self, oprot):
23820 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23821 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23822 
      return
9242 kshitij.so 23823 
    oprot.writeStructBegin('getSnapdealItemDetails_result')
8739 vikram.rag 23824 
    if self.success is not None:
23825 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23826 
      self.success.write(oprot)
23827 
      oprot.writeFieldEnd()
23828 
    oprot.writeFieldStop()
23829 
    oprot.writeStructEnd()
23830 
 
23831 
  def validate(self):
23832 
    return
23833 
 
23834 
 
23835 
  def __repr__(self):
23836 
    L = ['%s=%r' % (key, value)
23837 
      for key, value in self.__dict__.iteritems()]
23838 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23839 
 
23840 
  def __eq__(self, other):
23841 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23842 
 
23843 
  def __ne__(self, other):
23844 
    return not (self == other)
23845 
 
23846 
class getAllSnapdealItems_args:
23847 
 
23848 
  thrift_spec = (
23849 
  )
23850 
 
23851 
  def read(self, iprot):
23852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23854 
      return
23855 
    iprot.readStructBegin()
23856 
    while True:
23857 
      (fname, ftype, fid) = iprot.readFieldBegin()
23858 
      if ftype == TType.STOP:
23859 
        break
23860 
      else:
23861 
        iprot.skip(ftype)
23862 
      iprot.readFieldEnd()
23863 
    iprot.readStructEnd()
23864 
 
23865 
  def write(self, oprot):
23866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23868 
      return
23869 
    oprot.writeStructBegin('getAllSnapdealItems_args')
23870 
    oprot.writeFieldStop()
23871 
    oprot.writeStructEnd()
23872 
 
23873 
  def validate(self):
23874 
    return
23875 
 
23876 
 
23877 
  def __repr__(self):
23878 
    L = ['%s=%r' % (key, value)
23879 
      for key, value in self.__dict__.iteritems()]
23880 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23881 
 
23882 
  def __eq__(self, other):
23883 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23884 
 
23885 
  def __ne__(self, other):
23886 
    return not (self == other)
23887 
 
23888 
class getAllSnapdealItems_result:
23889 
  """
23890 
  Attributes:
23891 
   - success
23892 
  """
23893 
 
23894 
  thrift_spec = (
9242 kshitij.so 23895 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
8739 vikram.rag 23896 
  )
23897 
 
23898 
  def __init__(self, success=None,):
23899 
    self.success = success
23900 
 
23901 
  def read(self, iprot):
23902 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23903 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23904 
      return
23905 
    iprot.readStructBegin()
23906 
    while True:
23907 
      (fname, ftype, fid) = iprot.readFieldBegin()
23908 
      if ftype == TType.STOP:
23909 
        break
23910 
      if fid == 0:
23911 
        if ftype == TType.LIST:
23912 
          self.success = []
9242 kshitij.so 23913 
          (_etype516, _size513) = iprot.readListBegin()
23914 
          for _i517 in xrange(_size513):
23915 
            _elem518 = SnapdealItemDetails()
23916 
            _elem518.read(iprot)
23917 
            self.success.append(_elem518)
23918 
          iprot.readListEnd()
23919 
        else:
23920 
          iprot.skip(ftype)
23921 
      else:
23922 
        iprot.skip(ftype)
23923 
      iprot.readFieldEnd()
23924 
    iprot.readStructEnd()
23925 
 
23926 
  def write(self, oprot):
23927 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23928 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23929 
      return
23930 
    oprot.writeStructBegin('getAllSnapdealItems_result')
23931 
    if self.success is not None:
23932 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23933 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
23934 
      for iter519 in self.success:
23935 
        iter519.write(oprot)
23936 
      oprot.writeListEnd()
23937 
      oprot.writeFieldEnd()
23938 
    oprot.writeFieldStop()
23939 
    oprot.writeStructEnd()
23940 
 
23941 
  def validate(self):
23942 
    return
23943 
 
23944 
 
23945 
  def __repr__(self):
23946 
    L = ['%s=%r' % (key, value)
23947 
      for key, value in self.__dict__.iteritems()]
23948 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23949 
 
23950 
  def __eq__(self, other):
23951 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23952 
 
23953 
  def __ne__(self, other):
23954 
    return not (self == other)
23955 
 
23956 
class getSnapdealItems_args:
23957 
  """
23958 
  Attributes:
23959 
   - offset
23960 
   - limit
23961 
  """
23962 
 
23963 
  thrift_spec = (
23964 
    None, # 0
23965 
    (1, TType.I64, 'offset', None, None, ), # 1
23966 
    (2, TType.I64, 'limit', None, None, ), # 2
23967 
  )
23968 
 
23969 
  def __init__(self, offset=None, limit=None,):
23970 
    self.offset = offset
23971 
    self.limit = limit
23972 
 
23973 
  def read(self, iprot):
23974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23976 
      return
23977 
    iprot.readStructBegin()
23978 
    while True:
23979 
      (fname, ftype, fid) = iprot.readFieldBegin()
23980 
      if ftype == TType.STOP:
23981 
        break
23982 
      if fid == 1:
23983 
        if ftype == TType.I64:
23984 
          self.offset = iprot.readI64();
23985 
        else:
23986 
          iprot.skip(ftype)
23987 
      elif fid == 2:
23988 
        if ftype == TType.I64:
23989 
          self.limit = iprot.readI64();
23990 
        else:
23991 
          iprot.skip(ftype)
23992 
      else:
23993 
        iprot.skip(ftype)
23994 
      iprot.readFieldEnd()
23995 
    iprot.readStructEnd()
23996 
 
23997 
  def write(self, oprot):
23998 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23999 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24000 
      return
24001 
    oprot.writeStructBegin('getSnapdealItems_args')
24002 
    if self.offset is not None:
24003 
      oprot.writeFieldBegin('offset', TType.I64, 1)
24004 
      oprot.writeI64(self.offset)
24005 
      oprot.writeFieldEnd()
24006 
    if self.limit is not None:
24007 
      oprot.writeFieldBegin('limit', TType.I64, 2)
24008 
      oprot.writeI64(self.limit)
24009 
      oprot.writeFieldEnd()
24010 
    oprot.writeFieldStop()
24011 
    oprot.writeStructEnd()
24012 
 
24013 
  def validate(self):
24014 
    return
24015 
 
24016 
 
24017 
  def __repr__(self):
24018 
    L = ['%s=%r' % (key, value)
24019 
      for key, value in self.__dict__.iteritems()]
24020 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24021 
 
24022 
  def __eq__(self, other):
24023 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24024 
 
24025 
  def __ne__(self, other):
24026 
    return not (self == other)
24027 
 
24028 
class getSnapdealItems_result:
24029 
  """
24030 
  Attributes:
24031 
   - success
24032 
  """
24033 
 
24034 
  thrift_spec = (
24035 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
24036 
  )
24037 
 
24038 
  def __init__(self, success=None,):
24039 
    self.success = success
24040 
 
24041 
  def read(self, iprot):
24042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24044 
      return
24045 
    iprot.readStructBegin()
24046 
    while True:
24047 
      (fname, ftype, fid) = iprot.readFieldBegin()
24048 
      if ftype == TType.STOP:
24049 
        break
24050 
      if fid == 0:
24051 
        if ftype == TType.LIST:
24052 
          self.success = []
9155 kshitij.so 24053 
          (_etype523, _size520) = iprot.readListBegin()
24054 
          for _i524 in xrange(_size520):
9242 kshitij.so 24055 
            _elem525 = SnapdealItemDetails()
9155 kshitij.so 24056 
            _elem525.read(iprot)
24057 
            self.success.append(_elem525)
8739 vikram.rag 24058 
          iprot.readListEnd()
24059 
        else:
24060 
          iprot.skip(ftype)
24061 
      else:
24062 
        iprot.skip(ftype)
24063 
      iprot.readFieldEnd()
24064 
    iprot.readStructEnd()
24065 
 
24066 
  def write(self, oprot):
24067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24069 
      return
9242 kshitij.so 24070 
    oprot.writeStructBegin('getSnapdealItems_result')
8739 vikram.rag 24071 
    if self.success is not None:
24072 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24073 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 24074 
      for iter526 in self.success:
24075 
        iter526.write(oprot)
8739 vikram.rag 24076 
      oprot.writeListEnd()
24077 
      oprot.writeFieldEnd()
24078 
    oprot.writeFieldStop()
24079 
    oprot.writeStructEnd()
24080 
 
24081 
  def validate(self):
24082 
    return
24083 
 
24084 
 
24085 
  def __repr__(self):
24086 
    L = ['%s=%r' % (key, value)
24087 
      for key, value in self.__dict__.iteritems()]
24088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24089 
 
24090 
  def __eq__(self, other):
24091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24092 
 
24093 
  def __ne__(self, other):
24094 
    return not (self == other)
9242 kshitij.so 24095 
 
24096 
class searchSnapdealItems_args:
24097 
  """
24098 
  Attributes:
24099 
   - searchTerm
24100 
   - offset
24101 
   - limit
24102 
  """
24103 
 
24104 
  thrift_spec = (
24105 
    None, # 0
24106 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
24107 
    (2, TType.I64, 'offset', None, None, ), # 2
24108 
    (3, TType.I64, 'limit', None, None, ), # 3
24109 
  )
24110 
 
24111 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
24112 
    self.searchTerm = searchTerm
24113 
    self.offset = offset
24114 
    self.limit = limit
24115 
 
24116 
  def read(self, iprot):
24117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24119 
      return
24120 
    iprot.readStructBegin()
24121 
    while True:
24122 
      (fname, ftype, fid) = iprot.readFieldBegin()
24123 
      if ftype == TType.STOP:
24124 
        break
24125 
      if fid == 1:
24126 
        if ftype == TType.LIST:
24127 
          self.searchTerm = []
24128 
          (_etype530, _size527) = iprot.readListBegin()
24129 
          for _i531 in xrange(_size527):
24130 
            _elem532 = iprot.readString();
24131 
            self.searchTerm.append(_elem532)
24132 
          iprot.readListEnd()
24133 
        else:
24134 
          iprot.skip(ftype)
24135 
      elif fid == 2:
24136 
        if ftype == TType.I64:
24137 
          self.offset = iprot.readI64();
24138 
        else:
24139 
          iprot.skip(ftype)
24140 
      elif fid == 3:
24141 
        if ftype == TType.I64:
24142 
          self.limit = iprot.readI64();
24143 
        else:
24144 
          iprot.skip(ftype)
24145 
      else:
24146 
        iprot.skip(ftype)
24147 
      iprot.readFieldEnd()
24148 
    iprot.readStructEnd()
24149 
 
24150 
  def write(self, oprot):
24151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24153 
      return
24154 
    oprot.writeStructBegin('searchSnapdealItems_args')
24155 
    if self.searchTerm is not None:
24156 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
24157 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
24158 
      for iter533 in self.searchTerm:
24159 
        oprot.writeString(iter533)
24160 
      oprot.writeListEnd()
24161 
      oprot.writeFieldEnd()
24162 
    if self.offset is not None:
24163 
      oprot.writeFieldBegin('offset', TType.I64, 2)
24164 
      oprot.writeI64(self.offset)
24165 
      oprot.writeFieldEnd()
24166 
    if self.limit is not None:
24167 
      oprot.writeFieldBegin('limit', TType.I64, 3)
24168 
      oprot.writeI64(self.limit)
24169 
      oprot.writeFieldEnd()
24170 
    oprot.writeFieldStop()
24171 
    oprot.writeStructEnd()
24172 
 
24173 
  def validate(self):
24174 
    return
24175 
 
24176 
 
24177 
  def __repr__(self):
24178 
    L = ['%s=%r' % (key, value)
24179 
      for key, value in self.__dict__.iteritems()]
24180 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24181 
 
24182 
  def __eq__(self, other):
24183 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24184 
 
24185 
  def __ne__(self, other):
24186 
    return not (self == other)
24187 
 
24188 
class searchSnapdealItems_result:
24189 
  """
24190 
  Attributes:
24191 
   - success
24192 
  """
24193 
 
24194 
  thrift_spec = (
24195 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
24196 
  )
24197 
 
24198 
  def __init__(self, success=None,):
24199 
    self.success = success
24200 
 
24201 
  def read(self, iprot):
24202 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24203 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24204 
      return
24205 
    iprot.readStructBegin()
24206 
    while True:
24207 
      (fname, ftype, fid) = iprot.readFieldBegin()
24208 
      if ftype == TType.STOP:
24209 
        break
24210 
      if fid == 0:
24211 
        if ftype == TType.LIST:
24212 
          self.success = []
24213 
          (_etype537, _size534) = iprot.readListBegin()
24214 
          for _i538 in xrange(_size534):
24215 
            _elem539 = SnapdealItemDetails()
24216 
            _elem539.read(iprot)
24217 
            self.success.append(_elem539)
24218 
          iprot.readListEnd()
24219 
        else:
24220 
          iprot.skip(ftype)
24221 
      else:
24222 
        iprot.skip(ftype)
24223 
      iprot.readFieldEnd()
24224 
    iprot.readStructEnd()
24225 
 
24226 
  def write(self, oprot):
24227 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24228 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24229 
      return
24230 
    oprot.writeStructBegin('searchSnapdealItems_result')
24231 
    if self.success is not None:
24232 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24233 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
24234 
      for iter540 in self.success:
24235 
        iter540.write(oprot)
24236 
      oprot.writeListEnd()
24237 
      oprot.writeFieldEnd()
24238 
    oprot.writeFieldStop()
24239 
    oprot.writeStructEnd()
24240 
 
24241 
  def validate(self):
24242 
    return
24243 
 
24244 
 
24245 
  def __repr__(self):
24246 
    L = ['%s=%r' % (key, value)
24247 
      for key, value in self.__dict__.iteritems()]
24248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24249 
 
24250 
  def __eq__(self, other):
24251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24252 
 
24253 
  def __ne__(self, other):
24254 
    return not (self == other)
24255 
 
24256 
class getCountForSnapdealItems_args:
24257 
 
24258 
  thrift_spec = (
24259 
  )
24260 
 
24261 
  def read(self, iprot):
24262 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24263 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24264 
      return
24265 
    iprot.readStructBegin()
24266 
    while True:
24267 
      (fname, ftype, fid) = iprot.readFieldBegin()
24268 
      if ftype == TType.STOP:
24269 
        break
24270 
      else:
24271 
        iprot.skip(ftype)
24272 
      iprot.readFieldEnd()
24273 
    iprot.readStructEnd()
24274 
 
24275 
  def write(self, oprot):
24276 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24277 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24278 
      return
24279 
    oprot.writeStructBegin('getCountForSnapdealItems_args')
24280 
    oprot.writeFieldStop()
24281 
    oprot.writeStructEnd()
24282 
 
24283 
  def validate(self):
24284 
    return
24285 
 
24286 
 
24287 
  def __repr__(self):
24288 
    L = ['%s=%r' % (key, value)
24289 
      for key, value in self.__dict__.iteritems()]
24290 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24291 
 
24292 
  def __eq__(self, other):
24293 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24294 
 
24295 
  def __ne__(self, other):
24296 
    return not (self == other)
24297 
 
24298 
class getCountForSnapdealItems_result:
24299 
  """
24300 
  Attributes:
24301 
   - success
24302 
  """
24303 
 
24304 
  thrift_spec = (
24305 
    (0, TType.I64, 'success', None, None, ), # 0
24306 
  )
24307 
 
24308 
  def __init__(self, success=None,):
24309 
    self.success = success
24310 
 
24311 
  def read(self, iprot):
24312 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24313 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24314 
      return
24315 
    iprot.readStructBegin()
24316 
    while True:
24317 
      (fname, ftype, fid) = iprot.readFieldBegin()
24318 
      if ftype == TType.STOP:
24319 
        break
24320 
      if fid == 0:
24321 
        if ftype == TType.I64:
24322 
          self.success = iprot.readI64();
24323 
        else:
24324 
          iprot.skip(ftype)
24325 
      else:
24326 
        iprot.skip(ftype)
24327 
      iprot.readFieldEnd()
24328 
    iprot.readStructEnd()
24329 
 
24330 
  def write(self, oprot):
24331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24333 
      return
24334 
    oprot.writeStructBegin('getCountForSnapdealItems_result')
24335 
    if self.success is not None:
24336 
      oprot.writeFieldBegin('success', TType.I64, 0)
24337 
      oprot.writeI64(self.success)
24338 
      oprot.writeFieldEnd()
24339 
    oprot.writeFieldStop()
24340 
    oprot.writeStructEnd()
24341 
 
24342 
  def validate(self):
24343 
    return
24344 
 
24345 
 
24346 
  def __repr__(self):
24347 
    L = ['%s=%r' % (key, value)
24348 
      for key, value in self.__dict__.iteritems()]
24349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24350 
 
24351 
  def __eq__(self, other):
24352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24353 
 
24354 
  def __ne__(self, other):
24355 
    return not (self == other)
24356 
 
24357 
class getSnapdealSearchResultCount_args:
24358 
  """
24359 
  Attributes:
24360 
   - searchTerm
24361 
  """
24362 
 
24363 
  thrift_spec = (
24364 
    None, # 0
24365 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
24366 
  )
24367 
 
24368 
  def __init__(self, searchTerm=None,):
24369 
    self.searchTerm = searchTerm
24370 
 
24371 
  def read(self, iprot):
24372 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24373 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24374 
      return
24375 
    iprot.readStructBegin()
24376 
    while True:
24377 
      (fname, ftype, fid) = iprot.readFieldBegin()
24378 
      if ftype == TType.STOP:
24379 
        break
24380 
      if fid == 1:
24381 
        if ftype == TType.LIST:
24382 
          self.searchTerm = []
24383 
          (_etype544, _size541) = iprot.readListBegin()
24384 
          for _i545 in xrange(_size541):
24385 
            _elem546 = iprot.readString();
24386 
            self.searchTerm.append(_elem546)
24387 
          iprot.readListEnd()
24388 
        else:
24389 
          iprot.skip(ftype)
24390 
      else:
24391 
        iprot.skip(ftype)
24392 
      iprot.readFieldEnd()
24393 
    iprot.readStructEnd()
24394 
 
24395 
  def write(self, oprot):
24396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24398 
      return
24399 
    oprot.writeStructBegin('getSnapdealSearchResultCount_args')
24400 
    if self.searchTerm is not None:
24401 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
24402 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
24403 
      for iter547 in self.searchTerm:
24404 
        oprot.writeString(iter547)
24405 
      oprot.writeListEnd()
24406 
      oprot.writeFieldEnd()
24407 
    oprot.writeFieldStop()
24408 
    oprot.writeStructEnd()
24409 
 
24410 
  def validate(self):
24411 
    return
24412 
 
24413 
 
24414 
  def __repr__(self):
24415 
    L = ['%s=%r' % (key, value)
24416 
      for key, value in self.__dict__.iteritems()]
24417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24418 
 
24419 
  def __eq__(self, other):
24420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24421 
 
24422 
  def __ne__(self, other):
24423 
    return not (self == other)
24424 
 
24425 
class getSnapdealSearchResultCount_result:
24426 
  """
24427 
  Attributes:
24428 
   - success
24429 
  """
24430 
 
24431 
  thrift_spec = (
24432 
    (0, TType.I64, 'success', None, None, ), # 0
24433 
  )
24434 
 
24435 
  def __init__(self, success=None,):
24436 
    self.success = success
24437 
 
24438 
  def read(self, iprot):
24439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24441 
      return
24442 
    iprot.readStructBegin()
24443 
    while True:
24444 
      (fname, ftype, fid) = iprot.readFieldBegin()
24445 
      if ftype == TType.STOP:
24446 
        break
24447 
      if fid == 0:
24448 
        if ftype == TType.I64:
24449 
          self.success = iprot.readI64();
24450 
        else:
24451 
          iprot.skip(ftype)
24452 
      else:
24453 
        iprot.skip(ftype)
24454 
      iprot.readFieldEnd()
24455 
    iprot.readStructEnd()
24456 
 
24457 
  def write(self, oprot):
24458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24460 
      return
24461 
    oprot.writeStructBegin('getSnapdealSearchResultCount_result')
24462 
    if self.success is not None:
24463 
      oprot.writeFieldBegin('success', TType.I64, 0)
24464 
      oprot.writeI64(self.success)
24465 
      oprot.writeFieldEnd()
24466 
    oprot.writeFieldStop()
24467 
    oprot.writeStructEnd()
24468 
 
24469 
  def validate(self):
24470 
    return
24471 
 
24472 
 
24473 
  def __repr__(self):
24474 
    L = ['%s=%r' % (key, value)
24475 
      for key, value in self.__dict__.iteritems()]
24476 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24477 
 
24478 
  def __eq__(self, other):
24479 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24480 
 
24481 
  def __ne__(self, other):
24482 
    return not (self == other)
9299 kshitij.so 24483 
 
24484 
class getPrefferedInsurerForItem_args:
24485 
  """
24486 
  Attributes:
24487 
   - itemId
24488 
   - insurerType
24489 
  """
24490 
 
24491 
  thrift_spec = (
24492 
    None, # 0
24493 
    (1, TType.I64, 'itemId', None, None, ), # 1
24494 
    (2, TType.I32, 'insurerType', None, None, ), # 2
24495 
  )
24496 
 
24497 
  def __init__(self, itemId=None, insurerType=None,):
24498 
    self.itemId = itemId
24499 
    self.insurerType = insurerType
24500 
 
24501 
  def read(self, iprot):
24502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24504 
      return
24505 
    iprot.readStructBegin()
24506 
    while True:
24507 
      (fname, ftype, fid) = iprot.readFieldBegin()
24508 
      if ftype == TType.STOP:
24509 
        break
24510 
      if fid == 1:
24511 
        if ftype == TType.I64:
24512 
          self.itemId = iprot.readI64();
24513 
        else:
24514 
          iprot.skip(ftype)
24515 
      elif fid == 2:
24516 
        if ftype == TType.I32:
24517 
          self.insurerType = iprot.readI32();
24518 
        else:
24519 
          iprot.skip(ftype)
24520 
      else:
24521 
        iprot.skip(ftype)
24522 
      iprot.readFieldEnd()
24523 
    iprot.readStructEnd()
24524 
 
24525 
  def write(self, oprot):
24526 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24527 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24528 
      return
24529 
    oprot.writeStructBegin('getPrefferedInsurerForItem_args')
24530 
    if self.itemId is not None:
24531 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
24532 
      oprot.writeI64(self.itemId)
24533 
      oprot.writeFieldEnd()
24534 
    if self.insurerType is not None:
24535 
      oprot.writeFieldBegin('insurerType', TType.I32, 2)
24536 
      oprot.writeI32(self.insurerType)
24537 
      oprot.writeFieldEnd()
24538 
    oprot.writeFieldStop()
24539 
    oprot.writeStructEnd()
24540 
 
24541 
  def validate(self):
24542 
    return
24543 
 
24544 
 
24545 
  def __repr__(self):
24546 
    L = ['%s=%r' % (key, value)
24547 
      for key, value in self.__dict__.iteritems()]
24548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24549 
 
24550 
  def __eq__(self, other):
24551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24552 
 
24553 
  def __ne__(self, other):
24554 
    return not (self == other)
24555 
 
24556 
class getPrefferedInsurerForItem_result:
24557 
  """
24558 
  Attributes:
24559 
   - success
24560 
  """
24561 
 
24562 
  thrift_spec = (
24563 
    (0, TType.I64, 'success', None, None, ), # 0
24564 
  )
24565 
 
24566 
  def __init__(self, success=None,):
24567 
    self.success = success
24568 
 
24569 
  def read(self, iprot):
24570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24572 
      return
24573 
    iprot.readStructBegin()
24574 
    while True:
24575 
      (fname, ftype, fid) = iprot.readFieldBegin()
24576 
      if ftype == TType.STOP:
24577 
        break
24578 
      if fid == 0:
24579 
        if ftype == TType.I64:
24580 
          self.success = iprot.readI64();
24581 
        else:
24582 
          iprot.skip(ftype)
24583 
      else:
24584 
        iprot.skip(ftype)
24585 
      iprot.readFieldEnd()
24586 
    iprot.readStructEnd()
24587 
 
24588 
  def write(self, oprot):
24589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24591 
      return
24592 
    oprot.writeStructBegin('getPrefferedInsurerForItem_result')
24593 
    if self.success is not None:
24594 
      oprot.writeFieldBegin('success', TType.I64, 0)
24595 
      oprot.writeI64(self.success)
24596 
      oprot.writeFieldEnd()
24597 
    oprot.writeFieldStop()
24598 
    oprot.writeStructEnd()
24599 
 
24600 
  def validate(self):
24601 
    return
24602 
 
24603 
 
24604 
  def __repr__(self):
24605 
    L = ['%s=%r' % (key, value)
24606 
      for key, value in self.__dict__.iteritems()]
24607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24608 
 
24609 
  def __eq__(self, other):
24610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24611 
 
24612 
  def __ne__(self, other):
24613 
    return not (self == other)
9456 vikram.rag 24614 
 
24615 
class getSnapdealItembySkuAtSnapdeal_args:
24616 
  """
24617 
  Attributes:
24618 
   - skuAtSnapdeal
24619 
  """
24620 
 
24621 
  thrift_spec = None
24622 
  def __init__(self, skuAtSnapdeal=None,):
24623 
    self.skuAtSnapdeal = skuAtSnapdeal
24624 
 
24625 
  def read(self, iprot):
24626 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24627 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24628 
      return
24629 
    iprot.readStructBegin()
24630 
    while True:
24631 
      (fname, ftype, fid) = iprot.readFieldBegin()
24632 
      if ftype == TType.STOP:
24633 
        break
24634 
      if fid == -1:
24635 
        if ftype == TType.STRING:
24636 
          self.skuAtSnapdeal = iprot.readString();
24637 
        else:
24638 
          iprot.skip(ftype)
24639 
      else:
24640 
        iprot.skip(ftype)
24641 
      iprot.readFieldEnd()
24642 
    iprot.readStructEnd()
24643 
 
24644 
  def write(self, oprot):
24645 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24646 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24647 
      return
24648 
    oprot.writeStructBegin('getSnapdealItembySkuAtSnapdeal_args')
24649 
    if self.skuAtSnapdeal is not None:
24650 
      oprot.writeFieldBegin('skuAtSnapdeal', TType.STRING, -1)
24651 
      oprot.writeString(self.skuAtSnapdeal)
24652 
      oprot.writeFieldEnd()
24653 
    oprot.writeFieldStop()
24654 
    oprot.writeStructEnd()
24655 
 
24656 
  def validate(self):
24657 
    return
24658 
 
24659 
 
24660 
  def __repr__(self):
24661 
    L = ['%s=%r' % (key, value)
24662 
      for key, value in self.__dict__.iteritems()]
24663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24664 
 
24665 
  def __eq__(self, other):
24666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24667 
 
24668 
  def __ne__(self, other):
24669 
    return not (self == other)
24670 
 
24671 
class getSnapdealItembySkuAtSnapdeal_result:
24672 
  """
24673 
  Attributes:
24674 
   - success
24675 
  """
24676 
 
24677 
  thrift_spec = (
24678 
    (0, TType.STRUCT, 'success', (SnapdealItem, SnapdealItem.thrift_spec), None, ), # 0
24679 
  )
24680 
 
24681 
  def __init__(self, success=None,):
24682 
    self.success = success
24683 
 
24684 
  def read(self, iprot):
24685 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24686 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24687 
      return
24688 
    iprot.readStructBegin()
24689 
    while True:
24690 
      (fname, ftype, fid) = iprot.readFieldBegin()
24691 
      if ftype == TType.STOP:
24692 
        break
24693 
      if fid == 0:
24694 
        if ftype == TType.STRUCT:
24695 
          self.success = SnapdealItem()
24696 
          self.success.read(iprot)
24697 
        else:
24698 
          iprot.skip(ftype)
24699 
      else:
24700 
        iprot.skip(ftype)
24701 
      iprot.readFieldEnd()
24702 
    iprot.readStructEnd()
24703 
 
24704 
  def write(self, oprot):
24705 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24706 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24707 
      return
24708 
    oprot.writeStructBegin('getSnapdealItembySkuAtSnapdeal_result')
24709 
    if self.success is not None:
24710 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24711 
      self.success.write(oprot)
24712 
      oprot.writeFieldEnd()
24713 
    oprot.writeFieldStop()
24714 
    oprot.writeStructEnd()
24715 
 
24716 
  def validate(self):
24717 
    return
24718 
 
24719 
 
24720 
  def __repr__(self):
24721 
    L = ['%s=%r' % (key, value)
24722 
      for key, value in self.__dict__.iteritems()]
24723 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24724 
 
24725 
  def __eq__(self, other):
24726 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24727 
 
24728 
  def __ne__(self, other):
24729 
    return not (self == other)
9621 manish.sha 24730 
 
24731 
class getProductFeedSubmit_args:
24732 
  """
24733 
  Attributes:
24734 
   - catalogItemId
24735 
  """
24736 
 
24737 
  thrift_spec = (
24738 
    None, # 0
24739 
    (1, TType.I64, 'catalogItemId', None, None, ), # 1
24740 
  )
24741 
 
24742 
  def __init__(self, catalogItemId=None,):
24743 
    self.catalogItemId = catalogItemId
24744 
 
24745 
  def read(self, iprot):
24746 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24747 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24748 
      return
24749 
    iprot.readStructBegin()
24750 
    while True:
24751 
      (fname, ftype, fid) = iprot.readFieldBegin()
24752 
      if ftype == TType.STOP:
24753 
        break
24754 
      if fid == 1:
24755 
        if ftype == TType.I64:
24756 
          self.catalogItemId = iprot.readI64();
24757 
        else:
24758 
          iprot.skip(ftype)
24759 
      else:
24760 
        iprot.skip(ftype)
24761 
      iprot.readFieldEnd()
24762 
    iprot.readStructEnd()
24763 
 
24764 
  def write(self, oprot):
24765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24767 
      return
24768 
    oprot.writeStructBegin('getProductFeedSubmit_args')
24769 
    if self.catalogItemId is not None:
24770 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 1)
24771 
      oprot.writeI64(self.catalogItemId)
24772 
      oprot.writeFieldEnd()
24773 
    oprot.writeFieldStop()
24774 
    oprot.writeStructEnd()
24775 
 
24776 
  def validate(self):
24777 
    return
24778 
 
24779 
 
24780 
  def __repr__(self):
24781 
    L = ['%s=%r' % (key, value)
24782 
      for key, value in self.__dict__.iteritems()]
24783 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24784 
 
24785 
  def __eq__(self, other):
24786 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24787 
 
24788 
  def __ne__(self, other):
24789 
    return not (self == other)
24790 
 
24791 
class getProductFeedSubmit_result:
24792 
  """
24793 
  Attributes:
24794 
   - success
24795 
   - cex
24796 
  """
24797 
 
24798 
  thrift_spec = (
24799 
    (0, TType.STRUCT, 'success', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 0
24800 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
24801 
  )
24802 
 
24803 
  def __init__(self, success=None, cex=None,):
24804 
    self.success = success
24805 
    self.cex = cex
24806 
 
24807 
  def read(self, iprot):
24808 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24809 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24810 
      return
24811 
    iprot.readStructBegin()
24812 
    while True:
24813 
      (fname, ftype, fid) = iprot.readFieldBegin()
24814 
      if ftype == TType.STOP:
24815 
        break
24816 
      if fid == 0:
24817 
        if ftype == TType.STRUCT:
24818 
          self.success = ProductFeedSubmit()
24819 
          self.success.read(iprot)
24820 
        else:
24821 
          iprot.skip(ftype)
24822 
      elif fid == 1:
24823 
        if ftype == TType.STRUCT:
24824 
          self.cex = CatalogServiceException()
24825 
          self.cex.read(iprot)
24826 
        else:
24827 
          iprot.skip(ftype)
24828 
      else:
24829 
        iprot.skip(ftype)
24830 
      iprot.readFieldEnd()
24831 
    iprot.readStructEnd()
24832 
 
24833 
  def write(self, oprot):
24834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24836 
      return
24837 
    oprot.writeStructBegin('getProductFeedSubmit_result')
24838 
    if self.success is not None:
24839 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24840 
      self.success.write(oprot)
24841 
      oprot.writeFieldEnd()
24842 
    if self.cex is not None:
24843 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
24844 
      self.cex.write(oprot)
24845 
      oprot.writeFieldEnd()
24846 
    oprot.writeFieldStop()
24847 
    oprot.writeStructEnd()
24848 
 
24849 
  def validate(self):
24850 
    return
24851 
 
24852 
 
24853 
  def __repr__(self):
24854 
    L = ['%s=%r' % (key, value)
24855 
      for key, value in self.__dict__.iteritems()]
24856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24857 
 
24858 
  def __eq__(self, other):
24859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24860 
 
24861 
  def __ne__(self, other):
24862 
    return not (self == other)
24863 
 
24864 
class addProductFeedSubmit_args:
24865 
  """
24866 
  Attributes:
24867 
   - productFeedSubmit
24868 
  """
24869 
 
24870 
  thrift_spec = (
24871 
    None, # 0
24872 
    (1, TType.STRUCT, 'productFeedSubmit', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 1
24873 
  )
24874 
 
24875 
  def __init__(self, productFeedSubmit=None,):
24876 
    self.productFeedSubmit = productFeedSubmit
24877 
 
24878 
  def read(self, iprot):
24879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24881 
      return
24882 
    iprot.readStructBegin()
24883 
    while True:
24884 
      (fname, ftype, fid) = iprot.readFieldBegin()
24885 
      if ftype == TType.STOP:
24886 
        break
24887 
      if fid == 1:
24888 
        if ftype == TType.STRUCT:
24889 
          self.productFeedSubmit = ProductFeedSubmit()
24890 
          self.productFeedSubmit.read(iprot)
24891 
        else:
24892 
          iprot.skip(ftype)
24893 
      else:
24894 
        iprot.skip(ftype)
24895 
      iprot.readFieldEnd()
24896 
    iprot.readStructEnd()
24897 
 
24898 
  def write(self, oprot):
24899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24901 
      return
24902 
    oprot.writeStructBegin('addProductFeedSubmit_args')
24903 
    if self.productFeedSubmit is not None:
24904 
      oprot.writeFieldBegin('productFeedSubmit', TType.STRUCT, 1)
24905 
      self.productFeedSubmit.write(oprot)
24906 
      oprot.writeFieldEnd()
24907 
    oprot.writeFieldStop()
24908 
    oprot.writeStructEnd()
24909 
 
24910 
  def validate(self):
24911 
    return
24912 
 
24913 
 
24914 
  def __repr__(self):
24915 
    L = ['%s=%r' % (key, value)
24916 
      for key, value in self.__dict__.iteritems()]
24917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24918 
 
24919 
  def __eq__(self, other):
24920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24921 
 
24922 
  def __ne__(self, other):
24923 
    return not (self == other)
24924 
 
24925 
class addProductFeedSubmit_result:
24926 
  """
24927 
  Attributes:
24928 
   - success
24929 
   - cex
24930 
  """
24931 
 
24932 
  thrift_spec = (
24933 
    (0, TType.BOOL, 'success', None, None, ), # 0
24934 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
24935 
  )
24936 
 
24937 
  def __init__(self, success=None, cex=None,):
24938 
    self.success = success
24939 
    self.cex = cex
24940 
 
24941 
  def read(self, iprot):
24942 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24943 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24944 
      return
24945 
    iprot.readStructBegin()
24946 
    while True:
24947 
      (fname, ftype, fid) = iprot.readFieldBegin()
24948 
      if ftype == TType.STOP:
24949 
        break
24950 
      if fid == 0:
24951 
        if ftype == TType.BOOL:
24952 
          self.success = iprot.readBool();
24953 
        else:
24954 
          iprot.skip(ftype)
24955 
      elif fid == 1:
24956 
        if ftype == TType.STRUCT:
24957 
          self.cex = CatalogServiceException()
24958 
          self.cex.read(iprot)
24959 
        else:
24960 
          iprot.skip(ftype)
24961 
      else:
24962 
        iprot.skip(ftype)
24963 
      iprot.readFieldEnd()
24964 
    iprot.readStructEnd()
24965 
 
24966 
  def write(self, oprot):
24967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24969 
      return
24970 
    oprot.writeStructBegin('addProductFeedSubmit_result')
24971 
    if self.success is not None:
24972 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
24973 
      oprot.writeBool(self.success)
24974 
      oprot.writeFieldEnd()
24975 
    if self.cex is not None:
24976 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
24977 
      self.cex.write(oprot)
24978 
      oprot.writeFieldEnd()
24979 
    oprot.writeFieldStop()
24980 
    oprot.writeStructEnd()
24981 
 
24982 
  def validate(self):
24983 
    return
24984 
 
24985 
 
24986 
  def __repr__(self):
24987 
    L = ['%s=%r' % (key, value)
24988 
      for key, value in self.__dict__.iteritems()]
24989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24990 
 
24991 
  def __eq__(self, other):
24992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24993 
 
24994 
  def __ne__(self, other):
24995 
    return not (self == other)
24996 
 
24997 
class updateProductFeedSubmit_args:
24998 
  """
24999 
  Attributes:
25000 
   - productFeedSubmit
25001 
  """
25002 
 
25003 
  thrift_spec = (
25004 
    None, # 0
25005 
    (1, TType.STRUCT, 'productFeedSubmit', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 1
25006 
  )
25007 
 
25008 
  def __init__(self, productFeedSubmit=None,):
25009 
    self.productFeedSubmit = productFeedSubmit
25010 
 
25011 
  def read(self, iprot):
25012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25014 
      return
25015 
    iprot.readStructBegin()
25016 
    while True:
25017 
      (fname, ftype, fid) = iprot.readFieldBegin()
25018 
      if ftype == TType.STOP:
25019 
        break
25020 
      if fid == 1:
25021 
        if ftype == TType.STRUCT:
25022 
          self.productFeedSubmit = ProductFeedSubmit()
25023 
          self.productFeedSubmit.read(iprot)
25024 
        else:
25025 
          iprot.skip(ftype)
25026 
      else:
25027 
        iprot.skip(ftype)
25028 
      iprot.readFieldEnd()
25029 
    iprot.readStructEnd()
25030 
 
25031 
  def write(self, oprot):
25032 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25033 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25034 
      return
25035 
    oprot.writeStructBegin('updateProductFeedSubmit_args')
25036 
    if self.productFeedSubmit is not None:
25037 
      oprot.writeFieldBegin('productFeedSubmit', TType.STRUCT, 1)
25038 
      self.productFeedSubmit.write(oprot)
25039 
      oprot.writeFieldEnd()
25040 
    oprot.writeFieldStop()
25041 
    oprot.writeStructEnd()
25042 
 
25043 
  def validate(self):
25044 
    return
25045 
 
25046 
 
25047 
  def __repr__(self):
25048 
    L = ['%s=%r' % (key, value)
25049 
      for key, value in self.__dict__.iteritems()]
25050 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25051 
 
25052 
  def __eq__(self, other):
25053 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25054 
 
25055 
  def __ne__(self, other):
25056 
    return not (self == other)
25057 
 
25058 
class updateProductFeedSubmit_result:
25059 
  """
25060 
  Attributes:
25061 
   - success
25062 
   - cex
25063 
  """
25064 
 
25065 
  thrift_spec = (
25066 
    (0, TType.BOOL, 'success', None, None, ), # 0
25067 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
25068 
  )
25069 
 
25070 
  def __init__(self, success=None, cex=None,):
25071 
    self.success = success
25072 
    self.cex = cex
25073 
 
25074 
  def read(self, iprot):
25075 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25076 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25077 
      return
25078 
    iprot.readStructBegin()
25079 
    while True:
25080 
      (fname, ftype, fid) = iprot.readFieldBegin()
25081 
      if ftype == TType.STOP:
25082 
        break
25083 
      if fid == 0:
25084 
        if ftype == TType.BOOL:
25085 
          self.success = iprot.readBool();
25086 
        else:
25087 
          iprot.skip(ftype)
25088 
      elif fid == 1:
25089 
        if ftype == TType.STRUCT:
25090 
          self.cex = CatalogServiceException()
25091 
          self.cex.read(iprot)
25092 
        else:
25093 
          iprot.skip(ftype)
25094 
      else:
25095 
        iprot.skip(ftype)
25096 
      iprot.readFieldEnd()
25097 
    iprot.readStructEnd()
25098 
 
25099 
  def write(self, oprot):
25100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25102 
      return
25103 
    oprot.writeStructBegin('updateProductFeedSubmit_result')
25104 
    if self.success is not None:
25105 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
25106 
      oprot.writeBool(self.success)
25107 
      oprot.writeFieldEnd()
25108 
    if self.cex is not None:
25109 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
25110 
      self.cex.write(oprot)
25111 
      oprot.writeFieldEnd()
25112 
    oprot.writeFieldStop()
25113 
    oprot.writeStructEnd()
25114 
 
25115 
  def validate(self):
25116 
    return
25117 
 
25118 
 
25119 
  def __repr__(self):
25120 
    L = ['%s=%r' % (key, value)
25121 
      for key, value in self.__dict__.iteritems()]
25122 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25123 
 
25124 
  def __eq__(self, other):
25125 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25126 
 
25127 
  def __ne__(self, other):
25128 
    return not (self == other)
25129 
 
25130 
class deleteProductFeedSubmit_args:
25131 
  """
25132 
  Attributes:
25133 
   - catalogItemId
25134 
  """
25135 
 
25136 
  thrift_spec = (
25137 
    None, # 0
25138 
    (1, TType.I64, 'catalogItemId', None, None, ), # 1
25139 
  )
25140 
 
25141 
  def __init__(self, catalogItemId=None,):
25142 
    self.catalogItemId = catalogItemId
25143 
 
25144 
  def read(self, iprot):
25145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25147 
      return
25148 
    iprot.readStructBegin()
25149 
    while True:
25150 
      (fname, ftype, fid) = iprot.readFieldBegin()
25151 
      if ftype == TType.STOP:
25152 
        break
25153 
      if fid == 1:
25154 
        if ftype == TType.I64:
25155 
          self.catalogItemId = iprot.readI64();
25156 
        else:
25157 
          iprot.skip(ftype)
25158 
      else:
25159 
        iprot.skip(ftype)
25160 
      iprot.readFieldEnd()
25161 
    iprot.readStructEnd()
25162 
 
25163 
  def write(self, oprot):
25164 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25165 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25166 
      return
25167 
    oprot.writeStructBegin('deleteProductFeedSubmit_args')
25168 
    if self.catalogItemId is not None:
25169 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 1)
25170 
      oprot.writeI64(self.catalogItemId)
25171 
      oprot.writeFieldEnd()
25172 
    oprot.writeFieldStop()
25173 
    oprot.writeStructEnd()
25174 
 
25175 
  def validate(self):
25176 
    return
25177 
 
25178 
 
25179 
  def __repr__(self):
25180 
    L = ['%s=%r' % (key, value)
25181 
      for key, value in self.__dict__.iteritems()]
25182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25183 
 
25184 
  def __eq__(self, other):
25185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25186 
 
25187 
  def __ne__(self, other):
25188 
    return not (self == other)
25189 
 
25190 
class deleteProductFeedSubmit_result:
25191 
  """
25192 
  Attributes:
25193 
   - success
25194 
   - cex
25195 
  """
25196 
 
25197 
  thrift_spec = (
25198 
    (0, TType.BOOL, 'success', None, None, ), # 0
25199 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
25200 
  )
25201 
 
25202 
  def __init__(self, success=None, cex=None,):
25203 
    self.success = success
25204 
    self.cex = cex
25205 
 
25206 
  def read(self, iprot):
25207 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25208 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25209 
      return
25210 
    iprot.readStructBegin()
25211 
    while True:
25212 
      (fname, ftype, fid) = iprot.readFieldBegin()
25213 
      if ftype == TType.STOP:
25214 
        break
25215 
      if fid == 0:
25216 
        if ftype == TType.BOOL:
25217 
          self.success = iprot.readBool();
25218 
        else:
25219 
          iprot.skip(ftype)
25220 
      elif fid == 1:
25221 
        if ftype == TType.STRUCT:
25222 
          self.cex = CatalogServiceException()
25223 
          self.cex.read(iprot)
25224 
        else:
25225 
          iprot.skip(ftype)
25226 
      else:
25227 
        iprot.skip(ftype)
25228 
      iprot.readFieldEnd()
25229 
    iprot.readStructEnd()
25230 
 
25231 
  def write(self, oprot):
25232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25234 
      return
25235 
    oprot.writeStructBegin('deleteProductFeedSubmit_result')
25236 
    if self.success is not None:
25237 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
25238 
      oprot.writeBool(self.success)
25239 
      oprot.writeFieldEnd()
25240 
    if self.cex is not None:
25241 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
25242 
      self.cex.write(oprot)
25243 
      oprot.writeFieldEnd()
25244 
    oprot.writeFieldStop()
25245 
    oprot.writeStructEnd()
25246 
 
25247 
  def validate(self):
25248 
    return
25249 
 
25250 
 
25251 
  def __repr__(self):
25252 
    L = ['%s=%r' % (key, value)
25253 
      for key, value in self.__dict__.iteritems()]
25254 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25255 
 
25256 
  def __eq__(self, other):
25257 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25258 
 
25259 
  def __ne__(self, other):
25260 
    return not (self == other)
25261 
 
25262 
class getAllProductFeedSubmit_args:
25263 
 
25264 
  thrift_spec = (
25265 
  )
25266 
 
25267 
  def read(self, iprot):
25268 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25269 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25270 
      return
25271 
    iprot.readStructBegin()
25272 
    while True:
25273 
      (fname, ftype, fid) = iprot.readFieldBegin()
25274 
      if ftype == TType.STOP:
25275 
        break
25276 
      else:
25277 
        iprot.skip(ftype)
25278 
      iprot.readFieldEnd()
25279 
    iprot.readStructEnd()
25280 
 
25281 
  def write(self, oprot):
25282 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25283 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25284 
      return
25285 
    oprot.writeStructBegin('getAllProductFeedSubmit_args')
25286 
    oprot.writeFieldStop()
25287 
    oprot.writeStructEnd()
25288 
 
25289 
  def validate(self):
25290 
    return
25291 
 
25292 
 
25293 
  def __repr__(self):
25294 
    L = ['%s=%r' % (key, value)
25295 
      for key, value in self.__dict__.iteritems()]
25296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25297 
 
25298 
  def __eq__(self, other):
25299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25300 
 
25301 
  def __ne__(self, other):
25302 
    return not (self == other)
25303 
 
25304 
class getAllProductFeedSubmit_result:
25305 
  """
25306 
  Attributes:
25307 
   - success
25308 
   - cex
25309 
  """
25310 
 
25311 
  thrift_spec = (
25312 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductFeedSubmit, ProductFeedSubmit.thrift_spec)), None, ), # 0
25313 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
25314 
  )
25315 
 
25316 
  def __init__(self, success=None, cex=None,):
25317 
    self.success = success
25318 
    self.cex = cex
25319 
 
25320 
  def read(self, iprot):
25321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25323 
      return
25324 
    iprot.readStructBegin()
25325 
    while True:
25326 
      (fname, ftype, fid) = iprot.readFieldBegin()
25327 
      if ftype == TType.STOP:
25328 
        break
25329 
      if fid == 0:
25330 
        if ftype == TType.LIST:
25331 
          self.success = []
25332 
          (_etype551, _size548) = iprot.readListBegin()
25333 
          for _i552 in xrange(_size548):
25334 
            _elem553 = ProductFeedSubmit()
25335 
            _elem553.read(iprot)
25336 
            self.success.append(_elem553)
25337 
          iprot.readListEnd()
25338 
        else:
25339 
          iprot.skip(ftype)
25340 
      elif fid == 1:
25341 
        if ftype == TType.STRUCT:
25342 
          self.cex = CatalogServiceException()
25343 
          self.cex.read(iprot)
25344 
        else:
25345 
          iprot.skip(ftype)
25346 
      else:
25347 
        iprot.skip(ftype)
25348 
      iprot.readFieldEnd()
25349 
    iprot.readStructEnd()
25350 
 
25351 
  def write(self, oprot):
25352 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25353 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25354 
      return
25355 
    oprot.writeStructBegin('getAllProductFeedSubmit_result')
25356 
    if self.success is not None:
25357 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25358 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
25359 
      for iter554 in self.success:
25360 
        iter554.write(oprot)
25361 
      oprot.writeListEnd()
25362 
      oprot.writeFieldEnd()
25363 
    if self.cex is not None:
25364 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
25365 
      self.cex.write(oprot)
25366 
      oprot.writeFieldEnd()
25367 
    oprot.writeFieldStop()
25368 
    oprot.writeStructEnd()
25369 
 
25370 
  def validate(self):
25371 
    return
25372 
 
25373 
 
25374 
  def __repr__(self):
25375 
    L = ['%s=%r' % (key, value)
25376 
      for key, value in self.__dict__.iteritems()]
25377 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25378 
 
25379 
  def __eq__(self, other):
25380 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25381 
 
25382 
  def __ne__(self, other):
25383 
    return not (self == other)
9724 kshitij.so 25384 
 
25385 
class getMarketplacedetailsForItem_args:
25386 
  """
25387 
  Attributes:
25388 
   - itemId
25389 
   - sourceId
25390 
  """
25391 
 
25392 
  thrift_spec = (
25393 
    None, # 0
25394 
    (1, TType.I64, 'itemId', None, None, ), # 1
25395 
    (2, TType.I64, 'sourceId', None, None, ), # 2
25396 
  )
25397 
 
25398 
  def __init__(self, itemId=None, sourceId=None,):
25399 
    self.itemId = itemId
25400 
    self.sourceId = sourceId
25401 
 
25402 
  def read(self, iprot):
25403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25405 
      return
25406 
    iprot.readStructBegin()
25407 
    while True:
25408 
      (fname, ftype, fid) = iprot.readFieldBegin()
25409 
      if ftype == TType.STOP:
25410 
        break
25411 
      if fid == 1:
25412 
        if ftype == TType.I64:
25413 
          self.itemId = iprot.readI64();
25414 
        else:
25415 
          iprot.skip(ftype)
25416 
      elif fid == 2:
25417 
        if ftype == TType.I64:
25418 
          self.sourceId = iprot.readI64();
25419 
        else:
25420 
          iprot.skip(ftype)
25421 
      else:
25422 
        iprot.skip(ftype)
25423 
      iprot.readFieldEnd()
25424 
    iprot.readStructEnd()
25425 
 
25426 
  def write(self, oprot):
25427 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25428 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25429 
      return
25430 
    oprot.writeStructBegin('getMarketplacedetailsForItem_args')
25431 
    if self.itemId is not None:
25432 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
25433 
      oprot.writeI64(self.itemId)
25434 
      oprot.writeFieldEnd()
25435 
    if self.sourceId is not None:
25436 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
25437 
      oprot.writeI64(self.sourceId)
25438 
      oprot.writeFieldEnd()
25439 
    oprot.writeFieldStop()
25440 
    oprot.writeStructEnd()
25441 
 
25442 
  def validate(self):
25443 
    return
25444 
 
25445 
 
25446 
  def __repr__(self):
25447 
    L = ['%s=%r' % (key, value)
25448 
      for key, value in self.__dict__.iteritems()]
25449 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25450 
 
25451 
  def __eq__(self, other):
25452 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25453 
 
25454 
  def __ne__(self, other):
25455 
    return not (self == other)
25456 
 
25457 
class getMarketplacedetailsForItem_result:
25458 
  """
25459 
  Attributes:
25460 
   - success
25461 
  """
25462 
 
25463 
  thrift_spec = (
25464 
    (0, TType.STRUCT, 'success', (MarketplaceItems, MarketplaceItems.thrift_spec), None, ), # 0
25465 
  )
25466 
 
25467 
  def __init__(self, success=None,):
25468 
    self.success = success
25469 
 
25470 
  def read(self, iprot):
25471 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25472 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25473 
      return
25474 
    iprot.readStructBegin()
25475 
    while True:
25476 
      (fname, ftype, fid) = iprot.readFieldBegin()
25477 
      if ftype == TType.STOP:
25478 
        break
25479 
      if fid == 0:
25480 
        if ftype == TType.STRUCT:
25481 
          self.success = MarketplaceItems()
25482 
          self.success.read(iprot)
25483 
        else:
25484 
          iprot.skip(ftype)
25485 
      else:
25486 
        iprot.skip(ftype)
25487 
      iprot.readFieldEnd()
25488 
    iprot.readStructEnd()
25489 
 
25490 
  def write(self, oprot):
25491 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25492 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25493 
      return
25494 
    oprot.writeStructBegin('getMarketplacedetailsForItem_result')
25495 
    if self.success is not None:
25496 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
25497 
      self.success.write(oprot)
25498 
      oprot.writeFieldEnd()
25499 
    oprot.writeFieldStop()
25500 
    oprot.writeStructEnd()
25501 
 
25502 
  def validate(self):
25503 
    return
25504 
 
25505 
 
25506 
  def __repr__(self):
25507 
    L = ['%s=%r' % (key, value)
25508 
      for key, value in self.__dict__.iteritems()]
25509 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25510 
 
25511 
  def __eq__(self, other):
25512 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25513 
 
25514 
  def __ne__(self, other):
25515 
    return not (self == other)
25516 
 
25517 
class updateMarketplaceAttributesForItem_args:
25518 
  """
25519 
  Attributes:
25520 
   - marketPlaceItem
25521 
  """
25522 
 
25523 
  thrift_spec = (
25524 
    None, # 0
25525 
    (1, TType.STRUCT, 'marketPlaceItem', (MarketplaceItems, MarketplaceItems.thrift_spec), None, ), # 1
25526 
  )
25527 
 
25528 
  def __init__(self, marketPlaceItem=None,):
25529 
    self.marketPlaceItem = marketPlaceItem
25530 
 
25531 
  def read(self, iprot):
25532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25534 
      return
25535 
    iprot.readStructBegin()
25536 
    while True:
25537 
      (fname, ftype, fid) = iprot.readFieldBegin()
25538 
      if ftype == TType.STOP:
25539 
        break
25540 
      if fid == 1:
25541 
        if ftype == TType.STRUCT:
25542 
          self.marketPlaceItem = MarketplaceItems()
25543 
          self.marketPlaceItem.read(iprot)
25544 
        else:
25545 
          iprot.skip(ftype)
25546 
      else:
25547 
        iprot.skip(ftype)
25548 
      iprot.readFieldEnd()
25549 
    iprot.readStructEnd()
25550 
 
25551 
  def write(self, oprot):
25552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25554 
      return
25555 
    oprot.writeStructBegin('updateMarketplaceAttributesForItem_args')
25556 
    if self.marketPlaceItem is not None:
25557 
      oprot.writeFieldBegin('marketPlaceItem', TType.STRUCT, 1)
25558 
      self.marketPlaceItem.write(oprot)
25559 
      oprot.writeFieldEnd()
25560 
    oprot.writeFieldStop()
25561 
    oprot.writeStructEnd()
25562 
 
25563 
  def validate(self):
25564 
    return
25565 
 
25566 
 
25567 
  def __repr__(self):
25568 
    L = ['%s=%r' % (key, value)
25569 
      for key, value in self.__dict__.iteritems()]
25570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25571 
 
25572 
  def __eq__(self, other):
25573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25574 
 
25575 
  def __ne__(self, other):
25576 
    return not (self == other)
25577 
 
25578 
class updateMarketplaceAttributesForItem_result:
25579 
  """
25580 
  Attributes:
25581 
   - success
25582 
  """
25583 
 
25584 
  thrift_spec = (
25585 
    (0, TType.BOOL, 'success', None, None, ), # 0
25586 
  )
25587 
 
25588 
  def __init__(self, success=None,):
25589 
    self.success = success
25590 
 
25591 
  def read(self, iprot):
25592 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25593 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25594 
      return
25595 
    iprot.readStructBegin()
25596 
    while True:
25597 
      (fname, ftype, fid) = iprot.readFieldBegin()
25598 
      if ftype == TType.STOP:
25599 
        break
25600 
      if fid == 0:
25601 
        if ftype == TType.BOOL:
25602 
          self.success = iprot.readBool();
25603 
        else:
25604 
          iprot.skip(ftype)
25605 
      else:
25606 
        iprot.skip(ftype)
25607 
      iprot.readFieldEnd()
25608 
    iprot.readStructEnd()
25609 
 
25610 
  def write(self, oprot):
25611 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25612 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25613 
      return
25614 
    oprot.writeStructBegin('updateMarketplaceAttributesForItem_result')
25615 
    if self.success is not None:
25616 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
25617 
      oprot.writeBool(self.success)
25618 
      oprot.writeFieldEnd()
25619 
    oprot.writeFieldStop()
25620 
    oprot.writeStructEnd()
25621 
 
25622 
  def validate(self):
25623 
    return
25624 
 
25625 
 
25626 
  def __repr__(self):
25627 
    L = ['%s=%r' % (key, value)
25628 
      for key, value in self.__dict__.iteritems()]
25629 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25630 
 
25631 
  def __eq__(self, other):
25632 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25633 
 
25634 
  def __ne__(self, other):
25635 
    return not (self == other)
9776 vikram.rag 25636 
 
9779 kshitij.so 25637 
class getCostingForMarketplace_args:
25638 
  """
25639 
  Attributes:
25640 
   - source
25641 
   - item_id
25642 
  """
25643 
 
25644 
  thrift_spec = (
25645 
    None, # 0
25646 
    (1, TType.I64, 'source', None, None, ), # 1
25647 
    (2, TType.I64, 'item_id', None, None, ), # 2
25648 
  )
25649 
 
25650 
  def __init__(self, source=None, item_id=None,):
25651 
    self.source = source
25652 
    self.item_id = item_id
25653 
 
25654 
  def read(self, iprot):
25655 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25656 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25657 
      return
25658 
    iprot.readStructBegin()
25659 
    while True:
25660 
      (fname, ftype, fid) = iprot.readFieldBegin()
25661 
      if ftype == TType.STOP:
25662 
        break
25663 
      if fid == 1:
25664 
        if ftype == TType.I64:
25665 
          self.source = iprot.readI64();
25666 
        else:
25667 
          iprot.skip(ftype)
25668 
      elif fid == 2:
25669 
        if ftype == TType.I64:
25670 
          self.item_id = iprot.readI64();
25671 
        else:
25672 
          iprot.skip(ftype)
25673 
      else:
25674 
        iprot.skip(ftype)
25675 
      iprot.readFieldEnd()
25676 
    iprot.readStructEnd()
25677 
 
25678 
  def write(self, oprot):
25679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25681 
      return
25682 
    oprot.writeStructBegin('getCostingForMarketplace_args')
25683 
    if self.source is not None:
25684 
      oprot.writeFieldBegin('source', TType.I64, 1)
25685 
      oprot.writeI64(self.source)
25686 
      oprot.writeFieldEnd()
25687 
    if self.item_id is not None:
25688 
      oprot.writeFieldBegin('item_id', TType.I64, 2)
25689 
      oprot.writeI64(self.item_id)
25690 
      oprot.writeFieldEnd()
25691 
    oprot.writeFieldStop()
25692 
    oprot.writeStructEnd()
25693 
 
25694 
  def validate(self):
25695 
    return
25696 
 
25697 
 
25698 
  def __repr__(self):
25699 
    L = ['%s=%r' % (key, value)
25700 
      for key, value in self.__dict__.iteritems()]
25701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25702 
 
25703 
  def __eq__(self, other):
25704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25705 
 
25706 
  def __ne__(self, other):
25707 
    return not (self == other)
25708 
 
25709 
class getCostingForMarketplace_result:
25710 
  """
25711 
  Attributes:
25712 
   - success
25713 
  """
25714 
 
25715 
  thrift_spec = (
25716 
    (0, TType.STRUCT, 'success', (MarketplacePercentage, MarketplacePercentage.thrift_spec), None, ), # 0
25717 
  )
25718 
 
25719 
  def __init__(self, success=None,):
25720 
    self.success = success
25721 
 
25722 
  def read(self, iprot):
25723 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25724 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25725 
      return
25726 
    iprot.readStructBegin()
25727 
    while True:
25728 
      (fname, ftype, fid) = iprot.readFieldBegin()
25729 
      if ftype == TType.STOP:
25730 
        break
25731 
      if fid == 0:
25732 
        if ftype == TType.STRUCT:
25733 
          self.success = MarketplacePercentage()
25734 
          self.success.read(iprot)
25735 
        else:
25736 
          iprot.skip(ftype)
25737 
      else:
25738 
        iprot.skip(ftype)
25739 
      iprot.readFieldEnd()
25740 
    iprot.readStructEnd()
25741 
 
25742 
  def write(self, oprot):
25743 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25744 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25745 
      return
25746 
    oprot.writeStructBegin('getCostingForMarketplace_result')
25747 
    if self.success is not None:
25748 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
25749 
      self.success.write(oprot)
25750 
      oprot.writeFieldEnd()
25751 
    oprot.writeFieldStop()
25752 
    oprot.writeStructEnd()
25753 
 
25754 
  def validate(self):
25755 
    return
25756 
 
25757 
 
25758 
  def __repr__(self):
25759 
    L = ['%s=%r' % (key, value)
25760 
      for key, value in self.__dict__.iteritems()]
25761 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25762 
 
25763 
  def __eq__(self, other):
25764 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25765 
 
25766 
  def __ne__(self, other):
25767 
    return not (self == other)
25768 
 
9776 vikram.rag 25769 
class getMarketPlaceItemsForPriceUpdate_args:
25770 
  """
25771 
  Attributes:
25772 
   - source
25773 
  """
25774 
 
25775 
  thrift_spec = (
25776 
    None, # 0
25777 
    (1, TType.I64, 'source', None, None, ), # 1
25778 
  )
25779 
 
25780 
  def __init__(self, source=None,):
25781 
    self.source = source
25782 
 
25783 
  def read(self, iprot):
25784 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25785 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25786 
      return
25787 
    iprot.readStructBegin()
25788 
    while True:
25789 
      (fname, ftype, fid) = iprot.readFieldBegin()
25790 
      if ftype == TType.STOP:
25791 
        break
25792 
      if fid == 1:
25793 
        if ftype == TType.I64:
25794 
          self.source = iprot.readI64();
25795 
        else:
25796 
          iprot.skip(ftype)
25797 
      else:
25798 
        iprot.skip(ftype)
25799 
      iprot.readFieldEnd()
25800 
    iprot.readStructEnd()
25801 
 
25802 
  def write(self, oprot):
25803 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25804 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25805 
      return
25806 
    oprot.writeStructBegin('getMarketPlaceItemsForPriceUpdate_args')
25807 
    if self.source is not None:
25808 
      oprot.writeFieldBegin('source', TType.I64, 1)
25809 
      oprot.writeI64(self.source)
25810 
      oprot.writeFieldEnd()
25811 
    oprot.writeFieldStop()
25812 
    oprot.writeStructEnd()
25813 
 
25814 
  def validate(self):
25815 
    return
25816 
 
25817 
 
25818 
  def __repr__(self):
25819 
    L = ['%s=%r' % (key, value)
25820 
      for key, value in self.__dict__.iteritems()]
25821 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25822 
 
25823 
  def __eq__(self, other):
25824 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25825 
 
25826 
  def __ne__(self, other):
25827 
    return not (self == other)
25828 
 
25829 
class getMarketPlaceItemsForPriceUpdate_result:
25830 
  """
25831 
  Attributes:
25832 
   - success
25833 
  """
25834 
 
25835 
  thrift_spec = (
25836 
    (0, TType.LIST, 'success', (TType.STRUCT,(MarketPlaceItemPrice, MarketPlaceItemPrice.thrift_spec)), None, ), # 0
25837 
  )
25838 
 
25839 
  def __init__(self, success=None,):
25840 
    self.success = success
25841 
 
25842 
  def read(self, iprot):
25843 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25844 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25845 
      return
25846 
    iprot.readStructBegin()
25847 
    while True:
25848 
      (fname, ftype, fid) = iprot.readFieldBegin()
25849 
      if ftype == TType.STOP:
25850 
        break
25851 
      if fid == 0:
25852 
        if ftype == TType.LIST:
25853 
          self.success = []
25854 
          (_etype558, _size555) = iprot.readListBegin()
25855 
          for _i559 in xrange(_size555):
25856 
            _elem560 = MarketPlaceItemPrice()
25857 
            _elem560.read(iprot)
25858 
            self.success.append(_elem560)
25859 
          iprot.readListEnd()
25860 
        else:
25861 
          iprot.skip(ftype)
25862 
      else:
25863 
        iprot.skip(ftype)
25864 
      iprot.readFieldEnd()
25865 
    iprot.readStructEnd()
25866 
 
25867 
  def write(self, oprot):
25868 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25869 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25870 
      return
25871 
    oprot.writeStructBegin('getMarketPlaceItemsForPriceUpdate_result')
25872 
    if self.success is not None:
25873 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25874 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
25875 
      for iter561 in self.success:
25876 
        iter561.write(oprot)
25877 
      oprot.writeListEnd()
25878 
      oprot.writeFieldEnd()
25879 
    oprot.writeFieldStop()
25880 
    oprot.writeStructEnd()
25881 
 
25882 
  def validate(self):
25883 
    return
25884 
 
25885 
 
25886 
  def __repr__(self):
25887 
    L = ['%s=%r' % (key, value)
25888 
      for key, value in self.__dict__.iteritems()]
25889 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25890 
 
25891 
  def __eq__(self, other):
25892 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25893 
 
25894 
  def __ne__(self, other):
25895 
    return not (self == other)
25896 
 
25897 
class updateMarketPlacePriceUpdateStatus_args:
25898 
  """
25899 
  Attributes:
25900 
   - skulist
25901 
   - timestamp
9816 kshitij.so 25902 
   - source
9776 vikram.rag 25903 
  """
25904 
 
25905 
  thrift_spec = (
25906 
    None, # 0
25907 
    (1, TType.LIST, 'skulist', (TType.I64,None), None, ), # 1
25908 
    (2, TType.I64, 'timestamp', None, None, ), # 2
9816 kshitij.so 25909 
    (3, TType.I64, 'source', None, None, ), # 3
9776 vikram.rag 25910 
  )
25911 
 
9816 kshitij.so 25912 
  def __init__(self, skulist=None, timestamp=None, source=None,):
9776 vikram.rag 25913 
    self.skulist = skulist
25914 
    self.timestamp = timestamp
9816 kshitij.so 25915 
    self.source = source
9776 vikram.rag 25916 
 
25917 
  def read(self, iprot):
25918 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25919 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25920 
      return
25921 
    iprot.readStructBegin()
25922 
    while True:
25923 
      (fname, ftype, fid) = iprot.readFieldBegin()
25924 
      if ftype == TType.STOP:
25925 
        break
25926 
      if fid == 1:
25927 
        if ftype == TType.LIST:
25928 
          self.skulist = []
25929 
          (_etype565, _size562) = iprot.readListBegin()
25930 
          for _i566 in xrange(_size562):
25931 
            _elem567 = iprot.readI64();
25932 
            self.skulist.append(_elem567)
25933 
          iprot.readListEnd()
25934 
        else:
25935 
          iprot.skip(ftype)
25936 
      elif fid == 2:
25937 
        if ftype == TType.I64:
25938 
          self.timestamp = iprot.readI64();
25939 
        else:
25940 
          iprot.skip(ftype)
9816 kshitij.so 25941 
      elif fid == 3:
25942 
        if ftype == TType.I64:
25943 
          self.source = iprot.readI64();
25944 
        else:
25945 
          iprot.skip(ftype)
9776 vikram.rag 25946 
      else:
25947 
        iprot.skip(ftype)
25948 
      iprot.readFieldEnd()
25949 
    iprot.readStructEnd()
25950 
 
25951 
  def write(self, oprot):
25952 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25953 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25954 
      return
25955 
    oprot.writeStructBegin('updateMarketPlacePriceUpdateStatus_args')
25956 
    if self.skulist is not None:
25957 
      oprot.writeFieldBegin('skulist', TType.LIST, 1)
25958 
      oprot.writeListBegin(TType.I64, len(self.skulist))
25959 
      for iter568 in self.skulist:
25960 
        oprot.writeI64(iter568)
25961 
      oprot.writeListEnd()
25962 
      oprot.writeFieldEnd()
25963 
    if self.timestamp is not None:
25964 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
25965 
      oprot.writeI64(self.timestamp)
25966 
      oprot.writeFieldEnd()
9816 kshitij.so 25967 
    if self.source is not None:
25968 
      oprot.writeFieldBegin('source', TType.I64, 3)
25969 
      oprot.writeI64(self.source)
25970 
      oprot.writeFieldEnd()
9776 vikram.rag 25971 
    oprot.writeFieldStop()
25972 
    oprot.writeStructEnd()
25973 
 
25974 
  def validate(self):
25975 
    return
25976 
 
25977 
 
25978 
  def __repr__(self):
25979 
    L = ['%s=%r' % (key, value)
25980 
      for key, value in self.__dict__.iteritems()]
25981 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25982 
 
25983 
  def __eq__(self, other):
25984 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25985 
 
25986 
  def __ne__(self, other):
25987 
    return not (self == other)
25988 
 
25989 
class updateMarketPlacePriceUpdateStatus_result:
25990 
 
25991 
  thrift_spec = (
25992 
  )
25993 
 
25994 
  def read(self, iprot):
25995 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25996 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25997 
      return
25998 
    iprot.readStructBegin()
25999 
    while True:
26000 
      (fname, ftype, fid) = iprot.readFieldBegin()
26001 
      if ftype == TType.STOP:
26002 
        break
26003 
      else:
26004 
        iprot.skip(ftype)
26005 
      iprot.readFieldEnd()
26006 
    iprot.readStructEnd()
26007 
 
26008 
  def write(self, oprot):
26009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26011 
      return
26012 
    oprot.writeStructBegin('updateMarketPlacePriceUpdateStatus_result')
26013 
    oprot.writeFieldStop()
26014 
    oprot.writeStructEnd()
26015 
 
26016 
  def validate(self):
26017 
    return
26018 
 
26019 
 
26020 
  def __repr__(self):
26021 
    L = ['%s=%r' % (key, value)
26022 
      for key, value in self.__dict__.iteritems()]
26023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26024 
 
26025 
  def __eq__(self, other):
26026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26027 
 
26028 
  def __ne__(self, other):
26029 
    return not (self == other)
9861 rajveer 26030 
 
26031 
class updateItemHoldInventory_args:
26032 
  """
26033 
  Attributes:
26034 
   - itemHoldMap
26035 
  """
26036 
 
26037 
  thrift_spec = (
26038 
    None, # 0
26039 
    (1, TType.MAP, 'itemHoldMap', (TType.I64,None,TType.I64,None), None, ), # 1
26040 
  )
26041 
 
26042 
  def __init__(self, itemHoldMap=None,):
26043 
    self.itemHoldMap = itemHoldMap
26044 
 
26045 
  def read(self, iprot):
26046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26048 
      return
26049 
    iprot.readStructBegin()
26050 
    while True:
26051 
      (fname, ftype, fid) = iprot.readFieldBegin()
26052 
      if ftype == TType.STOP:
26053 
        break
26054 
      if fid == 1:
26055 
        if ftype == TType.MAP:
26056 
          self.itemHoldMap = {}
26057 
          (_ktype570, _vtype571, _size569 ) = iprot.readMapBegin()
26058 
          for _i573 in xrange(_size569):
26059 
            _key574 = iprot.readI64();
26060 
            _val575 = iprot.readI64();
26061 
            self.itemHoldMap[_key574] = _val575
26062 
          iprot.readMapEnd()
26063 
        else:
26064 
          iprot.skip(ftype)
26065 
      else:
26066 
        iprot.skip(ftype)
26067 
      iprot.readFieldEnd()
26068 
    iprot.readStructEnd()
26069 
 
26070 
  def write(self, oprot):
26071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26073 
      return
26074 
    oprot.writeStructBegin('updateItemHoldInventory_args')
26075 
    if self.itemHoldMap is not None:
26076 
      oprot.writeFieldBegin('itemHoldMap', TType.MAP, 1)
26077 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.itemHoldMap))
26078 
      for kiter576,viter577 in self.itemHoldMap.items():
26079 
        oprot.writeI64(kiter576)
26080 
        oprot.writeI64(viter577)
26081 
      oprot.writeMapEnd()
26082 
      oprot.writeFieldEnd()
26083 
    oprot.writeFieldStop()
26084 
    oprot.writeStructEnd()
26085 
 
26086 
  def validate(self):
26087 
    return
26088 
 
26089 
 
26090 
  def __repr__(self):
26091 
    L = ['%s=%r' % (key, value)
26092 
      for key, value in self.__dict__.iteritems()]
26093 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26094 
 
26095 
  def __eq__(self, other):
26096 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26097 
 
26098 
  def __ne__(self, other):
26099 
    return not (self == other)
26100 
 
26101 
class updateItemHoldInventory_result:
26102 
 
26103 
  thrift_spec = (
26104 
  )
26105 
 
26106 
  def read(self, iprot):
26107 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26108 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26109 
      return
26110 
    iprot.readStructBegin()
26111 
    while True:
26112 
      (fname, ftype, fid) = iprot.readFieldBegin()
26113 
      if ftype == TType.STOP:
26114 
        break
26115 
      else:
26116 
        iprot.skip(ftype)
26117 
      iprot.readFieldEnd()
26118 
    iprot.readStructEnd()
26119 
 
26120 
  def write(self, oprot):
26121 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26122 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26123 
      return
26124 
    oprot.writeStructBegin('updateItemHoldInventory_result')
26125 
    oprot.writeFieldStop()
26126 
    oprot.writeStructEnd()
26127 
 
26128 
  def validate(self):
26129 
    return
26130 
 
26131 
 
26132 
  def __repr__(self):
26133 
    L = ['%s=%r' % (key, value)
26134 
      for key, value in self.__dict__.iteritems()]
26135 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26136 
 
26137 
  def __eq__(self, other):
26138 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26139 
 
26140 
  def __ne__(self, other):
26141 
    return not (self == other)
9895 vikram.rag 26142 
 
26143 
class updateNlcAtMarketplaces_args:
26144 
  """
26145 
  Attributes:
26146 
   - item_id
26147 
   - vendor_id
26148 
   - nlc
26149 
  """
26150 
 
26151 
  thrift_spec = None
26152 
  def __init__(self, item_id=None, vendor_id=None, nlc=None,):
26153 
    self.item_id = item_id
26154 
    self.vendor_id = vendor_id
26155 
    self.nlc = nlc
26156 
 
26157 
  def read(self, iprot):
26158 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26159 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26160 
      return
26161 
    iprot.readStructBegin()
26162 
    while True:
26163 
      (fname, ftype, fid) = iprot.readFieldBegin()
26164 
      if ftype == TType.STOP:
26165 
        break
26166 
      if fid == 1:
26167 
        if ftype == TType.I64:
26168 
          self.item_id = iprot.readI64();
26169 
        else:
26170 
          iprot.skip(ftype)
26171 
      elif fid == 2:
26172 
        if ftype == TType.I64:
26173 
          self.vendor_id = iprot.readI64();
26174 
        else:
26175 
          iprot.skip(ftype)
26176 
      elif fid == -1:
26177 
        if ftype == TType.DOUBLE:
26178 
          self.nlc = iprot.readDouble();
26179 
        else:
26180 
          iprot.skip(ftype)
26181 
      else:
26182 
        iprot.skip(ftype)
26183 
      iprot.readFieldEnd()
26184 
    iprot.readStructEnd()
26185 
 
26186 
  def write(self, oprot):
26187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26189 
      return
26190 
    oprot.writeStructBegin('updateNlcAtMarketplaces_args')
26191 
    if self.nlc is not None:
26192 
      oprot.writeFieldBegin('nlc', TType.DOUBLE, -1)
26193 
      oprot.writeDouble(self.nlc)
26194 
      oprot.writeFieldEnd()
26195 
    if self.item_id is not None:
26196 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
26197 
      oprot.writeI64(self.item_id)
26198 
      oprot.writeFieldEnd()
26199 
    if self.vendor_id is not None:
26200 
      oprot.writeFieldBegin('vendor_id', TType.I64, 2)
26201 
      oprot.writeI64(self.vendor_id)
26202 
      oprot.writeFieldEnd()
26203 
    oprot.writeFieldStop()
26204 
    oprot.writeStructEnd()
26205 
 
26206 
  def validate(self):
26207 
    return
26208 
 
26209 
 
26210 
  def __repr__(self):
26211 
    L = ['%s=%r' % (key, value)
26212 
      for key, value in self.__dict__.iteritems()]
26213 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26214 
 
26215 
  def __eq__(self, other):
26216 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26217 
 
26218 
  def __ne__(self, other):
26219 
    return not (self == other)
26220 
 
26221 
class updateNlcAtMarketplaces_result:
26222 
 
26223 
  thrift_spec = (
26224 
  )
26225 
 
26226 
  def read(self, iprot):
26227 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26228 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26229 
      return
26230 
    iprot.readStructBegin()
26231 
    while True:
26232 
      (fname, ftype, fid) = iprot.readFieldBegin()
26233 
      if ftype == TType.STOP:
26234 
        break
26235 
      else:
26236 
        iprot.skip(ftype)
26237 
      iprot.readFieldEnd()
26238 
    iprot.readStructEnd()
26239 
 
26240 
  def write(self, oprot):
26241 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26242 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26243 
      return
26244 
    oprot.writeStructBegin('updateNlcAtMarketplaces_result')
26245 
    oprot.writeFieldStop()
26246 
    oprot.writeStructEnd()
26247 
 
26248 
  def validate(self):
26249 
    return
26250 
 
26251 
 
26252 
  def __repr__(self):
26253 
    L = ['%s=%r' % (key, value)
26254 
      for key, value in self.__dict__.iteritems()]
26255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26256 
 
26257 
  def __eq__(self, other):
26258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26259 
 
26260 
  def __ne__(self, other):
26261 
    return not (self == other)
9945 vikram.rag 26262 
 
26263 
class getAllFlipkartItems_args:
26264 
 
26265 
  thrift_spec = (
26266 
  )
26267 
 
26268 
  def read(self, iprot):
26269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26271 
      return
26272 
    iprot.readStructBegin()
26273 
    while True:
26274 
      (fname, ftype, fid) = iprot.readFieldBegin()
26275 
      if ftype == TType.STOP:
26276 
        break
26277 
      else:
26278 
        iprot.skip(ftype)
26279 
      iprot.readFieldEnd()
26280 
    iprot.readStructEnd()
26281 
 
26282 
  def write(self, oprot):
26283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26285 
      return
26286 
    oprot.writeStructBegin('getAllFlipkartItems_args')
26287 
    oprot.writeFieldStop()
26288 
    oprot.writeStructEnd()
26289 
 
26290 
  def validate(self):
26291 
    return
26292 
 
26293 
 
26294 
  def __repr__(self):
26295 
    L = ['%s=%r' % (key, value)
26296 
      for key, value in self.__dict__.iteritems()]
26297 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26298 
 
26299 
  def __eq__(self, other):
26300 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26301 
 
26302 
  def __ne__(self, other):
26303 
    return not (self == other)
26304 
 
26305 
class getAllFlipkartItems_result:
26306 
  """
26307 
  Attributes:
26308 
   - success
26309 
  """
26310 
 
26311 
  thrift_spec = (
26312 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartItem, FlipkartItem.thrift_spec)), None, ), # 0
26313 
  )
26314 
 
26315 
  def __init__(self, success=None,):
26316 
    self.success = success
26317 
 
26318 
  def read(self, iprot):
26319 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26320 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26321 
      return
26322 
    iprot.readStructBegin()
26323 
    while True:
26324 
      (fname, ftype, fid) = iprot.readFieldBegin()
26325 
      if ftype == TType.STOP:
26326 
        break
26327 
      if fid == 0:
26328 
        if ftype == TType.LIST:
26329 
          self.success = []
26330 
          (_etype581, _size578) = iprot.readListBegin()
26331 
          for _i582 in xrange(_size578):
26332 
            _elem583 = FlipkartItem()
26333 
            _elem583.read(iprot)
26334 
            self.success.append(_elem583)
26335 
          iprot.readListEnd()
26336 
        else:
26337 
          iprot.skip(ftype)
26338 
      else:
26339 
        iprot.skip(ftype)
26340 
      iprot.readFieldEnd()
26341 
    iprot.readStructEnd()
26342 
 
26343 
  def write(self, oprot):
26344 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26345 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26346 
      return
26347 
    oprot.writeStructBegin('getAllFlipkartItems_result')
26348 
    if self.success is not None:
26349 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26350 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
26351 
      for iter584 in self.success:
26352 
        iter584.write(oprot)
26353 
      oprot.writeListEnd()
26354 
      oprot.writeFieldEnd()
26355 
    oprot.writeFieldStop()
26356 
    oprot.writeStructEnd()
26357 
 
26358 
  def validate(self):
26359 
    return
26360 
 
26361 
 
26362 
  def __repr__(self):
26363 
    L = ['%s=%r' % (key, value)
26364 
      for key, value in self.__dict__.iteritems()]
26365 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26366 
 
26367 
  def __eq__(self, other):
26368 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26369 
 
26370 
  def __ne__(self, other):
26371 
    return not (self == other)
10097 kshitij.so 26372 
 
26373 
class addOrUpdateFlipkartItem_args:
26374 
  """
26375 
  Attributes:
26376 
   - flipkartitem
26377 
  """
26378 
 
26379 
  thrift_spec = None
26380 
  def __init__(self, flipkartitem=None,):
26381 
    self.flipkartitem = flipkartitem
26382 
 
26383 
  def read(self, iprot):
26384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26386 
      return
26387 
    iprot.readStructBegin()
26388 
    while True:
26389 
      (fname, ftype, fid) = iprot.readFieldBegin()
26390 
      if ftype == TType.STOP:
26391 
        break
26392 
      if fid == -1:
26393 
        if ftype == TType.STRUCT:
26394 
          self.flipkartitem = FlipkartItem()
26395 
          self.flipkartitem.read(iprot)
26396 
        else:
26397 
          iprot.skip(ftype)
26398 
      else:
26399 
        iprot.skip(ftype)
26400 
      iprot.readFieldEnd()
26401 
    iprot.readStructEnd()
26402 
 
26403 
  def write(self, oprot):
26404 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26405 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26406 
      return
26407 
    oprot.writeStructBegin('addOrUpdateFlipkartItem_args')
26408 
    if self.flipkartitem is not None:
26409 
      oprot.writeFieldBegin('flipkartitem', TType.STRUCT, -1)
26410 
      self.flipkartitem.write(oprot)
26411 
      oprot.writeFieldEnd()
26412 
    oprot.writeFieldStop()
26413 
    oprot.writeStructEnd()
26414 
 
26415 
  def validate(self):
26416 
    return
26417 
 
26418 
 
26419 
  def __repr__(self):
26420 
    L = ['%s=%r' % (key, value)
26421 
      for key, value in self.__dict__.iteritems()]
26422 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26423 
 
26424 
  def __eq__(self, other):
26425 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26426 
 
26427 
  def __ne__(self, other):
26428 
    return not (self == other)
26429 
 
26430 
class addOrUpdateFlipkartItem_result:
26431 
  """
26432 
  Attributes:
26433 
   - success
26434 
  """
26435 
 
26436 
  thrift_spec = (
26437 
    (0, TType.BOOL, 'success', None, None, ), # 0
26438 
  )
26439 
 
26440 
  def __init__(self, success=None,):
26441 
    self.success = success
26442 
 
26443 
  def read(self, iprot):
26444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26446 
      return
26447 
    iprot.readStructBegin()
26448 
    while True:
26449 
      (fname, ftype, fid) = iprot.readFieldBegin()
26450 
      if ftype == TType.STOP:
26451 
        break
26452 
      if fid == 0:
26453 
        if ftype == TType.BOOL:
26454 
          self.success = iprot.readBool();
26455 
        else:
26456 
          iprot.skip(ftype)
26457 
      else:
26458 
        iprot.skip(ftype)
26459 
      iprot.readFieldEnd()
26460 
    iprot.readStructEnd()
26461 
 
26462 
  def write(self, oprot):
26463 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26464 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26465 
      return
26466 
    oprot.writeStructBegin('addOrUpdateFlipkartItem_result')
26467 
    if self.success is not None:
26468 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26469 
      oprot.writeBool(self.success)
26470 
      oprot.writeFieldEnd()
26471 
    oprot.writeFieldStop()
26472 
    oprot.writeStructEnd()
26473 
 
26474 
  def validate(self):
26475 
    return
26476 
 
26477 
 
26478 
  def __repr__(self):
26479 
    L = ['%s=%r' % (key, value)
26480 
      for key, value in self.__dict__.iteritems()]
26481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26482 
 
26483 
  def __eq__(self, other):
26484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26485 
 
26486 
  def __ne__(self, other):
26487 
    return not (self == other)
26488 
 
26489 
class getFlipkartItem_args:
26490 
  """
26491 
  Attributes:
26492 
   - item_id
26493 
  """
26494 
 
26495 
  thrift_spec = (
26496 
    None, # 0
26497 
    (1, TType.I64, 'item_id', None, None, ), # 1
26498 
  )
26499 
 
26500 
  def __init__(self, item_id=None,):
26501 
    self.item_id = item_id
26502 
 
26503 
  def read(self, iprot):
26504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26506 
      return
26507 
    iprot.readStructBegin()
26508 
    while True:
26509 
      (fname, ftype, fid) = iprot.readFieldBegin()
26510 
      if ftype == TType.STOP:
26511 
        break
26512 
      if fid == 1:
26513 
        if ftype == TType.I64:
26514 
          self.item_id = iprot.readI64();
26515 
        else:
26516 
          iprot.skip(ftype)
26517 
      else:
26518 
        iprot.skip(ftype)
26519 
      iprot.readFieldEnd()
26520 
    iprot.readStructEnd()
26521 
 
26522 
  def write(self, oprot):
26523 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26524 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26525 
      return
26526 
    oprot.writeStructBegin('getFlipkartItem_args')
26527 
    if self.item_id is not None:
26528 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
26529 
      oprot.writeI64(self.item_id)
26530 
      oprot.writeFieldEnd()
26531 
    oprot.writeFieldStop()
26532 
    oprot.writeStructEnd()
26533 
 
26534 
  def validate(self):
26535 
    return
26536 
 
26537 
 
26538 
  def __repr__(self):
26539 
    L = ['%s=%r' % (key, value)
26540 
      for key, value in self.__dict__.iteritems()]
26541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26542 
 
26543 
  def __eq__(self, other):
26544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26545 
 
26546 
  def __ne__(self, other):
26547 
    return not (self == other)
26548 
 
26549 
class getFlipkartItem_result:
26550 
  """
26551 
  Attributes:
26552 
   - success
26553 
  """
26554 
 
26555 
  thrift_spec = (
26556 
    (0, TType.STRUCT, 'success', (FlipkartItem, FlipkartItem.thrift_spec), None, ), # 0
26557 
  )
26558 
 
26559 
  def __init__(self, success=None,):
26560 
    self.success = success
26561 
 
26562 
  def read(self, iprot):
26563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26565 
      return
26566 
    iprot.readStructBegin()
26567 
    while True:
26568 
      (fname, ftype, fid) = iprot.readFieldBegin()
26569 
      if ftype == TType.STOP:
26570 
        break
26571 
      if fid == 0:
26572 
        if ftype == TType.STRUCT:
26573 
          self.success = FlipkartItem()
26574 
          self.success.read(iprot)
26575 
        else:
26576 
          iprot.skip(ftype)
26577 
      else:
26578 
        iprot.skip(ftype)
26579 
      iprot.readFieldEnd()
26580 
    iprot.readStructEnd()
26581 
 
26582 
  def write(self, oprot):
26583 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26584 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26585 
      return
26586 
    oprot.writeStructBegin('getFlipkartItem_result')
26587 
    if self.success is not None:
26588 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26589 
      self.success.write(oprot)
26590 
      oprot.writeFieldEnd()
26591 
    oprot.writeFieldStop()
26592 
    oprot.writeStructEnd()
26593 
 
26594 
  def validate(self):
26595 
    return
26596 
 
26597 
 
26598 
  def __repr__(self):
26599 
    L = ['%s=%r' % (key, value)
26600 
      for key, value in self.__dict__.iteritems()]
26601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26602 
 
26603 
  def __eq__(self, other):
26604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26605 
 
26606 
  def __ne__(self, other):
26607 
    return not (self == other)
26608 
 
26609 
class getFlipkartItemDetails_args:
26610 
  """
26611 
  Attributes:
26612 
   - item_id
26613 
  """
26614 
 
26615 
  thrift_spec = (
26616 
    None, # 0
26617 
    (1, TType.I64, 'item_id', None, None, ), # 1
26618 
  )
26619 
 
26620 
  def __init__(self, item_id=None,):
26621 
    self.item_id = item_id
26622 
 
26623 
  def read(self, iprot):
26624 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26625 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26626 
      return
26627 
    iprot.readStructBegin()
26628 
    while True:
26629 
      (fname, ftype, fid) = iprot.readFieldBegin()
26630 
      if ftype == TType.STOP:
26631 
        break
26632 
      if fid == 1:
26633 
        if ftype == TType.I64:
26634 
          self.item_id = iprot.readI64();
26635 
        else:
26636 
          iprot.skip(ftype)
26637 
      else:
26638 
        iprot.skip(ftype)
26639 
      iprot.readFieldEnd()
26640 
    iprot.readStructEnd()
26641 
 
26642 
  def write(self, oprot):
26643 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26644 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26645 
      return
26646 
    oprot.writeStructBegin('getFlipkartItemDetails_args')
26647 
    if self.item_id is not None:
26648 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
26649 
      oprot.writeI64(self.item_id)
26650 
      oprot.writeFieldEnd()
26651 
    oprot.writeFieldStop()
26652 
    oprot.writeStructEnd()
26653 
 
26654 
  def validate(self):
26655 
    return
26656 
 
26657 
 
26658 
  def __repr__(self):
26659 
    L = ['%s=%r' % (key, value)
26660 
      for key, value in self.__dict__.iteritems()]
26661 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26662 
 
26663 
  def __eq__(self, other):
26664 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26665 
 
26666 
  def __ne__(self, other):
26667 
    return not (self == other)
26668 
 
26669 
class getFlipkartItemDetails_result:
26670 
  """
26671 
  Attributes:
26672 
   - success
26673 
  """
26674 
 
26675 
  thrift_spec = (
26676 
    (0, TType.STRUCT, 'success', (FlipkartItemDetails, FlipkartItemDetails.thrift_spec), None, ), # 0
26677 
  )
26678 
 
26679 
  def __init__(self, success=None,):
26680 
    self.success = success
26681 
 
26682 
  def read(self, iprot):
26683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26685 
      return
26686 
    iprot.readStructBegin()
26687 
    while True:
26688 
      (fname, ftype, fid) = iprot.readFieldBegin()
26689 
      if ftype == TType.STOP:
26690 
        break
26691 
      if fid == 0:
26692 
        if ftype == TType.STRUCT:
26693 
          self.success = FlipkartItemDetails()
26694 
          self.success.read(iprot)
26695 
        else:
26696 
          iprot.skip(ftype)
26697 
      else:
26698 
        iprot.skip(ftype)
26699 
      iprot.readFieldEnd()
26700 
    iprot.readStructEnd()
26701 
 
26702 
  def write(self, oprot):
26703 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26704 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26705 
      return
26706 
    oprot.writeStructBegin('getFlipkartItemDetails_result')
26707 
    if self.success is not None:
26708 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26709 
      self.success.write(oprot)
26710 
      oprot.writeFieldEnd()
26711 
    oprot.writeFieldStop()
26712 
    oprot.writeStructEnd()
26713 
 
26714 
  def validate(self):
26715 
    return
26716 
 
26717 
 
26718 
  def __repr__(self):
26719 
    L = ['%s=%r' % (key, value)
26720 
      for key, value in self.__dict__.iteritems()]
26721 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26722 
 
26723 
  def __eq__(self, other):
26724 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26725 
 
26726 
  def __ne__(self, other):
26727 
    return not (self == other)
26728 
 
26729 
class getFlipkartItems_args:
26730 
  """
26731 
  Attributes:
26732 
   - offset
26733 
   - limit
26734 
  """
26735 
 
26736 
  thrift_spec = (
26737 
    None, # 0
26738 
    (1, TType.I64, 'offset', None, None, ), # 1
26739 
    (2, TType.I64, 'limit', None, None, ), # 2
26740 
  )
26741 
 
26742 
  def __init__(self, offset=None, limit=None,):
26743 
    self.offset = offset
26744 
    self.limit = limit
26745 
 
26746 
  def read(self, iprot):
26747 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26748 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26749 
      return
26750 
    iprot.readStructBegin()
26751 
    while True:
26752 
      (fname, ftype, fid) = iprot.readFieldBegin()
26753 
      if ftype == TType.STOP:
26754 
        break
26755 
      if fid == 1:
26756 
        if ftype == TType.I64:
26757 
          self.offset = iprot.readI64();
26758 
        else:
26759 
          iprot.skip(ftype)
26760 
      elif fid == 2:
26761 
        if ftype == TType.I64:
26762 
          self.limit = iprot.readI64();
26763 
        else:
26764 
          iprot.skip(ftype)
26765 
      else:
26766 
        iprot.skip(ftype)
26767 
      iprot.readFieldEnd()
26768 
    iprot.readStructEnd()
26769 
 
26770 
  def write(self, oprot):
26771 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26772 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26773 
      return
26774 
    oprot.writeStructBegin('getFlipkartItems_args')
26775 
    if self.offset is not None:
26776 
      oprot.writeFieldBegin('offset', TType.I64, 1)
26777 
      oprot.writeI64(self.offset)
26778 
      oprot.writeFieldEnd()
26779 
    if self.limit is not None:
26780 
      oprot.writeFieldBegin('limit', TType.I64, 2)
26781 
      oprot.writeI64(self.limit)
26782 
      oprot.writeFieldEnd()
26783 
    oprot.writeFieldStop()
26784 
    oprot.writeStructEnd()
26785 
 
26786 
  def validate(self):
26787 
    return
26788 
 
26789 
 
26790 
  def __repr__(self):
26791 
    L = ['%s=%r' % (key, value)
26792 
      for key, value in self.__dict__.iteritems()]
26793 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26794 
 
26795 
  def __eq__(self, other):
26796 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26797 
 
26798 
  def __ne__(self, other):
26799 
    return not (self == other)
26800 
 
26801 
class getFlipkartItems_result:
26802 
  """
26803 
  Attributes:
26804 
   - success
26805 
  """
26806 
 
26807 
  thrift_spec = (
26808 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartItemDetails, FlipkartItemDetails.thrift_spec)), None, ), # 0
26809 
  )
26810 
 
26811 
  def __init__(self, success=None,):
26812 
    self.success = success
26813 
 
26814 
  def read(self, iprot):
26815 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26816 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26817 
      return
26818 
    iprot.readStructBegin()
26819 
    while True:
26820 
      (fname, ftype, fid) = iprot.readFieldBegin()
26821 
      if ftype == TType.STOP:
26822 
        break
26823 
      if fid == 0:
26824 
        if ftype == TType.LIST:
26825 
          self.success = []
26826 
          (_etype588, _size585) = iprot.readListBegin()
26827 
          for _i589 in xrange(_size585):
26828 
            _elem590 = FlipkartItemDetails()
26829 
            _elem590.read(iprot)
26830 
            self.success.append(_elem590)
26831 
          iprot.readListEnd()
26832 
        else:
26833 
          iprot.skip(ftype)
26834 
      else:
26835 
        iprot.skip(ftype)
26836 
      iprot.readFieldEnd()
26837 
    iprot.readStructEnd()
26838 
 
26839 
  def write(self, oprot):
26840 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26841 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26842 
      return
26843 
    oprot.writeStructBegin('getFlipkartItems_result')
26844 
    if self.success is not None:
26845 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26846 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
26847 
      for iter591 in self.success:
26848 
        iter591.write(oprot)
26849 
      oprot.writeListEnd()
26850 
      oprot.writeFieldEnd()
26851 
    oprot.writeFieldStop()
26852 
    oprot.writeStructEnd()
26853 
 
26854 
  def validate(self):
26855 
    return
26856 
 
26857 
 
26858 
  def __repr__(self):
26859 
    L = ['%s=%r' % (key, value)
26860 
      for key, value in self.__dict__.iteritems()]
26861 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26862 
 
26863 
  def __eq__(self, other):
26864 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26865 
 
26866 
  def __ne__(self, other):
26867 
    return not (self == other)
26868 
 
26869 
class searchFlipkartItems_args:
26870 
  """
26871 
  Attributes:
26872 
   - searchTerm
26873 
   - offset
26874 
   - limit
26875 
  """
26876 
 
26877 
  thrift_spec = (
26878 
    None, # 0
26879 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
26880 
    (2, TType.I64, 'offset', None, None, ), # 2
26881 
    (3, TType.I64, 'limit', None, None, ), # 3
26882 
  )
26883 
 
26884 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
26885 
    self.searchTerm = searchTerm
26886 
    self.offset = offset
26887 
    self.limit = limit
26888 
 
26889 
  def read(self, iprot):
26890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26892 
      return
26893 
    iprot.readStructBegin()
26894 
    while True:
26895 
      (fname, ftype, fid) = iprot.readFieldBegin()
26896 
      if ftype == TType.STOP:
26897 
        break
26898 
      if fid == 1:
26899 
        if ftype == TType.LIST:
26900 
          self.searchTerm = []
26901 
          (_etype595, _size592) = iprot.readListBegin()
26902 
          for _i596 in xrange(_size592):
26903 
            _elem597 = iprot.readString();
26904 
            self.searchTerm.append(_elem597)
26905 
          iprot.readListEnd()
26906 
        else:
26907 
          iprot.skip(ftype)
26908 
      elif fid == 2:
26909 
        if ftype == TType.I64:
26910 
          self.offset = iprot.readI64();
26911 
        else:
26912 
          iprot.skip(ftype)
26913 
      elif fid == 3:
26914 
        if ftype == TType.I64:
26915 
          self.limit = iprot.readI64();
26916 
        else:
26917 
          iprot.skip(ftype)
26918 
      else:
26919 
        iprot.skip(ftype)
26920 
      iprot.readFieldEnd()
26921 
    iprot.readStructEnd()
26922 
 
26923 
  def write(self, oprot):
26924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26926 
      return
26927 
    oprot.writeStructBegin('searchFlipkartItems_args')
26928 
    if self.searchTerm is not None:
26929 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
26930 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
26931 
      for iter598 in self.searchTerm:
26932 
        oprot.writeString(iter598)
26933 
      oprot.writeListEnd()
26934 
      oprot.writeFieldEnd()
26935 
    if self.offset is not None:
26936 
      oprot.writeFieldBegin('offset', TType.I64, 2)
26937 
      oprot.writeI64(self.offset)
26938 
      oprot.writeFieldEnd()
26939 
    if self.limit is not None:
26940 
      oprot.writeFieldBegin('limit', TType.I64, 3)
26941 
      oprot.writeI64(self.limit)
26942 
      oprot.writeFieldEnd()
26943 
    oprot.writeFieldStop()
26944 
    oprot.writeStructEnd()
26945 
 
26946 
  def validate(self):
26947 
    return
26948 
 
26949 
 
26950 
  def __repr__(self):
26951 
    L = ['%s=%r' % (key, value)
26952 
      for key, value in self.__dict__.iteritems()]
26953 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26954 
 
26955 
  def __eq__(self, other):
26956 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26957 
 
26958 
  def __ne__(self, other):
26959 
    return not (self == other)
26960 
 
26961 
class searchFlipkartItems_result:
26962 
  """
26963 
  Attributes:
26964 
   - success
26965 
  """
26966 
 
26967 
  thrift_spec = (
26968 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartItemDetails, FlipkartItemDetails.thrift_spec)), None, ), # 0
26969 
  )
26970 
 
26971 
  def __init__(self, success=None,):
26972 
    self.success = success
26973 
 
26974 
  def read(self, iprot):
26975 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26976 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26977 
      return
26978 
    iprot.readStructBegin()
26979 
    while True:
26980 
      (fname, ftype, fid) = iprot.readFieldBegin()
26981 
      if ftype == TType.STOP:
26982 
        break
26983 
      if fid == 0:
26984 
        if ftype == TType.LIST:
26985 
          self.success = []
26986 
          (_etype602, _size599) = iprot.readListBegin()
26987 
          for _i603 in xrange(_size599):
26988 
            _elem604 = FlipkartItemDetails()
26989 
            _elem604.read(iprot)
26990 
            self.success.append(_elem604)
26991 
          iprot.readListEnd()
26992 
        else:
26993 
          iprot.skip(ftype)
26994 
      else:
26995 
        iprot.skip(ftype)
26996 
      iprot.readFieldEnd()
26997 
    iprot.readStructEnd()
26998 
 
26999 
  def write(self, oprot):
27000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27002 
      return
27003 
    oprot.writeStructBegin('searchFlipkartItems_result')
27004 
    if self.success is not None:
27005 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27006 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
27007 
      for iter605 in self.success:
27008 
        iter605.write(oprot)
27009 
      oprot.writeListEnd()
27010 
      oprot.writeFieldEnd()
27011 
    oprot.writeFieldStop()
27012 
    oprot.writeStructEnd()
27013 
 
27014 
  def validate(self):
27015 
    return
27016 
 
27017 
 
27018 
  def __repr__(self):
27019 
    L = ['%s=%r' % (key, value)
27020 
      for key, value in self.__dict__.iteritems()]
27021 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27022 
 
27023 
  def __eq__(self, other):
27024 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27025 
 
27026 
  def __ne__(self, other):
27027 
    return not (self == other)
27028 
 
27029 
class getCountForFlipkartItems_args:
27030 
 
27031 
  thrift_spec = (
27032 
  )
27033 
 
27034 
  def read(self, iprot):
27035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27037 
      return
27038 
    iprot.readStructBegin()
27039 
    while True:
27040 
      (fname, ftype, fid) = iprot.readFieldBegin()
27041 
      if ftype == TType.STOP:
27042 
        break
27043 
      else:
27044 
        iprot.skip(ftype)
27045 
      iprot.readFieldEnd()
27046 
    iprot.readStructEnd()
27047 
 
27048 
  def write(self, oprot):
27049 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27050 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27051 
      return
27052 
    oprot.writeStructBegin('getCountForFlipkartItems_args')
27053 
    oprot.writeFieldStop()
27054 
    oprot.writeStructEnd()
27055 
 
27056 
  def validate(self):
27057 
    return
27058 
 
27059 
 
27060 
  def __repr__(self):
27061 
    L = ['%s=%r' % (key, value)
27062 
      for key, value in self.__dict__.iteritems()]
27063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27064 
 
27065 
  def __eq__(self, other):
27066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27067 
 
27068 
  def __ne__(self, other):
27069 
    return not (self == other)
27070 
 
27071 
class getCountForFlipkartItems_result:
27072 
  """
27073 
  Attributes:
27074 
   - success
27075 
  """
27076 
 
27077 
  thrift_spec = (
27078 
    (0, TType.I64, 'success', None, None, ), # 0
27079 
  )
27080 
 
27081 
  def __init__(self, success=None,):
27082 
    self.success = success
27083 
 
27084 
  def read(self, iprot):
27085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27087 
      return
27088 
    iprot.readStructBegin()
27089 
    while True:
27090 
      (fname, ftype, fid) = iprot.readFieldBegin()
27091 
      if ftype == TType.STOP:
27092 
        break
27093 
      if fid == 0:
27094 
        if ftype == TType.I64:
27095 
          self.success = iprot.readI64();
27096 
        else:
27097 
          iprot.skip(ftype)
27098 
      else:
27099 
        iprot.skip(ftype)
27100 
      iprot.readFieldEnd()
27101 
    iprot.readStructEnd()
27102 
 
27103 
  def write(self, oprot):
27104 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27105 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27106 
      return
27107 
    oprot.writeStructBegin('getCountForFlipkartItems_result')
27108 
    if self.success is not None:
27109 
      oprot.writeFieldBegin('success', TType.I64, 0)
27110 
      oprot.writeI64(self.success)
27111 
      oprot.writeFieldEnd()
27112 
    oprot.writeFieldStop()
27113 
    oprot.writeStructEnd()
27114 
 
27115 
  def validate(self):
27116 
    return
27117 
 
27118 
 
27119 
  def __repr__(self):
27120 
    L = ['%s=%r' % (key, value)
27121 
      for key, value in self.__dict__.iteritems()]
27122 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27123 
 
27124 
  def __eq__(self, other):
27125 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27126 
 
27127 
  def __ne__(self, other):
27128 
    return not (self == other)
27129 
 
27130 
class getFlipkartSearchResultCount_args:
27131 
  """
27132 
  Attributes:
27133 
   - searchTerm
27134 
  """
27135 
 
27136 
  thrift_spec = (
27137 
    None, # 0
27138 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
27139 
  )
27140 
 
27141 
  def __init__(self, searchTerm=None,):
27142 
    self.searchTerm = searchTerm
27143 
 
27144 
  def read(self, iprot):
27145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27147 
      return
27148 
    iprot.readStructBegin()
27149 
    while True:
27150 
      (fname, ftype, fid) = iprot.readFieldBegin()
27151 
      if ftype == TType.STOP:
27152 
        break
27153 
      if fid == 1:
27154 
        if ftype == TType.LIST:
27155 
          self.searchTerm = []
27156 
          (_etype609, _size606) = iprot.readListBegin()
27157 
          for _i610 in xrange(_size606):
27158 
            _elem611 = iprot.readString();
27159 
            self.searchTerm.append(_elem611)
27160 
          iprot.readListEnd()
27161 
        else:
27162 
          iprot.skip(ftype)
27163 
      else:
27164 
        iprot.skip(ftype)
27165 
      iprot.readFieldEnd()
27166 
    iprot.readStructEnd()
27167 
 
27168 
  def write(self, oprot):
27169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27171 
      return
27172 
    oprot.writeStructBegin('getFlipkartSearchResultCount_args')
27173 
    if self.searchTerm is not None:
27174 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
27175 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
27176 
      for iter612 in self.searchTerm:
27177 
        oprot.writeString(iter612)
27178 
      oprot.writeListEnd()
27179 
      oprot.writeFieldEnd()
27180 
    oprot.writeFieldStop()
27181 
    oprot.writeStructEnd()
27182 
 
27183 
  def validate(self):
27184 
    return
27185 
 
27186 
 
27187 
  def __repr__(self):
27188 
    L = ['%s=%r' % (key, value)
27189 
      for key, value in self.__dict__.iteritems()]
27190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27191 
 
27192 
  def __eq__(self, other):
27193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27194 
 
27195 
  def __ne__(self, other):
27196 
    return not (self == other)
27197 
 
27198 
class getFlipkartSearchResultCount_result:
27199 
  """
27200 
  Attributes:
27201 
   - success
27202 
  """
27203 
 
27204 
  thrift_spec = (
27205 
    (0, TType.I64, 'success', None, None, ), # 0
27206 
  )
27207 
 
27208 
  def __init__(self, success=None,):
27209 
    self.success = success
27210 
 
27211 
  def read(self, iprot):
27212 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27213 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27214 
      return
27215 
    iprot.readStructBegin()
27216 
    while True:
27217 
      (fname, ftype, fid) = iprot.readFieldBegin()
27218 
      if ftype == TType.STOP:
27219 
        break
27220 
      if fid == 0:
27221 
        if ftype == TType.I64:
27222 
          self.success = iprot.readI64();
27223 
        else:
27224 
          iprot.skip(ftype)
27225 
      else:
27226 
        iprot.skip(ftype)
27227 
      iprot.readFieldEnd()
27228 
    iprot.readStructEnd()
27229 
 
27230 
  def write(self, oprot):
27231 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27232 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27233 
      return
27234 
    oprot.writeStructBegin('getFlipkartSearchResultCount_result')
27235 
    if self.success is not None:
27236 
      oprot.writeFieldBegin('success', TType.I64, 0)
27237 
      oprot.writeI64(self.success)
27238 
      oprot.writeFieldEnd()
27239 
    oprot.writeFieldStop()
27240 
    oprot.writeStructEnd()
27241 
 
27242 
  def validate(self):
27243 
    return
27244 
 
27245 
 
27246 
  def __repr__(self):
27247 
    L = ['%s=%r' % (key, value)
27248 
      for key, value in self.__dict__.iteritems()]
27249 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27250 
 
27251 
  def __eq__(self, other):
27252 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27253 
 
27254 
  def __ne__(self, other):
27255 
    return not (self == other)
27256 
 
27257 
class getAllFkItems_args:
27258 
 
27259 
  thrift_spec = (
27260 
  )
27261 
 
27262 
  def read(self, iprot):
27263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27265 
      return
27266 
    iprot.readStructBegin()
27267 
    while True:
27268 
      (fname, ftype, fid) = iprot.readFieldBegin()
27269 
      if ftype == TType.STOP:
27270 
        break
27271 
      else:
27272 
        iprot.skip(ftype)
27273 
      iprot.readFieldEnd()
27274 
    iprot.readStructEnd()
27275 
 
27276 
  def write(self, oprot):
27277 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27278 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27279 
      return
27280 
    oprot.writeStructBegin('getAllFkItems_args')
27281 
    oprot.writeFieldStop()
27282 
    oprot.writeStructEnd()
27283 
 
27284 
  def validate(self):
27285 
    return
27286 
 
27287 
 
27288 
  def __repr__(self):
27289 
    L = ['%s=%r' % (key, value)
27290 
      for key, value in self.__dict__.iteritems()]
27291 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27292 
 
27293 
  def __eq__(self, other):
27294 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27295 
 
27296 
  def __ne__(self, other):
27297 
    return not (self == other)
27298 
 
27299 
class getAllFkItems_result:
27300 
  """
27301 
  Attributes:
27302 
   - success
27303 
  """
27304 
 
27305 
  thrift_spec = (
27306 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartItemDetails, FlipkartItemDetails.thrift_spec)), None, ), # 0
27307 
  )
27308 
 
27309 
  def __init__(self, success=None,):
27310 
    self.success = success
27311 
 
27312 
  def read(self, iprot):
27313 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27314 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27315 
      return
27316 
    iprot.readStructBegin()
27317 
    while True:
27318 
      (fname, ftype, fid) = iprot.readFieldBegin()
27319 
      if ftype == TType.STOP:
27320 
        break
27321 
      if fid == 0:
27322 
        if ftype == TType.LIST:
27323 
          self.success = []
27324 
          (_etype616, _size613) = iprot.readListBegin()
27325 
          for _i617 in xrange(_size613):
27326 
            _elem618 = FlipkartItemDetails()
27327 
            _elem618.read(iprot)
27328 
            self.success.append(_elem618)
27329 
          iprot.readListEnd()
27330 
        else:
27331 
          iprot.skip(ftype)
27332 
      else:
27333 
        iprot.skip(ftype)
27334 
      iprot.readFieldEnd()
27335 
    iprot.readStructEnd()
27336 
 
27337 
  def write(self, oprot):
27338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27340 
      return
27341 
    oprot.writeStructBegin('getAllFkItems_result')
27342 
    if self.success is not None:
27343 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27344 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
27345 
      for iter619 in self.success:
27346 
        iter619.write(oprot)
27347 
      oprot.writeListEnd()
27348 
      oprot.writeFieldEnd()
27349 
    oprot.writeFieldStop()
27350 
    oprot.writeStructEnd()
27351 
 
27352 
  def validate(self):
27353 
    return
27354 
 
27355 
 
27356 
  def __repr__(self):
27357 
    L = ['%s=%r' % (key, value)
27358 
      for key, value in self.__dict__.iteritems()]
27359 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27360 
 
27361 
  def __eq__(self, other):
27362 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27363 
 
27364 
  def __ne__(self, other):
27365 
    return not (self == other)
10140 vikram.rag 27366 
 
27367 
class getFlipkartItemBySkyAtFlipkart_args:
27368 
  """
27369 
  Attributes:
27370 
   - sku
27371 
  """
27372 
 
27373 
  thrift_spec = None
27374 
  def __init__(self, sku=None,):
27375 
    self.sku = sku
27376 
 
27377 
  def read(self, iprot):
27378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27380 
      return
27381 
    iprot.readStructBegin()
27382 
    while True:
27383 
      (fname, ftype, fid) = iprot.readFieldBegin()
27384 
      if ftype == TType.STOP:
27385 
        break
27386 
      if fid == -1:
27387 
        if ftype == TType.STRING:
27388 
          self.sku = iprot.readString();
27389 
        else:
27390 
          iprot.skip(ftype)
27391 
      else:
27392 
        iprot.skip(ftype)
27393 
      iprot.readFieldEnd()
27394 
    iprot.readStructEnd()
27395 
 
27396 
  def write(self, oprot):
27397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27399 
      return
27400 
    oprot.writeStructBegin('getFlipkartItemBySkyAtFlipkart_args')
27401 
    if self.sku is not None:
27402 
      oprot.writeFieldBegin('sku', TType.STRING, -1)
27403 
      oprot.writeString(self.sku)
27404 
      oprot.writeFieldEnd()
27405 
    oprot.writeFieldStop()
27406 
    oprot.writeStructEnd()
27407 
 
27408 
  def validate(self):
27409 
    return
27410 
 
27411 
 
27412 
  def __repr__(self):
27413 
    L = ['%s=%r' % (key, value)
27414 
      for key, value in self.__dict__.iteritems()]
27415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27416 
 
27417 
  def __eq__(self, other):
27418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27419 
 
27420 
  def __ne__(self, other):
27421 
    return not (self == other)
27422 
 
27423 
class getFlipkartItemBySkyAtFlipkart_result:
27424 
  """
27425 
  Attributes:
27426 
   - success
27427 
  """
27428 
 
27429 
  thrift_spec = (
27430 
    (0, TType.STRUCT, 'success', (FlipkartItem, FlipkartItem.thrift_spec), None, ), # 0
27431 
  )
27432 
 
27433 
  def __init__(self, success=None,):
27434 
    self.success = success
27435 
 
27436 
  def read(self, iprot):
27437 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27438 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27439 
      return
27440 
    iprot.readStructBegin()
27441 
    while True:
27442 
      (fname, ftype, fid) = iprot.readFieldBegin()
27443 
      if ftype == TType.STOP:
27444 
        break
27445 
      if fid == 0:
27446 
        if ftype == TType.STRUCT:
27447 
          self.success = FlipkartItem()
27448 
          self.success.read(iprot)
27449 
        else:
27450 
          iprot.skip(ftype)
27451 
      else:
27452 
        iprot.skip(ftype)
27453 
      iprot.readFieldEnd()
27454 
    iprot.readStructEnd()
27455 
 
27456 
  def write(self, oprot):
27457 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27458 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27459 
      return
27460 
    oprot.writeStructBegin('getFlipkartItemBySkyAtFlipkart_result')
27461 
    if self.success is not None:
27462 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27463 
      self.success.write(oprot)
27464 
      oprot.writeFieldEnd()
27465 
    oprot.writeFieldStop()
27466 
    oprot.writeStructEnd()
27467 
 
27468 
  def validate(self):
27469 
    return
27470 
 
27471 
 
27472 
  def __repr__(self):
27473 
    L = ['%s=%r' % (key, value)
27474 
      for key, value in self.__dict__.iteritems()]
27475 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27476 
 
27477 
  def __eq__(self, other):
27478 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27479 
 
27480 
  def __ne__(self, other):
27481 
    return not (self == other)
10909 vikram.rag 27482 
 
27483 
class getAllFbbListedItems_args:
27484 
 
27485 
  thrift_spec = (
27486 
  )
27487 
 
27488 
  def read(self, iprot):
27489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27491 
      return
27492 
    iprot.readStructBegin()
27493 
    while True:
27494 
      (fname, ftype, fid) = iprot.readFieldBegin()
27495 
      if ftype == TType.STOP:
27496 
        break
27497 
      else:
27498 
        iprot.skip(ftype)
27499 
      iprot.readFieldEnd()
27500 
    iprot.readStructEnd()
27501 
 
27502 
  def write(self, oprot):
27503 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27504 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27505 
      return
27506 
    oprot.writeStructBegin('getAllFbbListedItems_args')
27507 
    oprot.writeFieldStop()
27508 
    oprot.writeStructEnd()
27509 
 
27510 
  def validate(self):
27511 
    return
27512 
 
27513 
 
27514 
  def __repr__(self):
27515 
    L = ['%s=%r' % (key, value)
27516 
      for key, value in self.__dict__.iteritems()]
27517 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27518 
 
27519 
  def __eq__(self, other):
27520 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27521 
 
27522 
  def __ne__(self, other):
27523 
    return not (self == other)
27524 
 
27525 
class getAllFbbListedItems_result:
27526 
  """
27527 
  Attributes:
27528 
   - success
27529 
  """
27530 
 
27531 
  thrift_spec = (
27532 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
27533 
  )
27534 
 
27535 
  def __init__(self, success=None,):
27536 
    self.success = success
27537 
 
27538 
  def read(self, iprot):
27539 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27540 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27541 
      return
27542 
    iprot.readStructBegin()
27543 
    while True:
27544 
      (fname, ftype, fid) = iprot.readFieldBegin()
27545 
      if ftype == TType.STOP:
27546 
        break
27547 
      if fid == 0:
27548 
        if ftype == TType.LIST:
27549 
          self.success = []
27550 
          (_etype623, _size620) = iprot.readListBegin()
27551 
          for _i624 in xrange(_size620):
27552 
            _elem625 = Amazonlisted()
27553 
            _elem625.read(iprot)
27554 
            self.success.append(_elem625)
27555 
          iprot.readListEnd()
27556 
        else:
27557 
          iprot.skip(ftype)
27558 
      else:
27559 
        iprot.skip(ftype)
27560 
      iprot.readFieldEnd()
27561 
    iprot.readStructEnd()
27562 
 
27563 
  def write(self, oprot):
27564 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27565 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27566 
      return
27567 
    oprot.writeStructBegin('getAllFbbListedItems_result')
27568 
    if self.success is not None:
27569 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27570 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
27571 
      for iter626 in self.success:
27572 
        iter626.write(oprot)
27573 
      oprot.writeListEnd()
27574 
      oprot.writeFieldEnd()
27575 
    oprot.writeFieldStop()
27576 
    oprot.writeStructEnd()
27577 
 
27578 
  def validate(self):
27579 
    return
27580 
 
27581 
 
27582 
  def __repr__(self):
27583 
    L = ['%s=%r' % (key, value)
27584 
      for key, value in self.__dict__.iteritems()]
27585 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27586 
 
27587 
  def __eq__(self, other):
27588 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27589 
 
27590 
  def __ne__(self, other):
27591 
    return not (self == other)
10924 vikram.rag 27592 
 
27593 
class getAllFbbPricingItems_args:
27594 
 
27595 
  thrift_spec = (
27596 
  )
27597 
 
27598 
  def read(self, iprot):
27599 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27600 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27601 
      return
27602 
    iprot.readStructBegin()
27603 
    while True:
27604 
      (fname, ftype, fid) = iprot.readFieldBegin()
27605 
      if ftype == TType.STOP:
27606 
        break
27607 
      else:
27608 
        iprot.skip(ftype)
27609 
      iprot.readFieldEnd()
27610 
    iprot.readStructEnd()
27611 
 
27612 
  def write(self, oprot):
27613 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27614 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27615 
      return
27616 
    oprot.writeStructBegin('getAllFbbPricingItems_args')
27617 
    oprot.writeFieldStop()
27618 
    oprot.writeStructEnd()
27619 
 
27620 
  def validate(self):
27621 
    return
27622 
 
27623 
 
27624 
  def __repr__(self):
27625 
    L = ['%s=%r' % (key, value)
27626 
      for key, value in self.__dict__.iteritems()]
27627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27628 
 
27629 
  def __eq__(self, other):
27630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27631 
 
27632 
  def __ne__(self, other):
27633 
    return not (self == other)
27634 
 
27635 
class getAllFbbPricingItems_result:
27636 
  """
27637 
  Attributes:
27638 
   - success
27639 
  """
27640 
 
27641 
  thrift_spec = (
27642 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
27643 
  )
27644 
 
27645 
  def __init__(self, success=None,):
27646 
    self.success = success
27647 
 
27648 
  def read(self, iprot):
27649 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27650 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27651 
      return
27652 
    iprot.readStructBegin()
27653 
    while True:
27654 
      (fname, ftype, fid) = iprot.readFieldBegin()
27655 
      if ftype == TType.STOP:
27656 
        break
27657 
      if fid == 0:
27658 
        if ftype == TType.LIST:
27659 
          self.success = []
27660 
          (_etype630, _size627) = iprot.readListBegin()
27661 
          for _i631 in xrange(_size627):
27662 
            _elem632 = Amazonlisted()
27663 
            _elem632.read(iprot)
27664 
            self.success.append(_elem632)
27665 
          iprot.readListEnd()
27666 
        else:
27667 
          iprot.skip(ftype)
27668 
      else:
27669 
        iprot.skip(ftype)
27670 
      iprot.readFieldEnd()
27671 
    iprot.readStructEnd()
27672 
 
27673 
  def write(self, oprot):
27674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27676 
      return
27677 
    oprot.writeStructBegin('getAllFbbPricingItems_result')
27678 
    if self.success is not None:
27679 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27680 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
27681 
      for iter633 in self.success:
27682 
        iter633.write(oprot)
27683 
      oprot.writeListEnd()
27684 
      oprot.writeFieldEnd()
27685 
    oprot.writeFieldStop()
27686 
    oprot.writeStructEnd()
27687 
 
27688 
  def validate(self):
27689 
    return
27690 
 
27691 
 
27692 
  def __repr__(self):
27693 
    L = ['%s=%r' % (key, value)
27694 
      for key, value in self.__dict__.iteritems()]
27695 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27696 
 
27697 
  def __eq__(self, other):
27698 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27699 
 
27700 
  def __ne__(self, other):
27701 
    return not (self == other)