Subversion Repositories SmartDukaan

Rev

Rev 13709 | Rev 14362 | 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 
 
13493 amit.gupta 92 
  def getItems(self, item_ids):
93 
    """
94 
    Parameters:
95 
     - item_ids
96 
    """
97 
    pass
98 
 
5944 mandeep.dh 99 
  def getItemsByCatalogId(self, catalog_item_id):
100 
    """
101 
    Parameters:
102 
     - catalog_item_id
103 
    """
104 
    pass
105 
 
106 
  def getValidItemsByCatalogId(self, catalog_item_id):
107 
    """
108 
    Parameters:
109 
     - catalog_item_id
110 
    """
111 
    pass
112 
 
113 
  def getAllItems(self, isActive):
114 
    """
115 
    Parameters:
116 
     - isActive
117 
    """
118 
    pass
119 
 
120 
  def getAllItemsByStatus(self, itemStatus):
121 
    """
122 
    Parameters:
123 
     - itemStatus
124 
    """
125 
    pass
126 
 
9253 rajveer 127 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber, isAndroid):
5944 mandeep.dh 128 
    """
129 
    Parameters:
130 
     - entityId
131 
     - category
132 
     - brand
133 
     - modelName
134 
     - modelNumber
9253 rajveer 135 
     - isAndroid
5944 mandeep.dh 136 
    """
137 
    pass
138 
 
12567 amit.gupta 139 
  def getVatRates(self, itemId, categoryId):
140 
    """
141 
    Parameters:
142 
     - itemId
143 
     - categoryId
144 
    """
145 
    pass
146 
 
5944 mandeep.dh 147 
  def getAllItemsInRange(self, offset, limit):
148 
    """
149 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
150 
 
151 
    Parameters:
152 
     - offset
153 
     - limit
154 
    """
155 
    pass
156 
 
157 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
158 
    """
159 
    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.
160 
 
161 
    Parameters:
162 
     - itemStatus
163 
     - offset
164 
     - limit
165 
    """
166 
    pass
167 
 
168 
  def getItemCountByStatus(self, useStatus, itemStatus):
169 
    """
170 
    Gets a count of all items by status
171 
 
172 
    Parameters:
173 
     - useStatus
174 
     - itemStatus
175 
    """
176 
    pass
177 
 
178 
  def getBestSellers(self, ):
179 
    pass
180 
 
181 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
182 
    """
183 
    Parameters:
184 
     - beginIndex
185 
     - totalItems
186 
     - brand
187 
     - category
188 
    """
189 
    pass
190 
 
191 
  def getBestSellersCount(self, ):
192 
    pass
193 
 
194 
  def getBestDeals(self, ):
195 
    pass
196 
 
197 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
198 
    """
199 
    Parameters:
200 
     - beginIndex
201 
     - totalItems
202 
     - brand
203 
     - category
204 
    """
205 
    pass
206 
 
207 
  def getBestDealsCount(self, ):
208 
    pass
209 
 
210 
  def getComingSoon(self, ):
211 
    pass
212 
 
213 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
214 
    """
215 
    Parameters:
216 
     - beginIndex
217 
     - totalItems
218 
     - brand
219 
     - category
220 
    """
221 
    pass
222 
 
223 
  def getComingSoonCount(self, ):
224 
    pass
225 
 
226 
  def getLatestArrivals(self, ):
227 
    """
228 
    Returns a list of items sorted in the descending order by start date.
229 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
230 
    """
231 
    pass
232 
 
233 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
234 
    """
235 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
236 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
237 
 
238 
    Parameters:
239 
     - beginIndex
240 
     - totalItems
241 
     - brand
242 
     - categories
243 
    """
244 
    pass
245 
 
246 
  def getLatestArrivalsCount(self, ):
247 
    """
248 
    Get the total number of latest arrivals we are willing to show.
249 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
250 
    """
251 
    pass
252 
 
253 
  def generateNewEntityID(self, ):
254 
    pass
255 
 
256 
  def addCategory(self, category):
257 
    """
258 
    All category related functions
259 
 
260 
    Parameters:
261 
     - category
262 
    """
263 
    pass
264 
 
265 
  def getCategory(self, id):
266 
    """
267 
    Parameters:
268 
     - id
269 
    """
270 
    pass
271 
 
272 
  def getAllCategories(self, ):
273 
    pass
274 
 
275 
  def getAllSimilarItems(self, itemId):
276 
    """
277 
    Returns the list of similar items.
278 
 
279 
    Parameters:
280 
     - itemId
281 
    """
282 
    pass
283 
 
284 
  def addSimilarItem(self, itemId, catalogItemId):
285 
    """
286 
    Adds similar item.
287 
 
288 
    Parameters:
289 
     - itemId
290 
     - catalogItemId
291 
    """
292 
    pass
293 
 
6512 kshitij.so 294 
  def addTag(self, displayName, itemId):
295 
    """
296 
    Tag Related
297 
 
298 
    Parameters:
299 
     - displayName
300 
     - itemId
301 
    """
302 
    pass
303 
 
304 
  def deleteEntityTag(self, displayName, itemId):
305 
    """
306 
    Parameters:
307 
     - displayName
308 
     - itemId
309 
    """
310 
    pass
311 
 
312 
  def deleteTag(self, displayName):
313 
    """
314 
    Parameters:
315 
     - displayName
316 
    """
317 
    pass
318 
 
319 
  def getAllTags(self, ):
320 
    pass
321 
 
322 
  def getAllEntitiesByTagName(self, displayName):
323 
    """
324 
    Parameters:
325 
     - displayName
326 
    """
327 
    pass
328 
 
6845 amit.gupta 329 
  def getAllEntityTags(self, ):
330 
    pass
331 
 
8590 kshitij.so 332 
  def addBanner(self, bannerCongregate):
6850 kshitij.so 333 
    """
8579 kshitij.so 334 
    Banner Related
335 
 
6850 kshitij.so 336 
    Parameters:
8590 kshitij.so 337 
     - bannerCongregate
6850 kshitij.so 338 
    """
339 
    pass
340 
 
8579 kshitij.so 341 
  def updateBanner(self, banner):
342 
    """
343 
    Parameters:
344 
     - banner
345 
    """
346 
    pass
347 
 
6850 kshitij.so 348 
  def getAllBanners(self, ):
349 
    pass
350 
 
9155 kshitij.so 351 
  def deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 352 
    """
353 
    Parameters:
354 
     - bannerName
9155 kshitij.so 355 
     - bannerType
6850 kshitij.so 356 
    """
357 
    pass
358 
 
9155 kshitij.so 359 
  def getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 360 
    """
361 
    Parameters:
362 
     - bannerName
9155 kshitij.so 363 
     - bannerType
6850 kshitij.so 364 
    """
365 
    pass
366 
 
367 
  def getActiveBanners(self, ):
368 
    pass
369 
 
8579 kshitij.so 370 
  def addBannerMap(self, bannerMaps):
6849 kshitij.so 371 
    """
372 
    Parameters:
8579 kshitij.so 373 
     - bannerMaps
6849 kshitij.so 374 
    """
375 
    pass
376 
 
8579 kshitij.so 377 
  def updateBannerMap(self, bannerMap):
378 
    """
379 
    Parameters:
380 
     - bannerMap
381 
    """
382 
    pass
383 
 
6849 kshitij.so 384 
  def deleteBannerMap(self, bannerName):
385 
    """
386 
    Parameters:
387 
     - bannerName
388 
    """
389 
    pass
390 
 
9155 kshitij.so 391 
  def getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 392 
    """
393 
    Parameters:
394 
     - bannerName
9155 kshitij.so 395 
     - bannerType
6849 kshitij.so 396 
    """
397 
    pass
398 
 
8579 kshitij.so 399 
  def addBannerUri(self, bannerUriMappings):
400 
    """
401 
    Parameters:
402 
     - bannerUriMappings
403 
    """
404 
    pass
405 
 
9155 kshitij.so 406 
  def getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 407 
    """
408 
    Parameters:
409 
     - bannerName
9155 kshitij.so 410 
     - bannerType
8579 kshitij.so 411 
    """
412 
    pass
413 
 
414 
  def addCampaign(self, campaign):
415 
    """
416 
    Parameters:
417 
     - campaign
418 
    """
419 
    pass
420 
 
421 
  def getCampaigns(self, campaignName):
422 
    """
423 
    Parameters:
424 
     - campaignName
425 
    """
426 
    pass
427 
 
428 
  def deleteCampaign(self, campaignId):
429 
    """
430 
    Parameters:
431 
     - campaignId
432 
    """
433 
    pass
434 
 
435 
  def getAllCampaigns(self, ):
436 
    pass
437 
 
9155 kshitij.so 438 
  def getActiveBannersForMobileSite(self, ):
439 
    pass
440 
 
5944 mandeep.dh 441 
  def deleteSimilarItem(self, itemId, catalogItemId):
442 
    """
443 
    Delete similar item.
444 
 
445 
    Parameters:
446 
     - itemId
447 
     - catalogItemId
448 
    """
449 
    pass
450 
 
451 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
452 
    """
453 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
454 
    If yes, returns the itemId else returns 0
455 
 
456 
    Parameters:
457 
     - brand
458 
     - modelNumber
459 
     - modelName
460 
     - color
461 
    """
462 
    pass
463 
 
464 
  def validateRiskyStatus(self, itemId):
465 
    """
466 
    Check wether item is risky and change status if inventory is not available for risky items
467 
 
468 
    Parameters:
469 
     - itemId
470 
    """
471 
    pass
472 
 
473 
  def changeItemRiskyFlag(self, itemId, risky):
474 
    """
475 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
476 
 
477 
    Parameters:
478 
     - itemId
479 
     - risky
480 
    """
481 
    pass
482 
 
483 
  def getItemsByRiskyFlag(self, ):
484 
    """
485 
    Returns list of items marked as risky.
486 
    """
487 
    pass
488 
 
489 
  def getItemsForMasterSheet(self, category, brand):
490 
    """
491 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
492 
 
493 
    Parameters:
494 
     - category
495 
     - brand
496 
    """
497 
    pass
498 
 
499 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
500 
    """
501 
    Returns list of catalog ids of items with same similarity index as of the given itemId
502 
 
503 
    Parameters:
504 
     - beginIndex
505 
     - totalItems
506 
     - itemId
507 
    """
508 
    pass
509 
 
510 
  def addProductNotification(self, itemId, email):
511 
    """
512 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
513 
 
514 
    Parameters:
515 
     - itemId
516 
     - email
517 
    """
518 
    pass
519 
 
520 
  def sendProductNotifications(self, ):
521 
    """
522 
    Send the product notifications to the users for items which has stock.
523 
    """
524 
    pass
525 
 
526 
  def getAllBrandsByCategory(self, categoryId):
527 
    """
528 
    Returns list of brand names for a given category Id
529 
 
530 
    Parameters:
531 
     - categoryId
532 
    """
533 
    pass
534 
 
535 
  def getAllBrands(self, ):
536 
    """
537 
    Returns list of brand names
538 
    """
539 
    pass
540 
 
541 
  def getAllSources(self, ):
542 
    """
543 
    Return list of all sources
544 
    """
545 
    pass
546 
 
547 
  def getItemPricingBySource(self, itemId, sourceId):
548 
    """
549 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
550 
 
551 
    Parameters:
552 
     - itemId
553 
     - sourceId
554 
    """
555 
    pass
556 
 
557 
  def addSourceItemPricing(self, sourceItemPricing):
558 
    """
559 
    Adds prices to be displayed corresponding to the item if user comes from a source.
560 
    If item is not found or source is not found, it will throw exception.
561 
 
562 
    Parameters:
563 
     - sourceItemPricing
564 
    """
565 
    pass
566 
 
567 
  def getAllSourcePricing(self, itemId):
568 
    """
569 
    Returns the list of source pricing information of an item.
570 
    Raises an exception if item not found corresponding to itemId
571 
 
572 
    Parameters:
573 
     - itemId
574 
    """
575 
    pass
576 
 
577 
  def getItemForSource(self, item_id, sourceId):
578 
    """
579 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
580 
 
581 
    Parameters:
582 
     - item_id
583 
     - sourceId
584 
    """
585 
    pass
586 
 
587 
  def searchItemsInRange(self, searchTerms, offset, limit):
588 
    """
589 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
590 
 
591 
    Parameters:
592 
     - searchTerms
593 
     - offset
594 
     - limit
595 
    """
596 
    pass
597 
 
598 
  def getSearchResultCount(self, searchTerms):
599 
    """
600 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
601 
 
602 
    Parameters:
603 
     - searchTerms
604 
    """
605 
    pass
606 
 
607 
  def getProductNotifications(self, startDateTime):
608 
    """
609 
    Returns a list of product notifications added after a supplied datetime
610 
 
611 
    Parameters:
612 
     - startDateTime
613 
    """
614 
    pass
615 
 
7897 amar.kumar 616 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 617 
    """
618 
    Returns a list of count of requests for product notification against each item
619 
 
620 
    Parameters:
621 
     - startDateTime
7897 amar.kumar 622 
     - categoryId
5944 mandeep.dh 623 
    """
624 
    pass
625 
 
626 
  def addAuthorizationLog(self, itemId, username, reason):
627 
    """
628 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
629 
 
630 
    Parameters:
631 
     - itemId
632 
     - username
633 
     - reason
634 
    """
635 
    pass
636 
 
637 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
638 
    """
639 
    Parameters:
640 
     - catalog_item_id
641 
     - voucherType
642 
     - voucherAmount
643 
    """
644 
    pass
645 
 
646 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
647 
    """
648 
    Parameters:
649 
     - catalog_item_id
650 
     - voucherType
651 
    """
652 
    pass
653 
 
654 
  def getVoucherAmount(self, itemId, voucherType):
655 
    """
656 
    Parameters:
657 
     - itemId
658 
     - voucherType
659 
    """
660 
    pass
661 
 
662 
  def getAllItemVouchers(self, itemId):
663 
    """
664 
    Parameters:
665 
     - itemId
666 
    """
667 
    pass
668 
 
669 
  def isValidCatalogItemId(self, catalog_item_id):
670 
    """
671 
    Parameters:
672 
     - catalog_item_id
673 
    """
674 
    pass
675 
 
7330 amit.gupta 676 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 677 
    """
678 
    Parameters:
679 
     - itemId
7330 amit.gupta 680 
     - stateId
6039 amit.gupta 681 
     - price
682 
    """
683 
    pass
5944 mandeep.dh 684 
 
6039 amit.gupta 685 
  def getVatAmountForItem(self, itemId, price):
686 
    """
687 
    Parameters:
688 
     - itemId
689 
     - price
690 
    """
691 
    pass
692 
 
6531 vikram.rag 693 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
694 
    """
695 
    Parameters:
696 
     - offset
697 
     - limit
698 
    """
699 
    pass
6039 amit.gupta 700 
 
6821 amar.kumar 701 
  def getAllAliveItems(self, ):
702 
    pass
703 
 
6921 anupam.sin 704 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 705 
    """
706 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 707 
 
6805 anupam.sin 708 
    Parameters:
709 
     - itemId
6921 anupam.sin 710 
     - price
6805 anupam.sin 711 
     - insurerId
712 
     - quantity
713 
    """
714 
    pass
715 
 
716 
  def getInsurer(self, insurerId):
717 
    """
718 
    Parameters:
719 
     - insurerId
720 
    """
721 
    pass
722 
 
6838 vikram.rag 723 
  def getAllInsurers(self, ):
724 
    pass
6805 anupam.sin 725 
 
6962 rajveer 726 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
727 
    """
728 
    Parameters:
729 
     - insurerId
730 
     - amount
731 
    """
732 
    pass
6838 vikram.rag 733 
 
7190 amar.kumar 734 
  def getFreebieForItem(self, itemId):
735 
    """
736 
    Parameters:
737 
     - itemId
738 
    """
739 
    pass
6962 rajveer 740 
 
7190 amar.kumar 741 
  def addOrUpdateFreebieForItem(self, freebieItem):
742 
    """
743 
    Parameters:
744 
     - freebieItem
745 
    """
746 
    pass
747 
 
7272 amit.gupta 748 
  def addOrUpdateBrandInfo(self, brandInfo):
749 
    """
750 
    Parameters:
751 
     - brandInfo
752 
    """
753 
    pass
754 
 
755 
  def getBrandInfo(self, ):
756 
    pass
757 
 
7256 rajveer 758 
  def getStorePricing(self, itemId):
759 
    """
760 
    Parameters:
761 
     - itemId
762 
    """
763 
    pass
7190 amar.kumar 764 
 
7306 rajveer 765 
  def getStorePricings(self, itemIds):
766 
    """
767 
    Parameters:
768 
     - itemIds
769 
    """
770 
    pass
771 
 
7382 rajveer 772 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 773 
    """
774 
    Parameters:
775 
     - sp
7382 rajveer 776 
     - allColors
7265 rajveer 777 
    """
778 
    pass
7256 rajveer 779 
 
7281 kshitij.so 780 
  def getAllAmazonListedItems(self, ):
781 
    pass
7265 rajveer 782 
 
8619 kshitij.so 783 
  def searchAmazonItems(self, searchTerm, offset, limit):
784 
    """
785 
    Parameters:
786 
     - searchTerm
787 
     - offset
788 
     - limit
789 
    """
790 
    pass
791 
 
792 
  def getAmazonSearchResultCount(self, searchTerm):
793 
    """
794 
    Parameters:
795 
     - searchTerm
796 
    """
797 
    pass
798 
 
799 
  def getCountForAmazonlistedItems(self, ):
800 
    pass
801 
 
7281 kshitij.so 802 
  def getAmazonItemDetails(self, itemId):
803 
    """
804 
    Parameters:
805 
     - itemId
806 
    """
807 
    pass
808 
 
8168 kshitij.so 809 
  def updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 810 
    """
811 
    Parameters:
8168 kshitij.so 812 
     - amazonlisted
7281 kshitij.so 813 
    """
814 
    pass
815 
 
816 
  def addAmazonItem(self, amazonlisted):
817 
    """
818 
    Parameters:
819 
     - amazonlisted
820 
    """
821 
    pass
822 
 
7291 vikram.rag 823 
  def getAsinItems(self, ):
824 
    pass
7281 kshitij.so 825 
 
7291 vikram.rag 826 
  def getAllFbaListedItems(self, ):
827 
    pass
828 
 
829 
  def getAllNonFbaListedItems(self, ):
830 
    pass
831 
 
7460 kshitij.so 832 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
833 
    """
834 
    Parameters:
835 
     - itemId
836 
     - holdInventory
837 
     - defaultInventory
838 
    """
839 
    pass
7291 vikram.rag 840 
 
7770 kshitij.so 841 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
842 
    """
843 
    Parameters:
844 
     - type
845 
     - sku
846 
     - timestamp
847 
    """
848 
    pass
7460 kshitij.so 849 
 
7897 amar.kumar 850 
  def getAllParentCategories(self, ):
851 
    pass
7770 kshitij.so 852 
 
7977 kshitij.so 853 
  def addPageViewEvent(self, pageViewEvents):
854 
    """
855 
    Parameters:
856 
     - pageViewEvents
857 
    """
858 
    pass
7897 amar.kumar 859 
 
7977 kshitij.so 860 
  def addCartEvent(self, cartEvents):
861 
    """
862 
    Parameters:
863 
     - cartEvents
864 
    """
865 
    pass
866 
 
8182 amar.kumar 867 
  def addEbayItem(self, ebayItem):
868 
    """
869 
    Parameters:
870 
     - ebayItem
871 
    """
872 
    pass
873 
 
874 
  def getEbayItem(self, listingId):
875 
    """
876 
    Parameters:
877 
     - listingId
878 
    """
879 
    pass
880 
 
881 
  def updateEbayItem(self, ebayItem):
882 
    """
883 
    Parameters:
884 
     - ebayItem
885 
    """
886 
    pass
887 
 
8139 kshitij.so 888 
  def getAmazonListedItems(self, offset, limit):
889 
    """
890 
    Parameters:
891 
     - offset
892 
     - limit
893 
    """
894 
    pass
7977 kshitij.so 895 
 
8168 kshitij.so 896 
  def updateAmazonAttributesInBulk(self, amazonlisted):
897 
    """
898 
    Parameters:
899 
     - amazonlisted
900 
    """
901 
    pass
8139 kshitij.so 902 
 
8379 vikram.rag 903 
  def getAllItemstoListOnFba(self, ):
904 
    pass
8168 kshitij.so 905 
 
8379 vikram.rag 906 
  def getAllItemstoListOnNonFba(self, ):
907 
    pass
908 
 
8619 kshitij.so 909 
  def updateAsin(self, item):
910 
    """
911 
    Parameters:
912 
     - item
913 
    """
914 
    pass
8616 vikram.rag 915 
 
8739 vikram.rag 916 
  def addOrUpdateSnapdealItem(self, snapdealitem):
917 
    """
918 
    Parameters:
919 
     - snapdealitem
920 
    """
921 
    pass
8619 kshitij.so 922 
 
8739 vikram.rag 923 
  def getSnapdealItem(self, item_id):
924 
    """
925 
    Parameters:
926 
     - item_id
927 
    """
928 
    pass
929 
 
9242 kshitij.so 930 
  def getSnapdealItemDetails(self, item_id):
931 
    """
932 
    Parameters:
933 
     - item_id
934 
    """
935 
    pass
936 
 
8739 vikram.rag 937 
  def getAllSnapdealItems(self, ):
938 
    pass
939 
 
9242 kshitij.so 940 
  def getSnapdealItems(self, offset, limit):
941 
    """
942 
    Parameters:
943 
     - offset
944 
     - limit
945 
    """
946 
    pass
8739 vikram.rag 947 
 
9242 kshitij.so 948 
  def searchSnapdealItems(self, searchTerm, offset, limit):
949 
    """
950 
    Parameters:
951 
     - searchTerm
952 
     - offset
953 
     - limit
954 
    """
955 
    pass
956 
 
957 
  def getCountForSnapdealItems(self, ):
958 
    pass
959 
 
960 
  def getSnapdealSearchResultCount(self, searchTerm):
961 
    """
962 
    Parameters:
963 
     - searchTerm
964 
    """
965 
    pass
966 
 
9299 kshitij.so 967 
  def getPrefferedInsurerForItem(self, itemId, insurerType):
968 
    """
969 
    Parameters:
970 
     - itemId
971 
     - insurerType
972 
    """
973 
    pass
9242 kshitij.so 974 
 
9456 vikram.rag 975 
  def getSnapdealItembySkuAtSnapdeal(self, skuAtSnapdeal):
976 
    """
977 
    Parameters:
978 
     - skuAtSnapdeal
979 
    """
980 
    pass
9299 kshitij.so 981 
 
9621 manish.sha 982 
  def getProductFeedSubmit(self, catalogItemId):
983 
    """
984 
    Parameters:
985 
     - catalogItemId
986 
    """
987 
    pass
9456 vikram.rag 988 
 
9621 manish.sha 989 
  def addProductFeedSubmit(self, productFeedSubmit):
990 
    """
991 
    Parameters:
992 
     - productFeedSubmit
993 
    """
994 
    pass
995 
 
996 
  def updateProductFeedSubmit(self, productFeedSubmit):
997 
    """
998 
    Parameters:
999 
     - productFeedSubmit
1000 
    """
1001 
    pass
1002 
 
1003 
  def deleteProductFeedSubmit(self, catalogItemId):
1004 
    """
1005 
    Parameters:
1006 
     - catalogItemId
1007 
    """
1008 
    pass
1009 
 
1010 
  def getAllProductFeedSubmit(self, ):
1011 
    pass
1012 
 
9724 kshitij.so 1013 
  def getMarketplacedetailsForItem(self, itemId, sourceId):
1014 
    """
1015 
    Parameters:
1016 
     - itemId
1017 
     - sourceId
1018 
    """
1019 
    pass
9621 manish.sha 1020 
 
9724 kshitij.so 1021 
  def updateMarketplaceAttributesForItem(self, marketPlaceItem):
1022 
    """
1023 
    Parameters:
1024 
     - marketPlaceItem
1025 
    """
1026 
    pass
1027 
 
9779 kshitij.so 1028 
  def getCostingForMarketplace(self, source, item_id):
1029 
    """
1030 
    Parameters:
1031 
     - source
1032 
     - item_id
1033 
    """
1034 
    pass
1035 
 
9776 vikram.rag 1036 
  def getMarketPlaceItemsForPriceUpdate(self, source):
1037 
    """
1038 
    Parameters:
1039 
     - source
1040 
    """
1041 
    pass
9724 kshitij.so 1042 
 
9816 kshitij.so 1043 
  def updateMarketPlacePriceUpdateStatus(self, skulist, timestamp, source):
9776 vikram.rag 1044 
    """
1045 
    Parameters:
1046 
     - skulist
1047 
     - timestamp
9816 kshitij.so 1048 
     - source
9776 vikram.rag 1049 
    """
1050 
    pass
1051 
 
9861 rajveer 1052 
  def updateItemHoldInventory(self, itemHoldMap):
1053 
    """
1054 
    Parameters:
1055 
     - itemHoldMap
1056 
    """
1057 
    pass
9776 vikram.rag 1058 
 
9895 vikram.rag 1059 
  def updateNlcAtMarketplaces(self, item_id, vendor_id, nlc):
1060 
    """
1061 
    Parameters:
1062 
     - item_id
1063 
     - vendor_id
1064 
     - nlc
1065 
    """
1066 
    pass
9861 rajveer 1067 
 
9945 vikram.rag 1068 
  def getAllFlipkartItems(self, ):
1069 
    pass
9895 vikram.rag 1070 
 
10097 kshitij.so 1071 
  def addOrUpdateFlipkartItem(self, flipkartitem):
1072 
    """
1073 
    Parameters:
1074 
     - flipkartitem
1075 
    """
1076 
    pass
9945 vikram.rag 1077 
 
10097 kshitij.so 1078 
  def getFlipkartItem(self, item_id):
1079 
    """
1080 
    Parameters:
1081 
     - item_id
1082 
    """
1083 
    pass
1084 
 
1085 
  def getFlipkartItemDetails(self, item_id):
1086 
    """
1087 
    Parameters:
1088 
     - item_id
1089 
    """
1090 
    pass
1091 
 
1092 
  def getFlipkartItems(self, offset, limit):
1093 
    """
1094 
    Parameters:
1095 
     - offset
1096 
     - limit
1097 
    """
1098 
    pass
1099 
 
1100 
  def searchFlipkartItems(self, searchTerm, offset, limit):
1101 
    """
1102 
    Parameters:
1103 
     - searchTerm
1104 
     - offset
1105 
     - limit
1106 
    """
1107 
    pass
1108 
 
1109 
  def getCountForFlipkartItems(self, ):
1110 
    pass
1111 
 
1112 
  def getFlipkartSearchResultCount(self, searchTerm):
1113 
    """
1114 
    Parameters:
1115 
     - searchTerm
1116 
    """
1117 
    pass
1118 
 
1119 
  def getAllFkItems(self, ):
1120 
    pass
1121 
 
10140 vikram.rag 1122 
  def getFlipkartItemBySkyAtFlipkart(self, sku):
1123 
    """
1124 
    Parameters:
1125 
     - sku
1126 
    """
1127 
    pass
10097 kshitij.so 1128 
 
11015 kshitij.so 1129 
  def getMarketplaceHistory(self, source, offset, itemId):
1130 
    """
1131 
    Parameters:
1132 
     - source
1133 
     - offset
1134 
     - itemId
1135 
    """
1136 
    pass
1137 
 
10909 vikram.rag 1138 
  def getAllFbbListedItems(self, ):
1139 
    pass
10140 vikram.rag 1140 
 
10924 vikram.rag 1141 
  def getAllFbbPricingItems(self, ):
1142 
    pass
10909 vikram.rag 1143 
 
11015 kshitij.so 1144 
  def getCountForMarketplaceHistory(self, source, itemId):
1145 
    """
1146 
    Parameters:
1147 
     - source
1148 
     - itemId
1149 
    """
1150 
    pass
10924 vikram.rag 1151 
 
11015 kshitij.so 1152 
  def getMarketplaceHistoryByDate(self, source, startDate, endDate, offset, limit, itemId):
1153 
    """
1154 
    Parameters:
1155 
     - source
1156 
     - startDate
1157 
     - endDate
1158 
     - offset
1159 
     - limit
1160 
     - itemId
1161 
    """
1162 
    pass
1163 
 
11531 vikram.rag 1164 
  def getPrivateDealDetails(self, item_id):
1165 
    """
1166 
    Parameters:
1167 
     - item_id
1168 
    """
1169 
    pass
11015 kshitij.so 1170 
 
11531 vikram.rag 1171 
  def getPrivateDealItems(self, offset, limit):
1172 
    """
1173 
    Parameters:
1174 
     - offset
1175 
     - limit
1176 
    """
1177 
    pass
1178 
 
11653 amit.gupta 1179 
  def getAllActivePrivateDeals(self, itemIds, daysDelta):
1180 
    """
1181 
    Parameters:
1182 
     - itemIds
1183 
     - daysDelta
1184 
    """
11592 amit.gupta 1185 
    pass
1186 
 
11531 vikram.rag 1187 
  def addOrUpdatePrivateDeal(self, privateDeal):
1188 
    """
1189 
    Parameters:
1190 
     - privateDeal
1191 
    """
1192 
    pass
1193 
 
11635 vikram.rag 1194 
  def getPrivateDealsCatalogIds(self, beginIndex, totalItems):
1195 
    """
1196 
    Parameters:
1197 
     - beginIndex
1198 
     - totalItems
1199 
    """
1200 
    pass
11531 vikram.rag 1201 
 
11645 amit.gupta 1202 
  def getPrivateDealsCount(self, ):
1203 
    pass
11635 vikram.rag 1204 
 
11905 kshitij.so 1205 
  def getAmazonOutSyncItems(self, item_id):
1206 
    """
1207 
    Parameters:
1208 
     - item_id
1209 
    """
1210 
    pass
11645 amit.gupta 1211 
 
11905 kshitij.so 1212 
  def getAllPrivateDealsComparison(self, ):
1213 
    pass
1214 
 
12133 kshitij.so 1215 
  def getAllSnapdealMarketplaceItem(self, ):
1216 
    pass
11905 kshitij.so 1217 
 
12133 kshitij.so 1218 
  def getAllFlipkartMarketplaceItem(self, ):
1219 
    pass
1220 
 
12243 kshitij.so 1221 
  def addCompetitorScraping(self, competitorPricingMap):
1222 
    """
1223 
    Parameters:
1224 
     - competitorPricingMap
1225 
    """
1226 
    pass
12133 kshitij.so 1227 
 
12243 kshitij.so 1228 
  def getPreviousCompetitorScraping(self, delta):
1229 
    """
1230 
    Parameters:
1231 
     - delta
1232 
    """
1233 
    pass
1234 
 
12256 kshitij.so 1235 
  def getUploadResultById(self, uploadId):
1236 
    """
1237 
    Parameters:
1238 
     - uploadId
1239 
    """
1240 
    pass
12243 kshitij.so 1241 
 
12363 kshitij.so 1242 
  def addAmazonPromotion(self, amazonPromotions):
1243 
    """
1244 
    Parameters:
1245 
     - amazonPromotions
1246 
    """
1247 
    pass
12256 kshitij.so 1248 
 
12363 kshitij.so 1249 
  def getAmazonPromotion(self, startDate, endDate):
1250 
    """
1251 
    Parameters:
1252 
     - startDate
1253 
     - endDate
1254 
    """
1255 
    pass
1256 
 
1257 
  def updateAmazonPromotion(self, amazonPromotions):
1258 
    """
1259 
    Parameters:
1260 
     - amazonPromotions
1261 
    """
1262 
    pass
1263 
 
12567 amit.gupta 1264 
  def markPartiallyActive(self, itemId, categoryId):
1265 
    """
1266 
    Parameters:
1267 
     - itemId
1268 
     - categoryId
1269 
    """
1270 
    pass
12363 kshitij.so 1271 
 
12567 amit.gupta 1272 
  def updateItemStateVat(self, itemId, statevat):
1273 
    """
1274 
    Parameters:
1275 
     - itemId
1276 
     - statevat
1277 
    """
1278 
    pass
1279 
 
12620 amit.gupta 1280 
  def getExAffiliateItemInfo(self, ):
1281 
    pass
12567 amit.gupta 1282 
 
12888 kshitij.so 1283 
  def getAllItemstoListOnFbg(self, ):
1284 
    pass
12620 amit.gupta 1285 
 
12892 kshitij.so 1286 
  def getAllFbgListedItems(self, ):
1287 
    pass
12888 kshitij.so 1288 
 
13136 amit.gupta 1289 
  def checkServices(self, lines):
1290 
    """
1291 
    Parameters:
1292 
     - lines
1293 
    """
1294 
    pass
12892 kshitij.so 1295 
 
13709 manish.sha 1296 
  def addHsItem(self, hsItems):
1297 
    """
1298 
    Parameters:
1299 
     - hsItems
1300 
    """
1301 
    pass
13136 amit.gupta 1302 
 
13709 manish.sha 1303 
  def getHsItem(self, hsItemId):
1304 
    """
1305 
    Parameters:
1306 
     - hsItemId
1307 
    """
1308 
    pass
1309 
 
1310 
  def updateHsItem(self, hsItem):
1311 
    """
1312 
    Parameters:
1313 
     - hsItem
1314 
    """
1315 
    pass
1316 
 
14182 kshitij.so 1317 
  def getPricingForDtr(self, catalogItemId):
1318 
    """
1319 
    Parameters:
1320 
     - catalogItemId
1321 
    """
1322 
    pass
13709 manish.sha 1323 
 
14182 kshitij.so 1324 
 
5944 mandeep.dh 1325 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
1326 
  def __init__(self, iprot, oprot=None):
1327 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
1328 
 
1329 
  def addItem(self, item):
1330 
    """
1331 
    Availability and inventory attributes
1332 
 
1333 
    Parameters:
1334 
     - item
1335 
    """
1336 
    self.send_addItem(item)
1337 
    return self.recv_addItem()
1338 
 
1339 
  def send_addItem(self, item):
1340 
    self._oprot.writeMessageBegin('addItem', TMessageType.CALL, self._seqid)
1341 
    args = addItem_args()
1342 
    args.item = item
1343 
    args.write(self._oprot)
1344 
    self._oprot.writeMessageEnd()
1345 
    self._oprot.trans.flush()
1346 
 
1347 
  def recv_addItem(self, ):
1348 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1349 
    if mtype == TMessageType.EXCEPTION:
1350 
      x = TApplicationException()
1351 
      x.read(self._iprot)
1352 
      self._iprot.readMessageEnd()
1353 
      raise x
1354 
    result = addItem_result()
1355 
    result.read(self._iprot)
1356 
    self._iprot.readMessageEnd()
1357 
    if result.success is not None:
1358 
      return result.success
1359 
    if result.cex is not None:
1360 
      raise result.cex
1361 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItem failed: unknown result");
1362 
 
1363 
  def updateItem(self, item):
1364 
    """
1365 
    Parameters:
1366 
     - item
1367 
    """
1368 
    self.send_updateItem(item)
1369 
    return self.recv_updateItem()
1370 
 
1371 
  def send_updateItem(self, item):
1372 
    self._oprot.writeMessageBegin('updateItem', TMessageType.CALL, self._seqid)
1373 
    args = updateItem_args()
1374 
    args.item = item
1375 
    args.write(self._oprot)
1376 
    self._oprot.writeMessageEnd()
1377 
    self._oprot.trans.flush()
1378 
 
1379 
  def recv_updateItem(self, ):
1380 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1381 
    if mtype == TMessageType.EXCEPTION:
1382 
      x = TApplicationException()
1383 
      x.read(self._iprot)
1384 
      self._iprot.readMessageEnd()
1385 
      raise x
1386 
    result = updateItem_result()
1387 
    result.read(self._iprot)
1388 
    self._iprot.readMessageEnd()
1389 
    if result.success is not None:
1390 
      return result.success
1391 
    if result.cex is not None:
1392 
      raise result.cex
1393 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItem failed: unknown result");
1394 
 
1395 
  def isActive(self, itemId):
1396 
    """
1397 
    Checks if the item given to the corresponding itemId is active. If it's active,
1398 
    whether it's risky and if it's risky, its inventory position.
1399 
 
1400 
    Parameters:
1401 
     - itemId
1402 
    """
1403 
    self.send_isActive(itemId)
1404 
    return self.recv_isActive()
1405 
 
1406 
  def send_isActive(self, itemId):
1407 
    self._oprot.writeMessageBegin('isActive', TMessageType.CALL, self._seqid)
1408 
    args = isActive_args()
1409 
    args.itemId = itemId
1410 
    args.write(self._oprot)
1411 
    self._oprot.writeMessageEnd()
1412 
    self._oprot.trans.flush()
1413 
 
1414 
  def recv_isActive(self, ):
1415 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1416 
    if mtype == TMessageType.EXCEPTION:
1417 
      x = TApplicationException()
1418 
      x.read(self._iprot)
1419 
      self._iprot.readMessageEnd()
1420 
      raise x
1421 
    result = isActive_result()
1422 
    result.read(self._iprot)
1423 
    self._iprot.readMessageEnd()
1424 
    if result.success is not None:
1425 
      return result.success
1426 
    if result.isex is not None:
1427 
      raise result.isex
1428 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isActive failed: unknown result");
1429 
 
7438 amit.gupta 1430 
  def getItemsStatus(self, itemIds):
1431 
    """
1432 
    Parameters:
1433 
     - itemIds
1434 
    """
1435 
    self.send_getItemsStatus(itemIds)
1436 
    return self.recv_getItemsStatus()
1437 
 
1438 
  def send_getItemsStatus(self, itemIds):
1439 
    self._oprot.writeMessageBegin('getItemsStatus', TMessageType.CALL, self._seqid)
1440 
    args = getItemsStatus_args()
1441 
    args.itemIds = itemIds
1442 
    args.write(self._oprot)
1443 
    self._oprot.writeMessageEnd()
1444 
    self._oprot.trans.flush()
1445 
 
1446 
  def recv_getItemsStatus(self, ):
1447 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1448 
    if mtype == TMessageType.EXCEPTION:
1449 
      x = TApplicationException()
1450 
      x.read(self._iprot)
1451 
      self._iprot.readMessageEnd()
1452 
      raise x
1453 
    result = getItemsStatus_result()
1454 
    result.read(self._iprot)
1455 
    self._iprot.readMessageEnd()
1456 
    if result.success is not None:
1457 
      return result.success
1458 
    if result.isex is not None:
1459 
      raise result.isex
1460 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsStatus failed: unknown result");
1461 
 
5944 mandeep.dh 1462 
  def getItemStatusDescription(self, itemId):
1463 
    """
1464 
    Parameters:
1465 
     - itemId
1466 
    """
1467 
    self.send_getItemStatusDescription(itemId)
1468 
    return self.recv_getItemStatusDescription()
1469 
 
1470 
  def send_getItemStatusDescription(self, itemId):
1471 
    self._oprot.writeMessageBegin('getItemStatusDescription', TMessageType.CALL, self._seqid)
1472 
    args = getItemStatusDescription_args()
1473 
    args.itemId = itemId
1474 
    args.write(self._oprot)
1475 
    self._oprot.writeMessageEnd()
1476 
    self._oprot.trans.flush()
1477 
 
1478 
  def recv_getItemStatusDescription(self, ):
1479 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1480 
    if mtype == TMessageType.EXCEPTION:
1481 
      x = TApplicationException()
1482 
      x.read(self._iprot)
1483 
      self._iprot.readMessageEnd()
1484 
      raise x
1485 
    result = getItemStatusDescription_result()
1486 
    result.read(self._iprot)
1487 
    self._iprot.readMessageEnd()
1488 
    if result.success is not None:
1489 
      return result.success
1490 
    if result.isex is not None:
1491 
      raise result.isex
1492 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStatusDescription failed: unknown result");
1493 
 
1494 
  def startItemOn(self, item_id, timestamp):
1495 
    """
1496 
    Parameters:
1497 
     - item_id
1498 
     - timestamp
1499 
    """
1500 
    self.send_startItemOn(item_id, timestamp)
1501 
    self.recv_startItemOn()
1502 
 
1503 
  def send_startItemOn(self, item_id, timestamp):
1504 
    self._oprot.writeMessageBegin('startItemOn', TMessageType.CALL, self._seqid)
1505 
    args = startItemOn_args()
1506 
    args.item_id = item_id
1507 
    args.timestamp = timestamp
1508 
    args.write(self._oprot)
1509 
    self._oprot.writeMessageEnd()
1510 
    self._oprot.trans.flush()
1511 
 
1512 
  def recv_startItemOn(self, ):
1513 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1514 
    if mtype == TMessageType.EXCEPTION:
1515 
      x = TApplicationException()
1516 
      x.read(self._iprot)
1517 
      self._iprot.readMessageEnd()
1518 
      raise x
1519 
    result = startItemOn_result()
1520 
    result.read(self._iprot)
1521 
    self._iprot.readMessageEnd()
1522 
    if result.cex is not None:
1523 
      raise result.cex
1524 
    return
1525 
 
1526 
  def retireItemOn(self, item_id, timestamp):
1527 
    """
1528 
    Parameters:
1529 
     - item_id
1530 
     - timestamp
1531 
    """
1532 
    self.send_retireItemOn(item_id, timestamp)
1533 
    self.recv_retireItemOn()
1534 
 
1535 
  def send_retireItemOn(self, item_id, timestamp):
1536 
    self._oprot.writeMessageBegin('retireItemOn', TMessageType.CALL, self._seqid)
1537 
    args = retireItemOn_args()
1538 
    args.item_id = item_id
1539 
    args.timestamp = timestamp
1540 
    args.write(self._oprot)
1541 
    self._oprot.writeMessageEnd()
1542 
    self._oprot.trans.flush()
1543 
 
1544 
  def recv_retireItemOn(self, ):
1545 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1546 
    if mtype == TMessageType.EXCEPTION:
1547 
      x = TApplicationException()
1548 
      x.read(self._iprot)
1549 
      self._iprot.readMessageEnd()
1550 
      raise x
1551 
    result = retireItemOn_result()
1552 
    result.read(self._iprot)
1553 
    self._iprot.readMessageEnd()
1554 
    if result.cex is not None:
1555 
      raise result.cex
1556 
    return
1557 
 
1558 
  def changeItemStatus(self, item_id, timestamp, newstatus):
1559 
    """
1560 
    Parameters:
1561 
     - item_id
1562 
     - timestamp
1563 
     - newstatus
1564 
    """
1565 
    self.send_changeItemStatus(item_id, timestamp, newstatus)
1566 
    self.recv_changeItemStatus()
1567 
 
1568 
  def send_changeItemStatus(self, item_id, timestamp, newstatus):
1569 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
1570 
    args = changeItemStatus_args()
1571 
    args.item_id = item_id
1572 
    args.timestamp = timestamp
1573 
    args.newstatus = newstatus
1574 
    args.write(self._oprot)
1575 
    self._oprot.writeMessageEnd()
1576 
    self._oprot.trans.flush()
1577 
 
1578 
  def recv_changeItemStatus(self, ):
1579 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1580 
    if mtype == TMessageType.EXCEPTION:
1581 
      x = TApplicationException()
1582 
      x.read(self._iprot)
1583 
      self._iprot.readMessageEnd()
1584 
      raise x
1585 
    result = changeItemStatus_result()
1586 
    result.read(self._iprot)
1587 
    self._iprot.readMessageEnd()
1588 
    if result.cex is not None:
1589 
      raise result.cex
1590 
    return
1591 
 
1592 
  def getItem(self, item_id):
1593 
    """
1594 
    Parameters:
1595 
     - item_id
1596 
    """
1597 
    self.send_getItem(item_id)
1598 
    return self.recv_getItem()
1599 
 
1600 
  def send_getItem(self, item_id):
1601 
    self._oprot.writeMessageBegin('getItem', TMessageType.CALL, self._seqid)
1602 
    args = getItem_args()
1603 
    args.item_id = item_id
1604 
    args.write(self._oprot)
1605 
    self._oprot.writeMessageEnd()
1606 
    self._oprot.trans.flush()
1607 
 
1608 
  def recv_getItem(self, ):
1609 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1610 
    if mtype == TMessageType.EXCEPTION:
1611 
      x = TApplicationException()
1612 
      x.read(self._iprot)
1613 
      self._iprot.readMessageEnd()
1614 
      raise x
1615 
    result = getItem_result()
1616 
    result.read(self._iprot)
1617 
    self._iprot.readMessageEnd()
1618 
    if result.success is not None:
1619 
      return result.success
1620 
    if result.cex is not None:
1621 
      raise result.cex
1622 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItem failed: unknown result");
1623 
 
13493 amit.gupta 1624 
  def getItems(self, item_ids):
1625 
    """
1626 
    Parameters:
1627 
     - item_ids
1628 
    """
1629 
    self.send_getItems(item_ids)
1630 
    return self.recv_getItems()
1631 
 
1632 
  def send_getItems(self, item_ids):
1633 
    self._oprot.writeMessageBegin('getItems', TMessageType.CALL, self._seqid)
1634 
    args = getItems_args()
1635 
    args.item_ids = item_ids
1636 
    args.write(self._oprot)
1637 
    self._oprot.writeMessageEnd()
1638 
    self._oprot.trans.flush()
1639 
 
1640 
  def recv_getItems(self, ):
1641 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1642 
    if mtype == TMessageType.EXCEPTION:
1643 
      x = TApplicationException()
1644 
      x.read(self._iprot)
1645 
      self._iprot.readMessageEnd()
1646 
      raise x
1647 
    result = getItems_result()
1648 
    result.read(self._iprot)
1649 
    self._iprot.readMessageEnd()
1650 
    if result.success is not None:
1651 
      return result.success
1652 
    if result.cex is not None:
1653 
      raise result.cex
1654 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItems failed: unknown result");
1655 
 
5944 mandeep.dh 1656 
  def getItemsByCatalogId(self, catalog_item_id):
1657 
    """
1658 
    Parameters:
1659 
     - catalog_item_id
1660 
    """
1661 
    self.send_getItemsByCatalogId(catalog_item_id)
1662 
    return self.recv_getItemsByCatalogId()
1663 
 
1664 
  def send_getItemsByCatalogId(self, catalog_item_id):
1665 
    self._oprot.writeMessageBegin('getItemsByCatalogId', TMessageType.CALL, self._seqid)
1666 
    args = getItemsByCatalogId_args()
1667 
    args.catalog_item_id = catalog_item_id
1668 
    args.write(self._oprot)
1669 
    self._oprot.writeMessageEnd()
1670 
    self._oprot.trans.flush()
1671 
 
1672 
  def recv_getItemsByCatalogId(self, ):
1673 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1674 
    if mtype == TMessageType.EXCEPTION:
1675 
      x = TApplicationException()
1676 
      x.read(self._iprot)
1677 
      self._iprot.readMessageEnd()
1678 
      raise x
1679 
    result = getItemsByCatalogId_result()
1680 
    result.read(self._iprot)
1681 
    self._iprot.readMessageEnd()
1682 
    if result.success is not None:
1683 
      return result.success
1684 
    if result.cex is not None:
1685 
      raise result.cex
1686 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByCatalogId failed: unknown result");
1687 
 
1688 
  def getValidItemsByCatalogId(self, catalog_item_id):
1689 
    """
1690 
    Parameters:
1691 
     - catalog_item_id
1692 
    """
1693 
    self.send_getValidItemsByCatalogId(catalog_item_id)
1694 
    return self.recv_getValidItemsByCatalogId()
1695 
 
1696 
  def send_getValidItemsByCatalogId(self, catalog_item_id):
1697 
    self._oprot.writeMessageBegin('getValidItemsByCatalogId', TMessageType.CALL, self._seqid)
1698 
    args = getValidItemsByCatalogId_args()
1699 
    args.catalog_item_id = catalog_item_id
1700 
    args.write(self._oprot)
1701 
    self._oprot.writeMessageEnd()
1702 
    self._oprot.trans.flush()
1703 
 
1704 
  def recv_getValidItemsByCatalogId(self, ):
1705 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1706 
    if mtype == TMessageType.EXCEPTION:
1707 
      x = TApplicationException()
1708 
      x.read(self._iprot)
1709 
      self._iprot.readMessageEnd()
1710 
      raise x
1711 
    result = getValidItemsByCatalogId_result()
1712 
    result.read(self._iprot)
1713 
    self._iprot.readMessageEnd()
1714 
    if result.success is not None:
1715 
      return result.success
1716 
    if result.cex is not None:
1717 
      raise result.cex
1718 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidItemsByCatalogId failed: unknown result");
1719 
 
1720 
  def getAllItems(self, isActive):
1721 
    """
1722 
    Parameters:
1723 
     - isActive
1724 
    """
1725 
    self.send_getAllItems(isActive)
1726 
    return self.recv_getAllItems()
1727 
 
1728 
  def send_getAllItems(self, isActive):
1729 
    self._oprot.writeMessageBegin('getAllItems', TMessageType.CALL, self._seqid)
1730 
    args = getAllItems_args()
1731 
    args.isActive = isActive
1732 
    args.write(self._oprot)
1733 
    self._oprot.writeMessageEnd()
1734 
    self._oprot.trans.flush()
1735 
 
1736 
  def recv_getAllItems(self, ):
1737 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1738 
    if mtype == TMessageType.EXCEPTION:
1739 
      x = TApplicationException()
1740 
      x.read(self._iprot)
1741 
      self._iprot.readMessageEnd()
1742 
      raise x
1743 
    result = getAllItems_result()
1744 
    result.read(self._iprot)
1745 
    self._iprot.readMessageEnd()
1746 
    if result.success is not None:
1747 
      return result.success
1748 
    if result.cex is not None:
1749 
      raise result.cex
1750 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItems failed: unknown result");
1751 
 
1752 
  def getAllItemsByStatus(self, itemStatus):
1753 
    """
1754 
    Parameters:
1755 
     - itemStatus
1756 
    """
1757 
    self.send_getAllItemsByStatus(itemStatus)
1758 
    return self.recv_getAllItemsByStatus()
1759 
 
1760 
  def send_getAllItemsByStatus(self, itemStatus):
1761 
    self._oprot.writeMessageBegin('getAllItemsByStatus', TMessageType.CALL, self._seqid)
1762 
    args = getAllItemsByStatus_args()
1763 
    args.itemStatus = itemStatus
1764 
    args.write(self._oprot)
1765 
    self._oprot.writeMessageEnd()
1766 
    self._oprot.trans.flush()
1767 
 
1768 
  def recv_getAllItemsByStatus(self, ):
1769 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1770 
    if mtype == TMessageType.EXCEPTION:
1771 
      x = TApplicationException()
1772 
      x.read(self._iprot)
1773 
      self._iprot.readMessageEnd()
1774 
      raise x
1775 
    result = getAllItemsByStatus_result()
1776 
    result.read(self._iprot)
1777 
    self._iprot.readMessageEnd()
1778 
    if result.success is not None:
1779 
      return result.success
1780 
    if result.cex is not None:
1781 
      raise result.cex
1782 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatus failed: unknown result");
1783 
 
9253 rajveer 1784 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber, isAndroid):
5944 mandeep.dh 1785 
    """
1786 
    Parameters:
1787 
     - entityId
1788 
     - category
1789 
     - brand
1790 
     - modelName
1791 
     - modelNumber
9253 rajveer 1792 
     - isAndroid
5944 mandeep.dh 1793 
    """
9253 rajveer 1794 
    self.send_markItemAsContentComplete(entityId, category, brand, modelName, modelNumber, isAndroid)
5944 mandeep.dh 1795 
    return self.recv_markItemAsContentComplete()
1796 
 
9253 rajveer 1797 
  def send_markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber, isAndroid):
5944 mandeep.dh 1798 
    self._oprot.writeMessageBegin('markItemAsContentComplete', TMessageType.CALL, self._seqid)
1799 
    args = markItemAsContentComplete_args()
1800 
    args.entityId = entityId
1801 
    args.category = category
1802 
    args.brand = brand
1803 
    args.modelName = modelName
1804 
    args.modelNumber = modelNumber
9253 rajveer 1805 
    args.isAndroid = isAndroid
5944 mandeep.dh 1806 
    args.write(self._oprot)
1807 
    self._oprot.writeMessageEnd()
1808 
    self._oprot.trans.flush()
1809 
 
1810 
  def recv_markItemAsContentComplete(self, ):
1811 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1812 
    if mtype == TMessageType.EXCEPTION:
1813 
      x = TApplicationException()
1814 
      x.read(self._iprot)
1815 
      self._iprot.readMessageEnd()
1816 
      raise x
1817 
    result = markItemAsContentComplete_result()
1818 
    result.read(self._iprot)
1819 
    self._iprot.readMessageEnd()
1820 
    if result.success is not None:
1821 
      return result.success
1822 
    if result.cex is not None:
1823 
      raise result.cex
1824 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markItemAsContentComplete failed: unknown result");
1825 
 
12567 amit.gupta 1826 
  def getVatRates(self, itemId, categoryId):
1827 
    """
1828 
    Parameters:
1829 
     - itemId
1830 
     - categoryId
1831 
    """
1832 
    self.send_getVatRates(itemId, categoryId)
1833 
    return self.recv_getVatRates()
1834 
 
1835 
  def send_getVatRates(self, itemId, categoryId):
1836 
    self._oprot.writeMessageBegin('getVatRates', TMessageType.CALL, self._seqid)
1837 
    args = getVatRates_args()
1838 
    args.itemId = itemId
1839 
    args.categoryId = categoryId
1840 
    args.write(self._oprot)
1841 
    self._oprot.writeMessageEnd()
1842 
    self._oprot.trans.flush()
1843 
 
1844 
  def recv_getVatRates(self, ):
1845 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1846 
    if mtype == TMessageType.EXCEPTION:
1847 
      x = TApplicationException()
1848 
      x.read(self._iprot)
1849 
      self._iprot.readMessageEnd()
1850 
      raise x
1851 
    result = getVatRates_result()
1852 
    result.read(self._iprot)
1853 
    self._iprot.readMessageEnd()
1854 
    if result.success is not None:
1855 
      return result.success
1856 
    if result.cex is not None:
1857 
      raise result.cex
1858 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatRates failed: unknown result");
1859 
 
5944 mandeep.dh 1860 
  def getAllItemsInRange(self, offset, limit):
1861 
    """
1862 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
1863 
 
1864 
    Parameters:
1865 
     - offset
1866 
     - limit
1867 
    """
1868 
    self.send_getAllItemsInRange(offset, limit)
1869 
    return self.recv_getAllItemsInRange()
1870 
 
1871 
  def send_getAllItemsInRange(self, offset, limit):
1872 
    self._oprot.writeMessageBegin('getAllItemsInRange', TMessageType.CALL, self._seqid)
1873 
    args = getAllItemsInRange_args()
1874 
    args.offset = offset
1875 
    args.limit = limit
1876 
    args.write(self._oprot)
1877 
    self._oprot.writeMessageEnd()
1878 
    self._oprot.trans.flush()
1879 
 
1880 
  def recv_getAllItemsInRange(self, ):
1881 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1882 
    if mtype == TMessageType.EXCEPTION:
1883 
      x = TApplicationException()
1884 
      x.read(self._iprot)
1885 
      self._iprot.readMessageEnd()
1886 
      raise x
1887 
    result = getAllItemsInRange_result()
1888 
    result.read(self._iprot)
1889 
    self._iprot.readMessageEnd()
1890 
    if result.success is not None:
1891 
      return result.success
1892 
    if result.cex is not None:
1893 
      raise result.cex
1894 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsInRange failed: unknown result");
1895 
 
1896 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1897 
    """
1898 
    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.
1899 
 
1900 
    Parameters:
1901 
     - itemStatus
1902 
     - offset
1903 
     - limit
1904 
    """
1905 
    self.send_getAllItemsByStatusInRange(itemStatus, offset, limit)
1906 
    return self.recv_getAllItemsByStatusInRange()
1907 
 
1908 
  def send_getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1909 
    self._oprot.writeMessageBegin('getAllItemsByStatusInRange', TMessageType.CALL, self._seqid)
1910 
    args = getAllItemsByStatusInRange_args()
1911 
    args.itemStatus = itemStatus
1912 
    args.offset = offset
1913 
    args.limit = limit
1914 
    args.write(self._oprot)
1915 
    self._oprot.writeMessageEnd()
1916 
    self._oprot.trans.flush()
1917 
 
1918 
  def recv_getAllItemsByStatusInRange(self, ):
1919 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1920 
    if mtype == TMessageType.EXCEPTION:
1921 
      x = TApplicationException()
1922 
      x.read(self._iprot)
1923 
      self._iprot.readMessageEnd()
1924 
      raise x
1925 
    result = getAllItemsByStatusInRange_result()
1926 
    result.read(self._iprot)
1927 
    self._iprot.readMessageEnd()
1928 
    if result.success is not None:
1929 
      return result.success
1930 
    if result.cex is not None:
1931 
      raise result.cex
1932 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatusInRange failed: unknown result");
1933 
 
1934 
  def getItemCountByStatus(self, useStatus, itemStatus):
1935 
    """
1936 
    Gets a count of all items by status
1937 
 
1938 
    Parameters:
1939 
     - useStatus
1940 
     - itemStatus
1941 
    """
1942 
    self.send_getItemCountByStatus(useStatus, itemStatus)
1943 
    return self.recv_getItemCountByStatus()
1944 
 
1945 
  def send_getItemCountByStatus(self, useStatus, itemStatus):
1946 
    self._oprot.writeMessageBegin('getItemCountByStatus', TMessageType.CALL, self._seqid)
1947 
    args = getItemCountByStatus_args()
1948 
    args.useStatus = useStatus
1949 
    args.itemStatus = itemStatus
1950 
    args.write(self._oprot)
1951 
    self._oprot.writeMessageEnd()
1952 
    self._oprot.trans.flush()
1953 
 
1954 
  def recv_getItemCountByStatus(self, ):
1955 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1956 
    if mtype == TMessageType.EXCEPTION:
1957 
      x = TApplicationException()
1958 
      x.read(self._iprot)
1959 
      self._iprot.readMessageEnd()
1960 
      raise x
1961 
    result = getItemCountByStatus_result()
1962 
    result.read(self._iprot)
1963 
    self._iprot.readMessageEnd()
1964 
    if result.success is not None:
1965 
      return result.success
1966 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemCountByStatus failed: unknown result");
1967 
 
1968 
  def getBestSellers(self, ):
1969 
    self.send_getBestSellers()
1970 
    return self.recv_getBestSellers()
1971 
 
1972 
  def send_getBestSellers(self, ):
1973 
    self._oprot.writeMessageBegin('getBestSellers', TMessageType.CALL, self._seqid)
1974 
    args = getBestSellers_args()
1975 
    args.write(self._oprot)
1976 
    self._oprot.writeMessageEnd()
1977 
    self._oprot.trans.flush()
1978 
 
1979 
  def recv_getBestSellers(self, ):
1980 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1981 
    if mtype == TMessageType.EXCEPTION:
1982 
      x = TApplicationException()
1983 
      x.read(self._iprot)
1984 
      self._iprot.readMessageEnd()
1985 
      raise x
1986 
    result = getBestSellers_result()
1987 
    result.read(self._iprot)
1988 
    self._iprot.readMessageEnd()
1989 
    if result.success is not None:
1990 
      return result.success
1991 
    if result.isex is not None:
1992 
      raise result.isex
1993 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellers failed: unknown result");
1994 
 
1995 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1996 
    """
1997 
    Parameters:
1998 
     - beginIndex
1999 
     - totalItems
2000 
     - brand
2001 
     - category
2002 
    """
2003 
    self.send_getBestSellersCatalogIds(beginIndex, totalItems, brand, category)
2004 
    return self.recv_getBestSellersCatalogIds()
2005 
 
2006 
  def send_getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
2007 
    self._oprot.writeMessageBegin('getBestSellersCatalogIds', TMessageType.CALL, self._seqid)
2008 
    args = getBestSellersCatalogIds_args()
2009 
    args.beginIndex = beginIndex
2010 
    args.totalItems = totalItems
2011 
    args.brand = brand
2012 
    args.category = category
2013 
    args.write(self._oprot)
2014 
    self._oprot.writeMessageEnd()
2015 
    self._oprot.trans.flush()
2016 
 
2017 
  def recv_getBestSellersCatalogIds(self, ):
2018 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2019 
    if mtype == TMessageType.EXCEPTION:
2020 
      x = TApplicationException()
2021 
      x.read(self._iprot)
2022 
      self._iprot.readMessageEnd()
2023 
      raise x
2024 
    result = getBestSellersCatalogIds_result()
2025 
    result.read(self._iprot)
2026 
    self._iprot.readMessageEnd()
2027 
    if result.success is not None:
2028 
      return result.success
2029 
    if result.cex is not None:
2030 
      raise result.cex
2031 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCatalogIds failed: unknown result");
2032 
 
2033 
  def getBestSellersCount(self, ):
2034 
    self.send_getBestSellersCount()
2035 
    return self.recv_getBestSellersCount()
2036 
 
2037 
  def send_getBestSellersCount(self, ):
2038 
    self._oprot.writeMessageBegin('getBestSellersCount', TMessageType.CALL, self._seqid)
2039 
    args = getBestSellersCount_args()
2040 
    args.write(self._oprot)
2041 
    self._oprot.writeMessageEnd()
2042 
    self._oprot.trans.flush()
2043 
 
2044 
  def recv_getBestSellersCount(self, ):
2045 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2046 
    if mtype == TMessageType.EXCEPTION:
2047 
      x = TApplicationException()
2048 
      x.read(self._iprot)
2049 
      self._iprot.readMessageEnd()
2050 
      raise x
2051 
    result = getBestSellersCount_result()
2052 
    result.read(self._iprot)
2053 
    self._iprot.readMessageEnd()
2054 
    if result.success is not None:
2055 
      return result.success
2056 
    if result.cex is not None:
2057 
      raise result.cex
2058 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCount failed: unknown result");
2059 
 
2060 
  def getBestDeals(self, ):
2061 
    self.send_getBestDeals()
2062 
    return self.recv_getBestDeals()
2063 
 
2064 
  def send_getBestDeals(self, ):
2065 
    self._oprot.writeMessageBegin('getBestDeals', TMessageType.CALL, self._seqid)
2066 
    args = getBestDeals_args()
2067 
    args.write(self._oprot)
2068 
    self._oprot.writeMessageEnd()
2069 
    self._oprot.trans.flush()
2070 
 
2071 
  def recv_getBestDeals(self, ):
2072 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2073 
    if mtype == TMessageType.EXCEPTION:
2074 
      x = TApplicationException()
2075 
      x.read(self._iprot)
2076 
      self._iprot.readMessageEnd()
2077 
      raise x
2078 
    result = getBestDeals_result()
2079 
    result.read(self._iprot)
2080 
    self._iprot.readMessageEnd()
2081 
    if result.success is not None:
2082 
      return result.success
2083 
    if result.isex is not None:
2084 
      raise result.isex
2085 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDeals failed: unknown result");
2086 
 
2087 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
2088 
    """
2089 
    Parameters:
2090 
     - beginIndex
2091 
     - totalItems
2092 
     - brand
2093 
     - category
2094 
    """
2095 
    self.send_getBestDealsCatalogIds(beginIndex, totalItems, brand, category)
2096 
    return self.recv_getBestDealsCatalogIds()
2097 
 
2098 
  def send_getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
2099 
    self._oprot.writeMessageBegin('getBestDealsCatalogIds', TMessageType.CALL, self._seqid)
2100 
    args = getBestDealsCatalogIds_args()
2101 
    args.beginIndex = beginIndex
2102 
    args.totalItems = totalItems
2103 
    args.brand = brand
2104 
    args.category = category
2105 
    args.write(self._oprot)
2106 
    self._oprot.writeMessageEnd()
2107 
    self._oprot.trans.flush()
2108 
 
2109 
  def recv_getBestDealsCatalogIds(self, ):
2110 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2111 
    if mtype == TMessageType.EXCEPTION:
2112 
      x = TApplicationException()
2113 
      x.read(self._iprot)
2114 
      self._iprot.readMessageEnd()
2115 
      raise x
2116 
    result = getBestDealsCatalogIds_result()
2117 
    result.read(self._iprot)
2118 
    self._iprot.readMessageEnd()
2119 
    if result.success is not None:
2120 
      return result.success
2121 
    if result.cex is not None:
2122 
      raise result.cex
2123 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCatalogIds failed: unknown result");
2124 
 
2125 
  def getBestDealsCount(self, ):
2126 
    self.send_getBestDealsCount()
2127 
    return self.recv_getBestDealsCount()
2128 
 
2129 
  def send_getBestDealsCount(self, ):
2130 
    self._oprot.writeMessageBegin('getBestDealsCount', TMessageType.CALL, self._seqid)
2131 
    args = getBestDealsCount_args()
2132 
    args.write(self._oprot)
2133 
    self._oprot.writeMessageEnd()
2134 
    self._oprot.trans.flush()
2135 
 
2136 
  def recv_getBestDealsCount(self, ):
2137 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2138 
    if mtype == TMessageType.EXCEPTION:
2139 
      x = TApplicationException()
2140 
      x.read(self._iprot)
2141 
      self._iprot.readMessageEnd()
2142 
      raise x
2143 
    result = getBestDealsCount_result()
2144 
    result.read(self._iprot)
2145 
    self._iprot.readMessageEnd()
2146 
    if result.success is not None:
2147 
      return result.success
2148 
    if result.cex is not None:
2149 
      raise result.cex
2150 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCount failed: unknown result");
2151 
 
2152 
  def getComingSoon(self, ):
2153 
    self.send_getComingSoon()
2154 
    return self.recv_getComingSoon()
2155 
 
2156 
  def send_getComingSoon(self, ):
2157 
    self._oprot.writeMessageBegin('getComingSoon', TMessageType.CALL, self._seqid)
2158 
    args = getComingSoon_args()
2159 
    args.write(self._oprot)
2160 
    self._oprot.writeMessageEnd()
2161 
    self._oprot.trans.flush()
2162 
 
2163 
  def recv_getComingSoon(self, ):
2164 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2165 
    if mtype == TMessageType.EXCEPTION:
2166 
      x = TApplicationException()
2167 
      x.read(self._iprot)
2168 
      self._iprot.readMessageEnd()
2169 
      raise x
2170 
    result = getComingSoon_result()
2171 
    result.read(self._iprot)
2172 
    self._iprot.readMessageEnd()
2173 
    if result.success is not None:
2174 
      return result.success
2175 
    if result.isex is not None:
2176 
      raise result.isex
2177 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoon failed: unknown result");
2178 
 
2179 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
2180 
    """
2181 
    Parameters:
2182 
     - beginIndex
2183 
     - totalItems
2184 
     - brand
2185 
     - category
2186 
    """
2187 
    self.send_getComingSoonCatalogIds(beginIndex, totalItems, brand, category)
2188 
    return self.recv_getComingSoonCatalogIds()
2189 
 
2190 
  def send_getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
2191 
    self._oprot.writeMessageBegin('getComingSoonCatalogIds', TMessageType.CALL, self._seqid)
2192 
    args = getComingSoonCatalogIds_args()
2193 
    args.beginIndex = beginIndex
2194 
    args.totalItems = totalItems
2195 
    args.brand = brand
2196 
    args.category = category
2197 
    args.write(self._oprot)
2198 
    self._oprot.writeMessageEnd()
2199 
    self._oprot.trans.flush()
2200 
 
2201 
  def recv_getComingSoonCatalogIds(self, ):
2202 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2203 
    if mtype == TMessageType.EXCEPTION:
2204 
      x = TApplicationException()
2205 
      x.read(self._iprot)
2206 
      self._iprot.readMessageEnd()
2207 
      raise x
2208 
    result = getComingSoonCatalogIds_result()
2209 
    result.read(self._iprot)
2210 
    self._iprot.readMessageEnd()
2211 
    if result.success is not None:
2212 
      return result.success
2213 
    if result.cex is not None:
2214 
      raise result.cex
2215 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCatalogIds failed: unknown result");
2216 
 
2217 
  def getComingSoonCount(self, ):
2218 
    self.send_getComingSoonCount()
2219 
    return self.recv_getComingSoonCount()
2220 
 
2221 
  def send_getComingSoonCount(self, ):
2222 
    self._oprot.writeMessageBegin('getComingSoonCount', TMessageType.CALL, self._seqid)
2223 
    args = getComingSoonCount_args()
2224 
    args.write(self._oprot)
2225 
    self._oprot.writeMessageEnd()
2226 
    self._oprot.trans.flush()
2227 
 
2228 
  def recv_getComingSoonCount(self, ):
2229 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2230 
    if mtype == TMessageType.EXCEPTION:
2231 
      x = TApplicationException()
2232 
      x.read(self._iprot)
2233 
      self._iprot.readMessageEnd()
2234 
      raise x
2235 
    result = getComingSoonCount_result()
2236 
    result.read(self._iprot)
2237 
    self._iprot.readMessageEnd()
2238 
    if result.success is not None:
2239 
      return result.success
2240 
    if result.cex is not None:
2241 
      raise result.cex
2242 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCount failed: unknown result");
2243 
 
2244 
  def getLatestArrivals(self, ):
2245 
    """
2246 
    Returns a list of items sorted in the descending order by start date.
2247 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
2248 
    """
2249 
    self.send_getLatestArrivals()
2250 
    return self.recv_getLatestArrivals()
2251 
 
2252 
  def send_getLatestArrivals(self, ):
2253 
    self._oprot.writeMessageBegin('getLatestArrivals', TMessageType.CALL, self._seqid)
2254 
    args = getLatestArrivals_args()
2255 
    args.write(self._oprot)
2256 
    self._oprot.writeMessageEnd()
2257 
    self._oprot.trans.flush()
2258 
 
2259 
  def recv_getLatestArrivals(self, ):
2260 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2261 
    if mtype == TMessageType.EXCEPTION:
2262 
      x = TApplicationException()
2263 
      x.read(self._iprot)
2264 
      self._iprot.readMessageEnd()
2265 
      raise x
2266 
    result = getLatestArrivals_result()
2267 
    result.read(self._iprot)
2268 
    self._iprot.readMessageEnd()
2269 
    if result.success is not None:
2270 
      return result.success
2271 
    if result.isex is not None:
2272 
      raise result.isex
2273 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivals failed: unknown result");
2274 
 
2275 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
2276 
    """
2277 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
2278 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
2279 
 
2280 
    Parameters:
2281 
     - beginIndex
2282 
     - totalItems
2283 
     - brand
2284 
     - categories
2285 
    """
2286 
    self.send_getLatestArrivalsCatalogIds(beginIndex, totalItems, brand, categories)
2287 
    return self.recv_getLatestArrivalsCatalogIds()
2288 
 
2289 
  def send_getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
2290 
    self._oprot.writeMessageBegin('getLatestArrivalsCatalogIds', TMessageType.CALL, self._seqid)
2291 
    args = getLatestArrivalsCatalogIds_args()
2292 
    args.beginIndex = beginIndex
2293 
    args.totalItems = totalItems
2294 
    args.brand = brand
2295 
    args.categories = categories
2296 
    args.write(self._oprot)
2297 
    self._oprot.writeMessageEnd()
2298 
    self._oprot.trans.flush()
2299 
 
2300 
  def recv_getLatestArrivalsCatalogIds(self, ):
2301 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2302 
    if mtype == TMessageType.EXCEPTION:
2303 
      x = TApplicationException()
2304 
      x.read(self._iprot)
2305 
      self._iprot.readMessageEnd()
2306 
      raise x
2307 
    result = getLatestArrivalsCatalogIds_result()
2308 
    result.read(self._iprot)
2309 
    self._iprot.readMessageEnd()
2310 
    if result.success is not None:
2311 
      return result.success
2312 
    if result.cex is not None:
2313 
      raise result.cex
2314 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCatalogIds failed: unknown result");
2315 
 
2316 
  def getLatestArrivalsCount(self, ):
2317 
    """
2318 
    Get the total number of latest arrivals we are willing to show.
2319 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
2320 
    """
2321 
    self.send_getLatestArrivalsCount()
2322 
    return self.recv_getLatestArrivalsCount()
2323 
 
2324 
  def send_getLatestArrivalsCount(self, ):
2325 
    self._oprot.writeMessageBegin('getLatestArrivalsCount', TMessageType.CALL, self._seqid)
2326 
    args = getLatestArrivalsCount_args()
2327 
    args.write(self._oprot)
2328 
    self._oprot.writeMessageEnd()
2329 
    self._oprot.trans.flush()
2330 
 
2331 
  def recv_getLatestArrivalsCount(self, ):
2332 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2333 
    if mtype == TMessageType.EXCEPTION:
2334 
      x = TApplicationException()
2335 
      x.read(self._iprot)
2336 
      self._iprot.readMessageEnd()
2337 
      raise x
2338 
    result = getLatestArrivalsCount_result()
2339 
    result.read(self._iprot)
2340 
    self._iprot.readMessageEnd()
2341 
    if result.success is not None:
2342 
      return result.success
2343 
    if result.cex is not None:
2344 
      raise result.cex
2345 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCount failed: unknown result");
2346 
 
2347 
  def generateNewEntityID(self, ):
2348 
    self.send_generateNewEntityID()
2349 
    return self.recv_generateNewEntityID()
2350 
 
2351 
  def send_generateNewEntityID(self, ):
2352 
    self._oprot.writeMessageBegin('generateNewEntityID', TMessageType.CALL, self._seqid)
2353 
    args = generateNewEntityID_args()
2354 
    args.write(self._oprot)
2355 
    self._oprot.writeMessageEnd()
2356 
    self._oprot.trans.flush()
2357 
 
2358 
  def recv_generateNewEntityID(self, ):
2359 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2360 
    if mtype == TMessageType.EXCEPTION:
2361 
      x = TApplicationException()
2362 
      x.read(self._iprot)
2363 
      self._iprot.readMessageEnd()
2364 
      raise x
2365 
    result = generateNewEntityID_result()
2366 
    result.read(self._iprot)
2367 
    self._iprot.readMessageEnd()
2368 
    if result.success is not None:
2369 
      return result.success
2370 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateNewEntityID failed: unknown result");
2371 
 
2372 
  def addCategory(self, category):
2373 
    """
2374 
    All category related functions
2375 
 
2376 
    Parameters:
2377 
     - category
2378 
    """
2379 
    self.send_addCategory(category)
2380 
    return self.recv_addCategory()
2381 
 
2382 
  def send_addCategory(self, category):
2383 
    self._oprot.writeMessageBegin('addCategory', TMessageType.CALL, self._seqid)
2384 
    args = addCategory_args()
2385 
    args.category = category
2386 
    args.write(self._oprot)
2387 
    self._oprot.writeMessageEnd()
2388 
    self._oprot.trans.flush()
2389 
 
2390 
  def recv_addCategory(self, ):
2391 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2392 
    if mtype == TMessageType.EXCEPTION:
2393 
      x = TApplicationException()
2394 
      x.read(self._iprot)
2395 
      self._iprot.readMessageEnd()
2396 
      raise x
2397 
    result = addCategory_result()
2398 
    result.read(self._iprot)
2399 
    self._iprot.readMessageEnd()
2400 
    if result.success is not None:
2401 
      return result.success
2402 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addCategory failed: unknown result");
2403 
 
2404 
  def getCategory(self, id):
2405 
    """
2406 
    Parameters:
2407 
     - id
2408 
    """
2409 
    self.send_getCategory(id)
2410 
    return self.recv_getCategory()
2411 
 
2412 
  def send_getCategory(self, id):
2413 
    self._oprot.writeMessageBegin('getCategory', TMessageType.CALL, self._seqid)
2414 
    args = getCategory_args()
2415 
    args.id = id
2416 
    args.write(self._oprot)
2417 
    self._oprot.writeMessageEnd()
2418 
    self._oprot.trans.flush()
2419 
 
2420 
  def recv_getCategory(self, ):
2421 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2422 
    if mtype == TMessageType.EXCEPTION:
2423 
      x = TApplicationException()
2424 
      x.read(self._iprot)
2425 
      self._iprot.readMessageEnd()
2426 
      raise x
2427 
    result = getCategory_result()
2428 
    result.read(self._iprot)
2429 
    self._iprot.readMessageEnd()
2430 
    if result.success is not None:
2431 
      return result.success
2432 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCategory failed: unknown result");
2433 
 
2434 
  def getAllCategories(self, ):
2435 
    self.send_getAllCategories()
2436 
    return self.recv_getAllCategories()
2437 
 
2438 
  def send_getAllCategories(self, ):
2439 
    self._oprot.writeMessageBegin('getAllCategories', TMessageType.CALL, self._seqid)
2440 
    args = getAllCategories_args()
2441 
    args.write(self._oprot)
2442 
    self._oprot.writeMessageEnd()
2443 
    self._oprot.trans.flush()
2444 
 
2445 
  def recv_getAllCategories(self, ):
2446 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2447 
    if mtype == TMessageType.EXCEPTION:
2448 
      x = TApplicationException()
2449 
      x.read(self._iprot)
2450 
      self._iprot.readMessageEnd()
2451 
      raise x
2452 
    result = getAllCategories_result()
2453 
    result.read(self._iprot)
2454 
    self._iprot.readMessageEnd()
2455 
    if result.success is not None:
2456 
      return result.success
2457 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCategories failed: unknown result");
2458 
 
2459 
  def getAllSimilarItems(self, itemId):
2460 
    """
2461 
    Returns the list of similar items.
2462 
 
2463 
    Parameters:
2464 
     - itemId
2465 
    """
2466 
    self.send_getAllSimilarItems(itemId)
2467 
    return self.recv_getAllSimilarItems()
2468 
 
2469 
  def send_getAllSimilarItems(self, itemId):
2470 
    self._oprot.writeMessageBegin('getAllSimilarItems', TMessageType.CALL, self._seqid)
2471 
    args = getAllSimilarItems_args()
2472 
    args.itemId = itemId
2473 
    args.write(self._oprot)
2474 
    self._oprot.writeMessageEnd()
2475 
    self._oprot.trans.flush()
2476 
 
2477 
  def recv_getAllSimilarItems(self, ):
2478 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2479 
    if mtype == TMessageType.EXCEPTION:
2480 
      x = TApplicationException()
2481 
      x.read(self._iprot)
2482 
      self._iprot.readMessageEnd()
2483 
      raise x
2484 
    result = getAllSimilarItems_result()
2485 
    result.read(self._iprot)
2486 
    self._iprot.readMessageEnd()
2487 
    if result.success is not None:
2488 
      return result.success
2489 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSimilarItems failed: unknown result");
2490 
 
2491 
  def addSimilarItem(self, itemId, catalogItemId):
2492 
    """
2493 
    Adds similar item.
2494 
 
2495 
    Parameters:
2496 
     - itemId
2497 
     - catalogItemId
2498 
    """
2499 
    self.send_addSimilarItem(itemId, catalogItemId)
2500 
    return self.recv_addSimilarItem()
2501 
 
2502 
  def send_addSimilarItem(self, itemId, catalogItemId):
2503 
    self._oprot.writeMessageBegin('addSimilarItem', TMessageType.CALL, self._seqid)
2504 
    args = addSimilarItem_args()
2505 
    args.itemId = itemId
2506 
    args.catalogItemId = catalogItemId
2507 
    args.write(self._oprot)
2508 
    self._oprot.writeMessageEnd()
2509 
    self._oprot.trans.flush()
2510 
 
2511 
  def recv_addSimilarItem(self, ):
2512 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2513 
    if mtype == TMessageType.EXCEPTION:
2514 
      x = TApplicationException()
2515 
      x.read(self._iprot)
2516 
      self._iprot.readMessageEnd()
2517 
      raise x
2518 
    result = addSimilarItem_result()
2519 
    result.read(self._iprot)
2520 
    self._iprot.readMessageEnd()
2521 
    if result.success is not None:
2522 
      return result.success
2523 
    if result.cex is not None:
2524 
      raise result.cex
2525 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSimilarItem failed: unknown result");
2526 
 
6512 kshitij.so 2527 
  def addTag(self, displayName, itemId):
2528 
    """
2529 
    Tag Related
2530 
 
2531 
    Parameters:
2532 
     - displayName
2533 
     - itemId
2534 
    """
2535 
    self.send_addTag(displayName, itemId)
2536 
    return self.recv_addTag()
2537 
 
2538 
  def send_addTag(self, displayName, itemId):
2539 
    self._oprot.writeMessageBegin('addTag', TMessageType.CALL, self._seqid)
2540 
    args = addTag_args()
2541 
    args.displayName = displayName
2542 
    args.itemId = itemId
2543 
    args.write(self._oprot)
2544 
    self._oprot.writeMessageEnd()
2545 
    self._oprot.trans.flush()
2546 
 
2547 
  def recv_addTag(self, ):
2548 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2549 
    if mtype == TMessageType.EXCEPTION:
2550 
      x = TApplicationException()
2551 
      x.read(self._iprot)
2552 
      self._iprot.readMessageEnd()
2553 
      raise x
2554 
    result = addTag_result()
2555 
    result.read(self._iprot)
2556 
    self._iprot.readMessageEnd()
2557 
    if result.success is not None:
2558 
      return result.success
2559 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTag failed: unknown result");
2560 
 
2561 
  def deleteEntityTag(self, displayName, itemId):
2562 
    """
2563 
    Parameters:
2564 
     - displayName
2565 
     - itemId
2566 
    """
2567 
    self.send_deleteEntityTag(displayName, itemId)
2568 
    return self.recv_deleteEntityTag()
2569 
 
2570 
  def send_deleteEntityTag(self, displayName, itemId):
2571 
    self._oprot.writeMessageBegin('deleteEntityTag', TMessageType.CALL, self._seqid)
2572 
    args = deleteEntityTag_args()
2573 
    args.displayName = displayName
2574 
    args.itemId = itemId
2575 
    args.write(self._oprot)
2576 
    self._oprot.writeMessageEnd()
2577 
    self._oprot.trans.flush()
2578 
 
2579 
  def recv_deleteEntityTag(self, ):
2580 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2581 
    if mtype == TMessageType.EXCEPTION:
2582 
      x = TApplicationException()
2583 
      x.read(self._iprot)
2584 
      self._iprot.readMessageEnd()
2585 
      raise x
2586 
    result = deleteEntityTag_result()
2587 
    result.read(self._iprot)
2588 
    self._iprot.readMessageEnd()
2589 
    if result.success is not None:
2590 
      return result.success
2591 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteEntityTag failed: unknown result");
2592 
 
2593 
  def deleteTag(self, displayName):
2594 
    """
2595 
    Parameters:
2596 
     - displayName
2597 
    """
2598 
    self.send_deleteTag(displayName)
2599 
    return self.recv_deleteTag()
2600 
 
2601 
  def send_deleteTag(self, displayName):
2602 
    self._oprot.writeMessageBegin('deleteTag', TMessageType.CALL, self._seqid)
2603 
    args = deleteTag_args()
2604 
    args.displayName = displayName
2605 
    args.write(self._oprot)
2606 
    self._oprot.writeMessageEnd()
2607 
    self._oprot.trans.flush()
2608 
 
2609 
  def recv_deleteTag(self, ):
2610 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2611 
    if mtype == TMessageType.EXCEPTION:
2612 
      x = TApplicationException()
2613 
      x.read(self._iprot)
2614 
      self._iprot.readMessageEnd()
2615 
      raise x
2616 
    result = deleteTag_result()
2617 
    result.read(self._iprot)
2618 
    self._iprot.readMessageEnd()
2619 
    if result.success is not None:
2620 
      return result.success
2621 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteTag failed: unknown result");
2622 
 
2623 
  def getAllTags(self, ):
2624 
    self.send_getAllTags()
2625 
    return self.recv_getAllTags()
2626 
 
2627 
  def send_getAllTags(self, ):
2628 
    self._oprot.writeMessageBegin('getAllTags', TMessageType.CALL, self._seqid)
2629 
    args = getAllTags_args()
2630 
    args.write(self._oprot)
2631 
    self._oprot.writeMessageEnd()
2632 
    self._oprot.trans.flush()
2633 
 
2634 
  def recv_getAllTags(self, ):
2635 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2636 
    if mtype == TMessageType.EXCEPTION:
2637 
      x = TApplicationException()
2638 
      x.read(self._iprot)
2639 
      self._iprot.readMessageEnd()
2640 
      raise x
2641 
    result = getAllTags_result()
2642 
    result.read(self._iprot)
2643 
    self._iprot.readMessageEnd()
2644 
    if result.success is not None:
2645 
      return result.success
2646 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllTags failed: unknown result");
2647 
 
2648 
  def getAllEntitiesByTagName(self, displayName):
2649 
    """
2650 
    Parameters:
2651 
     - displayName
2652 
    """
2653 
    self.send_getAllEntitiesByTagName(displayName)
2654 
    return self.recv_getAllEntitiesByTagName()
2655 
 
2656 
  def send_getAllEntitiesByTagName(self, displayName):
2657 
    self._oprot.writeMessageBegin('getAllEntitiesByTagName', TMessageType.CALL, self._seqid)
2658 
    args = getAllEntitiesByTagName_args()
2659 
    args.displayName = displayName
2660 
    args.write(self._oprot)
2661 
    self._oprot.writeMessageEnd()
2662 
    self._oprot.trans.flush()
2663 
 
2664 
  def recv_getAllEntitiesByTagName(self, ):
2665 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2666 
    if mtype == TMessageType.EXCEPTION:
2667 
      x = TApplicationException()
2668 
      x.read(self._iprot)
2669 
      self._iprot.readMessageEnd()
2670 
      raise x
2671 
    result = getAllEntitiesByTagName_result()
2672 
    result.read(self._iprot)
2673 
    self._iprot.readMessageEnd()
2674 
    if result.success is not None:
2675 
      return result.success
2676 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntitiesByTagName failed: unknown result");
2677 
 
6845 amit.gupta 2678 
  def getAllEntityTags(self, ):
2679 
    self.send_getAllEntityTags()
2680 
    return self.recv_getAllEntityTags()
2681 
 
2682 
  def send_getAllEntityTags(self, ):
2683 
    self._oprot.writeMessageBegin('getAllEntityTags', TMessageType.CALL, self._seqid)
2684 
    args = getAllEntityTags_args()
2685 
    args.write(self._oprot)
2686 
    self._oprot.writeMessageEnd()
2687 
    self._oprot.trans.flush()
2688 
 
2689 
  def recv_getAllEntityTags(self, ):
2690 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2691 
    if mtype == TMessageType.EXCEPTION:
2692 
      x = TApplicationException()
2693 
      x.read(self._iprot)
2694 
      self._iprot.readMessageEnd()
2695 
      raise x
2696 
    result = getAllEntityTags_result()
2697 
    result.read(self._iprot)
2698 
    self._iprot.readMessageEnd()
2699 
    if result.success is not None:
2700 
      return result.success
2701 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntityTags failed: unknown result");
2702 
 
8590 kshitij.so 2703 
  def addBanner(self, bannerCongregate):
6850 kshitij.so 2704 
    """
8579 kshitij.so 2705 
    Banner Related
2706 
 
6850 kshitij.so 2707 
    Parameters:
8590 kshitij.so 2708 
     - bannerCongregate
6850 kshitij.so 2709 
    """
8590 kshitij.so 2710 
    self.send_addBanner(bannerCongregate)
10097 kshitij.so 2711 
    return self.recv_addBanner()
6850 kshitij.so 2712 
 
8590 kshitij.so 2713 
  def send_addBanner(self, bannerCongregate):
6850 kshitij.so 2714 
    self._oprot.writeMessageBegin('addBanner', TMessageType.CALL, self._seqid)
2715 
    args = addBanner_args()
8590 kshitij.so 2716 
    args.bannerCongregate = bannerCongregate
6850 kshitij.so 2717 
    args.write(self._oprot)
2718 
    self._oprot.writeMessageEnd()
2719 
    self._oprot.trans.flush()
2720 
 
2721 
  def recv_addBanner(self, ):
2722 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2723 
    if mtype == TMessageType.EXCEPTION:
2724 
      x = TApplicationException()
2725 
      x.read(self._iprot)
2726 
      self._iprot.readMessageEnd()
2727 
      raise x
2728 
    result = addBanner_result()
2729 
    result.read(self._iprot)
2730 
    self._iprot.readMessageEnd()
10097 kshitij.so 2731 
    if result.success is not None:
2732 
      return result.success
2733 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBanner failed: unknown result");
6850 kshitij.so 2734 
 
8579 kshitij.so 2735 
  def updateBanner(self, banner):
2736 
    """
2737 
    Parameters:
2738 
     - banner
2739 
    """
2740 
    self.send_updateBanner(banner)
2741 
    return self.recv_updateBanner()
2742 
 
2743 
  def send_updateBanner(self, banner):
2744 
    self._oprot.writeMessageBegin('updateBanner', TMessageType.CALL, self._seqid)
2745 
    args = updateBanner_args()
2746 
    args.banner = banner
2747 
    args.write(self._oprot)
2748 
    self._oprot.writeMessageEnd()
2749 
    self._oprot.trans.flush()
2750 
 
2751 
  def recv_updateBanner(self, ):
2752 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2753 
    if mtype == TMessageType.EXCEPTION:
2754 
      x = TApplicationException()
2755 
      x.read(self._iprot)
2756 
      self._iprot.readMessageEnd()
2757 
      raise x
2758 
    result = updateBanner_result()
2759 
    result.read(self._iprot)
2760 
    self._iprot.readMessageEnd()
2761 
    if result.success is not None:
2762 
      return result.success
2763 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBanner failed: unknown result");
2764 
 
6850 kshitij.so 2765 
  def getAllBanners(self, ):
2766 
    self.send_getAllBanners()
2767 
    return self.recv_getAllBanners()
2768 
 
2769 
  def send_getAllBanners(self, ):
2770 
    self._oprot.writeMessageBegin('getAllBanners', TMessageType.CALL, self._seqid)
2771 
    args = getAllBanners_args()
2772 
    args.write(self._oprot)
2773 
    self._oprot.writeMessageEnd()
2774 
    self._oprot.trans.flush()
2775 
 
2776 
  def recv_getAllBanners(self, ):
2777 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2778 
    if mtype == TMessageType.EXCEPTION:
2779 
      x = TApplicationException()
2780 
      x.read(self._iprot)
2781 
      self._iprot.readMessageEnd()
2782 
      raise x
2783 
    result = getAllBanners_result()
2784 
    result.read(self._iprot)
2785 
    self._iprot.readMessageEnd()
2786 
    if result.success is not None:
2787 
      return result.success
2788 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBanners failed: unknown result");
2789 
 
9155 kshitij.so 2790 
  def deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 2791 
    """
2792 
    Parameters:
2793 
     - bannerName
9155 kshitij.so 2794 
     - bannerType
6850 kshitij.so 2795 
    """
9155 kshitij.so 2796 
    self.send_deleteBanner(bannerName, bannerType)
6850 kshitij.so 2797 
    return self.recv_deleteBanner()
2798 
 
9155 kshitij.so 2799 
  def send_deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 2800 
    self._oprot.writeMessageBegin('deleteBanner', TMessageType.CALL, self._seqid)
2801 
    args = deleteBanner_args()
2802 
    args.bannerName = bannerName
9155 kshitij.so 2803 
    args.bannerType = bannerType
6850 kshitij.so 2804 
    args.write(self._oprot)
2805 
    self._oprot.writeMessageEnd()
2806 
    self._oprot.trans.flush()
2807 
 
2808 
  def recv_deleteBanner(self, ):
2809 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2810 
    if mtype == TMessageType.EXCEPTION:
2811 
      x = TApplicationException()
2812 
      x.read(self._iprot)
2813 
      self._iprot.readMessageEnd()
2814 
      raise x
2815 
    result = deleteBanner_result()
2816 
    result.read(self._iprot)
2817 
    self._iprot.readMessageEnd()
2818 
    if result.success is not None:
2819 
      return result.success
2820 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBanner failed: unknown result");
2821 
 
9155 kshitij.so 2822 
  def getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 2823 
    """
2824 
    Parameters:
2825 
     - bannerName
9155 kshitij.so 2826 
     - bannerType
6850 kshitij.so 2827 
    """
9155 kshitij.so 2828 
    self.send_getBannerDetails(bannerName, bannerType)
6850 kshitij.so 2829 
    return self.recv_getBannerDetails()
2830 
 
9155 kshitij.so 2831 
  def send_getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 2832 
    self._oprot.writeMessageBegin('getBannerDetails', TMessageType.CALL, self._seqid)
2833 
    args = getBannerDetails_args()
2834 
    args.bannerName = bannerName
9155 kshitij.so 2835 
    args.bannerType = bannerType
6850 kshitij.so 2836 
    args.write(self._oprot)
2837 
    self._oprot.writeMessageEnd()
2838 
    self._oprot.trans.flush()
2839 
 
2840 
  def recv_getBannerDetails(self, ):
2841 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2842 
    if mtype == TMessageType.EXCEPTION:
2843 
      x = TApplicationException()
2844 
      x.read(self._iprot)
2845 
      self._iprot.readMessageEnd()
2846 
      raise x
2847 
    result = getBannerDetails_result()
2848 
    result.read(self._iprot)
2849 
    self._iprot.readMessageEnd()
2850 
    if result.success is not None:
2851 
      return result.success
2852 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerDetails failed: unknown result");
2853 
 
2854 
  def getActiveBanners(self, ):
2855 
    self.send_getActiveBanners()
2856 
    return self.recv_getActiveBanners()
2857 
 
2858 
  def send_getActiveBanners(self, ):
2859 
    self._oprot.writeMessageBegin('getActiveBanners', TMessageType.CALL, self._seqid)
2860 
    args = getActiveBanners_args()
2861 
    args.write(self._oprot)
2862 
    self._oprot.writeMessageEnd()
2863 
    self._oprot.trans.flush()
2864 
 
2865 
  def recv_getActiveBanners(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 = getActiveBanners_result()
2873 
    result.read(self._iprot)
2874 
    self._iprot.readMessageEnd()
2875 
    if result.success is not None:
2876 
      return result.success
2877 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBanners failed: unknown result");
2878 
 
8579 kshitij.so 2879 
  def addBannerMap(self, bannerMaps):
6849 kshitij.so 2880 
    """
2881 
    Parameters:
8579 kshitij.so 2882 
     - bannerMaps
6849 kshitij.so 2883 
    """
8579 kshitij.so 2884 
    self.send_addBannerMap(bannerMaps)
6849 kshitij.so 2885 
    return self.recv_addBannerMap()
2886 
 
8579 kshitij.so 2887 
  def send_addBannerMap(self, bannerMaps):
6849 kshitij.so 2888 
    self._oprot.writeMessageBegin('addBannerMap', TMessageType.CALL, self._seqid)
2889 
    args = addBannerMap_args()
8579 kshitij.so 2890 
    args.bannerMaps = bannerMaps
6849 kshitij.so 2891 
    args.write(self._oprot)
2892 
    self._oprot.writeMessageEnd()
2893 
    self._oprot.trans.flush()
2894 
 
2895 
  def recv_addBannerMap(self, ):
2896 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2897 
    if mtype == TMessageType.EXCEPTION:
2898 
      x = TApplicationException()
2899 
      x.read(self._iprot)
2900 
      self._iprot.readMessageEnd()
2901 
      raise x
2902 
    result = addBannerMap_result()
2903 
    result.read(self._iprot)
2904 
    self._iprot.readMessageEnd()
2905 
    if result.success is not None:
2906 
      return result.success
2907 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBannerMap failed: unknown result");
2908 
 
8579 kshitij.so 2909 
  def updateBannerMap(self, bannerMap):
2910 
    """
2911 
    Parameters:
2912 
     - bannerMap
2913 
    """
2914 
    self.send_updateBannerMap(bannerMap)
2915 
    return self.recv_updateBannerMap()
2916 
 
2917 
  def send_updateBannerMap(self, bannerMap):
2918 
    self._oprot.writeMessageBegin('updateBannerMap', TMessageType.CALL, self._seqid)
2919 
    args = updateBannerMap_args()
2920 
    args.bannerMap = bannerMap
2921 
    args.write(self._oprot)
2922 
    self._oprot.writeMessageEnd()
2923 
    self._oprot.trans.flush()
2924 
 
2925 
  def recv_updateBannerMap(self, ):
2926 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2927 
    if mtype == TMessageType.EXCEPTION:
2928 
      x = TApplicationException()
2929 
      x.read(self._iprot)
2930 
      self._iprot.readMessageEnd()
2931 
      raise x
2932 
    result = updateBannerMap_result()
2933 
    result.read(self._iprot)
2934 
    self._iprot.readMessageEnd()
2935 
    if result.success is not None:
2936 
      return result.success
2937 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBannerMap failed: unknown result");
2938 
 
6849 kshitij.so 2939 
  def deleteBannerMap(self, bannerName):
2940 
    """
2941 
    Parameters:
2942 
     - bannerName
2943 
    """
2944 
    self.send_deleteBannerMap(bannerName)
2945 
    return self.recv_deleteBannerMap()
2946 
 
2947 
  def send_deleteBannerMap(self, bannerName):
2948 
    self._oprot.writeMessageBegin('deleteBannerMap', TMessageType.CALL, self._seqid)
2949 
    args = deleteBannerMap_args()
2950 
    args.bannerName = bannerName
2951 
    args.write(self._oprot)
2952 
    self._oprot.writeMessageEnd()
2953 
    self._oprot.trans.flush()
2954 
 
2955 
  def recv_deleteBannerMap(self, ):
2956 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2957 
    if mtype == TMessageType.EXCEPTION:
2958 
      x = TApplicationException()
2959 
      x.read(self._iprot)
2960 
      self._iprot.readMessageEnd()
2961 
      raise x
2962 
    result = deleteBannerMap_result()
2963 
    result.read(self._iprot)
2964 
    self._iprot.readMessageEnd()
2965 
    if result.success is not None:
2966 
      return result.success
2967 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBannerMap failed: unknown result");
2968 
 
9155 kshitij.so 2969 
  def getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 2970 
    """
2971 
    Parameters:
2972 
     - bannerName
9155 kshitij.so 2973 
     - bannerType
6849 kshitij.so 2974 
    """
9155 kshitij.so 2975 
    self.send_getBannerMapDetails(bannerName, bannerType)
6849 kshitij.so 2976 
    return self.recv_getBannerMapDetails()
2977 
 
9155 kshitij.so 2978 
  def send_getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 2979 
    self._oprot.writeMessageBegin('getBannerMapDetails', TMessageType.CALL, self._seqid)
2980 
    args = getBannerMapDetails_args()
2981 
    args.bannerName = bannerName
9155 kshitij.so 2982 
    args.bannerType = bannerType
6849 kshitij.so 2983 
    args.write(self._oprot)
2984 
    self._oprot.writeMessageEnd()
2985 
    self._oprot.trans.flush()
2986 
 
2987 
  def recv_getBannerMapDetails(self, ):
2988 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2989 
    if mtype == TMessageType.EXCEPTION:
2990 
      x = TApplicationException()
2991 
      x.read(self._iprot)
2992 
      self._iprot.readMessageEnd()
2993 
      raise x
2994 
    result = getBannerMapDetails_result()
2995 
    result.read(self._iprot)
2996 
    self._iprot.readMessageEnd()
2997 
    if result.success is not None:
2998 
      return result.success
2999 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerMapDetails failed: unknown result");
3000 
 
8579 kshitij.so 3001 
  def addBannerUri(self, bannerUriMappings):
3002 
    """
3003 
    Parameters:
3004 
     - bannerUriMappings
3005 
    """
3006 
    self.send_addBannerUri(bannerUriMappings)
3007 
    self.recv_addBannerUri()
3008 
 
3009 
  def send_addBannerUri(self, bannerUriMappings):
3010 
    self._oprot.writeMessageBegin('addBannerUri', TMessageType.CALL, self._seqid)
3011 
    args = addBannerUri_args()
3012 
    args.bannerUriMappings = bannerUriMappings
3013 
    args.write(self._oprot)
3014 
    self._oprot.writeMessageEnd()
3015 
    self._oprot.trans.flush()
3016 
 
3017 
  def recv_addBannerUri(self, ):
3018 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3019 
    if mtype == TMessageType.EXCEPTION:
3020 
      x = TApplicationException()
3021 
      x.read(self._iprot)
3022 
      self._iprot.readMessageEnd()
3023 
      raise x
3024 
    result = addBannerUri_result()
3025 
    result.read(self._iprot)
3026 
    self._iprot.readMessageEnd()
3027 
    return
3028 
 
9155 kshitij.so 3029 
  def getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 3030 
    """
3031 
    Parameters:
3032 
     - bannerName
9155 kshitij.so 3033 
     - bannerType
8579 kshitij.so 3034 
    """
9155 kshitij.so 3035 
    self.send_getUriMapping(bannerName, bannerType)
8579 kshitij.so 3036 
    return self.recv_getUriMapping()
3037 
 
9155 kshitij.so 3038 
  def send_getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 3039 
    self._oprot.writeMessageBegin('getUriMapping', TMessageType.CALL, self._seqid)
3040 
    args = getUriMapping_args()
3041 
    args.bannerName = bannerName
9155 kshitij.so 3042 
    args.bannerType = bannerType
8579 kshitij.so 3043 
    args.write(self._oprot)
3044 
    self._oprot.writeMessageEnd()
3045 
    self._oprot.trans.flush()
3046 
 
3047 
  def recv_getUriMapping(self, ):
3048 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3049 
    if mtype == TMessageType.EXCEPTION:
3050 
      x = TApplicationException()
3051 
      x.read(self._iprot)
3052 
      self._iprot.readMessageEnd()
3053 
      raise x
3054 
    result = getUriMapping_result()
3055 
    result.read(self._iprot)
3056 
    self._iprot.readMessageEnd()
3057 
    if result.success is not None:
3058 
      return result.success
3059 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUriMapping failed: unknown result");
3060 
 
3061 
  def addCampaign(self, campaign):
3062 
    """
3063 
    Parameters:
3064 
     - campaign
3065 
    """
3066 
    self.send_addCampaign(campaign)
3067 
    self.recv_addCampaign()
3068 
 
3069 
  def send_addCampaign(self, campaign):
3070 
    self._oprot.writeMessageBegin('addCampaign', TMessageType.CALL, self._seqid)
3071 
    args = addCampaign_args()
3072 
    args.campaign = campaign
3073 
    args.write(self._oprot)
3074 
    self._oprot.writeMessageEnd()
3075 
    self._oprot.trans.flush()
3076 
 
3077 
  def recv_addCampaign(self, ):
3078 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3079 
    if mtype == TMessageType.EXCEPTION:
3080 
      x = TApplicationException()
3081 
      x.read(self._iprot)
3082 
      self._iprot.readMessageEnd()
3083 
      raise x
3084 
    result = addCampaign_result()
3085 
    result.read(self._iprot)
3086 
    self._iprot.readMessageEnd()
3087 
    return
3088 
 
3089 
  def getCampaigns(self, campaignName):
3090 
    """
3091 
    Parameters:
3092 
     - campaignName
3093 
    """
3094 
    self.send_getCampaigns(campaignName)
3095 
    return self.recv_getCampaigns()
3096 
 
3097 
  def send_getCampaigns(self, campaignName):
3098 
    self._oprot.writeMessageBegin('getCampaigns', TMessageType.CALL, self._seqid)
3099 
    args = getCampaigns_args()
3100 
    args.campaignName = campaignName
3101 
    args.write(self._oprot)
3102 
    self._oprot.writeMessageEnd()
3103 
    self._oprot.trans.flush()
3104 
 
3105 
  def recv_getCampaigns(self, ):
3106 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3107 
    if mtype == TMessageType.EXCEPTION:
3108 
      x = TApplicationException()
3109 
      x.read(self._iprot)
3110 
      self._iprot.readMessageEnd()
3111 
      raise x
3112 
    result = getCampaigns_result()
3113 
    result.read(self._iprot)
3114 
    self._iprot.readMessageEnd()
3115 
    if result.success is not None:
3116 
      return result.success
3117 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCampaigns failed: unknown result");
3118 
 
3119 
  def deleteCampaign(self, campaignId):
3120 
    """
3121 
    Parameters:
3122 
     - campaignId
3123 
    """
3124 
    self.send_deleteCampaign(campaignId)
3125 
    self.recv_deleteCampaign()
3126 
 
3127 
  def send_deleteCampaign(self, campaignId):
3128 
    self._oprot.writeMessageBegin('deleteCampaign', TMessageType.CALL, self._seqid)
3129 
    args = deleteCampaign_args()
3130 
    args.campaignId = campaignId
3131 
    args.write(self._oprot)
3132 
    self._oprot.writeMessageEnd()
3133 
    self._oprot.trans.flush()
3134 
 
3135 
  def recv_deleteCampaign(self, ):
3136 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3137 
    if mtype == TMessageType.EXCEPTION:
3138 
      x = TApplicationException()
3139 
      x.read(self._iprot)
3140 
      self._iprot.readMessageEnd()
3141 
      raise x
3142 
    result = deleteCampaign_result()
3143 
    result.read(self._iprot)
3144 
    self._iprot.readMessageEnd()
3145 
    return
3146 
 
3147 
  def getAllCampaigns(self, ):
3148 
    self.send_getAllCampaigns()
3149 
    return self.recv_getAllCampaigns()
3150 
 
3151 
  def send_getAllCampaigns(self, ):
3152 
    self._oprot.writeMessageBegin('getAllCampaigns', TMessageType.CALL, self._seqid)
3153 
    args = getAllCampaigns_args()
3154 
    args.write(self._oprot)
3155 
    self._oprot.writeMessageEnd()
3156 
    self._oprot.trans.flush()
3157 
 
3158 
  def recv_getAllCampaigns(self, ):
3159 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3160 
    if mtype == TMessageType.EXCEPTION:
3161 
      x = TApplicationException()
3162 
      x.read(self._iprot)
3163 
      self._iprot.readMessageEnd()
3164 
      raise x
3165 
    result = getAllCampaigns_result()
3166 
    result.read(self._iprot)
3167 
    self._iprot.readMessageEnd()
3168 
    if result.success is not None:
3169 
      return result.success
3170 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCampaigns failed: unknown result");
3171 
 
9155 kshitij.so 3172 
  def getActiveBannersForMobileSite(self, ):
3173 
    self.send_getActiveBannersForMobileSite()
3174 
    return self.recv_getActiveBannersForMobileSite()
3175 
 
3176 
  def send_getActiveBannersForMobileSite(self, ):
3177 
    self._oprot.writeMessageBegin('getActiveBannersForMobileSite', TMessageType.CALL, self._seqid)
3178 
    args = getActiveBannersForMobileSite_args()
3179 
    args.write(self._oprot)
3180 
    self._oprot.writeMessageEnd()
3181 
    self._oprot.trans.flush()
3182 
 
3183 
  def recv_getActiveBannersForMobileSite(self, ):
3184 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3185 
    if mtype == TMessageType.EXCEPTION:
3186 
      x = TApplicationException()
3187 
      x.read(self._iprot)
3188 
      self._iprot.readMessageEnd()
3189 
      raise x
3190 
    result = getActiveBannersForMobileSite_result()
3191 
    result.read(self._iprot)
3192 
    self._iprot.readMessageEnd()
3193 
    if result.success is not None:
3194 
      return result.success
3195 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBannersForMobileSite failed: unknown result");
3196 
 
5944 mandeep.dh 3197 
  def deleteSimilarItem(self, itemId, catalogItemId):
3198 
    """
3199 
    Delete similar item.
3200 
 
3201 
    Parameters:
3202 
     - itemId
3203 
     - catalogItemId
3204 
    """
3205 
    self.send_deleteSimilarItem(itemId, catalogItemId)
3206 
    return self.recv_deleteSimilarItem()
3207 
 
3208 
  def send_deleteSimilarItem(self, itemId, catalogItemId):
3209 
    self._oprot.writeMessageBegin('deleteSimilarItem', TMessageType.CALL, self._seqid)
3210 
    args = deleteSimilarItem_args()
3211 
    args.itemId = itemId
3212 
    args.catalogItemId = catalogItemId
3213 
    args.write(self._oprot)
3214 
    self._oprot.writeMessageEnd()
3215 
    self._oprot.trans.flush()
3216 
 
3217 
  def recv_deleteSimilarItem(self, ):
3218 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3219 
    if mtype == TMessageType.EXCEPTION:
3220 
      x = TApplicationException()
3221 
      x.read(self._iprot)
3222 
      self._iprot.readMessageEnd()
3223 
      raise x
3224 
    result = deleteSimilarItem_result()
3225 
    result.read(self._iprot)
3226 
    self._iprot.readMessageEnd()
3227 
    if result.success is not None:
3228 
      return result.success
3229 
    if result.cex is not None:
3230 
      raise result.cex
3231 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteSimilarItem failed: unknown result");
3232 
 
3233 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
3234 
    """
3235 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
3236 
    If yes, returns the itemId else returns 0
3237 
 
3238 
    Parameters:
3239 
     - brand
3240 
     - modelNumber
3241 
     - modelName
3242 
     - color
3243 
    """
3244 
    self.send_checkSimilarItem(brand, modelNumber, modelName, color)
3245 
    return self.recv_checkSimilarItem()
3246 
 
3247 
  def send_checkSimilarItem(self, brand, modelNumber, modelName, color):
3248 
    self._oprot.writeMessageBegin('checkSimilarItem', TMessageType.CALL, self._seqid)
3249 
    args = checkSimilarItem_args()
3250 
    args.brand = brand
3251 
    args.modelNumber = modelNumber
3252 
    args.modelName = modelName
3253 
    args.color = color
3254 
    args.write(self._oprot)
3255 
    self._oprot.writeMessageEnd()
3256 
    self._oprot.trans.flush()
3257 
 
3258 
  def recv_checkSimilarItem(self, ):
3259 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3260 
    if mtype == TMessageType.EXCEPTION:
3261 
      x = TApplicationException()
3262 
      x.read(self._iprot)
3263 
      self._iprot.readMessageEnd()
3264 
      raise x
3265 
    result = checkSimilarItem_result()
3266 
    result.read(self._iprot)
3267 
    self._iprot.readMessageEnd()
3268 
    if result.success is not None:
3269 
      return result.success
3270 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkSimilarItem failed: unknown result");
3271 
 
3272 
  def validateRiskyStatus(self, itemId):
3273 
    """
3274 
    Check wether item is risky and change status if inventory is not available for risky items
3275 
 
3276 
    Parameters:
3277 
     - itemId
3278 
    """
3279 
    self.send_validateRiskyStatus(itemId)
3280 
    self.recv_validateRiskyStatus()
3281 
 
3282 
  def send_validateRiskyStatus(self, itemId):
3283 
    self._oprot.writeMessageBegin('validateRiskyStatus', TMessageType.CALL, self._seqid)
3284 
    args = validateRiskyStatus_args()
3285 
    args.itemId = itemId
3286 
    args.write(self._oprot)
3287 
    self._oprot.writeMessageEnd()
3288 
    self._oprot.trans.flush()
3289 
 
3290 
  def recv_validateRiskyStatus(self, ):
3291 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3292 
    if mtype == TMessageType.EXCEPTION:
3293 
      x = TApplicationException()
3294 
      x.read(self._iprot)
3295 
      self._iprot.readMessageEnd()
3296 
      raise x
3297 
    result = validateRiskyStatus_result()
3298 
    result.read(self._iprot)
3299 
    self._iprot.readMessageEnd()
3300 
    return
3301 
 
3302 
  def changeItemRiskyFlag(self, itemId, risky):
3303 
    """
3304 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
3305 
 
3306 
    Parameters:
3307 
     - itemId
3308 
     - risky
3309 
    """
3310 
    self.send_changeItemRiskyFlag(itemId, risky)
3311 
    self.recv_changeItemRiskyFlag()
3312 
 
3313 
  def send_changeItemRiskyFlag(self, itemId, risky):
3314 
    self._oprot.writeMessageBegin('changeItemRiskyFlag', TMessageType.CALL, self._seqid)
3315 
    args = changeItemRiskyFlag_args()
3316 
    args.itemId = itemId
3317 
    args.risky = risky
3318 
    args.write(self._oprot)
3319 
    self._oprot.writeMessageEnd()
3320 
    self._oprot.trans.flush()
3321 
 
3322 
  def recv_changeItemRiskyFlag(self, ):
3323 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3324 
    if mtype == TMessageType.EXCEPTION:
3325 
      x = TApplicationException()
3326 
      x.read(self._iprot)
3327 
      self._iprot.readMessageEnd()
3328 
      raise x
3329 
    result = changeItemRiskyFlag_result()
3330 
    result.read(self._iprot)
3331 
    self._iprot.readMessageEnd()
3332 
    return
3333 
 
3334 
  def getItemsByRiskyFlag(self, ):
3335 
    """
3336 
    Returns list of items marked as risky.
3337 
    """
3338 
    self.send_getItemsByRiskyFlag()
3339 
    return self.recv_getItemsByRiskyFlag()
3340 
 
3341 
  def send_getItemsByRiskyFlag(self, ):
3342 
    self._oprot.writeMessageBegin('getItemsByRiskyFlag', TMessageType.CALL, self._seqid)
3343 
    args = getItemsByRiskyFlag_args()
3344 
    args.write(self._oprot)
3345 
    self._oprot.writeMessageEnd()
3346 
    self._oprot.trans.flush()
3347 
 
3348 
  def recv_getItemsByRiskyFlag(self, ):
3349 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3350 
    if mtype == TMessageType.EXCEPTION:
3351 
      x = TApplicationException()
3352 
      x.read(self._iprot)
3353 
      self._iprot.readMessageEnd()
3354 
      raise x
3355 
    result = getItemsByRiskyFlag_result()
3356 
    result.read(self._iprot)
3357 
    self._iprot.readMessageEnd()
3358 
    if result.success is not None:
3359 
      return result.success
3360 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByRiskyFlag failed: unknown result");
3361 
 
3362 
  def getItemsForMasterSheet(self, category, brand):
3363 
    """
3364 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
3365 
 
3366 
    Parameters:
3367 
     - category
3368 
     - brand
3369 
    """
3370 
    self.send_getItemsForMasterSheet(category, brand)
3371 
    return self.recv_getItemsForMasterSheet()
3372 
 
3373 
  def send_getItemsForMasterSheet(self, category, brand):
3374 
    self._oprot.writeMessageBegin('getItemsForMasterSheet', TMessageType.CALL, self._seqid)
3375 
    args = getItemsForMasterSheet_args()
3376 
    args.category = category
3377 
    args.brand = brand
3378 
    args.write(self._oprot)
3379 
    self._oprot.writeMessageEnd()
3380 
    self._oprot.trans.flush()
3381 
 
3382 
  def recv_getItemsForMasterSheet(self, ):
3383 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3384 
    if mtype == TMessageType.EXCEPTION:
3385 
      x = TApplicationException()
3386 
      x.read(self._iprot)
3387 
      self._iprot.readMessageEnd()
3388 
      raise x
3389 
    result = getItemsForMasterSheet_result()
3390 
    result.read(self._iprot)
3391 
    self._iprot.readMessageEnd()
3392 
    if result.success is not None:
3393 
      return result.success
3394 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsForMasterSheet failed: unknown result");
3395 
 
3396 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
3397 
    """
3398 
    Returns list of catalog ids of items with same similarity index as of the given itemId
3399 
 
3400 
    Parameters:
3401 
     - beginIndex
3402 
     - totalItems
3403 
     - itemId
3404 
    """
3405 
    self.send_getSimilarItemsCatalogIds(beginIndex, totalItems, itemId)
3406 
    return self.recv_getSimilarItemsCatalogIds()
3407 
 
3408 
  def send_getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
3409 
    self._oprot.writeMessageBegin('getSimilarItemsCatalogIds', TMessageType.CALL, self._seqid)
3410 
    args = getSimilarItemsCatalogIds_args()
3411 
    args.beginIndex = beginIndex
3412 
    args.totalItems = totalItems
3413 
    args.itemId = itemId
3414 
    args.write(self._oprot)
3415 
    self._oprot.writeMessageEnd()
3416 
    self._oprot.trans.flush()
3417 
 
3418 
  def recv_getSimilarItemsCatalogIds(self, ):
3419 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3420 
    if mtype == TMessageType.EXCEPTION:
3421 
      x = TApplicationException()
3422 
      x.read(self._iprot)
3423 
      self._iprot.readMessageEnd()
3424 
      raise x
3425 
    result = getSimilarItemsCatalogIds_result()
3426 
    result.read(self._iprot)
3427 
    self._iprot.readMessageEnd()
3428 
    if result.success is not None:
3429 
      return result.success
3430 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSimilarItemsCatalogIds failed: unknown result");
3431 
 
3432 
  def addProductNotification(self, itemId, email):
3433 
    """
3434 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
3435 
 
3436 
    Parameters:
3437 
     - itemId
3438 
     - email
3439 
    """
3440 
    self.send_addProductNotification(itemId, email)
3441 
    return self.recv_addProductNotification()
3442 
 
3443 
  def send_addProductNotification(self, itemId, email):
3444 
    self._oprot.writeMessageBegin('addProductNotification', TMessageType.CALL, self._seqid)
3445 
    args = addProductNotification_args()
3446 
    args.itemId = itemId
3447 
    args.email = email
3448 
    args.write(self._oprot)
3449 
    self._oprot.writeMessageEnd()
3450 
    self._oprot.trans.flush()
3451 
 
3452 
  def recv_addProductNotification(self, ):
3453 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3454 
    if mtype == TMessageType.EXCEPTION:
3455 
      x = TApplicationException()
3456 
      x.read(self._iprot)
3457 
      self._iprot.readMessageEnd()
3458 
      raise x
3459 
    result = addProductNotification_result()
3460 
    result.read(self._iprot)
3461 
    self._iprot.readMessageEnd()
3462 
    if result.success is not None:
3463 
      return result.success
3464 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductNotification failed: unknown result");
3465 
 
3466 
  def sendProductNotifications(self, ):
3467 
    """
3468 
    Send the product notifications to the users for items which has stock.
3469 
    """
3470 
    self.send_sendProductNotifications()
3471 
    return self.recv_sendProductNotifications()
3472 
 
3473 
  def send_sendProductNotifications(self, ):
3474 
    self._oprot.writeMessageBegin('sendProductNotifications', TMessageType.CALL, self._seqid)
3475 
    args = sendProductNotifications_args()
3476 
    args.write(self._oprot)
3477 
    self._oprot.writeMessageEnd()
3478 
    self._oprot.trans.flush()
3479 
 
3480 
  def recv_sendProductNotifications(self, ):
3481 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3482 
    if mtype == TMessageType.EXCEPTION:
3483 
      x = TApplicationException()
3484 
      x.read(self._iprot)
3485 
      self._iprot.readMessageEnd()
3486 
      raise x
3487 
    result = sendProductNotifications_result()
3488 
    result.read(self._iprot)
3489 
    self._iprot.readMessageEnd()
3490 
    if result.success is not None:
3491 
      return result.success
3492 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendProductNotifications failed: unknown result");
3493 
 
3494 
  def getAllBrandsByCategory(self, categoryId):
3495 
    """
3496 
    Returns list of brand names for a given category Id
3497 
 
3498 
    Parameters:
3499 
     - categoryId
3500 
    """
3501 
    self.send_getAllBrandsByCategory(categoryId)
3502 
    return self.recv_getAllBrandsByCategory()
3503 
 
3504 
  def send_getAllBrandsByCategory(self, categoryId):
3505 
    self._oprot.writeMessageBegin('getAllBrandsByCategory', TMessageType.CALL, self._seqid)
3506 
    args = getAllBrandsByCategory_args()
3507 
    args.categoryId = categoryId
3508 
    args.write(self._oprot)
3509 
    self._oprot.writeMessageEnd()
3510 
    self._oprot.trans.flush()
3511 
 
3512 
  def recv_getAllBrandsByCategory(self, ):
3513 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3514 
    if mtype == TMessageType.EXCEPTION:
3515 
      x = TApplicationException()
3516 
      x.read(self._iprot)
3517 
      self._iprot.readMessageEnd()
3518 
      raise x
3519 
    result = getAllBrandsByCategory_result()
3520 
    result.read(self._iprot)
3521 
    self._iprot.readMessageEnd()
3522 
    if result.success is not None:
3523 
      return result.success
3524 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrandsByCategory failed: unknown result");
3525 
 
3526 
  def getAllBrands(self, ):
3527 
    """
3528 
    Returns list of brand names
3529 
    """
3530 
    self.send_getAllBrands()
3531 
    return self.recv_getAllBrands()
3532 
 
3533 
  def send_getAllBrands(self, ):
3534 
    self._oprot.writeMessageBegin('getAllBrands', TMessageType.CALL, self._seqid)
3535 
    args = getAllBrands_args()
3536 
    args.write(self._oprot)
3537 
    self._oprot.writeMessageEnd()
3538 
    self._oprot.trans.flush()
3539 
 
3540 
  def recv_getAllBrands(self, ):
3541 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3542 
    if mtype == TMessageType.EXCEPTION:
3543 
      x = TApplicationException()
3544 
      x.read(self._iprot)
3545 
      self._iprot.readMessageEnd()
3546 
      raise x
3547 
    result = getAllBrands_result()
3548 
    result.read(self._iprot)
3549 
    self._iprot.readMessageEnd()
3550 
    if result.success is not None:
3551 
      return result.success
3552 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrands failed: unknown result");
3553 
 
3554 
  def getAllSources(self, ):
3555 
    """
3556 
    Return list of all sources
3557 
    """
3558 
    self.send_getAllSources()
3559 
    return self.recv_getAllSources()
3560 
 
3561 
  def send_getAllSources(self, ):
3562 
    self._oprot.writeMessageBegin('getAllSources', TMessageType.CALL, self._seqid)
3563 
    args = getAllSources_args()
3564 
    args.write(self._oprot)
3565 
    self._oprot.writeMessageEnd()
3566 
    self._oprot.trans.flush()
3567 
 
3568 
  def recv_getAllSources(self, ):
3569 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3570 
    if mtype == TMessageType.EXCEPTION:
3571 
      x = TApplicationException()
3572 
      x.read(self._iprot)
3573 
      self._iprot.readMessageEnd()
3574 
      raise x
3575 
    result = getAllSources_result()
3576 
    result.read(self._iprot)
3577 
    self._iprot.readMessageEnd()
3578 
    if result.success is not None:
3579 
      return result.success
3580 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSources failed: unknown result");
3581 
 
3582 
  def getItemPricingBySource(self, itemId, sourceId):
3583 
    """
3584 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
3585 
 
3586 
    Parameters:
3587 
     - itemId
3588 
     - sourceId
3589 
    """
3590 
    self.send_getItemPricingBySource(itemId, sourceId)
3591 
    return self.recv_getItemPricingBySource()
3592 
 
3593 
  def send_getItemPricingBySource(self, itemId, sourceId):
3594 
    self._oprot.writeMessageBegin('getItemPricingBySource', TMessageType.CALL, self._seqid)
3595 
    args = getItemPricingBySource_args()
3596 
    args.itemId = itemId
3597 
    args.sourceId = sourceId
3598 
    args.write(self._oprot)
3599 
    self._oprot.writeMessageEnd()
3600 
    self._oprot.trans.flush()
3601 
 
3602 
  def recv_getItemPricingBySource(self, ):
3603 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3604 
    if mtype == TMessageType.EXCEPTION:
3605 
      x = TApplicationException()
3606 
      x.read(self._iprot)
3607 
      self._iprot.readMessageEnd()
3608 
      raise x
3609 
    result = getItemPricingBySource_result()
3610 
    result.read(self._iprot)
3611 
    self._iprot.readMessageEnd()
3612 
    if result.success is not None:
3613 
      return result.success
3614 
    if result.cex is not None:
3615 
      raise result.cex
3616 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricingBySource failed: unknown result");
3617 
 
3618 
  def addSourceItemPricing(self, sourceItemPricing):
3619 
    """
3620 
    Adds prices to be displayed corresponding to the item if user comes from a source.
3621 
    If item is not found or source is not found, it will throw exception.
3622 
 
3623 
    Parameters:
3624 
     - sourceItemPricing
3625 
    """
3626 
    self.send_addSourceItemPricing(sourceItemPricing)
3627 
    self.recv_addSourceItemPricing()
3628 
 
3629 
  def send_addSourceItemPricing(self, sourceItemPricing):
3630 
    self._oprot.writeMessageBegin('addSourceItemPricing', TMessageType.CALL, self._seqid)
3631 
    args = addSourceItemPricing_args()
3632 
    args.sourceItemPricing = sourceItemPricing
3633 
    args.write(self._oprot)
3634 
    self._oprot.writeMessageEnd()
3635 
    self._oprot.trans.flush()
3636 
 
3637 
  def recv_addSourceItemPricing(self, ):
3638 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3639 
    if mtype == TMessageType.EXCEPTION:
3640 
      x = TApplicationException()
3641 
      x.read(self._iprot)
3642 
      self._iprot.readMessageEnd()
3643 
      raise x
3644 
    result = addSourceItemPricing_result()
3645 
    result.read(self._iprot)
3646 
    self._iprot.readMessageEnd()
3647 
    if result.cex is not None:
3648 
      raise result.cex
3649 
    return
3650 
 
3651 
  def getAllSourcePricing(self, itemId):
3652 
    """
3653 
    Returns the list of source pricing information of an item.
3654 
    Raises an exception if item not found corresponding to itemId
3655 
 
3656 
    Parameters:
3657 
     - itemId
3658 
    """
3659 
    self.send_getAllSourcePricing(itemId)
3660 
    return self.recv_getAllSourcePricing()
3661 
 
3662 
  def send_getAllSourcePricing(self, itemId):
3663 
    self._oprot.writeMessageBegin('getAllSourcePricing', TMessageType.CALL, self._seqid)
3664 
    args = getAllSourcePricing_args()
3665 
    args.itemId = itemId
3666 
    args.write(self._oprot)
3667 
    self._oprot.writeMessageEnd()
3668 
    self._oprot.trans.flush()
3669 
 
3670 
  def recv_getAllSourcePricing(self, ):
3671 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3672 
    if mtype == TMessageType.EXCEPTION:
3673 
      x = TApplicationException()
3674 
      x.read(self._iprot)
3675 
      self._iprot.readMessageEnd()
3676 
      raise x
3677 
    result = getAllSourcePricing_result()
3678 
    result.read(self._iprot)
3679 
    self._iprot.readMessageEnd()
3680 
    if result.success is not None:
3681 
      return result.success
3682 
    if result.cex is not None:
3683 
      raise result.cex
3684 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSourcePricing failed: unknown result");
3685 
 
3686 
  def getItemForSource(self, item_id, sourceId):
3687 
    """
3688 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
3689 
 
3690 
    Parameters:
3691 
     - item_id
3692 
     - sourceId
3693 
    """
3694 
    self.send_getItemForSource(item_id, sourceId)
3695 
    return self.recv_getItemForSource()
3696 
 
3697 
  def send_getItemForSource(self, item_id, sourceId):
3698 
    self._oprot.writeMessageBegin('getItemForSource', TMessageType.CALL, self._seqid)
3699 
    args = getItemForSource_args()
3700 
    args.item_id = item_id
3701 
    args.sourceId = sourceId
3702 
    args.write(self._oprot)
3703 
    self._oprot.writeMessageEnd()
3704 
    self._oprot.trans.flush()
3705 
 
3706 
  def recv_getItemForSource(self, ):
3707 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3708 
    if mtype == TMessageType.EXCEPTION:
3709 
      x = TApplicationException()
3710 
      x.read(self._iprot)
3711 
      self._iprot.readMessageEnd()
3712 
      raise x
3713 
    result = getItemForSource_result()
3714 
    result.read(self._iprot)
3715 
    self._iprot.readMessageEnd()
3716 
    if result.success is not None:
3717 
      return result.success
3718 
    if result.cex is not None:
3719 
      raise result.cex
3720 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemForSource failed: unknown result");
3721 
 
3722 
  def searchItemsInRange(self, searchTerms, offset, limit):
3723 
    """
3724 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
3725 
 
3726 
    Parameters:
3727 
     - searchTerms
3728 
     - offset
3729 
     - limit
3730 
    """
3731 
    self.send_searchItemsInRange(searchTerms, offset, limit)
3732 
    return self.recv_searchItemsInRange()
3733 
 
3734 
  def send_searchItemsInRange(self, searchTerms, offset, limit):
3735 
    self._oprot.writeMessageBegin('searchItemsInRange', TMessageType.CALL, self._seqid)
3736 
    args = searchItemsInRange_args()
3737 
    args.searchTerms = searchTerms
3738 
    args.offset = offset
3739 
    args.limit = limit
3740 
    args.write(self._oprot)
3741 
    self._oprot.writeMessageEnd()
3742 
    self._oprot.trans.flush()
3743 
 
3744 
  def recv_searchItemsInRange(self, ):
3745 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3746 
    if mtype == TMessageType.EXCEPTION:
3747 
      x = TApplicationException()
3748 
      x.read(self._iprot)
3749 
      self._iprot.readMessageEnd()
3750 
      raise x
3751 
    result = searchItemsInRange_result()
3752 
    result.read(self._iprot)
3753 
    self._iprot.readMessageEnd()
3754 
    if result.success is not None:
3755 
      return result.success
3756 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchItemsInRange failed: unknown result");
3757 
 
3758 
  def getSearchResultCount(self, searchTerms):
3759 
    """
3760 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
3761 
 
3762 
    Parameters:
3763 
     - searchTerms
3764 
    """
3765 
    self.send_getSearchResultCount(searchTerms)
3766 
    return self.recv_getSearchResultCount()
3767 
 
3768 
  def send_getSearchResultCount(self, searchTerms):
3769 
    self._oprot.writeMessageBegin('getSearchResultCount', TMessageType.CALL, self._seqid)
3770 
    args = getSearchResultCount_args()
3771 
    args.searchTerms = searchTerms
3772 
    args.write(self._oprot)
3773 
    self._oprot.writeMessageEnd()
3774 
    self._oprot.trans.flush()
3775 
 
3776 
  def recv_getSearchResultCount(self, ):
3777 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3778 
    if mtype == TMessageType.EXCEPTION:
3779 
      x = TApplicationException()
3780 
      x.read(self._iprot)
3781 
      self._iprot.readMessageEnd()
3782 
      raise x
3783 
    result = getSearchResultCount_result()
3784 
    result.read(self._iprot)
3785 
    self._iprot.readMessageEnd()
3786 
    if result.success is not None:
3787 
      return result.success
3788 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSearchResultCount failed: unknown result");
3789 
 
3790 
  def getProductNotifications(self, startDateTime):
3791 
    """
3792 
    Returns a list of product notifications added after a supplied datetime
3793 
 
3794 
    Parameters:
3795 
     - startDateTime
3796 
    """
3797 
    self.send_getProductNotifications(startDateTime)
3798 
    return self.recv_getProductNotifications()
3799 
 
3800 
  def send_getProductNotifications(self, startDateTime):
3801 
    self._oprot.writeMessageBegin('getProductNotifications', TMessageType.CALL, self._seqid)
3802 
    args = getProductNotifications_args()
3803 
    args.startDateTime = startDateTime
3804 
    args.write(self._oprot)
3805 
    self._oprot.writeMessageEnd()
3806 
    self._oprot.trans.flush()
3807 
 
3808 
  def recv_getProductNotifications(self, ):
3809 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3810 
    if mtype == TMessageType.EXCEPTION:
3811 
      x = TApplicationException()
3812 
      x.read(self._iprot)
3813 
      self._iprot.readMessageEnd()
3814 
      raise x
3815 
    result = getProductNotifications_result()
3816 
    result.read(self._iprot)
3817 
    self._iprot.readMessageEnd()
3818 
    if result.success is not None:
3819 
      return result.success
3820 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotifications failed: unknown result");
3821 
 
7897 amar.kumar 3822 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3823 
    """
3824 
    Returns a list of count of requests for product notification against each item
3825 
 
3826 
    Parameters:
3827 
     - startDateTime
7897 amar.kumar 3828 
     - categoryId
5944 mandeep.dh 3829 
    """
7897 amar.kumar 3830 
    self.send_getProductNotificationRequestCount(startDateTime, categoryId)
5944 mandeep.dh 3831 
    return self.recv_getProductNotificationRequestCount()
3832 
 
7897 amar.kumar 3833 
  def send_getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3834 
    self._oprot.writeMessageBegin('getProductNotificationRequestCount', TMessageType.CALL, self._seqid)
3835 
    args = getProductNotificationRequestCount_args()
3836 
    args.startDateTime = startDateTime
7897 amar.kumar 3837 
    args.categoryId = categoryId
5944 mandeep.dh 3838 
    args.write(self._oprot)
3839 
    self._oprot.writeMessageEnd()
3840 
    self._oprot.trans.flush()
3841 
 
3842 
  def recv_getProductNotificationRequestCount(self, ):
3843 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3844 
    if mtype == TMessageType.EXCEPTION:
3845 
      x = TApplicationException()
3846 
      x.read(self._iprot)
3847 
      self._iprot.readMessageEnd()
3848 
      raise x
3849 
    result = getProductNotificationRequestCount_result()
3850 
    result.read(self._iprot)
3851 
    self._iprot.readMessageEnd()
3852 
    if result.success is not None:
3853 
      return result.success
3854 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotificationRequestCount failed: unknown result");
3855 
 
3856 
  def addAuthorizationLog(self, itemId, username, reason):
3857 
    """
3858 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
3859 
 
3860 
    Parameters:
3861 
     - itemId
3862 
     - username
3863 
     - reason
3864 
    """
3865 
    self.send_addAuthorizationLog(itemId, username, reason)
3866 
    return self.recv_addAuthorizationLog()
3867 
 
3868 
  def send_addAuthorizationLog(self, itemId, username, reason):
3869 
    self._oprot.writeMessageBegin('addAuthorizationLog', TMessageType.CALL, self._seqid)
3870 
    args = addAuthorizationLog_args()
3871 
    args.itemId = itemId
3872 
    args.username = username
3873 
    args.reason = reason
3874 
    args.write(self._oprot)
3875 
    self._oprot.writeMessageEnd()
3876 
    self._oprot.trans.flush()
3877 
 
3878 
  def recv_addAuthorizationLog(self, ):
3879 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3880 
    if mtype == TMessageType.EXCEPTION:
3881 
      x = TApplicationException()
3882 
      x.read(self._iprot)
3883 
      self._iprot.readMessageEnd()
3884 
      raise x
3885 
    result = addAuthorizationLog_result()
3886 
    result.read(self._iprot)
3887 
    self._iprot.readMessageEnd()
3888 
    if result.success is not None:
3889 
      return result.success
3890 
    if result.cex is not None:
3891 
      raise result.cex
3892 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAuthorizationLog failed: unknown result");
3893 
 
3894 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3895 
    """
3896 
    Parameters:
3897 
     - catalog_item_id
3898 
     - voucherType
3899 
     - voucherAmount
3900 
    """
3901 
    self.send_addupdateVoucherForItem(catalog_item_id, voucherType, voucherAmount)
3902 
    return self.recv_addupdateVoucherForItem()
3903 
 
3904 
  def send_addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3905 
    self._oprot.writeMessageBegin('addupdateVoucherForItem', TMessageType.CALL, self._seqid)
3906 
    args = addupdateVoucherForItem_args()
3907 
    args.catalog_item_id = catalog_item_id
3908 
    args.voucherType = voucherType
3909 
    args.voucherAmount = voucherAmount
3910 
    args.write(self._oprot)
3911 
    self._oprot.writeMessageEnd()
3912 
    self._oprot.trans.flush()
3913 
 
3914 
  def recv_addupdateVoucherForItem(self, ):
3915 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3916 
    if mtype == TMessageType.EXCEPTION:
3917 
      x = TApplicationException()
3918 
      x.read(self._iprot)
3919 
      self._iprot.readMessageEnd()
3920 
      raise x
3921 
    result = addupdateVoucherForItem_result()
3922 
    result.read(self._iprot)
3923 
    self._iprot.readMessageEnd()
3924 
    if result.success is not None:
3925 
      return result.success
3926 
    if result.cex is not None:
3927 
      raise result.cex
3928 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addupdateVoucherForItem failed: unknown result");
3929 
 
3930 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
3931 
    """
3932 
    Parameters:
3933 
     - catalog_item_id
3934 
     - voucherType
3935 
    """
3936 
    self.send_deleteVoucherForItem(catalog_item_id, voucherType)
3937 
    return self.recv_deleteVoucherForItem()
3938 
 
3939 
  def send_deleteVoucherForItem(self, catalog_item_id, voucherType):
3940 
    self._oprot.writeMessageBegin('deleteVoucherForItem', TMessageType.CALL, self._seqid)
3941 
    args = deleteVoucherForItem_args()
3942 
    args.catalog_item_id = catalog_item_id
3943 
    args.voucherType = voucherType
3944 
    args.write(self._oprot)
3945 
    self._oprot.writeMessageEnd()
3946 
    self._oprot.trans.flush()
3947 
 
3948 
  def recv_deleteVoucherForItem(self, ):
3949 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3950 
    if mtype == TMessageType.EXCEPTION:
3951 
      x = TApplicationException()
3952 
      x.read(self._iprot)
3953 
      self._iprot.readMessageEnd()
3954 
      raise x
3955 
    result = deleteVoucherForItem_result()
3956 
    result.read(self._iprot)
3957 
    self._iprot.readMessageEnd()
3958 
    if result.success is not None:
3959 
      return result.success
3960 
    if result.cex is not None:
3961 
      raise result.cex
3962 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteVoucherForItem failed: unknown result");
3963 
 
3964 
  def getVoucherAmount(self, itemId, voucherType):
3965 
    """
3966 
    Parameters:
3967 
     - itemId
3968 
     - voucherType
3969 
    """
3970 
    self.send_getVoucherAmount(itemId, voucherType)
3971 
    return self.recv_getVoucherAmount()
3972 
 
3973 
  def send_getVoucherAmount(self, itemId, voucherType):
3974 
    self._oprot.writeMessageBegin('getVoucherAmount', TMessageType.CALL, self._seqid)
3975 
    args = getVoucherAmount_args()
3976 
    args.itemId = itemId
3977 
    args.voucherType = voucherType
3978 
    args.write(self._oprot)
3979 
    self._oprot.writeMessageEnd()
3980 
    self._oprot.trans.flush()
3981 
 
3982 
  def recv_getVoucherAmount(self, ):
3983 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3984 
    if mtype == TMessageType.EXCEPTION:
3985 
      x = TApplicationException()
3986 
      x.read(self._iprot)
3987 
      self._iprot.readMessageEnd()
3988 
      raise x
3989 
    result = getVoucherAmount_result()
3990 
    result.read(self._iprot)
3991 
    self._iprot.readMessageEnd()
3992 
    if result.success is not None:
3993 
      return result.success
3994 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVoucherAmount failed: unknown result");
3995 
 
3996 
  def getAllItemVouchers(self, itemId):
3997 
    """
3998 
    Parameters:
3999 
     - itemId
4000 
    """
4001 
    self.send_getAllItemVouchers(itemId)
4002 
    return self.recv_getAllItemVouchers()
4003 
 
4004 
  def send_getAllItemVouchers(self, itemId):
4005 
    self._oprot.writeMessageBegin('getAllItemVouchers', TMessageType.CALL, self._seqid)
4006 
    args = getAllItemVouchers_args()
4007 
    args.itemId = itemId
4008 
    args.write(self._oprot)
4009 
    self._oprot.writeMessageEnd()
4010 
    self._oprot.trans.flush()
4011 
 
4012 
  def recv_getAllItemVouchers(self, ):
4013 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4014 
    if mtype == TMessageType.EXCEPTION:
4015 
      x = TApplicationException()
4016 
      x.read(self._iprot)
4017 
      self._iprot.readMessageEnd()
4018 
      raise x
4019 
    result = getAllItemVouchers_result()
4020 
    result.read(self._iprot)
4021 
    self._iprot.readMessageEnd()
4022 
    if result.success is not None:
4023 
      return result.success
4024 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemVouchers failed: unknown result");
4025 
 
4026 
  def isValidCatalogItemId(self, catalog_item_id):
4027 
    """
4028 
    Parameters:
4029 
     - catalog_item_id
4030 
    """
4031 
    self.send_isValidCatalogItemId(catalog_item_id)
4032 
    return self.recv_isValidCatalogItemId()
4033 
 
4034 
  def send_isValidCatalogItemId(self, catalog_item_id):
4035 
    self._oprot.writeMessageBegin('isValidCatalogItemId', TMessageType.CALL, self._seqid)
4036 
    args = isValidCatalogItemId_args()
4037 
    args.catalog_item_id = catalog_item_id
4038 
    args.write(self._oprot)
4039 
    self._oprot.writeMessageEnd()
4040 
    self._oprot.trans.flush()
4041 
 
4042 
  def recv_isValidCatalogItemId(self, ):
4043 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4044 
    if mtype == TMessageType.EXCEPTION:
4045 
      x = TApplicationException()
4046 
      x.read(self._iprot)
4047 
      self._iprot.readMessageEnd()
4048 
      raise x
4049 
    result = isValidCatalogItemId_result()
4050 
    result.read(self._iprot)
4051 
    self._iprot.readMessageEnd()
4052 
    if result.success is not None:
4053 
      return result.success
4054 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isValidCatalogItemId failed: unknown result");
4055 
 
7330 amit.gupta 4056 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 4057 
    """
4058 
    Parameters:
4059 
     - itemId
7330 amit.gupta 4060 
     - stateId
6039 amit.gupta 4061 
     - price
4062 
    """
7330 amit.gupta 4063 
    self.send_getVatPercentageForItem(itemId, stateId, price)
6039 amit.gupta 4064 
    return self.recv_getVatPercentageForItem()
5944 mandeep.dh 4065 
 
7330 amit.gupta 4066 
  def send_getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 4067 
    self._oprot.writeMessageBegin('getVatPercentageForItem', TMessageType.CALL, self._seqid)
4068 
    args = getVatPercentageForItem_args()
4069 
    args.itemId = itemId
7330 amit.gupta 4070 
    args.stateId = stateId
6039 amit.gupta 4071 
    args.price = price
4072 
    args.write(self._oprot)
4073 
    self._oprot.writeMessageEnd()
4074 
    self._oprot.trans.flush()
4075 
 
4076 
  def recv_getVatPercentageForItem(self, ):
4077 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4078 
    if mtype == TMessageType.EXCEPTION:
4079 
      x = TApplicationException()
4080 
      x.read(self._iprot)
4081 
      self._iprot.readMessageEnd()
4082 
      raise x
4083 
    result = getVatPercentageForItem_result()
4084 
    result.read(self._iprot)
4085 
    self._iprot.readMessageEnd()
4086 
    if result.success is not None:
4087 
      return result.success
7340 amit.gupta 4088 
    if result.cex is not None:
4089 
      raise result.cex
6039 amit.gupta 4090 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatPercentageForItem failed: unknown result");
4091 
 
4092 
  def getVatAmountForItem(self, itemId, price):
4093 
    """
4094 
    Parameters:
4095 
     - itemId
4096 
     - price
4097 
    """
4098 
    self.send_getVatAmountForItem(itemId, price)
4099 
    return self.recv_getVatAmountForItem()
4100 
 
4101 
  def send_getVatAmountForItem(self, itemId, price):
4102 
    self._oprot.writeMessageBegin('getVatAmountForItem', TMessageType.CALL, self._seqid)
4103 
    args = getVatAmountForItem_args()
4104 
    args.itemId = itemId
4105 
    args.price = price
4106 
    args.write(self._oprot)
4107 
    self._oprot.writeMessageEnd()
4108 
    self._oprot.trans.flush()
4109 
 
4110 
  def recv_getVatAmountForItem(self, ):
4111 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4112 
    if mtype == TMessageType.EXCEPTION:
4113 
      x = TApplicationException()
4114 
      x.read(self._iprot)
4115 
      self._iprot.readMessageEnd()
4116 
      raise x
4117 
    result = getVatAmountForItem_result()
4118 
    result.read(self._iprot)
4119 
    self._iprot.readMessageEnd()
4120 
    if result.success is not None:
4121 
      return result.success
4122 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatAmountForItem failed: unknown result");
4123 
 
6531 vikram.rag 4124 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
4125 
    """
4126 
    Parameters:
4127 
     - offset
4128 
     - limit
4129 
    """
4130 
    self.send_getAllIgnoredInventoryUpdateItemsList(offset, limit)
4131 
    return self.recv_getAllIgnoredInventoryUpdateItemsList()
6039 amit.gupta 4132 
 
6531 vikram.rag 4133 
  def send_getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
4134 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryUpdateItemsList', TMessageType.CALL, self._seqid)
4135 
    args = getAllIgnoredInventoryUpdateItemsList_args()
4136 
    args.offset = offset
4137 
    args.limit = limit
4138 
    args.write(self._oprot)
4139 
    self._oprot.writeMessageEnd()
4140 
    self._oprot.trans.flush()
4141 
 
4142 
  def recv_getAllIgnoredInventoryUpdateItemsList(self, ):
4143 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4144 
    if mtype == TMessageType.EXCEPTION:
4145 
      x = TApplicationException()
4146 
      x.read(self._iprot)
4147 
      self._iprot.readMessageEnd()
4148 
      raise x
4149 
    result = getAllIgnoredInventoryUpdateItemsList_result()
4150 
    result.read(self._iprot)
4151 
    self._iprot.readMessageEnd()
4152 
    if result.success is not None:
4153 
      return result.success
4154 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryUpdateItemsList failed: unknown result");
4155 
 
6821 amar.kumar 4156 
  def getAllAliveItems(self, ):
4157 
    self.send_getAllAliveItems()
4158 
    return self.recv_getAllAliveItems()
4159 
 
4160 
  def send_getAllAliveItems(self, ):
4161 
    self._oprot.writeMessageBegin('getAllAliveItems', TMessageType.CALL, self._seqid)
4162 
    args = getAllAliveItems_args()
4163 
    args.write(self._oprot)
4164 
    self._oprot.writeMessageEnd()
4165 
    self._oprot.trans.flush()
4166 
 
4167 
  def recv_getAllAliveItems(self, ):
4168 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4169 
    if mtype == TMessageType.EXCEPTION:
4170 
      x = TApplicationException()
4171 
      x.read(self._iprot)
4172 
      self._iprot.readMessageEnd()
4173 
      raise x
4174 
    result = getAllAliveItems_result()
4175 
    result.read(self._iprot)
4176 
    self._iprot.readMessageEnd()
4177 
    if result.success is not None:
4178 
      return result.success
4179 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAliveItems failed: unknown result");
4180 
 
6921 anupam.sin 4181 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 4182 
    """
4183 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 4184 
 
6805 anupam.sin 4185 
    Parameters:
4186 
     - itemId
6921 anupam.sin 4187 
     - price
6805 anupam.sin 4188 
     - insurerId
4189 
     - quantity
4190 
    """
6921 anupam.sin 4191 
    self.send_getInsuranceAmount(itemId, price, insurerId, quantity)
6805 anupam.sin 4192 
    return self.recv_getInsuranceAmount()
4193 
 
6921 anupam.sin 4194 
  def send_getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 4195 
    self._oprot.writeMessageBegin('getInsuranceAmount', TMessageType.CALL, self._seqid)
4196 
    args = getInsuranceAmount_args()
4197 
    args.itemId = itemId
6921 anupam.sin 4198 
    args.price = price
6805 anupam.sin 4199 
    args.insurerId = insurerId
4200 
    args.quantity = quantity
4201 
    args.write(self._oprot)
4202 
    self._oprot.writeMessageEnd()
4203 
    self._oprot.trans.flush()
4204 
 
4205 
  def recv_getInsuranceAmount(self, ):
4206 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4207 
    if mtype == TMessageType.EXCEPTION:
4208 
      x = TApplicationException()
4209 
      x.read(self._iprot)
4210 
      self._iprot.readMessageEnd()
4211 
      raise x
4212 
    result = getInsuranceAmount_result()
4213 
    result.read(self._iprot)
4214 
    self._iprot.readMessageEnd()
4215 
    if result.success is not None:
4216 
      return result.success
4217 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsuranceAmount failed: unknown result");
4218 
 
4219 
  def getInsurer(self, insurerId):
4220 
    """
4221 
    Parameters:
4222 
     - insurerId
4223 
    """
4224 
    self.send_getInsurer(insurerId)
4225 
    return self.recv_getInsurer()
4226 
 
4227 
  def send_getInsurer(self, insurerId):
4228 
    self._oprot.writeMessageBegin('getInsurer', TMessageType.CALL, self._seqid)
4229 
    args = getInsurer_args()
4230 
    args.insurerId = insurerId
4231 
    args.write(self._oprot)
4232 
    self._oprot.writeMessageEnd()
4233 
    self._oprot.trans.flush()
4234 
 
4235 
  def recv_getInsurer(self, ):
4236 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4237 
    if mtype == TMessageType.EXCEPTION:
4238 
      x = TApplicationException()
4239 
      x.read(self._iprot)
4240 
      self._iprot.readMessageEnd()
4241 
      raise x
4242 
    result = getInsurer_result()
4243 
    result.read(self._iprot)
4244 
    self._iprot.readMessageEnd()
4245 
    if result.success is not None:
4246 
      return result.success
4247 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsurer failed: unknown result");
4248 
 
6838 vikram.rag 4249 
  def getAllInsurers(self, ):
4250 
    self.send_getAllInsurers()
4251 
    return self.recv_getAllInsurers()
6805 anupam.sin 4252 
 
6838 vikram.rag 4253 
  def send_getAllInsurers(self, ):
4254 
    self._oprot.writeMessageBegin('getAllInsurers', TMessageType.CALL, self._seqid)
4255 
    args = getAllInsurers_args()
4256 
    args.write(self._oprot)
4257 
    self._oprot.writeMessageEnd()
4258 
    self._oprot.trans.flush()
4259 
 
4260 
  def recv_getAllInsurers(self, ):
4261 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4262 
    if mtype == TMessageType.EXCEPTION:
4263 
      x = TApplicationException()
4264 
      x.read(self._iprot)
4265 
      self._iprot.readMessageEnd()
4266 
      raise x
4267 
    result = getAllInsurers_result()
4268 
    result.read(self._iprot)
4269 
    self._iprot.readMessageEnd()
4270 
    if result.success is not None:
4271 
      return result.success
4272 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllInsurers failed: unknown result");
4273 
 
6962 rajveer 4274 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
4275 
    """
4276 
    Parameters:
4277 
     - insurerId
4278 
     - amount
4279 
    """
4280 
    self.send_updateInsuranceDeclaredAmount(insurerId, amount)
4281 
    self.recv_updateInsuranceDeclaredAmount()
6838 vikram.rag 4282 
 
6962 rajveer 4283 
  def send_updateInsuranceDeclaredAmount(self, insurerId, amount):
4284 
    self._oprot.writeMessageBegin('updateInsuranceDeclaredAmount', TMessageType.CALL, self._seqid)
4285 
    args = updateInsuranceDeclaredAmount_args()
4286 
    args.insurerId = insurerId
4287 
    args.amount = amount
4288 
    args.write(self._oprot)
4289 
    self._oprot.writeMessageEnd()
4290 
    self._oprot.trans.flush()
4291 
 
4292 
  def recv_updateInsuranceDeclaredAmount(self, ):
4293 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4294 
    if mtype == TMessageType.EXCEPTION:
4295 
      x = TApplicationException()
4296 
      x.read(self._iprot)
4297 
      self._iprot.readMessageEnd()
4298 
      raise x
4299 
    result = updateInsuranceDeclaredAmount_result()
4300 
    result.read(self._iprot)
4301 
    self._iprot.readMessageEnd()
4302 
    return
4303 
 
7190 amar.kumar 4304 
  def getFreebieForItem(self, itemId):
4305 
    """
4306 
    Parameters:
4307 
     - itemId
4308 
    """
4309 
    self.send_getFreebieForItem(itemId)
4310 
    return self.recv_getFreebieForItem()
6962 rajveer 4311 
 
7190 amar.kumar 4312 
  def send_getFreebieForItem(self, itemId):
4313 
    self._oprot.writeMessageBegin('getFreebieForItem', TMessageType.CALL, self._seqid)
4314 
    args = getFreebieForItem_args()
4315 
    args.itemId = itemId
4316 
    args.write(self._oprot)
4317 
    self._oprot.writeMessageEnd()
4318 
    self._oprot.trans.flush()
4319 
 
4320 
  def recv_getFreebieForItem(self, ):
4321 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4322 
    if mtype == TMessageType.EXCEPTION:
4323 
      x = TApplicationException()
4324 
      x.read(self._iprot)
4325 
      self._iprot.readMessageEnd()
4326 
      raise x
4327 
    result = getFreebieForItem_result()
4328 
    result.read(self._iprot)
4329 
    self._iprot.readMessageEnd()
4330 
    if result.success is not None:
4331 
      return result.success
4332 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFreebieForItem failed: unknown result");
4333 
 
4334 
  def addOrUpdateFreebieForItem(self, freebieItem):
4335 
    """
4336 
    Parameters:
4337 
     - freebieItem
4338 
    """
4339 
    self.send_addOrUpdateFreebieForItem(freebieItem)
4340 
    self.recv_addOrUpdateFreebieForItem()
4341 
 
4342 
  def send_addOrUpdateFreebieForItem(self, freebieItem):
4343 
    self._oprot.writeMessageBegin('addOrUpdateFreebieForItem', TMessageType.CALL, self._seqid)
4344 
    args = addOrUpdateFreebieForItem_args()
4345 
    args.freebieItem = freebieItem
4346 
    args.write(self._oprot)
4347 
    self._oprot.writeMessageEnd()
4348 
    self._oprot.trans.flush()
4349 
 
4350 
  def recv_addOrUpdateFreebieForItem(self, ):
4351 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4352 
    if mtype == TMessageType.EXCEPTION:
4353 
      x = TApplicationException()
4354 
      x.read(self._iprot)
4355 
      self._iprot.readMessageEnd()
4356 
      raise x
4357 
    result = addOrUpdateFreebieForItem_result()
4358 
    result.read(self._iprot)
4359 
    self._iprot.readMessageEnd()
4360 
    return
4361 
 
7272 amit.gupta 4362 
  def addOrUpdateBrandInfo(self, brandInfo):
4363 
    """
4364 
    Parameters:
4365 
     - brandInfo
4366 
    """
4367 
    self.send_addOrUpdateBrandInfo(brandInfo)
4368 
    self.recv_addOrUpdateBrandInfo()
4369 
 
4370 
  def send_addOrUpdateBrandInfo(self, brandInfo):
4371 
    self._oprot.writeMessageBegin('addOrUpdateBrandInfo', TMessageType.CALL, self._seqid)
4372 
    args = addOrUpdateBrandInfo_args()
4373 
    args.brandInfo = brandInfo
4374 
    args.write(self._oprot)
4375 
    self._oprot.writeMessageEnd()
4376 
    self._oprot.trans.flush()
4377 
 
4378 
  def recv_addOrUpdateBrandInfo(self, ):
4379 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4380 
    if mtype == TMessageType.EXCEPTION:
4381 
      x = TApplicationException()
4382 
      x.read(self._iprot)
4383 
      self._iprot.readMessageEnd()
4384 
      raise x
4385 
    result = addOrUpdateBrandInfo_result()
4386 
    result.read(self._iprot)
4387 
    self._iprot.readMessageEnd()
4388 
    return
4389 
 
4390 
  def getBrandInfo(self, ):
4391 
    self.send_getBrandInfo()
4392 
    return self.recv_getBrandInfo()
4393 
 
4394 
  def send_getBrandInfo(self, ):
4395 
    self._oprot.writeMessageBegin('getBrandInfo', TMessageType.CALL, self._seqid)
4396 
    args = getBrandInfo_args()
4397 
    args.write(self._oprot)
4398 
    self._oprot.writeMessageEnd()
4399 
    self._oprot.trans.flush()
4400 
 
4401 
  def recv_getBrandInfo(self, ):
4402 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4403 
    if mtype == TMessageType.EXCEPTION:
4404 
      x = TApplicationException()
4405 
      x.read(self._iprot)
4406 
      self._iprot.readMessageEnd()
4407 
      raise x
4408 
    result = getBrandInfo_result()
4409 
    result.read(self._iprot)
4410 
    self._iprot.readMessageEnd()
4411 
    if result.success is not None:
4412 
      return result.success
4413 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrandInfo failed: unknown result");
4414 
 
7256 rajveer 4415 
  def getStorePricing(self, itemId):
4416 
    """
4417 
    Parameters:
4418 
     - itemId
4419 
    """
4420 
    self.send_getStorePricing(itemId)
4421 
    return self.recv_getStorePricing()
7190 amar.kumar 4422 
 
7256 rajveer 4423 
  def send_getStorePricing(self, itemId):
4424 
    self._oprot.writeMessageBegin('getStorePricing', TMessageType.CALL, self._seqid)
4425 
    args = getStorePricing_args()
4426 
    args.itemId = itemId
4427 
    args.write(self._oprot)
4428 
    self._oprot.writeMessageEnd()
4429 
    self._oprot.trans.flush()
4430 
 
4431 
  def recv_getStorePricing(self, ):
4432 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4433 
    if mtype == TMessageType.EXCEPTION:
4434 
      x = TApplicationException()
4435 
      x.read(self._iprot)
4436 
      self._iprot.readMessageEnd()
4437 
      raise x
4438 
    result = getStorePricing_result()
4439 
    result.read(self._iprot)
4440 
    self._iprot.readMessageEnd()
4441 
    if result.success is not None:
4442 
      return result.success
4443 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricing failed: unknown result");
4444 
 
7306 rajveer 4445 
  def getStorePricings(self, itemIds):
4446 
    """
4447 
    Parameters:
4448 
     - itemIds
4449 
    """
4450 
    self.send_getStorePricings(itemIds)
4451 
    return self.recv_getStorePricings()
4452 
 
4453 
  def send_getStorePricings(self, itemIds):
4454 
    self._oprot.writeMessageBegin('getStorePricings', TMessageType.CALL, self._seqid)
4455 
    args = getStorePricings_args()
4456 
    args.itemIds = itemIds
4457 
    args.write(self._oprot)
4458 
    self._oprot.writeMessageEnd()
4459 
    self._oprot.trans.flush()
4460 
 
4461 
  def recv_getStorePricings(self, ):
4462 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4463 
    if mtype == TMessageType.EXCEPTION:
4464 
      x = TApplicationException()
4465 
      x.read(self._iprot)
4466 
      self._iprot.readMessageEnd()
4467 
      raise x
4468 
    result = getStorePricings_result()
4469 
    result.read(self._iprot)
4470 
    self._iprot.readMessageEnd()
4471 
    if result.success is not None:
4472 
      return result.success
4473 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricings failed: unknown result");
4474 
 
7382 rajveer 4475 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 4476 
    """
4477 
    Parameters:
4478 
     - sp
7382 rajveer 4479 
     - allColors
7265 rajveer 4480 
    """
7382 rajveer 4481 
    self.send_updateStorePricing(sp, allColors)
7265 rajveer 4482 
    self.recv_updateStorePricing()
7256 rajveer 4483 
 
7382 rajveer 4484 
  def send_updateStorePricing(self, sp, allColors):
7265 rajveer 4485 
    self._oprot.writeMessageBegin('updateStorePricing', TMessageType.CALL, self._seqid)
4486 
    args = updateStorePricing_args()
4487 
    args.sp = sp
7382 rajveer 4488 
    args.allColors = allColors
7265 rajveer 4489 
    args.write(self._oprot)
4490 
    self._oprot.writeMessageEnd()
4491 
    self._oprot.trans.flush()
4492 
 
4493 
  def recv_updateStorePricing(self, ):
4494 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4495 
    if mtype == TMessageType.EXCEPTION:
4496 
      x = TApplicationException()
4497 
      x.read(self._iprot)
4498 
      self._iprot.readMessageEnd()
4499 
      raise x
4500 
    result = updateStorePricing_result()
4501 
    result.read(self._iprot)
4502 
    self._iprot.readMessageEnd()
4503 
    return
4504 
 
7281 kshitij.so 4505 
  def getAllAmazonListedItems(self, ):
4506 
    self.send_getAllAmazonListedItems()
4507 
    return self.recv_getAllAmazonListedItems()
7265 rajveer 4508 
 
7281 kshitij.so 4509 
  def send_getAllAmazonListedItems(self, ):
4510 
    self._oprot.writeMessageBegin('getAllAmazonListedItems', TMessageType.CALL, self._seqid)
4511 
    args = getAllAmazonListedItems_args()
4512 
    args.write(self._oprot)
4513 
    self._oprot.writeMessageEnd()
4514 
    self._oprot.trans.flush()
4515 
 
4516 
  def recv_getAllAmazonListedItems(self, ):
4517 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4518 
    if mtype == TMessageType.EXCEPTION:
4519 
      x = TApplicationException()
4520 
      x.read(self._iprot)
4521 
      self._iprot.readMessageEnd()
4522 
      raise x
4523 
    result = getAllAmazonListedItems_result()
4524 
    result.read(self._iprot)
4525 
    self._iprot.readMessageEnd()
4526 
    if result.success is not None:
4527 
      return result.success
4528 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonListedItems failed: unknown result");
4529 
 
8619 kshitij.so 4530 
  def searchAmazonItems(self, searchTerm, offset, limit):
4531 
    """
4532 
    Parameters:
4533 
     - searchTerm
4534 
     - offset
4535 
     - limit
4536 
    """
4537 
    self.send_searchAmazonItems(searchTerm, offset, limit)
4538 
    return self.recv_searchAmazonItems()
4539 
 
4540 
  def send_searchAmazonItems(self, searchTerm, offset, limit):
4541 
    self._oprot.writeMessageBegin('searchAmazonItems', TMessageType.CALL, self._seqid)
4542 
    args = searchAmazonItems_args()
4543 
    args.searchTerm = searchTerm
4544 
    args.offset = offset
4545 
    args.limit = limit
4546 
    args.write(self._oprot)
4547 
    self._oprot.writeMessageEnd()
4548 
    self._oprot.trans.flush()
4549 
 
4550 
  def recv_searchAmazonItems(self, ):
4551 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4552 
    if mtype == TMessageType.EXCEPTION:
4553 
      x = TApplicationException()
4554 
      x.read(self._iprot)
4555 
      self._iprot.readMessageEnd()
4556 
      raise x
4557 
    result = searchAmazonItems_result()
4558 
    result.read(self._iprot)
4559 
    self._iprot.readMessageEnd()
4560 
    if result.success is not None:
4561 
      return result.success
4562 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchAmazonItems failed: unknown result");
4563 
 
4564 
  def getAmazonSearchResultCount(self, searchTerm):
4565 
    """
4566 
    Parameters:
4567 
     - searchTerm
4568 
    """
4569 
    self.send_getAmazonSearchResultCount(searchTerm)
4570 
    return self.recv_getAmazonSearchResultCount()
4571 
 
4572 
  def send_getAmazonSearchResultCount(self, searchTerm):
4573 
    self._oprot.writeMessageBegin('getAmazonSearchResultCount', TMessageType.CALL, self._seqid)
4574 
    args = getAmazonSearchResultCount_args()
4575 
    args.searchTerm = searchTerm
4576 
    args.write(self._oprot)
4577 
    self._oprot.writeMessageEnd()
4578 
    self._oprot.trans.flush()
4579 
 
4580 
  def recv_getAmazonSearchResultCount(self, ):
4581 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4582 
    if mtype == TMessageType.EXCEPTION:
4583 
      x = TApplicationException()
4584 
      x.read(self._iprot)
4585 
      self._iprot.readMessageEnd()
4586 
      raise x
4587 
    result = getAmazonSearchResultCount_result()
4588 
    result.read(self._iprot)
4589 
    self._iprot.readMessageEnd()
4590 
    if result.success is not None:
4591 
      return result.success
4592 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonSearchResultCount failed: unknown result");
4593 
 
4594 
  def getCountForAmazonlistedItems(self, ):
4595 
    self.send_getCountForAmazonlistedItems()
4596 
    return self.recv_getCountForAmazonlistedItems()
4597 
 
4598 
  def send_getCountForAmazonlistedItems(self, ):
4599 
    self._oprot.writeMessageBegin('getCountForAmazonlistedItems', TMessageType.CALL, self._seqid)
4600 
    args = getCountForAmazonlistedItems_args()
4601 
    args.write(self._oprot)
4602 
    self._oprot.writeMessageEnd()
4603 
    self._oprot.trans.flush()
4604 
 
4605 
  def recv_getCountForAmazonlistedItems(self, ):
4606 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4607 
    if mtype == TMessageType.EXCEPTION:
4608 
      x = TApplicationException()
4609 
      x.read(self._iprot)
4610 
      self._iprot.readMessageEnd()
4611 
      raise x
4612 
    result = getCountForAmazonlistedItems_result()
4613 
    result.read(self._iprot)
4614 
    self._iprot.readMessageEnd()
4615 
    if result.success is not None:
4616 
      return result.success
4617 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForAmazonlistedItems failed: unknown result");
4618 
 
7281 kshitij.so 4619 
  def getAmazonItemDetails(self, itemId):
4620 
    """
4621 
    Parameters:
4622 
     - itemId
4623 
    """
4624 
    self.send_getAmazonItemDetails(itemId)
4625 
    return self.recv_getAmazonItemDetails()
4626 
 
4627 
  def send_getAmazonItemDetails(self, itemId):
4628 
    self._oprot.writeMessageBegin('getAmazonItemDetails', TMessageType.CALL, self._seqid)
4629 
    args = getAmazonItemDetails_args()
4630 
    args.itemId = itemId
4631 
    args.write(self._oprot)
4632 
    self._oprot.writeMessageEnd()
4633 
    self._oprot.trans.flush()
4634 
 
4635 
  def recv_getAmazonItemDetails(self, ):
4636 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4637 
    if mtype == TMessageType.EXCEPTION:
4638 
      x = TApplicationException()
4639 
      x.read(self._iprot)
4640 
      self._iprot.readMessageEnd()
4641 
      raise x
4642 
    result = getAmazonItemDetails_result()
4643 
    result.read(self._iprot)
4644 
    self._iprot.readMessageEnd()
4645 
    if result.success is not None:
4646 
      return result.success
4647 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonItemDetails failed: unknown result");
4648 
 
8168 kshitij.so 4649 
  def updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4650 
    """
4651 
    Parameters:
8168 kshitij.so 4652 
     - amazonlisted
7281 kshitij.so 4653 
    """
8168 kshitij.so 4654 
    self.send_updateAmazonItemDetails(amazonlisted)
7281 kshitij.so 4655 
    self.recv_updateAmazonItemDetails()
4656 
 
8168 kshitij.so 4657 
  def send_updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4658 
    self._oprot.writeMessageBegin('updateAmazonItemDetails', TMessageType.CALL, self._seqid)
4659 
    args = updateAmazonItemDetails_args()
8168 kshitij.so 4660 
    args.amazonlisted = amazonlisted
7281 kshitij.so 4661 
    args.write(self._oprot)
4662 
    self._oprot.writeMessageEnd()
4663 
    self._oprot.trans.flush()
4664 
 
4665 
  def recv_updateAmazonItemDetails(self, ):
4666 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4667 
    if mtype == TMessageType.EXCEPTION:
4668 
      x = TApplicationException()
4669 
      x.read(self._iprot)
4670 
      self._iprot.readMessageEnd()
4671 
      raise x
4672 
    result = updateAmazonItemDetails_result()
4673 
    result.read(self._iprot)
4674 
    self._iprot.readMessageEnd()
4675 
    return
4676 
 
4677 
  def addAmazonItem(self, amazonlisted):
4678 
    """
4679 
    Parameters:
4680 
     - amazonlisted
4681 
    """
4682 
    self.send_addAmazonItem(amazonlisted)
4683 
    self.recv_addAmazonItem()
4684 
 
4685 
  def send_addAmazonItem(self, amazonlisted):
4686 
    self._oprot.writeMessageBegin('addAmazonItem', TMessageType.CALL, self._seqid)
4687 
    args = addAmazonItem_args()
4688 
    args.amazonlisted = amazonlisted
4689 
    args.write(self._oprot)
4690 
    self._oprot.writeMessageEnd()
4691 
    self._oprot.trans.flush()
4692 
 
4693 
  def recv_addAmazonItem(self, ):
4694 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4695 
    if mtype == TMessageType.EXCEPTION:
4696 
      x = TApplicationException()
4697 
      x.read(self._iprot)
4698 
      self._iprot.readMessageEnd()
4699 
      raise x
4700 
    result = addAmazonItem_result()
4701 
    result.read(self._iprot)
4702 
    self._iprot.readMessageEnd()
4703 
    return
4704 
 
7291 vikram.rag 4705 
  def getAsinItems(self, ):
4706 
    self.send_getAsinItems()
4707 
    return self.recv_getAsinItems()
7281 kshitij.so 4708 
 
7291 vikram.rag 4709 
  def send_getAsinItems(self, ):
4710 
    self._oprot.writeMessageBegin('getAsinItems', TMessageType.CALL, self._seqid)
4711 
    args = getAsinItems_args()
4712 
    args.write(self._oprot)
4713 
    self._oprot.writeMessageEnd()
4714 
    self._oprot.trans.flush()
4715 
 
4716 
  def recv_getAsinItems(self, ):
4717 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4718 
    if mtype == TMessageType.EXCEPTION:
4719 
      x = TApplicationException()
4720 
      x.read(self._iprot)
4721 
      self._iprot.readMessageEnd()
4722 
      raise x
4723 
    result = getAsinItems_result()
4724 
    result.read(self._iprot)
4725 
    self._iprot.readMessageEnd()
4726 
    if result.success is not None:
4727 
      return result.success
4728 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAsinItems failed: unknown result");
4729 
 
4730 
  def getAllFbaListedItems(self, ):
4731 
    self.send_getAllFbaListedItems()
4732 
    return self.recv_getAllFbaListedItems()
4733 
 
4734 
  def send_getAllFbaListedItems(self, ):
4735 
    self._oprot.writeMessageBegin('getAllFbaListedItems', TMessageType.CALL, self._seqid)
4736 
    args = getAllFbaListedItems_args()
4737 
    args.write(self._oprot)
4738 
    self._oprot.writeMessageEnd()
4739 
    self._oprot.trans.flush()
4740 
 
4741 
  def recv_getAllFbaListedItems(self, ):
4742 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4743 
    if mtype == TMessageType.EXCEPTION:
4744 
      x = TApplicationException()
4745 
      x.read(self._iprot)
4746 
      self._iprot.readMessageEnd()
4747 
      raise x
4748 
    result = getAllFbaListedItems_result()
4749 
    result.read(self._iprot)
4750 
    self._iprot.readMessageEnd()
4751 
    if result.success is not None:
4752 
      return result.success
4753 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbaListedItems failed: unknown result");
4754 
 
4755 
  def getAllNonFbaListedItems(self, ):
4756 
    self.send_getAllNonFbaListedItems()
4757 
    return self.recv_getAllNonFbaListedItems()
4758 
 
4759 
  def send_getAllNonFbaListedItems(self, ):
4760 
    self._oprot.writeMessageBegin('getAllNonFbaListedItems', TMessageType.CALL, self._seqid)
4761 
    args = getAllNonFbaListedItems_args()
4762 
    args.write(self._oprot)
4763 
    self._oprot.writeMessageEnd()
4764 
    self._oprot.trans.flush()
4765 
 
4766 
  def recv_getAllNonFbaListedItems(self, ):
4767 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4768 
    if mtype == TMessageType.EXCEPTION:
4769 
      x = TApplicationException()
4770 
      x.read(self._iprot)
4771 
      self._iprot.readMessageEnd()
4772 
      raise x
4773 
    result = getAllNonFbaListedItems_result()
4774 
    result.read(self._iprot)
4775 
    self._iprot.readMessageEnd()
4776 
    if result.success is not None:
4777 
      return result.success
4778 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllNonFbaListedItems failed: unknown result");
4779 
 
7460 kshitij.so 4780 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
4781 
    """
4782 
    Parameters:
4783 
     - itemId
4784 
     - holdInventory
4785 
     - defaultInventory
4786 
    """
4787 
    self.send_updateItemInventory(itemId, holdInventory, defaultInventory)
4788 
    return self.recv_updateItemInventory()
7291 vikram.rag 4789 
 
7460 kshitij.so 4790 
  def send_updateItemInventory(self, itemId, holdInventory, defaultInventory):
4791 
    self._oprot.writeMessageBegin('updateItemInventory', TMessageType.CALL, self._seqid)
4792 
    args = updateItemInventory_args()
4793 
    args.itemId = itemId
4794 
    args.holdInventory = holdInventory
4795 
    args.defaultInventory = defaultInventory
4796 
    args.write(self._oprot)
4797 
    self._oprot.writeMessageEnd()
4798 
    self._oprot.trans.flush()
4799 
 
4800 
  def recv_updateItemInventory(self, ):
4801 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4802 
    if mtype == TMessageType.EXCEPTION:
4803 
      x = TApplicationException()
4804 
      x.read(self._iprot)
4805 
      self._iprot.readMessageEnd()
4806 
      raise x
4807 
    result = updateItemInventory_result()
4808 
    result.read(self._iprot)
4809 
    self._iprot.readMessageEnd()
4810 
    if result.success is not None:
4811 
      return result.success
4812 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItemInventory failed: unknown result");
4813 
 
7770 kshitij.so 4814 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4815 
    """
4816 
    Parameters:
4817 
     - type
4818 
     - sku
4819 
     - timestamp
4820 
    """
4821 
    self.send_updateTimestampForAmazonFeeds(type, sku, timestamp)
4822 
    return self.recv_updateTimestampForAmazonFeeds()
7460 kshitij.so 4823 
 
7770 kshitij.so 4824 
  def send_updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4825 
    self._oprot.writeMessageBegin('updateTimestampForAmazonFeeds', TMessageType.CALL, self._seqid)
4826 
    args = updateTimestampForAmazonFeeds_args()
4827 
    args.type = type
4828 
    args.sku = sku
4829 
    args.timestamp = timestamp
4830 
    args.write(self._oprot)
4831 
    self._oprot.writeMessageEnd()
4832 
    self._oprot.trans.flush()
4833 
 
4834 
  def recv_updateTimestampForAmazonFeeds(self, ):
4835 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4836 
    if mtype == TMessageType.EXCEPTION:
4837 
      x = TApplicationException()
4838 
      x.read(self._iprot)
4839 
      self._iprot.readMessageEnd()
4840 
      raise x
4841 
    result = updateTimestampForAmazonFeeds_result()
4842 
    result.read(self._iprot)
4843 
    self._iprot.readMessageEnd()
4844 
    if result.success is not None:
4845 
      return result.success
4846 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateTimestampForAmazonFeeds failed: unknown result");
4847 
 
7897 amar.kumar 4848 
  def getAllParentCategories(self, ):
4849 
    self.send_getAllParentCategories()
4850 
    return self.recv_getAllParentCategories()
7770 kshitij.so 4851 
 
7897 amar.kumar 4852 
  def send_getAllParentCategories(self, ):
4853 
    self._oprot.writeMessageBegin('getAllParentCategories', TMessageType.CALL, self._seqid)
4854 
    args = getAllParentCategories_args()
4855 
    args.write(self._oprot)
4856 
    self._oprot.writeMessageEnd()
4857 
    self._oprot.trans.flush()
4858 
 
4859 
  def recv_getAllParentCategories(self, ):
4860 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4861 
    if mtype == TMessageType.EXCEPTION:
4862 
      x = TApplicationException()
4863 
      x.read(self._iprot)
4864 
      self._iprot.readMessageEnd()
4865 
      raise x
4866 
    result = getAllParentCategories_result()
4867 
    result.read(self._iprot)
4868 
    self._iprot.readMessageEnd()
4869 
    if result.success is not None:
4870 
      return result.success
4871 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllParentCategories failed: unknown result");
4872 
 
7977 kshitij.so 4873 
  def addPageViewEvent(self, pageViewEvents):
4874 
    """
4875 
    Parameters:
4876 
     - pageViewEvents
4877 
    """
4878 
    self.send_addPageViewEvent(pageViewEvents)
4879 
    self.recv_addPageViewEvent()
7897 amar.kumar 4880 
 
7977 kshitij.so 4881 
  def send_addPageViewEvent(self, pageViewEvents):
4882 
    self._oprot.writeMessageBegin('addPageViewEvent', TMessageType.CALL, self._seqid)
4883 
    args = addPageViewEvent_args()
4884 
    args.pageViewEvents = pageViewEvents
4885 
    args.write(self._oprot)
4886 
    self._oprot.writeMessageEnd()
4887 
    self._oprot.trans.flush()
4888 
 
4889 
  def recv_addPageViewEvent(self, ):
4890 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4891 
    if mtype == TMessageType.EXCEPTION:
4892 
      x = TApplicationException()
4893 
      x.read(self._iprot)
4894 
      self._iprot.readMessageEnd()
4895 
      raise x
4896 
    result = addPageViewEvent_result()
4897 
    result.read(self._iprot)
4898 
    self._iprot.readMessageEnd()
4899 
    return
4900 
 
4901 
  def addCartEvent(self, cartEvents):
4902 
    """
4903 
    Parameters:
4904 
     - cartEvents
4905 
    """
4906 
    self.send_addCartEvent(cartEvents)
4907 
    self.recv_addCartEvent()
4908 
 
4909 
  def send_addCartEvent(self, cartEvents):
4910 
    self._oprot.writeMessageBegin('addCartEvent', TMessageType.CALL, self._seqid)
4911 
    args = addCartEvent_args()
4912 
    args.cartEvents = cartEvents
4913 
    args.write(self._oprot)
4914 
    self._oprot.writeMessageEnd()
4915 
    self._oprot.trans.flush()
4916 
 
4917 
  def recv_addCartEvent(self, ):
4918 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4919 
    if mtype == TMessageType.EXCEPTION:
4920 
      x = TApplicationException()
4921 
      x.read(self._iprot)
4922 
      self._iprot.readMessageEnd()
4923 
      raise x
4924 
    result = addCartEvent_result()
4925 
    result.read(self._iprot)
4926 
    self._iprot.readMessageEnd()
4927 
    return
4928 
 
8182 amar.kumar 4929 
  def addEbayItem(self, ebayItem):
4930 
    """
4931 
    Parameters:
4932 
     - ebayItem
4933 
    """
4934 
    self.send_addEbayItem(ebayItem)
4935 
    self.recv_addEbayItem()
4936 
 
4937 
  def send_addEbayItem(self, ebayItem):
4938 
    self._oprot.writeMessageBegin('addEbayItem', TMessageType.CALL, self._seqid)
4939 
    args = addEbayItem_args()
4940 
    args.ebayItem = ebayItem
4941 
    args.write(self._oprot)
4942 
    self._oprot.writeMessageEnd()
4943 
    self._oprot.trans.flush()
4944 
 
4945 
  def recv_addEbayItem(self, ):
4946 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4947 
    if mtype == TMessageType.EXCEPTION:
4948 
      x = TApplicationException()
4949 
      x.read(self._iprot)
4950 
      self._iprot.readMessageEnd()
4951 
      raise x
4952 
    result = addEbayItem_result()
4953 
    result.read(self._iprot)
4954 
    self._iprot.readMessageEnd()
4955 
    return
4956 
 
4957 
  def getEbayItem(self, listingId):
4958 
    """
4959 
    Parameters:
4960 
     - listingId
4961 
    """
4962 
    self.send_getEbayItem(listingId)
4963 
    return self.recv_getEbayItem()
4964 
 
4965 
  def send_getEbayItem(self, listingId):
4966 
    self._oprot.writeMessageBegin('getEbayItem', TMessageType.CALL, self._seqid)
4967 
    args = getEbayItem_args()
4968 
    args.listingId = listingId
4969 
    args.write(self._oprot)
4970 
    self._oprot.writeMessageEnd()
4971 
    self._oprot.trans.flush()
4972 
 
4973 
  def recv_getEbayItem(self, ):
4974 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4975 
    if mtype == TMessageType.EXCEPTION:
4976 
      x = TApplicationException()
4977 
      x.read(self._iprot)
4978 
      self._iprot.readMessageEnd()
4979 
      raise x
4980 
    result = getEbayItem_result()
4981 
    result.read(self._iprot)
4982 
    self._iprot.readMessageEnd()
4983 
    if result.success is not None:
4984 
      return result.success
4985 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEbayItem failed: unknown result");
4986 
 
4987 
  def updateEbayItem(self, ebayItem):
4988 
    """
4989 
    Parameters:
4990 
     - ebayItem
4991 
    """
4992 
    self.send_updateEbayItem(ebayItem)
4993 
    self.recv_updateEbayItem()
4994 
 
4995 
  def send_updateEbayItem(self, ebayItem):
4996 
    self._oprot.writeMessageBegin('updateEbayItem', TMessageType.CALL, self._seqid)
4997 
    args = updateEbayItem_args()
4998 
    args.ebayItem = ebayItem
4999 
    args.write(self._oprot)
5000 
    self._oprot.writeMessageEnd()
5001 
    self._oprot.trans.flush()
5002 
 
5003 
  def recv_updateEbayItem(self, ):
5004 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5005 
    if mtype == TMessageType.EXCEPTION:
5006 
      x = TApplicationException()
5007 
      x.read(self._iprot)
5008 
      self._iprot.readMessageEnd()
5009 
      raise x
5010 
    result = updateEbayItem_result()
5011 
    result.read(self._iprot)
5012 
    self._iprot.readMessageEnd()
5013 
    return
5014 
 
8139 kshitij.so 5015 
  def getAmazonListedItems(self, offset, limit):
5016 
    """
5017 
    Parameters:
5018 
     - offset
5019 
     - limit
5020 
    """
5021 
    self.send_getAmazonListedItems(offset, limit)
5022 
    return self.recv_getAmazonListedItems()
7977 kshitij.so 5023 
 
8139 kshitij.so 5024 
  def send_getAmazonListedItems(self, offset, limit):
5025 
    self._oprot.writeMessageBegin('getAmazonListedItems', TMessageType.CALL, self._seqid)
5026 
    args = getAmazonListedItems_args()
5027 
    args.offset = offset
5028 
    args.limit = limit
5029 
    args.write(self._oprot)
5030 
    self._oprot.writeMessageEnd()
5031 
    self._oprot.trans.flush()
5032 
 
5033 
  def recv_getAmazonListedItems(self, ):
5034 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5035 
    if mtype == TMessageType.EXCEPTION:
5036 
      x = TApplicationException()
5037 
      x.read(self._iprot)
5038 
      self._iprot.readMessageEnd()
5039 
      raise x
5040 
    result = getAmazonListedItems_result()
5041 
    result.read(self._iprot)
5042 
    self._iprot.readMessageEnd()
5043 
    if result.success is not None:
5044 
      return result.success
5045 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonListedItems failed: unknown result");
5046 
 
8168 kshitij.so 5047 
  def updateAmazonAttributesInBulk(self, amazonlisted):
5048 
    """
5049 
    Parameters:
5050 
     - amazonlisted
5051 
    """
5052 
    self.send_updateAmazonAttributesInBulk(amazonlisted)
5053 
    return self.recv_updateAmazonAttributesInBulk()
8139 kshitij.so 5054 
 
8168 kshitij.so 5055 
  def send_updateAmazonAttributesInBulk(self, amazonlisted):
5056 
    self._oprot.writeMessageBegin('updateAmazonAttributesInBulk', TMessageType.CALL, self._seqid)
5057 
    args = updateAmazonAttributesInBulk_args()
5058 
    args.amazonlisted = amazonlisted
5059 
    args.write(self._oprot)
5060 
    self._oprot.writeMessageEnd()
5061 
    self._oprot.trans.flush()
5062 
 
5063 
  def recv_updateAmazonAttributesInBulk(self, ):
5064 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5065 
    if mtype == TMessageType.EXCEPTION:
5066 
      x = TApplicationException()
5067 
      x.read(self._iprot)
5068 
      self._iprot.readMessageEnd()
5069 
      raise x
5070 
    result = updateAmazonAttributesInBulk_result()
5071 
    result.read(self._iprot)
5072 
    self._iprot.readMessageEnd()
5073 
    if result.success is not None:
5074 
      return result.success
5075 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateAmazonAttributesInBulk failed: unknown result");
5076 
 
8379 vikram.rag 5077 
  def getAllItemstoListOnFba(self, ):
5078 
    self.send_getAllItemstoListOnFba()
5079 
    return self.recv_getAllItemstoListOnFba()
8168 kshitij.so 5080 
 
8379 vikram.rag 5081 
  def send_getAllItemstoListOnFba(self, ):
5082 
    self._oprot.writeMessageBegin('getAllItemstoListOnFba', TMessageType.CALL, self._seqid)
5083 
    args = getAllItemstoListOnFba_args()
5084 
    args.write(self._oprot)
5085 
    self._oprot.writeMessageEnd()
5086 
    self._oprot.trans.flush()
5087 
 
5088 
  def recv_getAllItemstoListOnFba(self, ):
5089 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5090 
    if mtype == TMessageType.EXCEPTION:
5091 
      x = TApplicationException()
5092 
      x.read(self._iprot)
5093 
      self._iprot.readMessageEnd()
5094 
      raise x
5095 
    result = getAllItemstoListOnFba_result()
5096 
    result.read(self._iprot)
5097 
    self._iprot.readMessageEnd()
5098 
    if result.success is not None:
5099 
      return result.success
5100 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnFba failed: unknown result");
5101 
 
5102 
  def getAllItemstoListOnNonFba(self, ):
5103 
    self.send_getAllItemstoListOnNonFba()
5104 
    return self.recv_getAllItemstoListOnNonFba()
5105 
 
5106 
  def send_getAllItemstoListOnNonFba(self, ):
5107 
    self._oprot.writeMessageBegin('getAllItemstoListOnNonFba', TMessageType.CALL, self._seqid)
5108 
    args = getAllItemstoListOnNonFba_args()
5109 
    args.write(self._oprot)
5110 
    self._oprot.writeMessageEnd()
5111 
    self._oprot.trans.flush()
5112 
 
5113 
  def recv_getAllItemstoListOnNonFba(self, ):
5114 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5115 
    if mtype == TMessageType.EXCEPTION:
5116 
      x = TApplicationException()
5117 
      x.read(self._iprot)
5118 
      self._iprot.readMessageEnd()
5119 
      raise x
5120 
    result = getAllItemstoListOnNonFba_result()
5121 
    result.read(self._iprot)
5122 
    self._iprot.readMessageEnd()
5123 
    if result.success is not None:
5124 
      return result.success
5125 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnNonFba failed: unknown result");
5126 
 
8619 kshitij.so 5127 
  def updateAsin(self, item):
5128 
    """
5129 
    Parameters:
5130 
     - item
5131 
    """
5132 
    self.send_updateAsin(item)
5133 
    self.recv_updateAsin()
8616 vikram.rag 5134 
 
8619 kshitij.so 5135 
  def send_updateAsin(self, item):
5136 
    self._oprot.writeMessageBegin('updateAsin', TMessageType.CALL, self._seqid)
5137 
    args = updateAsin_args()
5138 
    args.item = item
5139 
    args.write(self._oprot)
5140 
    self._oprot.writeMessageEnd()
5141 
    self._oprot.trans.flush()
5142 
 
5143 
  def recv_updateAsin(self, ):
5144 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5145 
    if mtype == TMessageType.EXCEPTION:
5146 
      x = TApplicationException()
5147 
      x.read(self._iprot)
5148 
      self._iprot.readMessageEnd()
5149 
      raise x
5150 
    result = updateAsin_result()
5151 
    result.read(self._iprot)
5152 
    self._iprot.readMessageEnd()
5153 
    return
5154 
 
8739 vikram.rag 5155 
  def addOrUpdateSnapdealItem(self, snapdealitem):
5156 
    """
5157 
    Parameters:
5158 
     - snapdealitem
5159 
    """
5160 
    self.send_addOrUpdateSnapdealItem(snapdealitem)
5161 
    return self.recv_addOrUpdateSnapdealItem()
8619 kshitij.so 5162 
 
8739 vikram.rag 5163 
  def send_addOrUpdateSnapdealItem(self, snapdealitem):
5164 
    self._oprot.writeMessageBegin('addOrUpdateSnapdealItem', TMessageType.CALL, self._seqid)
5165 
    args = addOrUpdateSnapdealItem_args()
5166 
    args.snapdealitem = snapdealitem
5167 
    args.write(self._oprot)
5168 
    self._oprot.writeMessageEnd()
5169 
    self._oprot.trans.flush()
5170 
 
5171 
  def recv_addOrUpdateSnapdealItem(self, ):
5172 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5173 
    if mtype == TMessageType.EXCEPTION:
5174 
      x = TApplicationException()
5175 
      x.read(self._iprot)
5176 
      self._iprot.readMessageEnd()
5177 
      raise x
5178 
    result = addOrUpdateSnapdealItem_result()
5179 
    result.read(self._iprot)
5180 
    self._iprot.readMessageEnd()
5181 
    if result.success is not None:
5182 
      return result.success
5183 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addOrUpdateSnapdealItem failed: unknown result");
5184 
 
5185 
  def getSnapdealItem(self, item_id):
5186 
    """
5187 
    Parameters:
5188 
     - item_id
5189 
    """
5190 
    self.send_getSnapdealItem(item_id)
5191 
    return self.recv_getSnapdealItem()
5192 
 
5193 
  def send_getSnapdealItem(self, item_id):
5194 
    self._oprot.writeMessageBegin('getSnapdealItem', TMessageType.CALL, self._seqid)
5195 
    args = getSnapdealItem_args()
5196 
    args.item_id = item_id
5197 
    args.write(self._oprot)
5198 
    self._oprot.writeMessageEnd()
5199 
    self._oprot.trans.flush()
5200 
 
5201 
  def recv_getSnapdealItem(self, ):
5202 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5203 
    if mtype == TMessageType.EXCEPTION:
5204 
      x = TApplicationException()
5205 
      x.read(self._iprot)
5206 
      self._iprot.readMessageEnd()
5207 
      raise x
5208 
    result = getSnapdealItem_result()
5209 
    result.read(self._iprot)
5210 
    self._iprot.readMessageEnd()
5211 
    if result.success is not None:
5212 
      return result.success
5213 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItem failed: unknown result");
5214 
 
9242 kshitij.so 5215 
  def getSnapdealItemDetails(self, item_id):
5216 
    """
5217 
    Parameters:
5218 
     - item_id
5219 
    """
5220 
    self.send_getSnapdealItemDetails(item_id)
5221 
    return self.recv_getSnapdealItemDetails()
5222 
 
5223 
  def send_getSnapdealItemDetails(self, item_id):
5224 
    self._oprot.writeMessageBegin('getSnapdealItemDetails', TMessageType.CALL, self._seqid)
5225 
    args = getSnapdealItemDetails_args()
5226 
    args.item_id = item_id
5227 
    args.write(self._oprot)
5228 
    self._oprot.writeMessageEnd()
5229 
    self._oprot.trans.flush()
5230 
 
5231 
  def recv_getSnapdealItemDetails(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 = getSnapdealItemDetails_result()
5239 
    result.read(self._iprot)
5240 
    self._iprot.readMessageEnd()
5241 
    if result.success is not None:
5242 
      return result.success
5243 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItemDetails failed: unknown result");
5244 
 
8739 vikram.rag 5245 
  def getAllSnapdealItems(self, ):
5246 
    self.send_getAllSnapdealItems()
5247 
    return self.recv_getAllSnapdealItems()
5248 
 
5249 
  def send_getAllSnapdealItems(self, ):
5250 
    self._oprot.writeMessageBegin('getAllSnapdealItems', TMessageType.CALL, self._seqid)
5251 
    args = getAllSnapdealItems_args()
5252 
    args.write(self._oprot)
5253 
    self._oprot.writeMessageEnd()
5254 
    self._oprot.trans.flush()
5255 
 
5256 
  def recv_getAllSnapdealItems(self, ):
5257 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5258 
    if mtype == TMessageType.EXCEPTION:
5259 
      x = TApplicationException()
5260 
      x.read(self._iprot)
5261 
      self._iprot.readMessageEnd()
5262 
      raise x
5263 
    result = getAllSnapdealItems_result()
5264 
    result.read(self._iprot)
5265 
    self._iprot.readMessageEnd()
5266 
    if result.success is not None:
5267 
      return result.success
5268 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSnapdealItems failed: unknown result");
5269 
 
9242 kshitij.so 5270 
  def getSnapdealItems(self, offset, limit):
5271 
    """
5272 
    Parameters:
5273 
     - offset
5274 
     - limit
5275 
    """
5276 
    self.send_getSnapdealItems(offset, limit)
5277 
    return self.recv_getSnapdealItems()
8739 vikram.rag 5278 
 
9242 kshitij.so 5279 
  def send_getSnapdealItems(self, offset, limit):
5280 
    self._oprot.writeMessageBegin('getSnapdealItems', TMessageType.CALL, self._seqid)
5281 
    args = getSnapdealItems_args()
5282 
    args.offset = offset
5283 
    args.limit = limit
5284 
    args.write(self._oprot)
5285 
    self._oprot.writeMessageEnd()
5286 
    self._oprot.trans.flush()
5287 
 
5288 
  def recv_getSnapdealItems(self, ):
5289 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5290 
    if mtype == TMessageType.EXCEPTION:
5291 
      x = TApplicationException()
5292 
      x.read(self._iprot)
5293 
      self._iprot.readMessageEnd()
5294 
      raise x
5295 
    result = getSnapdealItems_result()
5296 
    result.read(self._iprot)
5297 
    self._iprot.readMessageEnd()
5298 
    if result.success is not None:
5299 
      return result.success
5300 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItems failed: unknown result");
5301 
 
5302 
  def searchSnapdealItems(self, searchTerm, offset, limit):
5303 
    """
5304 
    Parameters:
5305 
     - searchTerm
5306 
     - offset
5307 
     - limit
5308 
    """
5309 
    self.send_searchSnapdealItems(searchTerm, offset, limit)
5310 
    return self.recv_searchSnapdealItems()
5311 
 
5312 
  def send_searchSnapdealItems(self, searchTerm, offset, limit):
5313 
    self._oprot.writeMessageBegin('searchSnapdealItems', TMessageType.CALL, self._seqid)
5314 
    args = searchSnapdealItems_args()
5315 
    args.searchTerm = searchTerm
5316 
    args.offset = offset
5317 
    args.limit = limit
5318 
    args.write(self._oprot)
5319 
    self._oprot.writeMessageEnd()
5320 
    self._oprot.trans.flush()
5321 
 
5322 
  def recv_searchSnapdealItems(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 = searchSnapdealItems_result()
5330 
    result.read(self._iprot)
5331 
    self._iprot.readMessageEnd()
5332 
    if result.success is not None:
5333 
      return result.success
5334 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchSnapdealItems failed: unknown result");
5335 
 
5336 
  def getCountForSnapdealItems(self, ):
5337 
    self.send_getCountForSnapdealItems()
5338 
    return self.recv_getCountForSnapdealItems()
5339 
 
5340 
  def send_getCountForSnapdealItems(self, ):
5341 
    self._oprot.writeMessageBegin('getCountForSnapdealItems', TMessageType.CALL, self._seqid)
5342 
    args = getCountForSnapdealItems_args()
5343 
    args.write(self._oprot)
5344 
    self._oprot.writeMessageEnd()
5345 
    self._oprot.trans.flush()
5346 
 
5347 
  def recv_getCountForSnapdealItems(self, ):
5348 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5349 
    if mtype == TMessageType.EXCEPTION:
5350 
      x = TApplicationException()
5351 
      x.read(self._iprot)
5352 
      self._iprot.readMessageEnd()
5353 
      raise x
5354 
    result = getCountForSnapdealItems_result()
5355 
    result.read(self._iprot)
5356 
    self._iprot.readMessageEnd()
5357 
    if result.success is not None:
5358 
      return result.success
5359 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForSnapdealItems failed: unknown result");
5360 
 
5361 
  def getSnapdealSearchResultCount(self, searchTerm):
5362 
    """
5363 
    Parameters:
5364 
     - searchTerm
5365 
    """
5366 
    self.send_getSnapdealSearchResultCount(searchTerm)
5367 
    return self.recv_getSnapdealSearchResultCount()
5368 
 
5369 
  def send_getSnapdealSearchResultCount(self, searchTerm):
5370 
    self._oprot.writeMessageBegin('getSnapdealSearchResultCount', TMessageType.CALL, self._seqid)
5371 
    args = getSnapdealSearchResultCount_args()
5372 
    args.searchTerm = searchTerm
5373 
    args.write(self._oprot)
5374 
    self._oprot.writeMessageEnd()
5375 
    self._oprot.trans.flush()
5376 
 
5377 
  def recv_getSnapdealSearchResultCount(self, ):
5378 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5379 
    if mtype == TMessageType.EXCEPTION:
5380 
      x = TApplicationException()
5381 
      x.read(self._iprot)
5382 
      self._iprot.readMessageEnd()
5383 
      raise x
5384 
    result = getSnapdealSearchResultCount_result()
5385 
    result.read(self._iprot)
5386 
    self._iprot.readMessageEnd()
5387 
    if result.success is not None:
5388 
      return result.success
5389 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealSearchResultCount failed: unknown result");
5390 
 
9299 kshitij.so 5391 
  def getPrefferedInsurerForItem(self, itemId, insurerType):
5392 
    """
5393 
    Parameters:
5394 
     - itemId
5395 
     - insurerType
5396 
    """
5397 
    self.send_getPrefferedInsurerForItem(itemId, insurerType)
5398 
    return self.recv_getPrefferedInsurerForItem()
9242 kshitij.so 5399 
 
9299 kshitij.so 5400 
  def send_getPrefferedInsurerForItem(self, itemId, insurerType):
5401 
    self._oprot.writeMessageBegin('getPrefferedInsurerForItem', TMessageType.CALL, self._seqid)
5402 
    args = getPrefferedInsurerForItem_args()
5403 
    args.itemId = itemId
5404 
    args.insurerType = insurerType
5405 
    args.write(self._oprot)
5406 
    self._oprot.writeMessageEnd()
5407 
    self._oprot.trans.flush()
5408 
 
5409 
  def recv_getPrefferedInsurerForItem(self, ):
5410 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5411 
    if mtype == TMessageType.EXCEPTION:
5412 
      x = TApplicationException()
5413 
      x.read(self._iprot)
5414 
      self._iprot.readMessageEnd()
5415 
      raise x
5416 
    result = getPrefferedInsurerForItem_result()
5417 
    result.read(self._iprot)
5418 
    self._iprot.readMessageEnd()
5419 
    if result.success is not None:
5420 
      return result.success
5421 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrefferedInsurerForItem failed: unknown result");
5422 
 
9456 vikram.rag 5423 
  def getSnapdealItembySkuAtSnapdeal(self, skuAtSnapdeal):
5424 
    """
5425 
    Parameters:
5426 
     - skuAtSnapdeal
5427 
    """
5428 
    self.send_getSnapdealItembySkuAtSnapdeal(skuAtSnapdeal)
5429 
    return self.recv_getSnapdealItembySkuAtSnapdeal()
9299 kshitij.so 5430 
 
9456 vikram.rag 5431 
  def send_getSnapdealItembySkuAtSnapdeal(self, skuAtSnapdeal):
5432 
    self._oprot.writeMessageBegin('getSnapdealItembySkuAtSnapdeal', TMessageType.CALL, self._seqid)
5433 
    args = getSnapdealItembySkuAtSnapdeal_args()
5434 
    args.skuAtSnapdeal = skuAtSnapdeal
5435 
    args.write(self._oprot)
5436 
    self._oprot.writeMessageEnd()
5437 
    self._oprot.trans.flush()
5438 
 
5439 
  def recv_getSnapdealItembySkuAtSnapdeal(self, ):
5440 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5441 
    if mtype == TMessageType.EXCEPTION:
5442 
      x = TApplicationException()
5443 
      x.read(self._iprot)
5444 
      self._iprot.readMessageEnd()
5445 
      raise x
5446 
    result = getSnapdealItembySkuAtSnapdeal_result()
5447 
    result.read(self._iprot)
5448 
    self._iprot.readMessageEnd()
5449 
    if result.success is not None:
5450 
      return result.success
5451 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItembySkuAtSnapdeal failed: unknown result");
5452 
 
9621 manish.sha 5453 
  def getProductFeedSubmit(self, catalogItemId):
5454 
    """
5455 
    Parameters:
5456 
     - catalogItemId
5457 
    """
5458 
    self.send_getProductFeedSubmit(catalogItemId)
5459 
    return self.recv_getProductFeedSubmit()
9456 vikram.rag 5460 
 
9621 manish.sha 5461 
  def send_getProductFeedSubmit(self, catalogItemId):
5462 
    self._oprot.writeMessageBegin('getProductFeedSubmit', TMessageType.CALL, self._seqid)
5463 
    args = getProductFeedSubmit_args()
5464 
    args.catalogItemId = catalogItemId
5465 
    args.write(self._oprot)
5466 
    self._oprot.writeMessageEnd()
5467 
    self._oprot.trans.flush()
5468 
 
5469 
  def recv_getProductFeedSubmit(self, ):
5470 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5471 
    if mtype == TMessageType.EXCEPTION:
5472 
      x = TApplicationException()
5473 
      x.read(self._iprot)
5474 
      self._iprot.readMessageEnd()
5475 
      raise x
5476 
    result = getProductFeedSubmit_result()
5477 
    result.read(self._iprot)
5478 
    self._iprot.readMessageEnd()
5479 
    if result.success is not None:
5480 
      return result.success
5481 
    if result.cex is not None:
5482 
      raise result.cex
5483 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductFeedSubmit failed: unknown result");
5484 
 
5485 
  def addProductFeedSubmit(self, productFeedSubmit):
5486 
    """
5487 
    Parameters:
5488 
     - productFeedSubmit
5489 
    """
5490 
    self.send_addProductFeedSubmit(productFeedSubmit)
5491 
    return self.recv_addProductFeedSubmit()
5492 
 
5493 
  def send_addProductFeedSubmit(self, productFeedSubmit):
5494 
    self._oprot.writeMessageBegin('addProductFeedSubmit', TMessageType.CALL, self._seqid)
5495 
    args = addProductFeedSubmit_args()
5496 
    args.productFeedSubmit = productFeedSubmit
5497 
    args.write(self._oprot)
5498 
    self._oprot.writeMessageEnd()
5499 
    self._oprot.trans.flush()
5500 
 
5501 
  def recv_addProductFeedSubmit(self, ):
5502 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5503 
    if mtype == TMessageType.EXCEPTION:
5504 
      x = TApplicationException()
5505 
      x.read(self._iprot)
5506 
      self._iprot.readMessageEnd()
5507 
      raise x
5508 
    result = addProductFeedSubmit_result()
5509 
    result.read(self._iprot)
5510 
    self._iprot.readMessageEnd()
5511 
    if result.success is not None:
5512 
      return result.success
5513 
    if result.cex is not None:
5514 
      raise result.cex
5515 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductFeedSubmit failed: unknown result");
5516 
 
5517 
  def updateProductFeedSubmit(self, productFeedSubmit):
5518 
    """
5519 
    Parameters:
5520 
     - productFeedSubmit
5521 
    """
5522 
    self.send_updateProductFeedSubmit(productFeedSubmit)
5523 
    return self.recv_updateProductFeedSubmit()
5524 
 
5525 
  def send_updateProductFeedSubmit(self, productFeedSubmit):
5526 
    self._oprot.writeMessageBegin('updateProductFeedSubmit', TMessageType.CALL, self._seqid)
5527 
    args = updateProductFeedSubmit_args()
5528 
    args.productFeedSubmit = productFeedSubmit
5529 
    args.write(self._oprot)
5530 
    self._oprot.writeMessageEnd()
5531 
    self._oprot.trans.flush()
5532 
 
5533 
  def recv_updateProductFeedSubmit(self, ):
5534 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5535 
    if mtype == TMessageType.EXCEPTION:
5536 
      x = TApplicationException()
5537 
      x.read(self._iprot)
5538 
      self._iprot.readMessageEnd()
5539 
      raise x
5540 
    result = updateProductFeedSubmit_result()
5541 
    result.read(self._iprot)
5542 
    self._iprot.readMessageEnd()
5543 
    if result.success is not None:
5544 
      return result.success
5545 
    if result.cex is not None:
5546 
      raise result.cex
5547 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateProductFeedSubmit failed: unknown result");
5548 
 
5549 
  def deleteProductFeedSubmit(self, catalogItemId):
5550 
    """
5551 
    Parameters:
5552 
     - catalogItemId
5553 
    """
5554 
    self.send_deleteProductFeedSubmit(catalogItemId)
5555 
    return self.recv_deleteProductFeedSubmit()
5556 
 
5557 
  def send_deleteProductFeedSubmit(self, catalogItemId):
5558 
    self._oprot.writeMessageBegin('deleteProductFeedSubmit', TMessageType.CALL, self._seqid)
5559 
    args = deleteProductFeedSubmit_args()
5560 
    args.catalogItemId = catalogItemId
5561 
    args.write(self._oprot)
5562 
    self._oprot.writeMessageEnd()
5563 
    self._oprot.trans.flush()
5564 
 
5565 
  def recv_deleteProductFeedSubmit(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 = deleteProductFeedSubmit_result()
5573 
    result.read(self._iprot)
5574 
    self._iprot.readMessageEnd()
5575 
    if result.success is not None:
5576 
      return result.success
5577 
    if result.cex is not None:
5578 
      raise result.cex
5579 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteProductFeedSubmit failed: unknown result");
5580 
 
5581 
  def getAllProductFeedSubmit(self, ):
5582 
    self.send_getAllProductFeedSubmit()
5583 
    return self.recv_getAllProductFeedSubmit()
5584 
 
5585 
  def send_getAllProductFeedSubmit(self, ):
5586 
    self._oprot.writeMessageBegin('getAllProductFeedSubmit', TMessageType.CALL, self._seqid)
5587 
    args = getAllProductFeedSubmit_args()
5588 
    args.write(self._oprot)
5589 
    self._oprot.writeMessageEnd()
5590 
    self._oprot.trans.flush()
5591 
 
5592 
  def recv_getAllProductFeedSubmit(self, ):
5593 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5594 
    if mtype == TMessageType.EXCEPTION:
5595 
      x = TApplicationException()
5596 
      x.read(self._iprot)
5597 
      self._iprot.readMessageEnd()
5598 
      raise x
5599 
    result = getAllProductFeedSubmit_result()
5600 
    result.read(self._iprot)
5601 
    self._iprot.readMessageEnd()
5602 
    if result.success is not None:
5603 
      return result.success
5604 
    if result.cex is not None:
5605 
      raise result.cex
5606 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllProductFeedSubmit failed: unknown result");
5607 
 
9724 kshitij.so 5608 
  def getMarketplacedetailsForItem(self, itemId, sourceId):
5609 
    """
5610 
    Parameters:
5611 
     - itemId
5612 
     - sourceId
5613 
    """
5614 
    self.send_getMarketplacedetailsForItem(itemId, sourceId)
5615 
    return self.recv_getMarketplacedetailsForItem()
9621 manish.sha 5616 
 
9724 kshitij.so 5617 
  def send_getMarketplacedetailsForItem(self, itemId, sourceId):
5618 
    self._oprot.writeMessageBegin('getMarketplacedetailsForItem', TMessageType.CALL, self._seqid)
5619 
    args = getMarketplacedetailsForItem_args()
5620 
    args.itemId = itemId
5621 
    args.sourceId = sourceId
5622 
    args.write(self._oprot)
5623 
    self._oprot.writeMessageEnd()
5624 
    self._oprot.trans.flush()
5625 
 
5626 
  def recv_getMarketplacedetailsForItem(self, ):
5627 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5628 
    if mtype == TMessageType.EXCEPTION:
5629 
      x = TApplicationException()
5630 
      x.read(self._iprot)
5631 
      self._iprot.readMessageEnd()
5632 
      raise x
5633 
    result = getMarketplacedetailsForItem_result()
5634 
    result.read(self._iprot)
5635 
    self._iprot.readMessageEnd()
5636 
    if result.success is not None:
5637 
      return result.success
5638 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMarketplacedetailsForItem failed: unknown result");
5639 
 
5640 
  def updateMarketplaceAttributesForItem(self, marketPlaceItem):
5641 
    """
5642 
    Parameters:
5643 
     - marketPlaceItem
5644 
    """
5645 
    self.send_updateMarketplaceAttributesForItem(marketPlaceItem)
5646 
    return self.recv_updateMarketplaceAttributesForItem()
5647 
 
5648 
  def send_updateMarketplaceAttributesForItem(self, marketPlaceItem):
5649 
    self._oprot.writeMessageBegin('updateMarketplaceAttributesForItem', TMessageType.CALL, self._seqid)
5650 
    args = updateMarketplaceAttributesForItem_args()
5651 
    args.marketPlaceItem = marketPlaceItem
5652 
    args.write(self._oprot)
5653 
    self._oprot.writeMessageEnd()
5654 
    self._oprot.trans.flush()
5655 
 
5656 
  def recv_updateMarketplaceAttributesForItem(self, ):
5657 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5658 
    if mtype == TMessageType.EXCEPTION:
5659 
      x = TApplicationException()
5660 
      x.read(self._iprot)
5661 
      self._iprot.readMessageEnd()
5662 
      raise x
5663 
    result = updateMarketplaceAttributesForItem_result()
5664 
    result.read(self._iprot)
5665 
    self._iprot.readMessageEnd()
5666 
    if result.success is not None:
5667 
      return result.success
5668 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMarketplaceAttributesForItem failed: unknown result");
5669 
 
9779 kshitij.so 5670 
  def getCostingForMarketplace(self, source, item_id):
5671 
    """
5672 
    Parameters:
5673 
     - source
5674 
     - item_id
5675 
    """
5676 
    self.send_getCostingForMarketplace(source, item_id)
5677 
    return self.recv_getCostingForMarketplace()
5678 
 
5679 
  def send_getCostingForMarketplace(self, source, item_id):
5680 
    self._oprot.writeMessageBegin('getCostingForMarketplace', TMessageType.CALL, self._seqid)
5681 
    args = getCostingForMarketplace_args()
5682 
    args.source = source
5683 
    args.item_id = item_id
5684 
    args.write(self._oprot)
5685 
    self._oprot.writeMessageEnd()
5686 
    self._oprot.trans.flush()
5687 
 
5688 
  def recv_getCostingForMarketplace(self, ):
5689 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5690 
    if mtype == TMessageType.EXCEPTION:
5691 
      x = TApplicationException()
5692 
      x.read(self._iprot)
5693 
      self._iprot.readMessageEnd()
5694 
      raise x
5695 
    result = getCostingForMarketplace_result()
5696 
    result.read(self._iprot)
5697 
    self._iprot.readMessageEnd()
5698 
    if result.success is not None:
5699 
      return result.success
5700 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCostingForMarketplace failed: unknown result");
5701 
 
9776 vikram.rag 5702 
  def getMarketPlaceItemsForPriceUpdate(self, source):
5703 
    """
5704 
    Parameters:
5705 
     - source
5706 
    """
5707 
    self.send_getMarketPlaceItemsForPriceUpdate(source)
5708 
    return self.recv_getMarketPlaceItemsForPriceUpdate()
9724 kshitij.so 5709 
 
9776 vikram.rag 5710 
  def send_getMarketPlaceItemsForPriceUpdate(self, source):
5711 
    self._oprot.writeMessageBegin('getMarketPlaceItemsForPriceUpdate', TMessageType.CALL, self._seqid)
5712 
    args = getMarketPlaceItemsForPriceUpdate_args()
5713 
    args.source = source
5714 
    args.write(self._oprot)
5715 
    self._oprot.writeMessageEnd()
5716 
    self._oprot.trans.flush()
5717 
 
5718 
  def recv_getMarketPlaceItemsForPriceUpdate(self, ):
5719 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5720 
    if mtype == TMessageType.EXCEPTION:
5721 
      x = TApplicationException()
5722 
      x.read(self._iprot)
5723 
      self._iprot.readMessageEnd()
5724 
      raise x
5725 
    result = getMarketPlaceItemsForPriceUpdate_result()
5726 
    result.read(self._iprot)
5727 
    self._iprot.readMessageEnd()
5728 
    if result.success is not None:
5729 
      return result.success
5730 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMarketPlaceItemsForPriceUpdate failed: unknown result");
5731 
 
9816 kshitij.so 5732 
  def updateMarketPlacePriceUpdateStatus(self, skulist, timestamp, source):
9776 vikram.rag 5733 
    """
5734 
    Parameters:
5735 
     - skulist
5736 
     - timestamp
9816 kshitij.so 5737 
     - source
9776 vikram.rag 5738 
    """
9816 kshitij.so 5739 
    self.send_updateMarketPlacePriceUpdateStatus(skulist, timestamp, source)
9776 vikram.rag 5740 
    self.recv_updateMarketPlacePriceUpdateStatus()
5741 
 
9816 kshitij.so 5742 
  def send_updateMarketPlacePriceUpdateStatus(self, skulist, timestamp, source):
9776 vikram.rag 5743 
    self._oprot.writeMessageBegin('updateMarketPlacePriceUpdateStatus', TMessageType.CALL, self._seqid)
5744 
    args = updateMarketPlacePriceUpdateStatus_args()
5745 
    args.skulist = skulist
5746 
    args.timestamp = timestamp
9816 kshitij.so 5747 
    args.source = source
9776 vikram.rag 5748 
    args.write(self._oprot)
5749 
    self._oprot.writeMessageEnd()
5750 
    self._oprot.trans.flush()
5751 
 
5752 
  def recv_updateMarketPlacePriceUpdateStatus(self, ):
5753 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5754 
    if mtype == TMessageType.EXCEPTION:
5755 
      x = TApplicationException()
5756 
      x.read(self._iprot)
5757 
      self._iprot.readMessageEnd()
5758 
      raise x
5759 
    result = updateMarketPlacePriceUpdateStatus_result()
5760 
    result.read(self._iprot)
5761 
    self._iprot.readMessageEnd()
5762 
    return
5763 
 
9861 rajveer 5764 
  def updateItemHoldInventory(self, itemHoldMap):
5765 
    """
5766 
    Parameters:
5767 
     - itemHoldMap
5768 
    """
5769 
    self.send_updateItemHoldInventory(itemHoldMap)
5770 
    self.recv_updateItemHoldInventory()
9776 vikram.rag 5771 
 
9861 rajveer 5772 
  def send_updateItemHoldInventory(self, itemHoldMap):
5773 
    self._oprot.writeMessageBegin('updateItemHoldInventory', TMessageType.CALL, self._seqid)
5774 
    args = updateItemHoldInventory_args()
5775 
    args.itemHoldMap = itemHoldMap
5776 
    args.write(self._oprot)
5777 
    self._oprot.writeMessageEnd()
5778 
    self._oprot.trans.flush()
5779 
 
5780 
  def recv_updateItemHoldInventory(self, ):
5781 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5782 
    if mtype == TMessageType.EXCEPTION:
5783 
      x = TApplicationException()
5784 
      x.read(self._iprot)
5785 
      self._iprot.readMessageEnd()
5786 
      raise x
5787 
    result = updateItemHoldInventory_result()
5788 
    result.read(self._iprot)
5789 
    self._iprot.readMessageEnd()
5790 
    return
5791 
 
9895 vikram.rag 5792 
  def updateNlcAtMarketplaces(self, item_id, vendor_id, nlc):
5793 
    """
5794 
    Parameters:
5795 
     - item_id
5796 
     - vendor_id
5797 
     - nlc
5798 
    """
5799 
    self.send_updateNlcAtMarketplaces(item_id, vendor_id, nlc)
5800 
    self.recv_updateNlcAtMarketplaces()
9861 rajveer 5801 
 
9895 vikram.rag 5802 
  def send_updateNlcAtMarketplaces(self, item_id, vendor_id, nlc):
5803 
    self._oprot.writeMessageBegin('updateNlcAtMarketplaces', TMessageType.CALL, self._seqid)
5804 
    args = updateNlcAtMarketplaces_args()
5805 
    args.item_id = item_id
5806 
    args.vendor_id = vendor_id
5807 
    args.nlc = nlc
5808 
    args.write(self._oprot)
5809 
    self._oprot.writeMessageEnd()
5810 
    self._oprot.trans.flush()
5811 
 
5812 
  def recv_updateNlcAtMarketplaces(self, ):
5813 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5814 
    if mtype == TMessageType.EXCEPTION:
5815 
      x = TApplicationException()
5816 
      x.read(self._iprot)
5817 
      self._iprot.readMessageEnd()
5818 
      raise x
5819 
    result = updateNlcAtMarketplaces_result()
5820 
    result.read(self._iprot)
5821 
    self._iprot.readMessageEnd()
5822 
    return
5823 
 
9945 vikram.rag 5824 
  def getAllFlipkartItems(self, ):
5825 
    self.send_getAllFlipkartItems()
5826 
    return self.recv_getAllFlipkartItems()
9895 vikram.rag 5827 
 
9945 vikram.rag 5828 
  def send_getAllFlipkartItems(self, ):
5829 
    self._oprot.writeMessageBegin('getAllFlipkartItems', TMessageType.CALL, self._seqid)
5830 
    args = getAllFlipkartItems_args()
5831 
    args.write(self._oprot)
5832 
    self._oprot.writeMessageEnd()
5833 
    self._oprot.trans.flush()
5834 
 
5835 
  def recv_getAllFlipkartItems(self, ):
5836 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5837 
    if mtype == TMessageType.EXCEPTION:
5838 
      x = TApplicationException()
5839 
      x.read(self._iprot)
5840 
      self._iprot.readMessageEnd()
5841 
      raise x
5842 
    result = getAllFlipkartItems_result()
5843 
    result.read(self._iprot)
5844 
    self._iprot.readMessageEnd()
5845 
    if result.success is not None:
5846 
      return result.success
5847 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFlipkartItems failed: unknown result");
5848 
 
10097 kshitij.so 5849 
  def addOrUpdateFlipkartItem(self, flipkartitem):
5850 
    """
5851 
    Parameters:
5852 
     - flipkartitem
5853 
    """
5854 
    self.send_addOrUpdateFlipkartItem(flipkartitem)
5855 
    return self.recv_addOrUpdateFlipkartItem()
9945 vikram.rag 5856 
 
10097 kshitij.so 5857 
  def send_addOrUpdateFlipkartItem(self, flipkartitem):
5858 
    self._oprot.writeMessageBegin('addOrUpdateFlipkartItem', TMessageType.CALL, self._seqid)
5859 
    args = addOrUpdateFlipkartItem_args()
5860 
    args.flipkartitem = flipkartitem
5861 
    args.write(self._oprot)
5862 
    self._oprot.writeMessageEnd()
5863 
    self._oprot.trans.flush()
5864 
 
5865 
  def recv_addOrUpdateFlipkartItem(self, ):
5866 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5867 
    if mtype == TMessageType.EXCEPTION:
5868 
      x = TApplicationException()
5869 
      x.read(self._iprot)
5870 
      self._iprot.readMessageEnd()
5871 
      raise x
5872 
    result = addOrUpdateFlipkartItem_result()
5873 
    result.read(self._iprot)
5874 
    self._iprot.readMessageEnd()
5875 
    if result.success is not None:
5876 
      return result.success
5877 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addOrUpdateFlipkartItem failed: unknown result");
5878 
 
5879 
  def getFlipkartItem(self, item_id):
5880 
    """
5881 
    Parameters:
5882 
     - item_id
5883 
    """
5884 
    self.send_getFlipkartItem(item_id)
5885 
    return self.recv_getFlipkartItem()
5886 
 
5887 
  def send_getFlipkartItem(self, item_id):
5888 
    self._oprot.writeMessageBegin('getFlipkartItem', TMessageType.CALL, self._seqid)
5889 
    args = getFlipkartItem_args()
5890 
    args.item_id = item_id
5891 
    args.write(self._oprot)
5892 
    self._oprot.writeMessageEnd()
5893 
    self._oprot.trans.flush()
5894 
 
5895 
  def recv_getFlipkartItem(self, ):
5896 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5897 
    if mtype == TMessageType.EXCEPTION:
5898 
      x = TApplicationException()
5899 
      x.read(self._iprot)
5900 
      self._iprot.readMessageEnd()
5901 
      raise x
5902 
    result = getFlipkartItem_result()
5903 
    result.read(self._iprot)
5904 
    self._iprot.readMessageEnd()
5905 
    if result.success is not None:
5906 
      return result.success
5907 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartItem failed: unknown result");
5908 
 
5909 
  def getFlipkartItemDetails(self, item_id):
5910 
    """
5911 
    Parameters:
5912 
     - item_id
5913 
    """
5914 
    self.send_getFlipkartItemDetails(item_id)
5915 
    return self.recv_getFlipkartItemDetails()
5916 
 
5917 
  def send_getFlipkartItemDetails(self, item_id):
5918 
    self._oprot.writeMessageBegin('getFlipkartItemDetails', TMessageType.CALL, self._seqid)
5919 
    args = getFlipkartItemDetails_args()
5920 
    args.item_id = item_id
5921 
    args.write(self._oprot)
5922 
    self._oprot.writeMessageEnd()
5923 
    self._oprot.trans.flush()
5924 
 
5925 
  def recv_getFlipkartItemDetails(self, ):
5926 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5927 
    if mtype == TMessageType.EXCEPTION:
5928 
      x = TApplicationException()
5929 
      x.read(self._iprot)
5930 
      self._iprot.readMessageEnd()
5931 
      raise x
5932 
    result = getFlipkartItemDetails_result()
5933 
    result.read(self._iprot)
5934 
    self._iprot.readMessageEnd()
5935 
    if result.success is not None:
5936 
      return result.success
5937 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartItemDetails failed: unknown result");
5938 
 
5939 
  def getFlipkartItems(self, offset, limit):
5940 
    """
5941 
    Parameters:
5942 
     - offset
5943 
     - limit
5944 
    """
5945 
    self.send_getFlipkartItems(offset, limit)
5946 
    return self.recv_getFlipkartItems()
5947 
 
5948 
  def send_getFlipkartItems(self, offset, limit):
5949 
    self._oprot.writeMessageBegin('getFlipkartItems', TMessageType.CALL, self._seqid)
5950 
    args = getFlipkartItems_args()
5951 
    args.offset = offset
5952 
    args.limit = limit
5953 
    args.write(self._oprot)
5954 
    self._oprot.writeMessageEnd()
5955 
    self._oprot.trans.flush()
5956 
 
5957 
  def recv_getFlipkartItems(self, ):
5958 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5959 
    if mtype == TMessageType.EXCEPTION:
5960 
      x = TApplicationException()
5961 
      x.read(self._iprot)
5962 
      self._iprot.readMessageEnd()
5963 
      raise x
5964 
    result = getFlipkartItems_result()
5965 
    result.read(self._iprot)
5966 
    self._iprot.readMessageEnd()
5967 
    if result.success is not None:
5968 
      return result.success
5969 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartItems failed: unknown result");
5970 
 
5971 
  def searchFlipkartItems(self, searchTerm, offset, limit):
5972 
    """
5973 
    Parameters:
5974 
     - searchTerm
5975 
     - offset
5976 
     - limit
5977 
    """
5978 
    self.send_searchFlipkartItems(searchTerm, offset, limit)
5979 
    return self.recv_searchFlipkartItems()
5980 
 
5981 
  def send_searchFlipkartItems(self, searchTerm, offset, limit):
5982 
    self._oprot.writeMessageBegin('searchFlipkartItems', TMessageType.CALL, self._seqid)
5983 
    args = searchFlipkartItems_args()
5984 
    args.searchTerm = searchTerm
5985 
    args.offset = offset
5986 
    args.limit = limit
5987 
    args.write(self._oprot)
5988 
    self._oprot.writeMessageEnd()
5989 
    self._oprot.trans.flush()
5990 
 
5991 
  def recv_searchFlipkartItems(self, ):
5992 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5993 
    if mtype == TMessageType.EXCEPTION:
5994 
      x = TApplicationException()
5995 
      x.read(self._iprot)
5996 
      self._iprot.readMessageEnd()
5997 
      raise x
5998 
    result = searchFlipkartItems_result()
5999 
    result.read(self._iprot)
6000 
    self._iprot.readMessageEnd()
6001 
    if result.success is not None:
6002 
      return result.success
6003 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchFlipkartItems failed: unknown result");
6004 
 
6005 
  def getCountForFlipkartItems(self, ):
6006 
    self.send_getCountForFlipkartItems()
6007 
    return self.recv_getCountForFlipkartItems()
6008 
 
6009 
  def send_getCountForFlipkartItems(self, ):
6010 
    self._oprot.writeMessageBegin('getCountForFlipkartItems', TMessageType.CALL, self._seqid)
6011 
    args = getCountForFlipkartItems_args()
6012 
    args.write(self._oprot)
6013 
    self._oprot.writeMessageEnd()
6014 
    self._oprot.trans.flush()
6015 
 
6016 
  def recv_getCountForFlipkartItems(self, ):
6017 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6018 
    if mtype == TMessageType.EXCEPTION:
6019 
      x = TApplicationException()
6020 
      x.read(self._iprot)
6021 
      self._iprot.readMessageEnd()
6022 
      raise x
6023 
    result = getCountForFlipkartItems_result()
6024 
    result.read(self._iprot)
6025 
    self._iprot.readMessageEnd()
6026 
    if result.success is not None:
6027 
      return result.success
6028 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForFlipkartItems failed: unknown result");
6029 
 
6030 
  def getFlipkartSearchResultCount(self, searchTerm):
6031 
    """
6032 
    Parameters:
6033 
     - searchTerm
6034 
    """
6035 
    self.send_getFlipkartSearchResultCount(searchTerm)
6036 
    return self.recv_getFlipkartSearchResultCount()
6037 
 
6038 
  def send_getFlipkartSearchResultCount(self, searchTerm):
6039 
    self._oprot.writeMessageBegin('getFlipkartSearchResultCount', TMessageType.CALL, self._seqid)
6040 
    args = getFlipkartSearchResultCount_args()
6041 
    args.searchTerm = searchTerm
6042 
    args.write(self._oprot)
6043 
    self._oprot.writeMessageEnd()
6044 
    self._oprot.trans.flush()
6045 
 
6046 
  def recv_getFlipkartSearchResultCount(self, ):
6047 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6048 
    if mtype == TMessageType.EXCEPTION:
6049 
      x = TApplicationException()
6050 
      x.read(self._iprot)
6051 
      self._iprot.readMessageEnd()
6052 
      raise x
6053 
    result = getFlipkartSearchResultCount_result()
6054 
    result.read(self._iprot)
6055 
    self._iprot.readMessageEnd()
6056 
    if result.success is not None:
6057 
      return result.success
6058 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartSearchResultCount failed: unknown result");
6059 
 
6060 
  def getAllFkItems(self, ):
6061 
    self.send_getAllFkItems()
6062 
    return self.recv_getAllFkItems()
6063 
 
6064 
  def send_getAllFkItems(self, ):
6065 
    self._oprot.writeMessageBegin('getAllFkItems', TMessageType.CALL, self._seqid)
6066 
    args = getAllFkItems_args()
6067 
    args.write(self._oprot)
6068 
    self._oprot.writeMessageEnd()
6069 
    self._oprot.trans.flush()
6070 
 
6071 
  def recv_getAllFkItems(self, ):
6072 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6073 
    if mtype == TMessageType.EXCEPTION:
6074 
      x = TApplicationException()
6075 
      x.read(self._iprot)
6076 
      self._iprot.readMessageEnd()
6077 
      raise x
6078 
    result = getAllFkItems_result()
6079 
    result.read(self._iprot)
6080 
    self._iprot.readMessageEnd()
6081 
    if result.success is not None:
6082 
      return result.success
6083 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFkItems failed: unknown result");
6084 
 
10140 vikram.rag 6085 
  def getFlipkartItemBySkyAtFlipkart(self, sku):
6086 
    """
6087 
    Parameters:
6088 
     - sku
6089 
    """
6090 
    self.send_getFlipkartItemBySkyAtFlipkart(sku)
6091 
    return self.recv_getFlipkartItemBySkyAtFlipkart()
10097 kshitij.so 6092 
 
10140 vikram.rag 6093 
  def send_getFlipkartItemBySkyAtFlipkart(self, sku):
6094 
    self._oprot.writeMessageBegin('getFlipkartItemBySkyAtFlipkart', TMessageType.CALL, self._seqid)
6095 
    args = getFlipkartItemBySkyAtFlipkart_args()
6096 
    args.sku = sku
6097 
    args.write(self._oprot)
6098 
    self._oprot.writeMessageEnd()
6099 
    self._oprot.trans.flush()
6100 
 
6101 
  def recv_getFlipkartItemBySkyAtFlipkart(self, ):
6102 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6103 
    if mtype == TMessageType.EXCEPTION:
6104 
      x = TApplicationException()
6105 
      x.read(self._iprot)
6106 
      self._iprot.readMessageEnd()
6107 
      raise x
6108 
    result = getFlipkartItemBySkyAtFlipkart_result()
6109 
    result.read(self._iprot)
6110 
    self._iprot.readMessageEnd()
6111 
    if result.success is not None:
6112 
      return result.success
6113 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartItemBySkyAtFlipkart failed: unknown result");
6114 
 
11015 kshitij.so 6115 
  def getMarketplaceHistory(self, source, offset, itemId):
6116 
    """
6117 
    Parameters:
6118 
     - source
6119 
     - offset
6120 
     - itemId
6121 
    """
6122 
    self.send_getMarketplaceHistory(source, offset, itemId)
6123 
    return self.recv_getMarketplaceHistory()
6124 
 
6125 
  def send_getMarketplaceHistory(self, source, offset, itemId):
6126 
    self._oprot.writeMessageBegin('getMarketplaceHistory', TMessageType.CALL, self._seqid)
6127 
    args = getMarketplaceHistory_args()
6128 
    args.source = source
6129 
    args.offset = offset
6130 
    args.itemId = itemId
6131 
    args.write(self._oprot)
6132 
    self._oprot.writeMessageEnd()
6133 
    self._oprot.trans.flush()
6134 
 
6135 
  def recv_getMarketplaceHistory(self, ):
6136 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6137 
    if mtype == TMessageType.EXCEPTION:
6138 
      x = TApplicationException()
6139 
      x.read(self._iprot)
6140 
      self._iprot.readMessageEnd()
6141 
      raise x
6142 
    result = getMarketplaceHistory_result()
6143 
    result.read(self._iprot)
6144 
    self._iprot.readMessageEnd()
6145 
    if result.success is not None:
6146 
      return result.success
6147 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMarketplaceHistory failed: unknown result");
6148 
 
10909 vikram.rag 6149 
  def getAllFbbListedItems(self, ):
6150 
    self.send_getAllFbbListedItems()
6151 
    return self.recv_getAllFbbListedItems()
10140 vikram.rag 6152 
 
10909 vikram.rag 6153 
  def send_getAllFbbListedItems(self, ):
6154 
    self._oprot.writeMessageBegin('getAllFbbListedItems', TMessageType.CALL, self._seqid)
6155 
    args = getAllFbbListedItems_args()
6156 
    args.write(self._oprot)
6157 
    self._oprot.writeMessageEnd()
6158 
    self._oprot.trans.flush()
6159 
 
6160 
  def recv_getAllFbbListedItems(self, ):
6161 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6162 
    if mtype == TMessageType.EXCEPTION:
6163 
      x = TApplicationException()
6164 
      x.read(self._iprot)
6165 
      self._iprot.readMessageEnd()
6166 
      raise x
6167 
    result = getAllFbbListedItems_result()
6168 
    result.read(self._iprot)
6169 
    self._iprot.readMessageEnd()
6170 
    if result.success is not None:
6171 
      return result.success
6172 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbbListedItems failed: unknown result");
6173 
 
10924 vikram.rag 6174 
  def getAllFbbPricingItems(self, ):
6175 
    self.send_getAllFbbPricingItems()
6176 
    return self.recv_getAllFbbPricingItems()
10909 vikram.rag 6177 
 
10924 vikram.rag 6178 
  def send_getAllFbbPricingItems(self, ):
6179 
    self._oprot.writeMessageBegin('getAllFbbPricingItems', TMessageType.CALL, self._seqid)
6180 
    args = getAllFbbPricingItems_args()
6181 
    args.write(self._oprot)
6182 
    self._oprot.writeMessageEnd()
6183 
    self._oprot.trans.flush()
6184 
 
6185 
  def recv_getAllFbbPricingItems(self, ):
6186 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6187 
    if mtype == TMessageType.EXCEPTION:
6188 
      x = TApplicationException()
6189 
      x.read(self._iprot)
6190 
      self._iprot.readMessageEnd()
6191 
      raise x
6192 
    result = getAllFbbPricingItems_result()
6193 
    result.read(self._iprot)
6194 
    self._iprot.readMessageEnd()
6195 
    if result.success is not None:
6196 
      return result.success
6197 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbbPricingItems failed: unknown result");
6198 
 
11015 kshitij.so 6199 
  def getCountForMarketplaceHistory(self, source, itemId):
6200 
    """
6201 
    Parameters:
6202 
     - source
6203 
     - itemId
6204 
    """
6205 
    self.send_getCountForMarketplaceHistory(source, itemId)
6206 
    return self.recv_getCountForMarketplaceHistory()
10924 vikram.rag 6207 
 
11015 kshitij.so 6208 
  def send_getCountForMarketplaceHistory(self, source, itemId):
6209 
    self._oprot.writeMessageBegin('getCountForMarketplaceHistory', TMessageType.CALL, self._seqid)
6210 
    args = getCountForMarketplaceHistory_args()
6211 
    args.source = source
6212 
    args.itemId = itemId
6213 
    args.write(self._oprot)
6214 
    self._oprot.writeMessageEnd()
6215 
    self._oprot.trans.flush()
6216 
 
6217 
  def recv_getCountForMarketplaceHistory(self, ):
6218 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6219 
    if mtype == TMessageType.EXCEPTION:
6220 
      x = TApplicationException()
6221 
      x.read(self._iprot)
6222 
      self._iprot.readMessageEnd()
6223 
      raise x
6224 
    result = getCountForMarketplaceHistory_result()
6225 
    result.read(self._iprot)
6226 
    self._iprot.readMessageEnd()
6227 
    if result.success is not None:
6228 
      return result.success
6229 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForMarketplaceHistory failed: unknown result");
6230 
 
6231 
  def getMarketplaceHistoryByDate(self, source, startDate, endDate, offset, limit, itemId):
6232 
    """
6233 
    Parameters:
6234 
     - source
6235 
     - startDate
6236 
     - endDate
6237 
     - offset
6238 
     - limit
6239 
     - itemId
6240 
    """
6241 
    self.send_getMarketplaceHistoryByDate(source, startDate, endDate, offset, limit, itemId)
6242 
    return self.recv_getMarketplaceHistoryByDate()
6243 
 
6244 
  def send_getMarketplaceHistoryByDate(self, source, startDate, endDate, offset, limit, itemId):
6245 
    self._oprot.writeMessageBegin('getMarketplaceHistoryByDate', TMessageType.CALL, self._seqid)
6246 
    args = getMarketplaceHistoryByDate_args()
6247 
    args.source = source
6248 
    args.startDate = startDate
6249 
    args.endDate = endDate
6250 
    args.offset = offset
6251 
    args.limit = limit
6252 
    args.itemId = itemId
6253 
    args.write(self._oprot)
6254 
    self._oprot.writeMessageEnd()
6255 
    self._oprot.trans.flush()
6256 
 
6257 
  def recv_getMarketplaceHistoryByDate(self, ):
6258 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6259 
    if mtype == TMessageType.EXCEPTION:
6260 
      x = TApplicationException()
6261 
      x.read(self._iprot)
6262 
      self._iprot.readMessageEnd()
6263 
      raise x
6264 
    result = getMarketplaceHistoryByDate_result()
6265 
    result.read(self._iprot)
6266 
    self._iprot.readMessageEnd()
6267 
    if result.success is not None:
6268 
      return result.success
6269 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMarketplaceHistoryByDate failed: unknown result");
6270 
 
11531 vikram.rag 6271 
  def getPrivateDealDetails(self, item_id):
6272 
    """
6273 
    Parameters:
6274 
     - item_id
6275 
    """
6276 
    self.send_getPrivateDealDetails(item_id)
6277 
    return self.recv_getPrivateDealDetails()
11015 kshitij.so 6278 
 
11531 vikram.rag 6279 
  def send_getPrivateDealDetails(self, item_id):
6280 
    self._oprot.writeMessageBegin('getPrivateDealDetails', TMessageType.CALL, self._seqid)
6281 
    args = getPrivateDealDetails_args()
6282 
    args.item_id = item_id
6283 
    args.write(self._oprot)
6284 
    self._oprot.writeMessageEnd()
6285 
    self._oprot.trans.flush()
6286 
 
6287 
  def recv_getPrivateDealDetails(self, ):
6288 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6289 
    if mtype == TMessageType.EXCEPTION:
6290 
      x = TApplicationException()
6291 
      x.read(self._iprot)
6292 
      self._iprot.readMessageEnd()
6293 
      raise x
6294 
    result = getPrivateDealDetails_result()
6295 
    result.read(self._iprot)
6296 
    self._iprot.readMessageEnd()
6297 
    if result.success is not None:
6298 
      return result.success
6299 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrivateDealDetails failed: unknown result");
6300 
 
6301 
  def getPrivateDealItems(self, offset, limit):
6302 
    """
6303 
    Parameters:
6304 
     - offset
6305 
     - limit
6306 
    """
6307 
    self.send_getPrivateDealItems(offset, limit)
6308 
    return self.recv_getPrivateDealItems()
6309 
 
6310 
  def send_getPrivateDealItems(self, offset, limit):
6311 
    self._oprot.writeMessageBegin('getPrivateDealItems', TMessageType.CALL, self._seqid)
6312 
    args = getPrivateDealItems_args()
6313 
    args.offset = offset
6314 
    args.limit = limit
6315 
    args.write(self._oprot)
6316 
    self._oprot.writeMessageEnd()
6317 
    self._oprot.trans.flush()
6318 
 
6319 
  def recv_getPrivateDealItems(self, ):
6320 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6321 
    if mtype == TMessageType.EXCEPTION:
6322 
      x = TApplicationException()
6323 
      x.read(self._iprot)
6324 
      self._iprot.readMessageEnd()
6325 
      raise x
6326 
    result = getPrivateDealItems_result()
6327 
    result.read(self._iprot)
6328 
    self._iprot.readMessageEnd()
6329 
    if result.success is not None:
6330 
      return result.success
6331 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrivateDealItems failed: unknown result");
6332 
 
11653 amit.gupta 6333 
  def getAllActivePrivateDeals(self, itemIds, daysDelta):
6334 
    """
6335 
    Parameters:
6336 
     - itemIds
6337 
     - daysDelta
6338 
    """
6339 
    self.send_getAllActivePrivateDeals(itemIds, daysDelta)
11592 amit.gupta 6340 
    return self.recv_getAllActivePrivateDeals()
6341 
 
11653 amit.gupta 6342 
  def send_getAllActivePrivateDeals(self, itemIds, daysDelta):
11592 amit.gupta 6343 
    self._oprot.writeMessageBegin('getAllActivePrivateDeals', TMessageType.CALL, self._seqid)
6344 
    args = getAllActivePrivateDeals_args()
11653 amit.gupta 6345 
    args.itemIds = itemIds
6346 
    args.daysDelta = daysDelta
11592 amit.gupta 6347 
    args.write(self._oprot)
6348 
    self._oprot.writeMessageEnd()
6349 
    self._oprot.trans.flush()
6350 
 
6351 
  def recv_getAllActivePrivateDeals(self, ):
6352 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6353 
    if mtype == TMessageType.EXCEPTION:
6354 
      x = TApplicationException()
6355 
      x.read(self._iprot)
6356 
      self._iprot.readMessageEnd()
6357 
      raise x
6358 
    result = getAllActivePrivateDeals_result()
6359 
    result.read(self._iprot)
6360 
    self._iprot.readMessageEnd()
6361 
    if result.success is not None:
6362 
      return result.success
6363 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllActivePrivateDeals failed: unknown result");
6364 
 
11531 vikram.rag 6365 
  def addOrUpdatePrivateDeal(self, privateDeal):
6366 
    """
6367 
    Parameters:
6368 
     - privateDeal
6369 
    """
6370 
    self.send_addOrUpdatePrivateDeal(privateDeal)
6371 
    return self.recv_addOrUpdatePrivateDeal()
6372 
 
6373 
  def send_addOrUpdatePrivateDeal(self, privateDeal):
6374 
    self._oprot.writeMessageBegin('addOrUpdatePrivateDeal', TMessageType.CALL, self._seqid)
6375 
    args = addOrUpdatePrivateDeal_args()
6376 
    args.privateDeal = privateDeal
6377 
    args.write(self._oprot)
6378 
    self._oprot.writeMessageEnd()
6379 
    self._oprot.trans.flush()
6380 
 
6381 
  def recv_addOrUpdatePrivateDeal(self, ):
6382 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6383 
    if mtype == TMessageType.EXCEPTION:
6384 
      x = TApplicationException()
6385 
      x.read(self._iprot)
6386 
      self._iprot.readMessageEnd()
6387 
      raise x
6388 
    result = addOrUpdatePrivateDeal_result()
6389 
    result.read(self._iprot)
6390 
    self._iprot.readMessageEnd()
6391 
    if result.success is not None:
6392 
      return result.success
6393 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addOrUpdatePrivateDeal failed: unknown result");
6394 
 
11635 vikram.rag 6395 
  def getPrivateDealsCatalogIds(self, beginIndex, totalItems):
6396 
    """
6397 
    Parameters:
6398 
     - beginIndex
6399 
     - totalItems
6400 
    """
6401 
    self.send_getPrivateDealsCatalogIds(beginIndex, totalItems)
6402 
    return self.recv_getPrivateDealsCatalogIds()
11531 vikram.rag 6403 
 
11635 vikram.rag 6404 
  def send_getPrivateDealsCatalogIds(self, beginIndex, totalItems):
6405 
    self._oprot.writeMessageBegin('getPrivateDealsCatalogIds', TMessageType.CALL, self._seqid)
6406 
    args = getPrivateDealsCatalogIds_args()
6407 
    args.beginIndex = beginIndex
6408 
    args.totalItems = totalItems
6409 
    args.write(self._oprot)
6410 
    self._oprot.writeMessageEnd()
6411 
    self._oprot.trans.flush()
6412 
 
6413 
  def recv_getPrivateDealsCatalogIds(self, ):
6414 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6415 
    if mtype == TMessageType.EXCEPTION:
6416 
      x = TApplicationException()
6417 
      x.read(self._iprot)
6418 
      self._iprot.readMessageEnd()
6419 
      raise x
6420 
    result = getPrivateDealsCatalogIds_result()
6421 
    result.read(self._iprot)
6422 
    self._iprot.readMessageEnd()
6423 
    if result.success is not None:
6424 
      return result.success
6425 
    if result.cex is not None:
6426 
      raise result.cex
6427 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrivateDealsCatalogIds failed: unknown result");
6428 
 
11645 amit.gupta 6429 
  def getPrivateDealsCount(self, ):
6430 
    self.send_getPrivateDealsCount()
6431 
    return self.recv_getPrivateDealsCount()
11635 vikram.rag 6432 
 
11645 amit.gupta 6433 
  def send_getPrivateDealsCount(self, ):
6434 
    self._oprot.writeMessageBegin('getPrivateDealsCount', TMessageType.CALL, self._seqid)
6435 
    args = getPrivateDealsCount_args()
6436 
    args.write(self._oprot)
6437 
    self._oprot.writeMessageEnd()
6438 
    self._oprot.trans.flush()
6439 
 
6440 
  def recv_getPrivateDealsCount(self, ):
6441 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6442 
    if mtype == TMessageType.EXCEPTION:
6443 
      x = TApplicationException()
6444 
      x.read(self._iprot)
6445 
      self._iprot.readMessageEnd()
6446 
      raise x
6447 
    result = getPrivateDealsCount_result()
6448 
    result.read(self._iprot)
6449 
    self._iprot.readMessageEnd()
6450 
    if result.success is not None:
6451 
      return result.success
6452 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrivateDealsCount failed: unknown result");
6453 
 
11905 kshitij.so 6454 
  def getAmazonOutSyncItems(self, item_id):
6455 
    """
6456 
    Parameters:
6457 
     - item_id
6458 
    """
6459 
    self.send_getAmazonOutSyncItems(item_id)
6460 
    return self.recv_getAmazonOutSyncItems()
11645 amit.gupta 6461 
 
11905 kshitij.so 6462 
  def send_getAmazonOutSyncItems(self, item_id):
6463 
    self._oprot.writeMessageBegin('getAmazonOutSyncItems', TMessageType.CALL, self._seqid)
6464 
    args = getAmazonOutSyncItems_args()
6465 
    args.item_id = item_id
6466 
    args.write(self._oprot)
6467 
    self._oprot.writeMessageEnd()
6468 
    self._oprot.trans.flush()
6469 
 
6470 
  def recv_getAmazonOutSyncItems(self, ):
6471 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6472 
    if mtype == TMessageType.EXCEPTION:
6473 
      x = TApplicationException()
6474 
      x.read(self._iprot)
6475 
      self._iprot.readMessageEnd()
6476 
      raise x
6477 
    result = getAmazonOutSyncItems_result()
6478 
    result.read(self._iprot)
6479 
    self._iprot.readMessageEnd()
6480 
    if result.success is not None:
6481 
      return result.success
6482 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonOutSyncItems failed: unknown result");
6483 
 
6484 
  def getAllPrivateDealsComparison(self, ):
6485 
    self.send_getAllPrivateDealsComparison()
6486 
    return self.recv_getAllPrivateDealsComparison()
6487 
 
6488 
  def send_getAllPrivateDealsComparison(self, ):
6489 
    self._oprot.writeMessageBegin('getAllPrivateDealsComparison', TMessageType.CALL, self._seqid)
6490 
    args = getAllPrivateDealsComparison_args()
6491 
    args.write(self._oprot)
6492 
    self._oprot.writeMessageEnd()
6493 
    self._oprot.trans.flush()
6494 
 
6495 
  def recv_getAllPrivateDealsComparison(self, ):
6496 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6497 
    if mtype == TMessageType.EXCEPTION:
6498 
      x = TApplicationException()
6499 
      x.read(self._iprot)
6500 
      self._iprot.readMessageEnd()
6501 
      raise x
6502 
    result = getAllPrivateDealsComparison_result()
6503 
    result.read(self._iprot)
6504 
    self._iprot.readMessageEnd()
6505 
    if result.success is not None:
6506 
      return result.success
6507 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllPrivateDealsComparison failed: unknown result");
6508 
 
12133 kshitij.so 6509 
  def getAllSnapdealMarketplaceItem(self, ):
6510 
    self.send_getAllSnapdealMarketplaceItem()
6511 
    return self.recv_getAllSnapdealMarketplaceItem()
11905 kshitij.so 6512 
 
12133 kshitij.so 6513 
  def send_getAllSnapdealMarketplaceItem(self, ):
6514 
    self._oprot.writeMessageBegin('getAllSnapdealMarketplaceItem', TMessageType.CALL, self._seqid)
6515 
    args = getAllSnapdealMarketplaceItem_args()
6516 
    args.write(self._oprot)
6517 
    self._oprot.writeMessageEnd()
6518 
    self._oprot.trans.flush()
6519 
 
6520 
  def recv_getAllSnapdealMarketplaceItem(self, ):
6521 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6522 
    if mtype == TMessageType.EXCEPTION:
6523 
      x = TApplicationException()
6524 
      x.read(self._iprot)
6525 
      self._iprot.readMessageEnd()
6526 
      raise x
6527 
    result = getAllSnapdealMarketplaceItem_result()
6528 
    result.read(self._iprot)
6529 
    self._iprot.readMessageEnd()
6530 
    if result.success is not None:
6531 
      return result.success
6532 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSnapdealMarketplaceItem failed: unknown result");
6533 
 
6534 
  def getAllFlipkartMarketplaceItem(self, ):
6535 
    self.send_getAllFlipkartMarketplaceItem()
6536 
    return self.recv_getAllFlipkartMarketplaceItem()
6537 
 
6538 
  def send_getAllFlipkartMarketplaceItem(self, ):
6539 
    self._oprot.writeMessageBegin('getAllFlipkartMarketplaceItem', TMessageType.CALL, self._seqid)
6540 
    args = getAllFlipkartMarketplaceItem_args()
6541 
    args.write(self._oprot)
6542 
    self._oprot.writeMessageEnd()
6543 
    self._oprot.trans.flush()
6544 
 
6545 
  def recv_getAllFlipkartMarketplaceItem(self, ):
6546 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6547 
    if mtype == TMessageType.EXCEPTION:
6548 
      x = TApplicationException()
6549 
      x.read(self._iprot)
6550 
      self._iprot.readMessageEnd()
6551 
      raise x
6552 
    result = getAllFlipkartMarketplaceItem_result()
6553 
    result.read(self._iprot)
6554 
    self._iprot.readMessageEnd()
6555 
    if result.success is not None:
6556 
      return result.success
6557 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFlipkartMarketplaceItem failed: unknown result");
6558 
 
12243 kshitij.so 6559 
  def addCompetitorScraping(self, competitorPricingMap):
6560 
    """
6561 
    Parameters:
6562 
     - competitorPricingMap
6563 
    """
6564 
    self.send_addCompetitorScraping(competitorPricingMap)
6565 
    self.recv_addCompetitorScraping()
12133 kshitij.so 6566 
 
12243 kshitij.so 6567 
  def send_addCompetitorScraping(self, competitorPricingMap):
6568 
    self._oprot.writeMessageBegin('addCompetitorScraping', TMessageType.CALL, self._seqid)
6569 
    args = addCompetitorScraping_args()
6570 
    args.competitorPricingMap = competitorPricingMap
6571 
    args.write(self._oprot)
6572 
    self._oprot.writeMessageEnd()
6573 
    self._oprot.trans.flush()
6574 
 
6575 
  def recv_addCompetitorScraping(self, ):
6576 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6577 
    if mtype == TMessageType.EXCEPTION:
6578 
      x = TApplicationException()
6579 
      x.read(self._iprot)
6580 
      self._iprot.readMessageEnd()
6581 
      raise x
6582 
    result = addCompetitorScraping_result()
6583 
    result.read(self._iprot)
6584 
    self._iprot.readMessageEnd()
6585 
    return
6586 
 
6587 
  def getPreviousCompetitorScraping(self, delta):
6588 
    """
6589 
    Parameters:
6590 
     - delta
6591 
    """
6592 
    self.send_getPreviousCompetitorScraping(delta)
6593 
    return self.recv_getPreviousCompetitorScraping()
6594 
 
6595 
  def send_getPreviousCompetitorScraping(self, delta):
6596 
    self._oprot.writeMessageBegin('getPreviousCompetitorScraping', TMessageType.CALL, self._seqid)
6597 
    args = getPreviousCompetitorScraping_args()
6598 
    args.delta = delta
6599 
    args.write(self._oprot)
6600 
    self._oprot.writeMessageEnd()
6601 
    self._oprot.trans.flush()
6602 
 
6603 
  def recv_getPreviousCompetitorScraping(self, ):
6604 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6605 
    if mtype == TMessageType.EXCEPTION:
6606 
      x = TApplicationException()
6607 
      x.read(self._iprot)
6608 
      self._iprot.readMessageEnd()
6609 
      raise x
6610 
    result = getPreviousCompetitorScraping_result()
6611 
    result.read(self._iprot)
6612 
    self._iprot.readMessageEnd()
6613 
    if result.success is not None:
6614 
      return result.success
6615 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPreviousCompetitorScraping failed: unknown result");
6616 
 
12256 kshitij.so 6617 
  def getUploadResultById(self, uploadId):
6618 
    """
6619 
    Parameters:
6620 
     - uploadId
6621 
    """
6622 
    self.send_getUploadResultById(uploadId)
6623 
    return self.recv_getUploadResultById()
12243 kshitij.so 6624 
 
12256 kshitij.so 6625 
  def send_getUploadResultById(self, uploadId):
6626 
    self._oprot.writeMessageBegin('getUploadResultById', TMessageType.CALL, self._seqid)
6627 
    args = getUploadResultById_args()
6628 
    args.uploadId = uploadId
6629 
    args.write(self._oprot)
6630 
    self._oprot.writeMessageEnd()
6631 
    self._oprot.trans.flush()
6632 
 
6633 
  def recv_getUploadResultById(self, ):
6634 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6635 
    if mtype == TMessageType.EXCEPTION:
6636 
      x = TApplicationException()
6637 
      x.read(self._iprot)
6638 
      self._iprot.readMessageEnd()
6639 
      raise x
6640 
    result = getUploadResultById_result()
6641 
    result.read(self._iprot)
6642 
    self._iprot.readMessageEnd()
6643 
    if result.success is not None:
6644 
      return result.success
6645 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUploadResultById failed: unknown result");
6646 
 
12363 kshitij.so 6647 
  def addAmazonPromotion(self, amazonPromotions):
6648 
    """
6649 
    Parameters:
6650 
     - amazonPromotions
6651 
    """
6652 
    self.send_addAmazonPromotion(amazonPromotions)
6653 
    return self.recv_addAmazonPromotion()
12256 kshitij.so 6654 
 
12363 kshitij.so 6655 
  def send_addAmazonPromotion(self, amazonPromotions):
6656 
    self._oprot.writeMessageBegin('addAmazonPromotion', TMessageType.CALL, self._seqid)
6657 
    args = addAmazonPromotion_args()
6658 
    args.amazonPromotions = amazonPromotions
6659 
    args.write(self._oprot)
6660 
    self._oprot.writeMessageEnd()
6661 
    self._oprot.trans.flush()
6662 
 
6663 
  def recv_addAmazonPromotion(self, ):
6664 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6665 
    if mtype == TMessageType.EXCEPTION:
6666 
      x = TApplicationException()
6667 
      x.read(self._iprot)
6668 
      self._iprot.readMessageEnd()
6669 
      raise x
6670 
    result = addAmazonPromotion_result()
6671 
    result.read(self._iprot)
6672 
    self._iprot.readMessageEnd()
6673 
    if result.success is not None:
6674 
      return result.success
12947 kshitij.so 6675 
    if result.cex is not None:
6676 
      raise result.cex
12363 kshitij.so 6677 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAmazonPromotion failed: unknown result");
6678 
 
6679 
  def getAmazonPromotion(self, startDate, endDate):
6680 
    """
6681 
    Parameters:
6682 
     - startDate
6683 
     - endDate
6684 
    """
6685 
    self.send_getAmazonPromotion(startDate, endDate)
6686 
    return self.recv_getAmazonPromotion()
6687 
 
6688 
  def send_getAmazonPromotion(self, startDate, endDate):
6689 
    self._oprot.writeMessageBegin('getAmazonPromotion', TMessageType.CALL, self._seqid)
6690 
    args = getAmazonPromotion_args()
6691 
    args.startDate = startDate
6692 
    args.endDate = endDate
6693 
    args.write(self._oprot)
6694 
    self._oprot.writeMessageEnd()
6695 
    self._oprot.trans.flush()
6696 
 
6697 
  def recv_getAmazonPromotion(self, ):
6698 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6699 
    if mtype == TMessageType.EXCEPTION:
6700 
      x = TApplicationException()
6701 
      x.read(self._iprot)
6702 
      self._iprot.readMessageEnd()
6703 
      raise x
6704 
    result = getAmazonPromotion_result()
6705 
    result.read(self._iprot)
6706 
    self._iprot.readMessageEnd()
6707 
    if result.success is not None:
6708 
      return result.success
6709 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonPromotion failed: unknown result");
6710 
 
6711 
  def updateAmazonPromotion(self, amazonPromotions):
6712 
    """
6713 
    Parameters:
6714 
     - amazonPromotions
6715 
    """
6716 
    self.send_updateAmazonPromotion(amazonPromotions)
6717 
    return self.recv_updateAmazonPromotion()
6718 
 
6719 
  def send_updateAmazonPromotion(self, amazonPromotions):
6720 
    self._oprot.writeMessageBegin('updateAmazonPromotion', TMessageType.CALL, self._seqid)
6721 
    args = updateAmazonPromotion_args()
6722 
    args.amazonPromotions = amazonPromotions
6723 
    args.write(self._oprot)
6724 
    self._oprot.writeMessageEnd()
6725 
    self._oprot.trans.flush()
6726 
 
6727 
  def recv_updateAmazonPromotion(self, ):
6728 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6729 
    if mtype == TMessageType.EXCEPTION:
6730 
      x = TApplicationException()
6731 
      x.read(self._iprot)
6732 
      self._iprot.readMessageEnd()
6733 
      raise x
6734 
    result = updateAmazonPromotion_result()
6735 
    result.read(self._iprot)
6736 
    self._iprot.readMessageEnd()
6737 
    if result.success is not None:
6738 
      return result.success
6739 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateAmazonPromotion failed: unknown result");
6740 
 
12567 amit.gupta 6741 
  def markPartiallyActive(self, itemId, categoryId):
6742 
    """
6743 
    Parameters:
6744 
     - itemId
6745 
     - categoryId
6746 
    """
6747 
    self.send_markPartiallyActive(itemId, categoryId)
6748 
    return self.recv_markPartiallyActive()
12363 kshitij.so 6749 
 
12567 amit.gupta 6750 
  def send_markPartiallyActive(self, itemId, categoryId):
6751 
    self._oprot.writeMessageBegin('markPartiallyActive', TMessageType.CALL, self._seqid)
6752 
    args = markPartiallyActive_args()
6753 
    args.itemId = itemId
6754 
    args.categoryId = categoryId
6755 
    args.write(self._oprot)
6756 
    self._oprot.writeMessageEnd()
6757 
    self._oprot.trans.flush()
6758 
 
6759 
  def recv_markPartiallyActive(self, ):
6760 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6761 
    if mtype == TMessageType.EXCEPTION:
6762 
      x = TApplicationException()
6763 
      x.read(self._iprot)
6764 
      self._iprot.readMessageEnd()
6765 
      raise x
6766 
    result = markPartiallyActive_result()
6767 
    result.read(self._iprot)
6768 
    self._iprot.readMessageEnd()
6769 
    if result.success is not None:
6770 
      return result.success
6771 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markPartiallyActive failed: unknown result");
6772 
 
6773 
  def updateItemStateVat(self, itemId, statevat):
6774 
    """
6775 
    Parameters:
6776 
     - itemId
6777 
     - statevat
6778 
    """
6779 
    self.send_updateItemStateVat(itemId, statevat)
6780 
    return self.recv_updateItemStateVat()
6781 
 
6782 
  def send_updateItemStateVat(self, itemId, statevat):
6783 
    self._oprot.writeMessageBegin('updateItemStateVat', TMessageType.CALL, self._seqid)
6784 
    args = updateItemStateVat_args()
6785 
    args.itemId = itemId
6786 
    args.statevat = statevat
6787 
    args.write(self._oprot)
6788 
    self._oprot.writeMessageEnd()
6789 
    self._oprot.trans.flush()
6790 
 
6791 
  def recv_updateItemStateVat(self, ):
6792 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6793 
    if mtype == TMessageType.EXCEPTION:
6794 
      x = TApplicationException()
6795 
      x.read(self._iprot)
6796 
      self._iprot.readMessageEnd()
6797 
      raise x
6798 
    result = updateItemStateVat_result()
6799 
    result.read(self._iprot)
6800 
    self._iprot.readMessageEnd()
6801 
    if result.success is not None:
6802 
      return result.success
6803 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItemStateVat failed: unknown result");
6804 
 
12620 amit.gupta 6805 
  def getExAffiliateItemInfo(self, ):
6806 
    self.send_getExAffiliateItemInfo()
6807 
    return self.recv_getExAffiliateItemInfo()
12567 amit.gupta 6808 
 
12620 amit.gupta 6809 
  def send_getExAffiliateItemInfo(self, ):
6810 
    self._oprot.writeMessageBegin('getExAffiliateItemInfo', TMessageType.CALL, self._seqid)
6811 
    args = getExAffiliateItemInfo_args()
6812 
    args.write(self._oprot)
6813 
    self._oprot.writeMessageEnd()
6814 
    self._oprot.trans.flush()
6815 
 
6816 
  def recv_getExAffiliateItemInfo(self, ):
6817 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6818 
    if mtype == TMessageType.EXCEPTION:
6819 
      x = TApplicationException()
6820 
      x.read(self._iprot)
6821 
      self._iprot.readMessageEnd()
6822 
      raise x
6823 
    result = getExAffiliateItemInfo_result()
6824 
    result.read(self._iprot)
6825 
    self._iprot.readMessageEnd()
6826 
    if result.success is not None:
6827 
      return result.success
6828 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getExAffiliateItemInfo failed: unknown result");
6829 
 
12888 kshitij.so 6830 
  def getAllItemstoListOnFbg(self, ):
6831 
    self.send_getAllItemstoListOnFbg()
6832 
    return self.recv_getAllItemstoListOnFbg()
12620 amit.gupta 6833 
 
12888 kshitij.so 6834 
  def send_getAllItemstoListOnFbg(self, ):
6835 
    self._oprot.writeMessageBegin('getAllItemstoListOnFbg', TMessageType.CALL, self._seqid)
6836 
    args = getAllItemstoListOnFbg_args()
6837 
    args.write(self._oprot)
6838 
    self._oprot.writeMessageEnd()
6839 
    self._oprot.trans.flush()
6840 
 
6841 
  def recv_getAllItemstoListOnFbg(self, ):
6842 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6843 
    if mtype == TMessageType.EXCEPTION:
6844 
      x = TApplicationException()
6845 
      x.read(self._iprot)
6846 
      self._iprot.readMessageEnd()
6847 
      raise x
6848 
    result = getAllItemstoListOnFbg_result()
6849 
    result.read(self._iprot)
6850 
    self._iprot.readMessageEnd()
6851 
    if result.success is not None:
6852 
      return result.success
6853 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnFbg failed: unknown result");
6854 
 
12892 kshitij.so 6855 
  def getAllFbgListedItems(self, ):
6856 
    self.send_getAllFbgListedItems()
6857 
    return self.recv_getAllFbgListedItems()
12888 kshitij.so 6858 
 
12892 kshitij.so 6859 
  def send_getAllFbgListedItems(self, ):
6860 
    self._oprot.writeMessageBegin('getAllFbgListedItems', TMessageType.CALL, self._seqid)
6861 
    args = getAllFbgListedItems_args()
6862 
    args.write(self._oprot)
6863 
    self._oprot.writeMessageEnd()
6864 
    self._oprot.trans.flush()
6865 
 
6866 
  def recv_getAllFbgListedItems(self, ):
6867 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6868 
    if mtype == TMessageType.EXCEPTION:
6869 
      x = TApplicationException()
6870 
      x.read(self._iprot)
6871 
      self._iprot.readMessageEnd()
6872 
      raise x
6873 
    result = getAllFbgListedItems_result()
6874 
    result.read(self._iprot)
6875 
    self._iprot.readMessageEnd()
6876 
    if result.success is not None:
6877 
      return result.success
6878 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbgListedItems failed: unknown result");
6879 
 
13136 amit.gupta 6880 
  def checkServices(self, lines):
6881 
    """
6882 
    Parameters:
6883 
     - lines
6884 
    """
6885 
    self.send_checkServices(lines)
6886 
    return self.recv_checkServices()
12892 kshitij.so 6887 
 
13136 amit.gupta 6888 
  def send_checkServices(self, lines):
6889 
    self._oprot.writeMessageBegin('checkServices', TMessageType.CALL, self._seqid)
6890 
    args = checkServices_args()
6891 
    args.lines = lines
6892 
    args.write(self._oprot)
6893 
    self._oprot.writeMessageEnd()
6894 
    self._oprot.trans.flush()
6895 
 
6896 
  def recv_checkServices(self, ):
6897 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6898 
    if mtype == TMessageType.EXCEPTION:
6899 
      x = TApplicationException()
6900 
      x.read(self._iprot)
6901 
      self._iprot.readMessageEnd()
6902 
      raise x
6903 
    result = checkServices_result()
6904 
    result.read(self._iprot)
6905 
    self._iprot.readMessageEnd()
6906 
    if result.success is not None:
6907 
      return result.success
6908 
    if result.cex is not None:
6909 
      raise result.cex
6910 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkServices failed: unknown result");
6911 
 
13709 manish.sha 6912 
  def addHsItem(self, hsItems):
6913 
    """
6914 
    Parameters:
6915 
     - hsItems
6916 
    """
6917 
    self.send_addHsItem(hsItems)
6918 
    self.recv_addHsItem()
13136 amit.gupta 6919 
 
13709 manish.sha 6920 
  def send_addHsItem(self, hsItems):
6921 
    self._oprot.writeMessageBegin('addHsItem', TMessageType.CALL, self._seqid)
6922 
    args = addHsItem_args()
6923 
    args.hsItems = hsItems
6924 
    args.write(self._oprot)
6925 
    self._oprot.writeMessageEnd()
6926 
    self._oprot.trans.flush()
6927 
 
6928 
  def recv_addHsItem(self, ):
6929 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6930 
    if mtype == TMessageType.EXCEPTION:
6931 
      x = TApplicationException()
6932 
      x.read(self._iprot)
6933 
      self._iprot.readMessageEnd()
6934 
      raise x
6935 
    result = addHsItem_result()
6936 
    result.read(self._iprot)
6937 
    self._iprot.readMessageEnd()
6938 
    return
6939 
 
6940 
  def getHsItem(self, hsItemId):
6941 
    """
6942 
    Parameters:
6943 
     - hsItemId
6944 
    """
6945 
    self.send_getHsItem(hsItemId)
6946 
    return self.recv_getHsItem()
6947 
 
6948 
  def send_getHsItem(self, hsItemId):
6949 
    self._oprot.writeMessageBegin('getHsItem', TMessageType.CALL, self._seqid)
6950 
    args = getHsItem_args()
6951 
    args.hsItemId = hsItemId
6952 
    args.write(self._oprot)
6953 
    self._oprot.writeMessageEnd()
6954 
    self._oprot.trans.flush()
6955 
 
6956 
  def recv_getHsItem(self, ):
6957 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6958 
    if mtype == TMessageType.EXCEPTION:
6959 
      x = TApplicationException()
6960 
      x.read(self._iprot)
6961 
      self._iprot.readMessageEnd()
6962 
      raise x
6963 
    result = getHsItem_result()
6964 
    result.read(self._iprot)
6965 
    self._iprot.readMessageEnd()
6966 
    if result.success is not None:
6967 
      return result.success
6968 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getHsItem failed: unknown result");
6969 
 
6970 
  def updateHsItem(self, hsItem):
6971 
    """
6972 
    Parameters:
6973 
     - hsItem
6974 
    """
6975 
    self.send_updateHsItem(hsItem)
6976 
    self.recv_updateHsItem()
6977 
 
6978 
  def send_updateHsItem(self, hsItem):
6979 
    self._oprot.writeMessageBegin('updateHsItem', TMessageType.CALL, self._seqid)
6980 
    args = updateHsItem_args()
6981 
    args.hsItem = hsItem
6982 
    args.write(self._oprot)
6983 
    self._oprot.writeMessageEnd()
6984 
    self._oprot.trans.flush()
6985 
 
6986 
  def recv_updateHsItem(self, ):
6987 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6988 
    if mtype == TMessageType.EXCEPTION:
6989 
      x = TApplicationException()
6990 
      x.read(self._iprot)
6991 
      self._iprot.readMessageEnd()
6992 
      raise x
6993 
    result = updateHsItem_result()
6994 
    result.read(self._iprot)
6995 
    self._iprot.readMessageEnd()
6996 
    return
6997 
 
14182 kshitij.so 6998 
  def getPricingForDtr(self, catalogItemId):
6999 
    """
7000 
    Parameters:
7001 
     - catalogItemId
7002 
    """
7003 
    self.send_getPricingForDtr(catalogItemId)
7004 
    return self.recv_getPricingForDtr()
13709 manish.sha 7005 
 
14182 kshitij.so 7006 
  def send_getPricingForDtr(self, catalogItemId):
7007 
    self._oprot.writeMessageBegin('getPricingForDtr', TMessageType.CALL, self._seqid)
7008 
    args = getPricingForDtr_args()
7009 
    args.catalogItemId = catalogItemId
7010 
    args.write(self._oprot)
7011 
    self._oprot.writeMessageEnd()
7012 
    self._oprot.trans.flush()
7013 
 
7014 
  def recv_getPricingForDtr(self, ):
7015 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7016 
    if mtype == TMessageType.EXCEPTION:
7017 
      x = TApplicationException()
7018 
      x.read(self._iprot)
7019 
      self._iprot.readMessageEnd()
7020 
      raise x
7021 
    result = getPricingForDtr_result()
7022 
    result.read(self._iprot)
7023 
    self._iprot.readMessageEnd()
7024 
    if result.success is not None:
7025 
      return result.success
7026 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPricingForDtr failed: unknown result");
7027 
 
7028 
 
5944 mandeep.dh 7029 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
7030 
  def __init__(self, handler):
7031 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
7032 
    self._processMap["addItem"] = Processor.process_addItem
7033 
    self._processMap["updateItem"] = Processor.process_updateItem
7034 
    self._processMap["isActive"] = Processor.process_isActive
7438 amit.gupta 7035 
    self._processMap["getItemsStatus"] = Processor.process_getItemsStatus
5944 mandeep.dh 7036 
    self._processMap["getItemStatusDescription"] = Processor.process_getItemStatusDescription
7037 
    self._processMap["startItemOn"] = Processor.process_startItemOn
7038 
    self._processMap["retireItemOn"] = Processor.process_retireItemOn
7039 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
7040 
    self._processMap["getItem"] = Processor.process_getItem
13493 amit.gupta 7041 
    self._processMap["getItems"] = Processor.process_getItems
5944 mandeep.dh 7042 
    self._processMap["getItemsByCatalogId"] = Processor.process_getItemsByCatalogId
7043 
    self._processMap["getValidItemsByCatalogId"] = Processor.process_getValidItemsByCatalogId
7044 
    self._processMap["getAllItems"] = Processor.process_getAllItems
7045 
    self._processMap["getAllItemsByStatus"] = Processor.process_getAllItemsByStatus
7046 
    self._processMap["markItemAsContentComplete"] = Processor.process_markItemAsContentComplete
12567 amit.gupta 7047 
    self._processMap["getVatRates"] = Processor.process_getVatRates
5944 mandeep.dh 7048 
    self._processMap["getAllItemsInRange"] = Processor.process_getAllItemsInRange
7049 
    self._processMap["getAllItemsByStatusInRange"] = Processor.process_getAllItemsByStatusInRange
7050 
    self._processMap["getItemCountByStatus"] = Processor.process_getItemCountByStatus
7051 
    self._processMap["getBestSellers"] = Processor.process_getBestSellers
7052 
    self._processMap["getBestSellersCatalogIds"] = Processor.process_getBestSellersCatalogIds
7053 
    self._processMap["getBestSellersCount"] = Processor.process_getBestSellersCount
7054 
    self._processMap["getBestDeals"] = Processor.process_getBestDeals
7055 
    self._processMap["getBestDealsCatalogIds"] = Processor.process_getBestDealsCatalogIds
7056 
    self._processMap["getBestDealsCount"] = Processor.process_getBestDealsCount
7057 
    self._processMap["getComingSoon"] = Processor.process_getComingSoon
7058 
    self._processMap["getComingSoonCatalogIds"] = Processor.process_getComingSoonCatalogIds
7059 
    self._processMap["getComingSoonCount"] = Processor.process_getComingSoonCount
7060 
    self._processMap["getLatestArrivals"] = Processor.process_getLatestArrivals
7061 
    self._processMap["getLatestArrivalsCatalogIds"] = Processor.process_getLatestArrivalsCatalogIds
7062 
    self._processMap["getLatestArrivalsCount"] = Processor.process_getLatestArrivalsCount
7063 
    self._processMap["generateNewEntityID"] = Processor.process_generateNewEntityID
7064 
    self._processMap["addCategory"] = Processor.process_addCategory
7065 
    self._processMap["getCategory"] = Processor.process_getCategory
7066 
    self._processMap["getAllCategories"] = Processor.process_getAllCategories
7067 
    self._processMap["getAllSimilarItems"] = Processor.process_getAllSimilarItems
7068 
    self._processMap["addSimilarItem"] = Processor.process_addSimilarItem
6512 kshitij.so 7069 
    self._processMap["addTag"] = Processor.process_addTag
7070 
    self._processMap["deleteEntityTag"] = Processor.process_deleteEntityTag
7071 
    self._processMap["deleteTag"] = Processor.process_deleteTag
7072 
    self._processMap["getAllTags"] = Processor.process_getAllTags
7073 
    self._processMap["getAllEntitiesByTagName"] = Processor.process_getAllEntitiesByTagName
6845 amit.gupta 7074 
    self._processMap["getAllEntityTags"] = Processor.process_getAllEntityTags
6850 kshitij.so 7075 
    self._processMap["addBanner"] = Processor.process_addBanner
8579 kshitij.so 7076 
    self._processMap["updateBanner"] = Processor.process_updateBanner
6850 kshitij.so 7077 
    self._processMap["getAllBanners"] = Processor.process_getAllBanners
7078 
    self._processMap["deleteBanner"] = Processor.process_deleteBanner
7079 
    self._processMap["getBannerDetails"] = Processor.process_getBannerDetails
7080 
    self._processMap["getActiveBanners"] = Processor.process_getActiveBanners
6849 kshitij.so 7081 
    self._processMap["addBannerMap"] = Processor.process_addBannerMap
8579 kshitij.so 7082 
    self._processMap["updateBannerMap"] = Processor.process_updateBannerMap
6849 kshitij.so 7083 
    self._processMap["deleteBannerMap"] = Processor.process_deleteBannerMap
7084 
    self._processMap["getBannerMapDetails"] = Processor.process_getBannerMapDetails
8579 kshitij.so 7085 
    self._processMap["addBannerUri"] = Processor.process_addBannerUri
7086 
    self._processMap["getUriMapping"] = Processor.process_getUriMapping
7087 
    self._processMap["addCampaign"] = Processor.process_addCampaign
7088 
    self._processMap["getCampaigns"] = Processor.process_getCampaigns
7089 
    self._processMap["deleteCampaign"] = Processor.process_deleteCampaign
7090 
    self._processMap["getAllCampaigns"] = Processor.process_getAllCampaigns
9155 kshitij.so 7091 
    self._processMap["getActiveBannersForMobileSite"] = Processor.process_getActiveBannersForMobileSite
5944 mandeep.dh 7092 
    self._processMap["deleteSimilarItem"] = Processor.process_deleteSimilarItem
7093 
    self._processMap["checkSimilarItem"] = Processor.process_checkSimilarItem
7094 
    self._processMap["validateRiskyStatus"] = Processor.process_validateRiskyStatus
7095 
    self._processMap["changeItemRiskyFlag"] = Processor.process_changeItemRiskyFlag
7096 
    self._processMap["getItemsByRiskyFlag"] = Processor.process_getItemsByRiskyFlag
7097 
    self._processMap["getItemsForMasterSheet"] = Processor.process_getItemsForMasterSheet
7098 
    self._processMap["getSimilarItemsCatalogIds"] = Processor.process_getSimilarItemsCatalogIds
7099 
    self._processMap["addProductNotification"] = Processor.process_addProductNotification
7100 
    self._processMap["sendProductNotifications"] = Processor.process_sendProductNotifications
7101 
    self._processMap["getAllBrandsByCategory"] = Processor.process_getAllBrandsByCategory
7102 
    self._processMap["getAllBrands"] = Processor.process_getAllBrands
7103 
    self._processMap["getAllSources"] = Processor.process_getAllSources
7104 
    self._processMap["getItemPricingBySource"] = Processor.process_getItemPricingBySource
7105 
    self._processMap["addSourceItemPricing"] = Processor.process_addSourceItemPricing
7106 
    self._processMap["getAllSourcePricing"] = Processor.process_getAllSourcePricing
7107 
    self._processMap["getItemForSource"] = Processor.process_getItemForSource
7108 
    self._processMap["searchItemsInRange"] = Processor.process_searchItemsInRange
7109 
    self._processMap["getSearchResultCount"] = Processor.process_getSearchResultCount
7110 
    self._processMap["getProductNotifications"] = Processor.process_getProductNotifications
7111 
    self._processMap["getProductNotificationRequestCount"] = Processor.process_getProductNotificationRequestCount
7112 
    self._processMap["addAuthorizationLog"] = Processor.process_addAuthorizationLog
7113 
    self._processMap["addupdateVoucherForItem"] = Processor.process_addupdateVoucherForItem
7114 
    self._processMap["deleteVoucherForItem"] = Processor.process_deleteVoucherForItem
7115 
    self._processMap["getVoucherAmount"] = Processor.process_getVoucherAmount
7116 
    self._processMap["getAllItemVouchers"] = Processor.process_getAllItemVouchers
7117 
    self._processMap["isValidCatalogItemId"] = Processor.process_isValidCatalogItemId
6039 amit.gupta 7118 
    self._processMap["getVatPercentageForItem"] = Processor.process_getVatPercentageForItem
7119 
    self._processMap["getVatAmountForItem"] = Processor.process_getVatAmountForItem
6531 vikram.rag 7120 
    self._processMap["getAllIgnoredInventoryUpdateItemsList"] = Processor.process_getAllIgnoredInventoryUpdateItemsList
6821 amar.kumar 7121 
    self._processMap["getAllAliveItems"] = Processor.process_getAllAliveItems
6805 anupam.sin 7122 
    self._processMap["getInsuranceAmount"] = Processor.process_getInsuranceAmount
7123 
    self._processMap["getInsurer"] = Processor.process_getInsurer
6838 vikram.rag 7124 
    self._processMap["getAllInsurers"] = Processor.process_getAllInsurers
6962 rajveer 7125 
    self._processMap["updateInsuranceDeclaredAmount"] = Processor.process_updateInsuranceDeclaredAmount
7190 amar.kumar 7126 
    self._processMap["getFreebieForItem"] = Processor.process_getFreebieForItem
7127 
    self._processMap["addOrUpdateFreebieForItem"] = Processor.process_addOrUpdateFreebieForItem
7272 amit.gupta 7128 
    self._processMap["addOrUpdateBrandInfo"] = Processor.process_addOrUpdateBrandInfo
7129 
    self._processMap["getBrandInfo"] = Processor.process_getBrandInfo
7256 rajveer 7130 
    self._processMap["getStorePricing"] = Processor.process_getStorePricing
7306 rajveer 7131 
    self._processMap["getStorePricings"] = Processor.process_getStorePricings
7265 rajveer 7132 
    self._processMap["updateStorePricing"] = Processor.process_updateStorePricing
7281 kshitij.so 7133 
    self._processMap["getAllAmazonListedItems"] = Processor.process_getAllAmazonListedItems
8619 kshitij.so 7134 
    self._processMap["searchAmazonItems"] = Processor.process_searchAmazonItems
7135 
    self._processMap["getAmazonSearchResultCount"] = Processor.process_getAmazonSearchResultCount
7136 
    self._processMap["getCountForAmazonlistedItems"] = Processor.process_getCountForAmazonlistedItems
7281 kshitij.so 7137 
    self._processMap["getAmazonItemDetails"] = Processor.process_getAmazonItemDetails
7138 
    self._processMap["updateAmazonItemDetails"] = Processor.process_updateAmazonItemDetails
7139 
    self._processMap["addAmazonItem"] = Processor.process_addAmazonItem
7291 vikram.rag 7140 
    self._processMap["getAsinItems"] = Processor.process_getAsinItems
7141 
    self._processMap["getAllFbaListedItems"] = Processor.process_getAllFbaListedItems
7142 
    self._processMap["getAllNonFbaListedItems"] = Processor.process_getAllNonFbaListedItems
7460 kshitij.so 7143 
    self._processMap["updateItemInventory"] = Processor.process_updateItemInventory
7770 kshitij.so 7144 
    self._processMap["updateTimestampForAmazonFeeds"] = Processor.process_updateTimestampForAmazonFeeds
7897 amar.kumar 7145 
    self._processMap["getAllParentCategories"] = Processor.process_getAllParentCategories
7977 kshitij.so 7146 
    self._processMap["addPageViewEvent"] = Processor.process_addPageViewEvent
7147 
    self._processMap["addCartEvent"] = Processor.process_addCartEvent
8182 amar.kumar 7148 
    self._processMap["addEbayItem"] = Processor.process_addEbayItem
7149 
    self._processMap["getEbayItem"] = Processor.process_getEbayItem
7150 
    self._processMap["updateEbayItem"] = Processor.process_updateEbayItem
8139 kshitij.so 7151 
    self._processMap["getAmazonListedItems"] = Processor.process_getAmazonListedItems
8168 kshitij.so 7152 
    self._processMap["updateAmazonAttributesInBulk"] = Processor.process_updateAmazonAttributesInBulk
8379 vikram.rag 7153 
    self._processMap["getAllItemstoListOnFba"] = Processor.process_getAllItemstoListOnFba
7154 
    self._processMap["getAllItemstoListOnNonFba"] = Processor.process_getAllItemstoListOnNonFba
8619 kshitij.so 7155 
    self._processMap["updateAsin"] = Processor.process_updateAsin
8739 vikram.rag 7156 
    self._processMap["addOrUpdateSnapdealItem"] = Processor.process_addOrUpdateSnapdealItem
7157 
    self._processMap["getSnapdealItem"] = Processor.process_getSnapdealItem
9242 kshitij.so 7158 
    self._processMap["getSnapdealItemDetails"] = Processor.process_getSnapdealItemDetails
8739 vikram.rag 7159 
    self._processMap["getAllSnapdealItems"] = Processor.process_getAllSnapdealItems
9242 kshitij.so 7160 
    self._processMap["getSnapdealItems"] = Processor.process_getSnapdealItems
7161 
    self._processMap["searchSnapdealItems"] = Processor.process_searchSnapdealItems
7162 
    self._processMap["getCountForSnapdealItems"] = Processor.process_getCountForSnapdealItems
7163 
    self._processMap["getSnapdealSearchResultCount"] = Processor.process_getSnapdealSearchResultCount
9299 kshitij.so 7164 
    self._processMap["getPrefferedInsurerForItem"] = Processor.process_getPrefferedInsurerForItem
9456 vikram.rag 7165 
    self._processMap["getSnapdealItembySkuAtSnapdeal"] = Processor.process_getSnapdealItembySkuAtSnapdeal
9621 manish.sha 7166 
    self._processMap["getProductFeedSubmit"] = Processor.process_getProductFeedSubmit
7167 
    self._processMap["addProductFeedSubmit"] = Processor.process_addProductFeedSubmit
7168 
    self._processMap["updateProductFeedSubmit"] = Processor.process_updateProductFeedSubmit
7169 
    self._processMap["deleteProductFeedSubmit"] = Processor.process_deleteProductFeedSubmit
7170 
    self._processMap["getAllProductFeedSubmit"] = Processor.process_getAllProductFeedSubmit
9724 kshitij.so 7171 
    self._processMap["getMarketplacedetailsForItem"] = Processor.process_getMarketplacedetailsForItem
7172 
    self._processMap["updateMarketplaceAttributesForItem"] = Processor.process_updateMarketplaceAttributesForItem
9779 kshitij.so 7173 
    self._processMap["getCostingForMarketplace"] = Processor.process_getCostingForMarketplace
9776 vikram.rag 7174 
    self._processMap["getMarketPlaceItemsForPriceUpdate"] = Processor.process_getMarketPlaceItemsForPriceUpdate
7175 
    self._processMap["updateMarketPlacePriceUpdateStatus"] = Processor.process_updateMarketPlacePriceUpdateStatus
9861 rajveer 7176 
    self._processMap["updateItemHoldInventory"] = Processor.process_updateItemHoldInventory
9895 vikram.rag 7177 
    self._processMap["updateNlcAtMarketplaces"] = Processor.process_updateNlcAtMarketplaces
9945 vikram.rag 7178 
    self._processMap["getAllFlipkartItems"] = Processor.process_getAllFlipkartItems
10097 kshitij.so 7179 
    self._processMap["addOrUpdateFlipkartItem"] = Processor.process_addOrUpdateFlipkartItem
7180 
    self._processMap["getFlipkartItem"] = Processor.process_getFlipkartItem
7181 
    self._processMap["getFlipkartItemDetails"] = Processor.process_getFlipkartItemDetails
7182 
    self._processMap["getFlipkartItems"] = Processor.process_getFlipkartItems
7183 
    self._processMap["searchFlipkartItems"] = Processor.process_searchFlipkartItems
7184 
    self._processMap["getCountForFlipkartItems"] = Processor.process_getCountForFlipkartItems
7185 
    self._processMap["getFlipkartSearchResultCount"] = Processor.process_getFlipkartSearchResultCount
7186 
    self._processMap["getAllFkItems"] = Processor.process_getAllFkItems
10140 vikram.rag 7187 
    self._processMap["getFlipkartItemBySkyAtFlipkart"] = Processor.process_getFlipkartItemBySkyAtFlipkart
11015 kshitij.so 7188 
    self._processMap["getMarketplaceHistory"] = Processor.process_getMarketplaceHistory
10909 vikram.rag 7189 
    self._processMap["getAllFbbListedItems"] = Processor.process_getAllFbbListedItems
10924 vikram.rag 7190 
    self._processMap["getAllFbbPricingItems"] = Processor.process_getAllFbbPricingItems
11015 kshitij.so 7191 
    self._processMap["getCountForMarketplaceHistory"] = Processor.process_getCountForMarketplaceHistory
7192 
    self._processMap["getMarketplaceHistoryByDate"] = Processor.process_getMarketplaceHistoryByDate
11531 vikram.rag 7193 
    self._processMap["getPrivateDealDetails"] = Processor.process_getPrivateDealDetails
7194 
    self._processMap["getPrivateDealItems"] = Processor.process_getPrivateDealItems
11592 amit.gupta 7195 
    self._processMap["getAllActivePrivateDeals"] = Processor.process_getAllActivePrivateDeals
11531 vikram.rag 7196 
    self._processMap["addOrUpdatePrivateDeal"] = Processor.process_addOrUpdatePrivateDeal
11635 vikram.rag 7197 
    self._processMap["getPrivateDealsCatalogIds"] = Processor.process_getPrivateDealsCatalogIds
11645 amit.gupta 7198 
    self._processMap["getPrivateDealsCount"] = Processor.process_getPrivateDealsCount
11905 kshitij.so 7199 
    self._processMap["getAmazonOutSyncItems"] = Processor.process_getAmazonOutSyncItems
7200 
    self._processMap["getAllPrivateDealsComparison"] = Processor.process_getAllPrivateDealsComparison
12133 kshitij.so 7201 
    self._processMap["getAllSnapdealMarketplaceItem"] = Processor.process_getAllSnapdealMarketplaceItem
7202 
    self._processMap["getAllFlipkartMarketplaceItem"] = Processor.process_getAllFlipkartMarketplaceItem
12243 kshitij.so 7203 
    self._processMap["addCompetitorScraping"] = Processor.process_addCompetitorScraping
7204 
    self._processMap["getPreviousCompetitorScraping"] = Processor.process_getPreviousCompetitorScraping
12256 kshitij.so 7205 
    self._processMap["getUploadResultById"] = Processor.process_getUploadResultById
12363 kshitij.so 7206 
    self._processMap["addAmazonPromotion"] = Processor.process_addAmazonPromotion
7207 
    self._processMap["getAmazonPromotion"] = Processor.process_getAmazonPromotion
7208 
    self._processMap["updateAmazonPromotion"] = Processor.process_updateAmazonPromotion
12567 amit.gupta 7209 
    self._processMap["markPartiallyActive"] = Processor.process_markPartiallyActive
7210 
    self._processMap["updateItemStateVat"] = Processor.process_updateItemStateVat
12620 amit.gupta 7211 
    self._processMap["getExAffiliateItemInfo"] = Processor.process_getExAffiliateItemInfo
12888 kshitij.so 7212 
    self._processMap["getAllItemstoListOnFbg"] = Processor.process_getAllItemstoListOnFbg
12892 kshitij.so 7213 
    self._processMap["getAllFbgListedItems"] = Processor.process_getAllFbgListedItems
13136 amit.gupta 7214 
    self._processMap["checkServices"] = Processor.process_checkServices
13709 manish.sha 7215 
    self._processMap["addHsItem"] = Processor.process_addHsItem
7216 
    self._processMap["getHsItem"] = Processor.process_getHsItem
7217 
    self._processMap["updateHsItem"] = Processor.process_updateHsItem
14182 kshitij.so 7218 
    self._processMap["getPricingForDtr"] = Processor.process_getPricingForDtr
5944 mandeep.dh 7219 
 
7220 
  def process(self, iprot, oprot):
7221 
    (name, type, seqid) = iprot.readMessageBegin()
7222 
    if name not in self._processMap:
7223 
      iprot.skip(TType.STRUCT)
7224 
      iprot.readMessageEnd()
7225 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
7226 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
7227 
      x.write(oprot)
7228 
      oprot.writeMessageEnd()
7229 
      oprot.trans.flush()
7230 
      return
7231 
    else:
7232 
      self._processMap[name](self, seqid, iprot, oprot)
7233 
    return True
7234 
 
7235 
  def process_addItem(self, seqid, iprot, oprot):
7236 
    args = addItem_args()
7237 
    args.read(iprot)
7238 
    iprot.readMessageEnd()
7239 
    result = addItem_result()
7240 
    try:
7241 
      result.success = self._handler.addItem(args.item)
7242 
    except CatalogServiceException, cex:
7243 
      result.cex = cex
7244 
    oprot.writeMessageBegin("addItem", TMessageType.REPLY, seqid)
7245 
    result.write(oprot)
7246 
    oprot.writeMessageEnd()
7247 
    oprot.trans.flush()
7248 
 
7249 
  def process_updateItem(self, seqid, iprot, oprot):
7250 
    args = updateItem_args()
7251 
    args.read(iprot)
7252 
    iprot.readMessageEnd()
7253 
    result = updateItem_result()
7254 
    try:
7255 
      result.success = self._handler.updateItem(args.item)
7256 
    except CatalogServiceException, cex:
7257 
      result.cex = cex
7258 
    oprot.writeMessageBegin("updateItem", TMessageType.REPLY, seqid)
7259 
    result.write(oprot)
7260 
    oprot.writeMessageEnd()
7261 
    oprot.trans.flush()
7262 
 
7263 
  def process_isActive(self, seqid, iprot, oprot):
7264 
    args = isActive_args()
7265 
    args.read(iprot)
7266 
    iprot.readMessageEnd()
7267 
    result = isActive_result()
7268 
    try:
7269 
      result.success = self._handler.isActive(args.itemId)
7270 
    except CatalogServiceException, isex:
7271 
      result.isex = isex
7272 
    oprot.writeMessageBegin("isActive", TMessageType.REPLY, seqid)
7273 
    result.write(oprot)
7274 
    oprot.writeMessageEnd()
7275 
    oprot.trans.flush()
7276 
 
7438 amit.gupta 7277 
  def process_getItemsStatus(self, seqid, iprot, oprot):
7278 
    args = getItemsStatus_args()
7279 
    args.read(iprot)
7280 
    iprot.readMessageEnd()
7281 
    result = getItemsStatus_result()
7282 
    try:
7283 
      result.success = self._handler.getItemsStatus(args.itemIds)
7284 
    except CatalogServiceException, isex:
7285 
      result.isex = isex
7286 
    oprot.writeMessageBegin("getItemsStatus", TMessageType.REPLY, seqid)
7287 
    result.write(oprot)
7288 
    oprot.writeMessageEnd()
7289 
    oprot.trans.flush()
7290 
 
5944 mandeep.dh 7291 
  def process_getItemStatusDescription(self, seqid, iprot, oprot):
7292 
    args = getItemStatusDescription_args()
7293 
    args.read(iprot)
7294 
    iprot.readMessageEnd()
7295 
    result = getItemStatusDescription_result()
7296 
    try:
7297 
      result.success = self._handler.getItemStatusDescription(args.itemId)
7298 
    except CatalogServiceException, isex:
7299 
      result.isex = isex
7300 
    oprot.writeMessageBegin("getItemStatusDescription", TMessageType.REPLY, seqid)
7301 
    result.write(oprot)
7302 
    oprot.writeMessageEnd()
7303 
    oprot.trans.flush()
7304 
 
7305 
  def process_startItemOn(self, seqid, iprot, oprot):
7306 
    args = startItemOn_args()
7307 
    args.read(iprot)
7308 
    iprot.readMessageEnd()
7309 
    result = startItemOn_result()
7310 
    try:
7311 
      self._handler.startItemOn(args.item_id, args.timestamp)
7312 
    except CatalogServiceException, cex:
7313 
      result.cex = cex
7314 
    oprot.writeMessageBegin("startItemOn", TMessageType.REPLY, seqid)
7315 
    result.write(oprot)
7316 
    oprot.writeMessageEnd()
7317 
    oprot.trans.flush()
7318 
 
7319 
  def process_retireItemOn(self, seqid, iprot, oprot):
7320 
    args = retireItemOn_args()
7321 
    args.read(iprot)
7322 
    iprot.readMessageEnd()
7323 
    result = retireItemOn_result()
7324 
    try:
7325 
      self._handler.retireItemOn(args.item_id, args.timestamp)
7326 
    except CatalogServiceException, cex:
7327 
      result.cex = cex
7328 
    oprot.writeMessageBegin("retireItemOn", TMessageType.REPLY, seqid)
7329 
    result.write(oprot)
7330 
    oprot.writeMessageEnd()
7331 
    oprot.trans.flush()
7332 
 
7333 
  def process_changeItemStatus(self, seqid, iprot, oprot):
7334 
    args = changeItemStatus_args()
7335 
    args.read(iprot)
7336 
    iprot.readMessageEnd()
7337 
    result = changeItemStatus_result()
7338 
    try:
7339 
      self._handler.changeItemStatus(args.item_id, args.timestamp, args.newstatus)
7340 
    except CatalogServiceException, cex:
7341 
      result.cex = cex
7342 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
7343 
    result.write(oprot)
7344 
    oprot.writeMessageEnd()
7345 
    oprot.trans.flush()
7346 
 
7347 
  def process_getItem(self, seqid, iprot, oprot):
7348 
    args = getItem_args()
7349 
    args.read(iprot)
7350 
    iprot.readMessageEnd()
7351 
    result = getItem_result()
7352 
    try:
7353 
      result.success = self._handler.getItem(args.item_id)
7354 
    except CatalogServiceException, cex:
7355 
      result.cex = cex
7356 
    oprot.writeMessageBegin("getItem", TMessageType.REPLY, seqid)
7357 
    result.write(oprot)
7358 
    oprot.writeMessageEnd()
7359 
    oprot.trans.flush()
7360 
 
13493 amit.gupta 7361 
  def process_getItems(self, seqid, iprot, oprot):
7362 
    args = getItems_args()
7363 
    args.read(iprot)
7364 
    iprot.readMessageEnd()
7365 
    result = getItems_result()
7366 
    try:
7367 
      result.success = self._handler.getItems(args.item_ids)
7368 
    except CatalogServiceException, cex:
7369 
      result.cex = cex
7370 
    oprot.writeMessageBegin("getItems", TMessageType.REPLY, seqid)
7371 
    result.write(oprot)
7372 
    oprot.writeMessageEnd()
7373 
    oprot.trans.flush()
7374 
 
5944 mandeep.dh 7375 
  def process_getItemsByCatalogId(self, seqid, iprot, oprot):
7376 
    args = getItemsByCatalogId_args()
7377 
    args.read(iprot)
7378 
    iprot.readMessageEnd()
7379 
    result = getItemsByCatalogId_result()
7380 
    try:
7381 
      result.success = self._handler.getItemsByCatalogId(args.catalog_item_id)
7382 
    except CatalogServiceException, cex:
7383 
      result.cex = cex
7384 
    oprot.writeMessageBegin("getItemsByCatalogId", TMessageType.REPLY, seqid)
7385 
    result.write(oprot)
7386 
    oprot.writeMessageEnd()
7387 
    oprot.trans.flush()
7388 
 
7389 
  def process_getValidItemsByCatalogId(self, seqid, iprot, oprot):
7390 
    args = getValidItemsByCatalogId_args()
7391 
    args.read(iprot)
7392 
    iprot.readMessageEnd()
7393 
    result = getValidItemsByCatalogId_result()
7394 
    try:
7395 
      result.success = self._handler.getValidItemsByCatalogId(args.catalog_item_id)
7396 
    except CatalogServiceException, cex:
7397 
      result.cex = cex
7398 
    oprot.writeMessageBegin("getValidItemsByCatalogId", TMessageType.REPLY, seqid)
7399 
    result.write(oprot)
7400 
    oprot.writeMessageEnd()
7401 
    oprot.trans.flush()
7402 
 
7403 
  def process_getAllItems(self, seqid, iprot, oprot):
7404 
    args = getAllItems_args()
7405 
    args.read(iprot)
7406 
    iprot.readMessageEnd()
7407 
    result = getAllItems_result()
7408 
    try:
7409 
      result.success = self._handler.getAllItems(args.isActive)
7410 
    except CatalogServiceException, cex:
7411 
      result.cex = cex
7412 
    oprot.writeMessageBegin("getAllItems", TMessageType.REPLY, seqid)
7413 
    result.write(oprot)
7414 
    oprot.writeMessageEnd()
7415 
    oprot.trans.flush()
7416 
 
7417 
  def process_getAllItemsByStatus(self, seqid, iprot, oprot):
7418 
    args = getAllItemsByStatus_args()
7419 
    args.read(iprot)
7420 
    iprot.readMessageEnd()
7421 
    result = getAllItemsByStatus_result()
7422 
    try:
7423 
      result.success = self._handler.getAllItemsByStatus(args.itemStatus)
7424 
    except CatalogServiceException, cex:
7425 
      result.cex = cex
7426 
    oprot.writeMessageBegin("getAllItemsByStatus", TMessageType.REPLY, seqid)
7427 
    result.write(oprot)
7428 
    oprot.writeMessageEnd()
7429 
    oprot.trans.flush()
7430 
 
7431 
  def process_markItemAsContentComplete(self, seqid, iprot, oprot):
7432 
    args = markItemAsContentComplete_args()
7433 
    args.read(iprot)
7434 
    iprot.readMessageEnd()
7435 
    result = markItemAsContentComplete_result()
7436 
    try:
9253 rajveer 7437 
      result.success = self._handler.markItemAsContentComplete(args.entityId, args.category, args.brand, args.modelName, args.modelNumber, args.isAndroid)
5944 mandeep.dh 7438 
    except CatalogServiceException, cex:
7439 
      result.cex = cex
7440 
    oprot.writeMessageBegin("markItemAsContentComplete", TMessageType.REPLY, seqid)
7441 
    result.write(oprot)
7442 
    oprot.writeMessageEnd()
7443 
    oprot.trans.flush()
7444 
 
12567 amit.gupta 7445 
  def process_getVatRates(self, seqid, iprot, oprot):
7446 
    args = getVatRates_args()
7447 
    args.read(iprot)
7448 
    iprot.readMessageEnd()
7449 
    result = getVatRates_result()
7450 
    try:
7451 
      result.success = self._handler.getVatRates(args.itemId, args.categoryId)
7452 
    except CatalogServiceException, cex:
7453 
      result.cex = cex
7454 
    oprot.writeMessageBegin("getVatRates", TMessageType.REPLY, seqid)
7455 
    result.write(oprot)
7456 
    oprot.writeMessageEnd()
7457 
    oprot.trans.flush()
7458 
 
5944 mandeep.dh 7459 
  def process_getAllItemsInRange(self, seqid, iprot, oprot):
7460 
    args = getAllItemsInRange_args()
7461 
    args.read(iprot)
7462 
    iprot.readMessageEnd()
7463 
    result = getAllItemsInRange_result()
7464 
    try:
7465 
      result.success = self._handler.getAllItemsInRange(args.offset, args.limit)
7466 
    except CatalogServiceException, cex:
7467 
      result.cex = cex
7468 
    oprot.writeMessageBegin("getAllItemsInRange", TMessageType.REPLY, seqid)
7469 
    result.write(oprot)
7470 
    oprot.writeMessageEnd()
7471 
    oprot.trans.flush()
7472 
 
7473 
  def process_getAllItemsByStatusInRange(self, seqid, iprot, oprot):
7474 
    args = getAllItemsByStatusInRange_args()
7475 
    args.read(iprot)
7476 
    iprot.readMessageEnd()
7477 
    result = getAllItemsByStatusInRange_result()
7478 
    try:
7479 
      result.success = self._handler.getAllItemsByStatusInRange(args.itemStatus, args.offset, args.limit)
7480 
    except CatalogServiceException, cex:
7481 
      result.cex = cex
7482 
    oprot.writeMessageBegin("getAllItemsByStatusInRange", TMessageType.REPLY, seqid)
7483 
    result.write(oprot)
7484 
    oprot.writeMessageEnd()
7485 
    oprot.trans.flush()
7486 
 
7487 
  def process_getItemCountByStatus(self, seqid, iprot, oprot):
7488 
    args = getItemCountByStatus_args()
7489 
    args.read(iprot)
7490 
    iprot.readMessageEnd()
7491 
    result = getItemCountByStatus_result()
7492 
    result.success = self._handler.getItemCountByStatus(args.useStatus, args.itemStatus)
7493 
    oprot.writeMessageBegin("getItemCountByStatus", TMessageType.REPLY, seqid)
7494 
    result.write(oprot)
7495 
    oprot.writeMessageEnd()
7496 
    oprot.trans.flush()
7497 
 
7498 
  def process_getBestSellers(self, seqid, iprot, oprot):
7499 
    args = getBestSellers_args()
7500 
    args.read(iprot)
7501 
    iprot.readMessageEnd()
7502 
    result = getBestSellers_result()
7503 
    try:
7504 
      result.success = self._handler.getBestSellers()
7505 
    except CatalogServiceException, isex:
7506 
      result.isex = isex
7507 
    oprot.writeMessageBegin("getBestSellers", TMessageType.REPLY, seqid)
7508 
    result.write(oprot)
7509 
    oprot.writeMessageEnd()
7510 
    oprot.trans.flush()
7511 
 
7512 
  def process_getBestSellersCatalogIds(self, seqid, iprot, oprot):
7513 
    args = getBestSellersCatalogIds_args()
7514 
    args.read(iprot)
7515 
    iprot.readMessageEnd()
7516 
    result = getBestSellersCatalogIds_result()
7517 
    try:
7518 
      result.success = self._handler.getBestSellersCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
7519 
    except CatalogServiceException, cex:
7520 
      result.cex = cex
7521 
    oprot.writeMessageBegin("getBestSellersCatalogIds", TMessageType.REPLY, seqid)
7522 
    result.write(oprot)
7523 
    oprot.writeMessageEnd()
7524 
    oprot.trans.flush()
7525 
 
7526 
  def process_getBestSellersCount(self, seqid, iprot, oprot):
7527 
    args = getBestSellersCount_args()
7528 
    args.read(iprot)
7529 
    iprot.readMessageEnd()
7530 
    result = getBestSellersCount_result()
7531 
    try:
7532 
      result.success = self._handler.getBestSellersCount()
7533 
    except CatalogServiceException, cex:
7534 
      result.cex = cex
7535 
    oprot.writeMessageBegin("getBestSellersCount", TMessageType.REPLY, seqid)
7536 
    result.write(oprot)
7537 
    oprot.writeMessageEnd()
7538 
    oprot.trans.flush()
7539 
 
7540 
  def process_getBestDeals(self, seqid, iprot, oprot):
7541 
    args = getBestDeals_args()
7542 
    args.read(iprot)
7543 
    iprot.readMessageEnd()
7544 
    result = getBestDeals_result()
7545 
    try:
7546 
      result.success = self._handler.getBestDeals()
7547 
    except CatalogServiceException, isex:
7548 
      result.isex = isex
7549 
    oprot.writeMessageBegin("getBestDeals", TMessageType.REPLY, seqid)
7550 
    result.write(oprot)
7551 
    oprot.writeMessageEnd()
7552 
    oprot.trans.flush()
7553 
 
7554 
  def process_getBestDealsCatalogIds(self, seqid, iprot, oprot):
7555 
    args = getBestDealsCatalogIds_args()
7556 
    args.read(iprot)
7557 
    iprot.readMessageEnd()
7558 
    result = getBestDealsCatalogIds_result()
7559 
    try:
7560 
      result.success = self._handler.getBestDealsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
7561 
    except CatalogServiceException, cex:
7562 
      result.cex = cex
7563 
    oprot.writeMessageBegin("getBestDealsCatalogIds", TMessageType.REPLY, seqid)
7564 
    result.write(oprot)
7565 
    oprot.writeMessageEnd()
7566 
    oprot.trans.flush()
7567 
 
7568 
  def process_getBestDealsCount(self, seqid, iprot, oprot):
7569 
    args = getBestDealsCount_args()
7570 
    args.read(iprot)
7571 
    iprot.readMessageEnd()
7572 
    result = getBestDealsCount_result()
7573 
    try:
7574 
      result.success = self._handler.getBestDealsCount()
7575 
    except CatalogServiceException, cex:
7576 
      result.cex = cex
7577 
    oprot.writeMessageBegin("getBestDealsCount", TMessageType.REPLY, seqid)
7578 
    result.write(oprot)
7579 
    oprot.writeMessageEnd()
7580 
    oprot.trans.flush()
7581 
 
7582 
  def process_getComingSoon(self, seqid, iprot, oprot):
7583 
    args = getComingSoon_args()
7584 
    args.read(iprot)
7585 
    iprot.readMessageEnd()
7586 
    result = getComingSoon_result()
7587 
    try:
7588 
      result.success = self._handler.getComingSoon()
7589 
    except CatalogServiceException, isex:
7590 
      result.isex = isex
7591 
    oprot.writeMessageBegin("getComingSoon", TMessageType.REPLY, seqid)
7592 
    result.write(oprot)
7593 
    oprot.writeMessageEnd()
7594 
    oprot.trans.flush()
7595 
 
7596 
  def process_getComingSoonCatalogIds(self, seqid, iprot, oprot):
7597 
    args = getComingSoonCatalogIds_args()
7598 
    args.read(iprot)
7599 
    iprot.readMessageEnd()
7600 
    result = getComingSoonCatalogIds_result()
7601 
    try:
7602 
      result.success = self._handler.getComingSoonCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
7603 
    except CatalogServiceException, cex:
7604 
      result.cex = cex
7605 
    oprot.writeMessageBegin("getComingSoonCatalogIds", TMessageType.REPLY, seqid)
7606 
    result.write(oprot)
7607 
    oprot.writeMessageEnd()
7608 
    oprot.trans.flush()
7609 
 
7610 
  def process_getComingSoonCount(self, seqid, iprot, oprot):
7611 
    args = getComingSoonCount_args()
7612 
    args.read(iprot)
7613 
    iprot.readMessageEnd()
7614 
    result = getComingSoonCount_result()
7615 
    try:
7616 
      result.success = self._handler.getComingSoonCount()
7617 
    except CatalogServiceException, cex:
7618 
      result.cex = cex
7619 
    oprot.writeMessageBegin("getComingSoonCount", TMessageType.REPLY, seqid)
7620 
    result.write(oprot)
7621 
    oprot.writeMessageEnd()
7622 
    oprot.trans.flush()
7623 
 
7624 
  def process_getLatestArrivals(self, seqid, iprot, oprot):
7625 
    args = getLatestArrivals_args()
7626 
    args.read(iprot)
7627 
    iprot.readMessageEnd()
7628 
    result = getLatestArrivals_result()
7629 
    try:
7630 
      result.success = self._handler.getLatestArrivals()
7631 
    except CatalogServiceException, isex:
7632 
      result.isex = isex
7633 
    oprot.writeMessageBegin("getLatestArrivals", TMessageType.REPLY, seqid)
7634 
    result.write(oprot)
7635 
    oprot.writeMessageEnd()
7636 
    oprot.trans.flush()
7637 
 
7638 
  def process_getLatestArrivalsCatalogIds(self, seqid, iprot, oprot):
7639 
    args = getLatestArrivalsCatalogIds_args()
7640 
    args.read(iprot)
7641 
    iprot.readMessageEnd()
7642 
    result = getLatestArrivalsCatalogIds_result()
7643 
    try:
7644 
      result.success = self._handler.getLatestArrivalsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.categories)
7645 
    except CatalogServiceException, cex:
7646 
      result.cex = cex
7647 
    oprot.writeMessageBegin("getLatestArrivalsCatalogIds", TMessageType.REPLY, seqid)
7648 
    result.write(oprot)
7649 
    oprot.writeMessageEnd()
7650 
    oprot.trans.flush()
7651 
 
7652 
  def process_getLatestArrivalsCount(self, seqid, iprot, oprot):
7653 
    args = getLatestArrivalsCount_args()
7654 
    args.read(iprot)
7655 
    iprot.readMessageEnd()
7656 
    result = getLatestArrivalsCount_result()
7657 
    try:
7658 
      result.success = self._handler.getLatestArrivalsCount()
7659 
    except CatalogServiceException, cex:
7660 
      result.cex = cex
7661 
    oprot.writeMessageBegin("getLatestArrivalsCount", TMessageType.REPLY, seqid)
7662 
    result.write(oprot)
7663 
    oprot.writeMessageEnd()
7664 
    oprot.trans.flush()
7665 
 
7666 
  def process_generateNewEntityID(self, seqid, iprot, oprot):
7667 
    args = generateNewEntityID_args()
7668 
    args.read(iprot)
7669 
    iprot.readMessageEnd()
7670 
    result = generateNewEntityID_result()
7671 
    result.success = self._handler.generateNewEntityID()
7672 
    oprot.writeMessageBegin("generateNewEntityID", TMessageType.REPLY, seqid)
7673 
    result.write(oprot)
7674 
    oprot.writeMessageEnd()
7675 
    oprot.trans.flush()
7676 
 
7677 
  def process_addCategory(self, seqid, iprot, oprot):
7678 
    args = addCategory_args()
7679 
    args.read(iprot)
7680 
    iprot.readMessageEnd()
7681 
    result = addCategory_result()
7682 
    result.success = self._handler.addCategory(args.category)
7683 
    oprot.writeMessageBegin("addCategory", TMessageType.REPLY, seqid)
7684 
    result.write(oprot)
7685 
    oprot.writeMessageEnd()
7686 
    oprot.trans.flush()
7687 
 
7688 
  def process_getCategory(self, seqid, iprot, oprot):
7689 
    args = getCategory_args()
7690 
    args.read(iprot)
7691 
    iprot.readMessageEnd()
7692 
    result = getCategory_result()
7693 
    result.success = self._handler.getCategory(args.id)
7694 
    oprot.writeMessageBegin("getCategory", TMessageType.REPLY, seqid)
7695 
    result.write(oprot)
7696 
    oprot.writeMessageEnd()
7697 
    oprot.trans.flush()
7698 
 
7699 
  def process_getAllCategories(self, seqid, iprot, oprot):
7700 
    args = getAllCategories_args()
7701 
    args.read(iprot)
7702 
    iprot.readMessageEnd()
7703 
    result = getAllCategories_result()
7704 
    result.success = self._handler.getAllCategories()
7705 
    oprot.writeMessageBegin("getAllCategories", TMessageType.REPLY, seqid)
7706 
    result.write(oprot)
7707 
    oprot.writeMessageEnd()
7708 
    oprot.trans.flush()
7709 
 
7710 
  def process_getAllSimilarItems(self, seqid, iprot, oprot):
7711 
    args = getAllSimilarItems_args()
7712 
    args.read(iprot)
7713 
    iprot.readMessageEnd()
7714 
    result = getAllSimilarItems_result()
7715 
    result.success = self._handler.getAllSimilarItems(args.itemId)
7716 
    oprot.writeMessageBegin("getAllSimilarItems", TMessageType.REPLY, seqid)
7717 
    result.write(oprot)
7718 
    oprot.writeMessageEnd()
7719 
    oprot.trans.flush()
7720 
 
7721 
  def process_addSimilarItem(self, seqid, iprot, oprot):
7722 
    args = addSimilarItem_args()
7723 
    args.read(iprot)
7724 
    iprot.readMessageEnd()
7725 
    result = addSimilarItem_result()
7726 
    try:
7727 
      result.success = self._handler.addSimilarItem(args.itemId, args.catalogItemId)
7728 
    except CatalogServiceException, cex:
7729 
      result.cex = cex
7730 
    oprot.writeMessageBegin("addSimilarItem", TMessageType.REPLY, seqid)
7731 
    result.write(oprot)
7732 
    oprot.writeMessageEnd()
7733 
    oprot.trans.flush()
7734 
 
6512 kshitij.so 7735 
  def process_addTag(self, seqid, iprot, oprot):
7736 
    args = addTag_args()
7737 
    args.read(iprot)
7738 
    iprot.readMessageEnd()
7739 
    result = addTag_result()
7740 
    result.success = self._handler.addTag(args.displayName, args.itemId)
7741 
    oprot.writeMessageBegin("addTag", TMessageType.REPLY, seqid)
7742 
    result.write(oprot)
7743 
    oprot.writeMessageEnd()
7744 
    oprot.trans.flush()
7745 
 
7746 
  def process_deleteEntityTag(self, seqid, iprot, oprot):
7747 
    args = deleteEntityTag_args()
7748 
    args.read(iprot)
7749 
    iprot.readMessageEnd()
7750 
    result = deleteEntityTag_result()
7751 
    result.success = self._handler.deleteEntityTag(args.displayName, args.itemId)
7752 
    oprot.writeMessageBegin("deleteEntityTag", TMessageType.REPLY, seqid)
7753 
    result.write(oprot)
7754 
    oprot.writeMessageEnd()
7755 
    oprot.trans.flush()
7756 
 
7757 
  def process_deleteTag(self, seqid, iprot, oprot):
7758 
    args = deleteTag_args()
7759 
    args.read(iprot)
7760 
    iprot.readMessageEnd()
7761 
    result = deleteTag_result()
7762 
    result.success = self._handler.deleteTag(args.displayName)
7763 
    oprot.writeMessageBegin("deleteTag", TMessageType.REPLY, seqid)
7764 
    result.write(oprot)
7765 
    oprot.writeMessageEnd()
7766 
    oprot.trans.flush()
7767 
 
7768 
  def process_getAllTags(self, seqid, iprot, oprot):
7769 
    args = getAllTags_args()
7770 
    args.read(iprot)
7771 
    iprot.readMessageEnd()
7772 
    result = getAllTags_result()
7773 
    result.success = self._handler.getAllTags()
7774 
    oprot.writeMessageBegin("getAllTags", TMessageType.REPLY, seqid)
7775 
    result.write(oprot)
7776 
    oprot.writeMessageEnd()
7777 
    oprot.trans.flush()
7778 
 
7779 
  def process_getAllEntitiesByTagName(self, seqid, iprot, oprot):
7780 
    args = getAllEntitiesByTagName_args()
7781 
    args.read(iprot)
7782 
    iprot.readMessageEnd()
7783 
    result = getAllEntitiesByTagName_result()
7784 
    result.success = self._handler.getAllEntitiesByTagName(args.displayName)
7785 
    oprot.writeMessageBegin("getAllEntitiesByTagName", TMessageType.REPLY, seqid)
7786 
    result.write(oprot)
7787 
    oprot.writeMessageEnd()
7788 
    oprot.trans.flush()
7789 
 
6845 amit.gupta 7790 
  def process_getAllEntityTags(self, seqid, iprot, oprot):
7791 
    args = getAllEntityTags_args()
7792 
    args.read(iprot)
7793 
    iprot.readMessageEnd()
7794 
    result = getAllEntityTags_result()
7795 
    result.success = self._handler.getAllEntityTags()
7796 
    oprot.writeMessageBegin("getAllEntityTags", TMessageType.REPLY, seqid)
7797 
    result.write(oprot)
7798 
    oprot.writeMessageEnd()
7799 
    oprot.trans.flush()
7800 
 
6850 kshitij.so 7801 
  def process_addBanner(self, seqid, iprot, oprot):
7802 
    args = addBanner_args()
7803 
    args.read(iprot)
7804 
    iprot.readMessageEnd()
7805 
    result = addBanner_result()
10097 kshitij.so 7806 
    result.success = self._handler.addBanner(args.bannerCongregate)
6850 kshitij.so 7807 
    oprot.writeMessageBegin("addBanner", TMessageType.REPLY, seqid)
7808 
    result.write(oprot)
7809 
    oprot.writeMessageEnd()
7810 
    oprot.trans.flush()
7811 
 
8579 kshitij.so 7812 
  def process_updateBanner(self, seqid, iprot, oprot):
7813 
    args = updateBanner_args()
7814 
    args.read(iprot)
7815 
    iprot.readMessageEnd()
7816 
    result = updateBanner_result()
7817 
    result.success = self._handler.updateBanner(args.banner)
7818 
    oprot.writeMessageBegin("updateBanner", TMessageType.REPLY, seqid)
7819 
    result.write(oprot)
7820 
    oprot.writeMessageEnd()
7821 
    oprot.trans.flush()
7822 
 
6850 kshitij.so 7823 
  def process_getAllBanners(self, seqid, iprot, oprot):
7824 
    args = getAllBanners_args()
7825 
    args.read(iprot)
7826 
    iprot.readMessageEnd()
7827 
    result = getAllBanners_result()
7828 
    result.success = self._handler.getAllBanners()
7829 
    oprot.writeMessageBegin("getAllBanners", TMessageType.REPLY, seqid)
7830 
    result.write(oprot)
7831 
    oprot.writeMessageEnd()
7832 
    oprot.trans.flush()
7833 
 
7834 
  def process_deleteBanner(self, seqid, iprot, oprot):
7835 
    args = deleteBanner_args()
7836 
    args.read(iprot)
7837 
    iprot.readMessageEnd()
7838 
    result = deleteBanner_result()
9155 kshitij.so 7839 
    result.success = self._handler.deleteBanner(args.bannerName, args.bannerType)
6850 kshitij.so 7840 
    oprot.writeMessageBegin("deleteBanner", TMessageType.REPLY, seqid)
7841 
    result.write(oprot)
7842 
    oprot.writeMessageEnd()
7843 
    oprot.trans.flush()
7844 
 
7845 
  def process_getBannerDetails(self, seqid, iprot, oprot):
7846 
    args = getBannerDetails_args()
7847 
    args.read(iprot)
7848 
    iprot.readMessageEnd()
7849 
    result = getBannerDetails_result()
9155 kshitij.so 7850 
    result.success = self._handler.getBannerDetails(args.bannerName, args.bannerType)
6850 kshitij.so 7851 
    oprot.writeMessageBegin("getBannerDetails", TMessageType.REPLY, seqid)
7852 
    result.write(oprot)
7853 
    oprot.writeMessageEnd()
7854 
    oprot.trans.flush()
7855 
 
7856 
  def process_getActiveBanners(self, seqid, iprot, oprot):
7857 
    args = getActiveBanners_args()
7858 
    args.read(iprot)
7859 
    iprot.readMessageEnd()
7860 
    result = getActiveBanners_result()
7861 
    result.success = self._handler.getActiveBanners()
7862 
    oprot.writeMessageBegin("getActiveBanners", TMessageType.REPLY, seqid)
7863 
    result.write(oprot)
7864 
    oprot.writeMessageEnd()
7865 
    oprot.trans.flush()
7866 
 
6849 kshitij.so 7867 
  def process_addBannerMap(self, seqid, iprot, oprot):
7868 
    args = addBannerMap_args()
7869 
    args.read(iprot)
7870 
    iprot.readMessageEnd()
7871 
    result = addBannerMap_result()
8579 kshitij.so 7872 
    result.success = self._handler.addBannerMap(args.bannerMaps)
6849 kshitij.so 7873 
    oprot.writeMessageBegin("addBannerMap", TMessageType.REPLY, seqid)
7874 
    result.write(oprot)
7875 
    oprot.writeMessageEnd()
7876 
    oprot.trans.flush()
7877 
 
8579 kshitij.so 7878 
  def process_updateBannerMap(self, seqid, iprot, oprot):
7879 
    args = updateBannerMap_args()
7880 
    args.read(iprot)
7881 
    iprot.readMessageEnd()
7882 
    result = updateBannerMap_result()
7883 
    result.success = self._handler.updateBannerMap(args.bannerMap)
7884 
    oprot.writeMessageBegin("updateBannerMap", TMessageType.REPLY, seqid)
7885 
    result.write(oprot)
7886 
    oprot.writeMessageEnd()
7887 
    oprot.trans.flush()
7888 
 
6849 kshitij.so 7889 
  def process_deleteBannerMap(self, seqid, iprot, oprot):
7890 
    args = deleteBannerMap_args()
7891 
    args.read(iprot)
7892 
    iprot.readMessageEnd()
7893 
    result = deleteBannerMap_result()
7894 
    result.success = self._handler.deleteBannerMap(args.bannerName)
7895 
    oprot.writeMessageBegin("deleteBannerMap", TMessageType.REPLY, seqid)
7896 
    result.write(oprot)
7897 
    oprot.writeMessageEnd()
7898 
    oprot.trans.flush()
7899 
 
7900 
  def process_getBannerMapDetails(self, seqid, iprot, oprot):
7901 
    args = getBannerMapDetails_args()
7902 
    args.read(iprot)
7903 
    iprot.readMessageEnd()
7904 
    result = getBannerMapDetails_result()
9155 kshitij.so 7905 
    result.success = self._handler.getBannerMapDetails(args.bannerName, args.bannerType)
6849 kshitij.so 7906 
    oprot.writeMessageBegin("getBannerMapDetails", TMessageType.REPLY, seqid)
7907 
    result.write(oprot)
7908 
    oprot.writeMessageEnd()
7909 
    oprot.trans.flush()
7910 
 
8579 kshitij.so 7911 
  def process_addBannerUri(self, seqid, iprot, oprot):
7912 
    args = addBannerUri_args()
7913 
    args.read(iprot)
7914 
    iprot.readMessageEnd()
7915 
    result = addBannerUri_result()
7916 
    self._handler.addBannerUri(args.bannerUriMappings)
7917 
    oprot.writeMessageBegin("addBannerUri", TMessageType.REPLY, seqid)
7918 
    result.write(oprot)
7919 
    oprot.writeMessageEnd()
7920 
    oprot.trans.flush()
7921 
 
7922 
  def process_getUriMapping(self, seqid, iprot, oprot):
7923 
    args = getUriMapping_args()
7924 
    args.read(iprot)
7925 
    iprot.readMessageEnd()
7926 
    result = getUriMapping_result()
9155 kshitij.so 7927 
    result.success = self._handler.getUriMapping(args.bannerName, args.bannerType)
8579 kshitij.so 7928 
    oprot.writeMessageBegin("getUriMapping", TMessageType.REPLY, seqid)
7929 
    result.write(oprot)
7930 
    oprot.writeMessageEnd()
7931 
    oprot.trans.flush()
7932 
 
7933 
  def process_addCampaign(self, seqid, iprot, oprot):
7934 
    args = addCampaign_args()
7935 
    args.read(iprot)
7936 
    iprot.readMessageEnd()
7937 
    result = addCampaign_result()
7938 
    self._handler.addCampaign(args.campaign)
7939 
    oprot.writeMessageBegin("addCampaign", TMessageType.REPLY, seqid)
7940 
    result.write(oprot)
7941 
    oprot.writeMessageEnd()
7942 
    oprot.trans.flush()
7943 
 
7944 
  def process_getCampaigns(self, seqid, iprot, oprot):
7945 
    args = getCampaigns_args()
7946 
    args.read(iprot)
7947 
    iprot.readMessageEnd()
7948 
    result = getCampaigns_result()
7949 
    result.success = self._handler.getCampaigns(args.campaignName)
7950 
    oprot.writeMessageBegin("getCampaigns", TMessageType.REPLY, seqid)
7951 
    result.write(oprot)
7952 
    oprot.writeMessageEnd()
7953 
    oprot.trans.flush()
7954 
 
7955 
  def process_deleteCampaign(self, seqid, iprot, oprot):
7956 
    args = deleteCampaign_args()
7957 
    args.read(iprot)
7958 
    iprot.readMessageEnd()
7959 
    result = deleteCampaign_result()
7960 
    self._handler.deleteCampaign(args.campaignId)
7961 
    oprot.writeMessageBegin("deleteCampaign", TMessageType.REPLY, seqid)
7962 
    result.write(oprot)
7963 
    oprot.writeMessageEnd()
7964 
    oprot.trans.flush()
7965 
 
7966 
  def process_getAllCampaigns(self, seqid, iprot, oprot):
7967 
    args = getAllCampaigns_args()
7968 
    args.read(iprot)
7969 
    iprot.readMessageEnd()
7970 
    result = getAllCampaigns_result()
7971 
    result.success = self._handler.getAllCampaigns()
7972 
    oprot.writeMessageBegin("getAllCampaigns", TMessageType.REPLY, seqid)
7973 
    result.write(oprot)
7974 
    oprot.writeMessageEnd()
7975 
    oprot.trans.flush()
7976 
 
9155 kshitij.so 7977 
  def process_getActiveBannersForMobileSite(self, seqid, iprot, oprot):
7978 
    args = getActiveBannersForMobileSite_args()
7979 
    args.read(iprot)
7980 
    iprot.readMessageEnd()
7981 
    result = getActiveBannersForMobileSite_result()
7982 
    result.success = self._handler.getActiveBannersForMobileSite()
7983 
    oprot.writeMessageBegin("getActiveBannersForMobileSite", TMessageType.REPLY, seqid)
7984 
    result.write(oprot)
7985 
    oprot.writeMessageEnd()
7986 
    oprot.trans.flush()
7987 
 
5944 mandeep.dh 7988 
  def process_deleteSimilarItem(self, seqid, iprot, oprot):
7989 
    args = deleteSimilarItem_args()
7990 
    args.read(iprot)
7991 
    iprot.readMessageEnd()
7992 
    result = deleteSimilarItem_result()
7993 
    try:
7994 
      result.success = self._handler.deleteSimilarItem(args.itemId, args.catalogItemId)
7995 
    except CatalogServiceException, cex:
7996 
      result.cex = cex
7997 
    oprot.writeMessageBegin("deleteSimilarItem", TMessageType.REPLY, seqid)
7998 
    result.write(oprot)
7999 
    oprot.writeMessageEnd()
8000 
    oprot.trans.flush()
8001 
 
8002 
  def process_checkSimilarItem(self, seqid, iprot, oprot):
8003 
    args = checkSimilarItem_args()
8004 
    args.read(iprot)
8005 
    iprot.readMessageEnd()
8006 
    result = checkSimilarItem_result()
8007 
    result.success = self._handler.checkSimilarItem(args.brand, args.modelNumber, args.modelName, args.color)
8008 
    oprot.writeMessageBegin("checkSimilarItem", TMessageType.REPLY, seqid)
8009 
    result.write(oprot)
8010 
    oprot.writeMessageEnd()
8011 
    oprot.trans.flush()
8012 
 
8013 
  def process_validateRiskyStatus(self, seqid, iprot, oprot):
8014 
    args = validateRiskyStatus_args()
8015 
    args.read(iprot)
8016 
    iprot.readMessageEnd()
8017 
    result = validateRiskyStatus_result()
8018 
    self._handler.validateRiskyStatus(args.itemId)
8019 
    oprot.writeMessageBegin("validateRiskyStatus", TMessageType.REPLY, seqid)
8020 
    result.write(oprot)
8021 
    oprot.writeMessageEnd()
8022 
    oprot.trans.flush()
8023 
 
8024 
  def process_changeItemRiskyFlag(self, seqid, iprot, oprot):
8025 
    args = changeItemRiskyFlag_args()
8026 
    args.read(iprot)
8027 
    iprot.readMessageEnd()
8028 
    result = changeItemRiskyFlag_result()
8029 
    self._handler.changeItemRiskyFlag(args.itemId, args.risky)
8030 
    oprot.writeMessageBegin("changeItemRiskyFlag", TMessageType.REPLY, seqid)
8031 
    result.write(oprot)
8032 
    oprot.writeMessageEnd()
8033 
    oprot.trans.flush()
8034 
 
8035 
  def process_getItemsByRiskyFlag(self, seqid, iprot, oprot):
8036 
    args = getItemsByRiskyFlag_args()
8037 
    args.read(iprot)
8038 
    iprot.readMessageEnd()
8039 
    result = getItemsByRiskyFlag_result()
8040 
    result.success = self._handler.getItemsByRiskyFlag()
8041 
    oprot.writeMessageBegin("getItemsByRiskyFlag", TMessageType.REPLY, seqid)
8042 
    result.write(oprot)
8043 
    oprot.writeMessageEnd()
8044 
    oprot.trans.flush()
8045 
 
8046 
  def process_getItemsForMasterSheet(self, seqid, iprot, oprot):
8047 
    args = getItemsForMasterSheet_args()
8048 
    args.read(iprot)
8049 
    iprot.readMessageEnd()
8050 
    result = getItemsForMasterSheet_result()
8051 
    result.success = self._handler.getItemsForMasterSheet(args.category, args.brand)
8052 
    oprot.writeMessageBegin("getItemsForMasterSheet", TMessageType.REPLY, seqid)
8053 
    result.write(oprot)
8054 
    oprot.writeMessageEnd()
8055 
    oprot.trans.flush()
8056 
 
8057 
  def process_getSimilarItemsCatalogIds(self, seqid, iprot, oprot):
8058 
    args = getSimilarItemsCatalogIds_args()
8059 
    args.read(iprot)
8060 
    iprot.readMessageEnd()
8061 
    result = getSimilarItemsCatalogIds_result()
8062 
    result.success = self._handler.getSimilarItemsCatalogIds(args.beginIndex, args.totalItems, args.itemId)
8063 
    oprot.writeMessageBegin("getSimilarItemsCatalogIds", TMessageType.REPLY, seqid)
8064 
    result.write(oprot)
8065 
    oprot.writeMessageEnd()
8066 
    oprot.trans.flush()
8067 
 
8068 
  def process_addProductNotification(self, seqid, iprot, oprot):
8069 
    args = addProductNotification_args()
8070 
    args.read(iprot)
8071 
    iprot.readMessageEnd()
8072 
    result = addProductNotification_result()
8073 
    result.success = self._handler.addProductNotification(args.itemId, args.email)
8074 
    oprot.writeMessageBegin("addProductNotification", TMessageType.REPLY, seqid)
8075 
    result.write(oprot)
8076 
    oprot.writeMessageEnd()
8077 
    oprot.trans.flush()
8078 
 
8079 
  def process_sendProductNotifications(self, seqid, iprot, oprot):
8080 
    args = sendProductNotifications_args()
8081 
    args.read(iprot)
8082 
    iprot.readMessageEnd()
8083 
    result = sendProductNotifications_result()
8084 
    result.success = self._handler.sendProductNotifications()
8085 
    oprot.writeMessageBegin("sendProductNotifications", TMessageType.REPLY, seqid)
8086 
    result.write(oprot)
8087 
    oprot.writeMessageEnd()
8088 
    oprot.trans.flush()
8089 
 
8090 
  def process_getAllBrandsByCategory(self, seqid, iprot, oprot):
8091 
    args = getAllBrandsByCategory_args()
8092 
    args.read(iprot)
8093 
    iprot.readMessageEnd()
8094 
    result = getAllBrandsByCategory_result()
8095 
    result.success = self._handler.getAllBrandsByCategory(args.categoryId)
8096 
    oprot.writeMessageBegin("getAllBrandsByCategory", TMessageType.REPLY, seqid)
8097 
    result.write(oprot)
8098 
    oprot.writeMessageEnd()
8099 
    oprot.trans.flush()
8100 
 
8101 
  def process_getAllBrands(self, seqid, iprot, oprot):
8102 
    args = getAllBrands_args()
8103 
    args.read(iprot)
8104 
    iprot.readMessageEnd()
8105 
    result = getAllBrands_result()
8106 
    result.success = self._handler.getAllBrands()
8107 
    oprot.writeMessageBegin("getAllBrands", TMessageType.REPLY, seqid)
8108 
    result.write(oprot)
8109 
    oprot.writeMessageEnd()
8110 
    oprot.trans.flush()
8111 
 
8112 
  def process_getAllSources(self, seqid, iprot, oprot):
8113 
    args = getAllSources_args()
8114 
    args.read(iprot)
8115 
    iprot.readMessageEnd()
8116 
    result = getAllSources_result()
8117 
    result.success = self._handler.getAllSources()
8118 
    oprot.writeMessageBegin("getAllSources", TMessageType.REPLY, seqid)
8119 
    result.write(oprot)
8120 
    oprot.writeMessageEnd()
8121 
    oprot.trans.flush()
8122 
 
8123 
  def process_getItemPricingBySource(self, seqid, iprot, oprot):
8124 
    args = getItemPricingBySource_args()
8125 
    args.read(iprot)
8126 
    iprot.readMessageEnd()
8127 
    result = getItemPricingBySource_result()
8128 
    try:
8129 
      result.success = self._handler.getItemPricingBySource(args.itemId, args.sourceId)
8130 
    except CatalogServiceException, cex:
8131 
      result.cex = cex
8132 
    oprot.writeMessageBegin("getItemPricingBySource", TMessageType.REPLY, seqid)
8133 
    result.write(oprot)
8134 
    oprot.writeMessageEnd()
8135 
    oprot.trans.flush()
8136 
 
8137 
  def process_addSourceItemPricing(self, seqid, iprot, oprot):
8138 
    args = addSourceItemPricing_args()
8139 
    args.read(iprot)
8140 
    iprot.readMessageEnd()
8141 
    result = addSourceItemPricing_result()
8142 
    try:
8143 
      self._handler.addSourceItemPricing(args.sourceItemPricing)
8144 
    except CatalogServiceException, cex:
8145 
      result.cex = cex
8146 
    oprot.writeMessageBegin("addSourceItemPricing", TMessageType.REPLY, seqid)
8147 
    result.write(oprot)
8148 
    oprot.writeMessageEnd()
8149 
    oprot.trans.flush()
8150 
 
8151 
  def process_getAllSourcePricing(self, seqid, iprot, oprot):
8152 
    args = getAllSourcePricing_args()
8153 
    args.read(iprot)
8154 
    iprot.readMessageEnd()
8155 
    result = getAllSourcePricing_result()
8156 
    try:
8157 
      result.success = self._handler.getAllSourcePricing(args.itemId)
8158 
    except CatalogServiceException, cex:
8159 
      result.cex = cex
8160 
    oprot.writeMessageBegin("getAllSourcePricing", TMessageType.REPLY, seqid)
8161 
    result.write(oprot)
8162 
    oprot.writeMessageEnd()
8163 
    oprot.trans.flush()
8164 
 
8165 
  def process_getItemForSource(self, seqid, iprot, oprot):
8166 
    args = getItemForSource_args()
8167 
    args.read(iprot)
8168 
    iprot.readMessageEnd()
8169 
    result = getItemForSource_result()
8170 
    try:
8171 
      result.success = self._handler.getItemForSource(args.item_id, args.sourceId)
8172 
    except CatalogServiceException, cex:
8173 
      result.cex = cex
8174 
    oprot.writeMessageBegin("getItemForSource", TMessageType.REPLY, seqid)
8175 
    result.write(oprot)
8176 
    oprot.writeMessageEnd()
8177 
    oprot.trans.flush()
8178 
 
8179 
  def process_searchItemsInRange(self, seqid, iprot, oprot):
8180 
    args = searchItemsInRange_args()
8181 
    args.read(iprot)
8182 
    iprot.readMessageEnd()
8183 
    result = searchItemsInRange_result()
8184 
    result.success = self._handler.searchItemsInRange(args.searchTerms, args.offset, args.limit)
8185 
    oprot.writeMessageBegin("searchItemsInRange", TMessageType.REPLY, seqid)
8186 
    result.write(oprot)
8187 
    oprot.writeMessageEnd()
8188 
    oprot.trans.flush()
8189 
 
8190 
  def process_getSearchResultCount(self, seqid, iprot, oprot):
8191 
    args = getSearchResultCount_args()
8192 
    args.read(iprot)
8193 
    iprot.readMessageEnd()
8194 
    result = getSearchResultCount_result()
8195 
    result.success = self._handler.getSearchResultCount(args.searchTerms)
8196 
    oprot.writeMessageBegin("getSearchResultCount", TMessageType.REPLY, seqid)
8197 
    result.write(oprot)
8198 
    oprot.writeMessageEnd()
8199 
    oprot.trans.flush()
8200 
 
8201 
  def process_getProductNotifications(self, seqid, iprot, oprot):
8202 
    args = getProductNotifications_args()
8203 
    args.read(iprot)
8204 
    iprot.readMessageEnd()
8205 
    result = getProductNotifications_result()
8206 
    result.success = self._handler.getProductNotifications(args.startDateTime)
8207 
    oprot.writeMessageBegin("getProductNotifications", TMessageType.REPLY, seqid)
8208 
    result.write(oprot)
8209 
    oprot.writeMessageEnd()
8210 
    oprot.trans.flush()
8211 
 
8212 
  def process_getProductNotificationRequestCount(self, seqid, iprot, oprot):
8213 
    args = getProductNotificationRequestCount_args()
8214 
    args.read(iprot)
8215 
    iprot.readMessageEnd()
8216 
    result = getProductNotificationRequestCount_result()
7897 amar.kumar 8217 
    result.success = self._handler.getProductNotificationRequestCount(args.startDateTime, args.categoryId)
5944 mandeep.dh 8218 
    oprot.writeMessageBegin("getProductNotificationRequestCount", TMessageType.REPLY, seqid)
8219 
    result.write(oprot)
8220 
    oprot.writeMessageEnd()
8221 
    oprot.trans.flush()
8222 
 
8223 
  def process_addAuthorizationLog(self, seqid, iprot, oprot):
8224 
    args = addAuthorizationLog_args()
8225 
    args.read(iprot)
8226 
    iprot.readMessageEnd()
8227 
    result = addAuthorizationLog_result()
8228 
    try:
8229 
      result.success = self._handler.addAuthorizationLog(args.itemId, args.username, args.reason)
8230 
    except CatalogServiceException, cex:
8231 
      result.cex = cex
8232 
    oprot.writeMessageBegin("addAuthorizationLog", TMessageType.REPLY, seqid)
8233 
    result.write(oprot)
8234 
    oprot.writeMessageEnd()
8235 
    oprot.trans.flush()
8236 
 
8237 
  def process_addupdateVoucherForItem(self, seqid, iprot, oprot):
8238 
    args = addupdateVoucherForItem_args()
8239 
    args.read(iprot)
8240 
    iprot.readMessageEnd()
8241 
    result = addupdateVoucherForItem_result()
8242 
    try:
8243 
      result.success = self._handler.addupdateVoucherForItem(args.catalog_item_id, args.voucherType, args.voucherAmount)
8244 
    except CatalogServiceException, cex:
8245 
      result.cex = cex
8246 
    oprot.writeMessageBegin("addupdateVoucherForItem", TMessageType.REPLY, seqid)
8247 
    result.write(oprot)
8248 
    oprot.writeMessageEnd()
8249 
    oprot.trans.flush()
8250 
 
8251 
  def process_deleteVoucherForItem(self, seqid, iprot, oprot):
8252 
    args = deleteVoucherForItem_args()
8253 
    args.read(iprot)
8254 
    iprot.readMessageEnd()
8255 
    result = deleteVoucherForItem_result()
8256 
    try:
8257 
      result.success = self._handler.deleteVoucherForItem(args.catalog_item_id, args.voucherType)
8258 
    except CatalogServiceException, cex:
8259 
      result.cex = cex
8260 
    oprot.writeMessageBegin("deleteVoucherForItem", TMessageType.REPLY, seqid)
8261 
    result.write(oprot)
8262 
    oprot.writeMessageEnd()
8263 
    oprot.trans.flush()
8264 
 
8265 
  def process_getVoucherAmount(self, seqid, iprot, oprot):
8266 
    args = getVoucherAmount_args()
8267 
    args.read(iprot)
8268 
    iprot.readMessageEnd()
8269 
    result = getVoucherAmount_result()
8270 
    result.success = self._handler.getVoucherAmount(args.itemId, args.voucherType)
8271 
    oprot.writeMessageBegin("getVoucherAmount", TMessageType.REPLY, seqid)
8272 
    result.write(oprot)
8273 
    oprot.writeMessageEnd()
8274 
    oprot.trans.flush()
8275 
 
8276 
  def process_getAllItemVouchers(self, seqid, iprot, oprot):
8277 
    args = getAllItemVouchers_args()
8278 
    args.read(iprot)
8279 
    iprot.readMessageEnd()
8280 
    result = getAllItemVouchers_result()
8281 
    result.success = self._handler.getAllItemVouchers(args.itemId)
8282 
    oprot.writeMessageBegin("getAllItemVouchers", TMessageType.REPLY, seqid)
8283 
    result.write(oprot)
8284 
    oprot.writeMessageEnd()
8285 
    oprot.trans.flush()
8286 
 
8287 
  def process_isValidCatalogItemId(self, seqid, iprot, oprot):
8288 
    args = isValidCatalogItemId_args()
8289 
    args.read(iprot)
8290 
    iprot.readMessageEnd()
8291 
    result = isValidCatalogItemId_result()
8292 
    result.success = self._handler.isValidCatalogItemId(args.catalog_item_id)
8293 
    oprot.writeMessageBegin("isValidCatalogItemId", TMessageType.REPLY, seqid)
8294 
    result.write(oprot)
8295 
    oprot.writeMessageEnd()
8296 
    oprot.trans.flush()
8297 
 
6039 amit.gupta 8298 
  def process_getVatPercentageForItem(self, seqid, iprot, oprot):
8299 
    args = getVatPercentageForItem_args()
8300 
    args.read(iprot)
8301 
    iprot.readMessageEnd()
8302 
    result = getVatPercentageForItem_result()
7340 amit.gupta 8303 
    try:
8304 
      result.success = self._handler.getVatPercentageForItem(args.itemId, args.stateId, args.price)
8305 
    except CatalogServiceException, cex:
8306 
      result.cex = cex
6039 amit.gupta 8307 
    oprot.writeMessageBegin("getVatPercentageForItem", TMessageType.REPLY, seqid)
8308 
    result.write(oprot)
8309 
    oprot.writeMessageEnd()
8310 
    oprot.trans.flush()
5944 mandeep.dh 8311 
 
6039 amit.gupta 8312 
  def process_getVatAmountForItem(self, seqid, iprot, oprot):
8313 
    args = getVatAmountForItem_args()
8314 
    args.read(iprot)
8315 
    iprot.readMessageEnd()
8316 
    result = getVatAmountForItem_result()
8317 
    result.success = self._handler.getVatAmountForItem(args.itemId, args.price)
8318 
    oprot.writeMessageBegin("getVatAmountForItem", TMessageType.REPLY, seqid)
8319 
    result.write(oprot)
8320 
    oprot.writeMessageEnd()
8321 
    oprot.trans.flush()
8322 
 
6531 vikram.rag 8323 
  def process_getAllIgnoredInventoryUpdateItemsList(self, seqid, iprot, oprot):
8324 
    args = getAllIgnoredInventoryUpdateItemsList_args()
8325 
    args.read(iprot)
8326 
    iprot.readMessageEnd()
8327 
    result = getAllIgnoredInventoryUpdateItemsList_result()
8328 
    result.success = self._handler.getAllIgnoredInventoryUpdateItemsList(args.offset, args.limit)
8329 
    oprot.writeMessageBegin("getAllIgnoredInventoryUpdateItemsList", TMessageType.REPLY, seqid)
8330 
    result.write(oprot)
8331 
    oprot.writeMessageEnd()
8332 
    oprot.trans.flush()
6039 amit.gupta 8333 
 
6821 amar.kumar 8334 
  def process_getAllAliveItems(self, seqid, iprot, oprot):
8335 
    args = getAllAliveItems_args()
8336 
    args.read(iprot)
8337 
    iprot.readMessageEnd()
8338 
    result = getAllAliveItems_result()
8339 
    result.success = self._handler.getAllAliveItems()
8340 
    oprot.writeMessageBegin("getAllAliveItems", TMessageType.REPLY, seqid)
8341 
    result.write(oprot)
8342 
    oprot.writeMessageEnd()
8343 
    oprot.trans.flush()
8344 
 
6805 anupam.sin 8345 
  def process_getInsuranceAmount(self, seqid, iprot, oprot):
8346 
    args = getInsuranceAmount_args()
8347 
    args.read(iprot)
8348 
    iprot.readMessageEnd()
8349 
    result = getInsuranceAmount_result()
6921 anupam.sin 8350 
    result.success = self._handler.getInsuranceAmount(args.itemId, args.price, args.insurerId, args.quantity)
6805 anupam.sin 8351 
    oprot.writeMessageBegin("getInsuranceAmount", TMessageType.REPLY, seqid)
8352 
    result.write(oprot)
8353 
    oprot.writeMessageEnd()
8354 
    oprot.trans.flush()
6531 vikram.rag 8355 
 
6805 anupam.sin 8356 
  def process_getInsurer(self, seqid, iprot, oprot):
8357 
    args = getInsurer_args()
8358 
    args.read(iprot)
8359 
    iprot.readMessageEnd()
8360 
    result = getInsurer_result()
8361 
    result.success = self._handler.getInsurer(args.insurerId)
8362 
    oprot.writeMessageBegin("getInsurer", TMessageType.REPLY, seqid)
8363 
    result.write(oprot)
8364 
    oprot.writeMessageEnd()
8365 
    oprot.trans.flush()
8366 
 
6838 vikram.rag 8367 
  def process_getAllInsurers(self, seqid, iprot, oprot):
8368 
    args = getAllInsurers_args()
8369 
    args.read(iprot)
8370 
    iprot.readMessageEnd()
8371 
    result = getAllInsurers_result()
8372 
    result.success = self._handler.getAllInsurers()
8373 
    oprot.writeMessageBegin("getAllInsurers", TMessageType.REPLY, seqid)
8374 
    result.write(oprot)
8375 
    oprot.writeMessageEnd()
8376 
    oprot.trans.flush()
6805 anupam.sin 8377 
 
6962 rajveer 8378 
  def process_updateInsuranceDeclaredAmount(self, seqid, iprot, oprot):
8379 
    args = updateInsuranceDeclaredAmount_args()
8380 
    args.read(iprot)
8381 
    iprot.readMessageEnd()
8382 
    result = updateInsuranceDeclaredAmount_result()
8383 
    self._handler.updateInsuranceDeclaredAmount(args.insurerId, args.amount)
8384 
    oprot.writeMessageBegin("updateInsuranceDeclaredAmount", TMessageType.REPLY, seqid)
8385 
    result.write(oprot)
8386 
    oprot.writeMessageEnd()
8387 
    oprot.trans.flush()
6838 vikram.rag 8388 
 
7190 amar.kumar 8389 
  def process_getFreebieForItem(self, seqid, iprot, oprot):
8390 
    args = getFreebieForItem_args()
8391 
    args.read(iprot)
8392 
    iprot.readMessageEnd()
8393 
    result = getFreebieForItem_result()
8394 
    result.success = self._handler.getFreebieForItem(args.itemId)
8395 
    oprot.writeMessageBegin("getFreebieForItem", TMessageType.REPLY, seqid)
8396 
    result.write(oprot)
8397 
    oprot.writeMessageEnd()
8398 
    oprot.trans.flush()
6962 rajveer 8399 
 
7190 amar.kumar 8400 
  def process_addOrUpdateFreebieForItem(self, seqid, iprot, oprot):
8401 
    args = addOrUpdateFreebieForItem_args()
8402 
    args.read(iprot)
8403 
    iprot.readMessageEnd()
8404 
    result = addOrUpdateFreebieForItem_result()
8405 
    self._handler.addOrUpdateFreebieForItem(args.freebieItem)
8406 
    oprot.writeMessageBegin("addOrUpdateFreebieForItem", TMessageType.REPLY, seqid)
8407 
    result.write(oprot)
8408 
    oprot.writeMessageEnd()
8409 
    oprot.trans.flush()
8410 
 
7272 amit.gupta 8411 
  def process_addOrUpdateBrandInfo(self, seqid, iprot, oprot):
8412 
    args = addOrUpdateBrandInfo_args()
8413 
    args.read(iprot)
8414 
    iprot.readMessageEnd()
8415 
    result = addOrUpdateBrandInfo_result()
8416 
    self._handler.addOrUpdateBrandInfo(args.brandInfo)
8417 
    oprot.writeMessageBegin("addOrUpdateBrandInfo", TMessageType.REPLY, seqid)
8418 
    result.write(oprot)
8419 
    oprot.writeMessageEnd()
8420 
    oprot.trans.flush()
8421 
 
8422 
  def process_getBrandInfo(self, seqid, iprot, oprot):
8423 
    args = getBrandInfo_args()
8424 
    args.read(iprot)
8425 
    iprot.readMessageEnd()
8426 
    result = getBrandInfo_result()
8427 
    result.success = self._handler.getBrandInfo()
8428 
    oprot.writeMessageBegin("getBrandInfo", TMessageType.REPLY, seqid)
8429 
    result.write(oprot)
8430 
    oprot.writeMessageEnd()
8431 
    oprot.trans.flush()
8432 
 
7256 rajveer 8433 
  def process_getStorePricing(self, seqid, iprot, oprot):
8434 
    args = getStorePricing_args()
8435 
    args.read(iprot)
8436 
    iprot.readMessageEnd()
8437 
    result = getStorePricing_result()
8438 
    result.success = self._handler.getStorePricing(args.itemId)
8439 
    oprot.writeMessageBegin("getStorePricing", TMessageType.REPLY, seqid)
8440 
    result.write(oprot)
8441 
    oprot.writeMessageEnd()
8442 
    oprot.trans.flush()
7190 amar.kumar 8443 
 
7306 rajveer 8444 
  def process_getStorePricings(self, seqid, iprot, oprot):
8445 
    args = getStorePricings_args()
8446 
    args.read(iprot)
8447 
    iprot.readMessageEnd()
8448 
    result = getStorePricings_result()
8449 
    result.success = self._handler.getStorePricings(args.itemIds)
8450 
    oprot.writeMessageBegin("getStorePricings", TMessageType.REPLY, seqid)
8451 
    result.write(oprot)
8452 
    oprot.writeMessageEnd()
8453 
    oprot.trans.flush()
8454 
 
7265 rajveer 8455 
  def process_updateStorePricing(self, seqid, iprot, oprot):
8456 
    args = updateStorePricing_args()
8457 
    args.read(iprot)
8458 
    iprot.readMessageEnd()
8459 
    result = updateStorePricing_result()
7382 rajveer 8460 
    self._handler.updateStorePricing(args.sp, args.allColors)
7265 rajveer 8461 
    oprot.writeMessageBegin("updateStorePricing", TMessageType.REPLY, seqid)
8462 
    result.write(oprot)
8463 
    oprot.writeMessageEnd()
8464 
    oprot.trans.flush()
7256 rajveer 8465 
 
7281 kshitij.so 8466 
  def process_getAllAmazonListedItems(self, seqid, iprot, oprot):
8467 
    args = getAllAmazonListedItems_args()
8468 
    args.read(iprot)
8469 
    iprot.readMessageEnd()
8470 
    result = getAllAmazonListedItems_result()
8471 
    result.success = self._handler.getAllAmazonListedItems()
8472 
    oprot.writeMessageBegin("getAllAmazonListedItems", TMessageType.REPLY, seqid)
8473 
    result.write(oprot)
8474 
    oprot.writeMessageEnd()
8475 
    oprot.trans.flush()
7265 rajveer 8476 
 
8619 kshitij.so 8477 
  def process_searchAmazonItems(self, seqid, iprot, oprot):
8478 
    args = searchAmazonItems_args()
8479 
    args.read(iprot)
8480 
    iprot.readMessageEnd()
8481 
    result = searchAmazonItems_result()
8482 
    result.success = self._handler.searchAmazonItems(args.searchTerm, args.offset, args.limit)
8483 
    oprot.writeMessageBegin("searchAmazonItems", TMessageType.REPLY, seqid)
8484 
    result.write(oprot)
8485 
    oprot.writeMessageEnd()
8486 
    oprot.trans.flush()
8487 
 
8488 
  def process_getAmazonSearchResultCount(self, seqid, iprot, oprot):
8489 
    args = getAmazonSearchResultCount_args()
8490 
    args.read(iprot)
8491 
    iprot.readMessageEnd()
8492 
    result = getAmazonSearchResultCount_result()
8493 
    result.success = self._handler.getAmazonSearchResultCount(args.searchTerm)
8494 
    oprot.writeMessageBegin("getAmazonSearchResultCount", TMessageType.REPLY, seqid)
8495 
    result.write(oprot)
8496 
    oprot.writeMessageEnd()
8497 
    oprot.trans.flush()
8498 
 
8499 
  def process_getCountForAmazonlistedItems(self, seqid, iprot, oprot):
8500 
    args = getCountForAmazonlistedItems_args()
8501 
    args.read(iprot)
8502 
    iprot.readMessageEnd()
8503 
    result = getCountForAmazonlistedItems_result()
8504 
    result.success = self._handler.getCountForAmazonlistedItems()
8505 
    oprot.writeMessageBegin("getCountForAmazonlistedItems", TMessageType.REPLY, seqid)
8506 
    result.write(oprot)
8507 
    oprot.writeMessageEnd()
8508 
    oprot.trans.flush()
8509 
 
7281 kshitij.so 8510 
  def process_getAmazonItemDetails(self, seqid, iprot, oprot):
8511 
    args = getAmazonItemDetails_args()
8512 
    args.read(iprot)
8513 
    iprot.readMessageEnd()
8514 
    result = getAmazonItemDetails_result()
8515 
    result.success = self._handler.getAmazonItemDetails(args.itemId)
8516 
    oprot.writeMessageBegin("getAmazonItemDetails", TMessageType.REPLY, seqid)
8517 
    result.write(oprot)
8518 
    oprot.writeMessageEnd()
8519 
    oprot.trans.flush()
8520 
 
8521 
  def process_updateAmazonItemDetails(self, seqid, iprot, oprot):
8522 
    args = updateAmazonItemDetails_args()
8523 
    args.read(iprot)
8524 
    iprot.readMessageEnd()
8525 
    result = updateAmazonItemDetails_result()
8168 kshitij.so 8526 
    self._handler.updateAmazonItemDetails(args.amazonlisted)
7281 kshitij.so 8527 
    oprot.writeMessageBegin("updateAmazonItemDetails", TMessageType.REPLY, seqid)
8528 
    result.write(oprot)
8529 
    oprot.writeMessageEnd()
8530 
    oprot.trans.flush()
8531 
 
8532 
  def process_addAmazonItem(self, seqid, iprot, oprot):
8533 
    args = addAmazonItem_args()
8534 
    args.read(iprot)
8535 
    iprot.readMessageEnd()
8536 
    result = addAmazonItem_result()
8537 
    self._handler.addAmazonItem(args.amazonlisted)
8538 
    oprot.writeMessageBegin("addAmazonItem", TMessageType.REPLY, seqid)
8539 
    result.write(oprot)
8540 
    oprot.writeMessageEnd()
8541 
    oprot.trans.flush()
8542 
 
7291 vikram.rag 8543 
  def process_getAsinItems(self, seqid, iprot, oprot):
8544 
    args = getAsinItems_args()
8545 
    args.read(iprot)
8546 
    iprot.readMessageEnd()
8547 
    result = getAsinItems_result()
8548 
    result.success = self._handler.getAsinItems()
8549 
    oprot.writeMessageBegin("getAsinItems", TMessageType.REPLY, seqid)
8550 
    result.write(oprot)
8551 
    oprot.writeMessageEnd()
8552 
    oprot.trans.flush()
7281 kshitij.so 8553 
 
7291 vikram.rag 8554 
  def process_getAllFbaListedItems(self, seqid, iprot, oprot):
8555 
    args = getAllFbaListedItems_args()
8556 
    args.read(iprot)
8557 
    iprot.readMessageEnd()
8558 
    result = getAllFbaListedItems_result()
8559 
    result.success = self._handler.getAllFbaListedItems()
8560 
    oprot.writeMessageBegin("getAllFbaListedItems", TMessageType.REPLY, seqid)
8561 
    result.write(oprot)
8562 
    oprot.writeMessageEnd()
8563 
    oprot.trans.flush()
8564 
 
8565 
  def process_getAllNonFbaListedItems(self, seqid, iprot, oprot):
8566 
    args = getAllNonFbaListedItems_args()
8567 
    args.read(iprot)
8568 
    iprot.readMessageEnd()
8569 
    result = getAllNonFbaListedItems_result()
8570 
    result.success = self._handler.getAllNonFbaListedItems()
8571 
    oprot.writeMessageBegin("getAllNonFbaListedItems", TMessageType.REPLY, seqid)
8572 
    result.write(oprot)
8573 
    oprot.writeMessageEnd()
8574 
    oprot.trans.flush()
8575 
 
7460 kshitij.so 8576 
  def process_updateItemInventory(self, seqid, iprot, oprot):
8577 
    args = updateItemInventory_args()
8578 
    args.read(iprot)
8579 
    iprot.readMessageEnd()
8580 
    result = updateItemInventory_result()
8581 
    result.success = self._handler.updateItemInventory(args.itemId, args.holdInventory, args.defaultInventory)
8582 
    oprot.writeMessageBegin("updateItemInventory", TMessageType.REPLY, seqid)
8583 
    result.write(oprot)
8584 
    oprot.writeMessageEnd()
8585 
    oprot.trans.flush()
7291 vikram.rag 8586 
 
7770 kshitij.so 8587 
  def process_updateTimestampForAmazonFeeds(self, seqid, iprot, oprot):
8588 
    args = updateTimestampForAmazonFeeds_args()
8589 
    args.read(iprot)
8590 
    iprot.readMessageEnd()
8591 
    result = updateTimestampForAmazonFeeds_result()
8592 
    result.success = self._handler.updateTimestampForAmazonFeeds(args.type, args.sku, args.timestamp)
8593 
    oprot.writeMessageBegin("updateTimestampForAmazonFeeds", TMessageType.REPLY, seqid)
8594 
    result.write(oprot)
8595 
    oprot.writeMessageEnd()
8596 
    oprot.trans.flush()
7460 kshitij.so 8597 
 
7897 amar.kumar 8598 
  def process_getAllParentCategories(self, seqid, iprot, oprot):
8599 
    args = getAllParentCategories_args()
8600 
    args.read(iprot)
8601 
    iprot.readMessageEnd()
8602 
    result = getAllParentCategories_result()
8603 
    result.success = self._handler.getAllParentCategories()
8604 
    oprot.writeMessageBegin("getAllParentCategories", TMessageType.REPLY, seqid)
8605 
    result.write(oprot)
8606 
    oprot.writeMessageEnd()
8607 
    oprot.trans.flush()
7770 kshitij.so 8608 
 
7977 kshitij.so 8609 
  def process_addPageViewEvent(self, seqid, iprot, oprot):
8610 
    args = addPageViewEvent_args()
8611 
    args.read(iprot)
8612 
    iprot.readMessageEnd()
8613 
    result = addPageViewEvent_result()
8614 
    self._handler.addPageViewEvent(args.pageViewEvents)
8615 
    oprot.writeMessageBegin("addPageViewEvent", TMessageType.REPLY, seqid)
8616 
    result.write(oprot)
8617 
    oprot.writeMessageEnd()
8618 
    oprot.trans.flush()
7897 amar.kumar 8619 
 
7977 kshitij.so 8620 
  def process_addCartEvent(self, seqid, iprot, oprot):
8621 
    args = addCartEvent_args()
8622 
    args.read(iprot)
8623 
    iprot.readMessageEnd()
8624 
    result = addCartEvent_result()
8625 
    self._handler.addCartEvent(args.cartEvents)
8626 
    oprot.writeMessageBegin("addCartEvent", TMessageType.REPLY, seqid)
8627 
    result.write(oprot)
8628 
    oprot.writeMessageEnd()
8629 
    oprot.trans.flush()
8630 
 
8182 amar.kumar 8631 
  def process_addEbayItem(self, seqid, iprot, oprot):
8632 
    args = addEbayItem_args()
8633 
    args.read(iprot)
8634 
    iprot.readMessageEnd()
8635 
    result = addEbayItem_result()
8636 
    self._handler.addEbayItem(args.ebayItem)
8637 
    oprot.writeMessageBegin("addEbayItem", TMessageType.REPLY, seqid)
8638 
    result.write(oprot)
8639 
    oprot.writeMessageEnd()
8640 
    oprot.trans.flush()
8641 
 
8642 
  def process_getEbayItem(self, seqid, iprot, oprot):
8643 
    args = getEbayItem_args()
8644 
    args.read(iprot)
8645 
    iprot.readMessageEnd()
8646 
    result = getEbayItem_result()
8647 
    result.success = self._handler.getEbayItem(args.listingId)
8648 
    oprot.writeMessageBegin("getEbayItem", TMessageType.REPLY, seqid)
8649 
    result.write(oprot)
8650 
    oprot.writeMessageEnd()
8651 
    oprot.trans.flush()
8652 
 
8653 
  def process_updateEbayItem(self, seqid, iprot, oprot):
8654 
    args = updateEbayItem_args()
8655 
    args.read(iprot)
8656 
    iprot.readMessageEnd()
8657 
    result = updateEbayItem_result()
8658 
    self._handler.updateEbayItem(args.ebayItem)
8659 
    oprot.writeMessageBegin("updateEbayItem", TMessageType.REPLY, seqid)
8660 
    result.write(oprot)
8661 
    oprot.writeMessageEnd()
8662 
    oprot.trans.flush()
8663 
 
8139 kshitij.so 8664 
  def process_getAmazonListedItems(self, seqid, iprot, oprot):
8665 
    args = getAmazonListedItems_args()
8666 
    args.read(iprot)
8667 
    iprot.readMessageEnd()
8668 
    result = getAmazonListedItems_result()
8669 
    result.success = self._handler.getAmazonListedItems(args.offset, args.limit)
8670 
    oprot.writeMessageBegin("getAmazonListedItems", TMessageType.REPLY, seqid)
8671 
    result.write(oprot)
8672 
    oprot.writeMessageEnd()
8673 
    oprot.trans.flush()
7977 kshitij.so 8674 
 
8168 kshitij.so 8675 
  def process_updateAmazonAttributesInBulk(self, seqid, iprot, oprot):
8676 
    args = updateAmazonAttributesInBulk_args()
8677 
    args.read(iprot)
8678 
    iprot.readMessageEnd()
8679 
    result = updateAmazonAttributesInBulk_result()
8680 
    result.success = self._handler.updateAmazonAttributesInBulk(args.amazonlisted)
8681 
    oprot.writeMessageBegin("updateAmazonAttributesInBulk", TMessageType.REPLY, seqid)
8682 
    result.write(oprot)
8683 
    oprot.writeMessageEnd()
8684 
    oprot.trans.flush()
8139 kshitij.so 8685 
 
8379 vikram.rag 8686 
  def process_getAllItemstoListOnFba(self, seqid, iprot, oprot):
8687 
    args = getAllItemstoListOnFba_args()
8688 
    args.read(iprot)
8689 
    iprot.readMessageEnd()
8690 
    result = getAllItemstoListOnFba_result()
8691 
    result.success = self._handler.getAllItemstoListOnFba()
8692 
    oprot.writeMessageBegin("getAllItemstoListOnFba", TMessageType.REPLY, seqid)
8693 
    result.write(oprot)
8694 
    oprot.writeMessageEnd()
8695 
    oprot.trans.flush()
8168 kshitij.so 8696 
 
8379 vikram.rag 8697 
  def process_getAllItemstoListOnNonFba(self, seqid, iprot, oprot):
8698 
    args = getAllItemstoListOnNonFba_args()
8699 
    args.read(iprot)
8700 
    iprot.readMessageEnd()
8701 
    result = getAllItemstoListOnNonFba_result()
8702 
    result.success = self._handler.getAllItemstoListOnNonFba()
8703 
    oprot.writeMessageBegin("getAllItemstoListOnNonFba", TMessageType.REPLY, seqid)
8704 
    result.write(oprot)
8705 
    oprot.writeMessageEnd()
8706 
    oprot.trans.flush()
8707 
 
8619 kshitij.so 8708 
  def process_updateAsin(self, seqid, iprot, oprot):
8709 
    args = updateAsin_args()
8710 
    args.read(iprot)
8711 
    iprot.readMessageEnd()
8712 
    result = updateAsin_result()
8713 
    self._handler.updateAsin(args.item)
8714 
    oprot.writeMessageBegin("updateAsin", TMessageType.REPLY, seqid)
8715 
    result.write(oprot)
8716 
    oprot.writeMessageEnd()
8717 
    oprot.trans.flush()
8616 vikram.rag 8718 
 
8739 vikram.rag 8719 
  def process_addOrUpdateSnapdealItem(self, seqid, iprot, oprot):
8720 
    args = addOrUpdateSnapdealItem_args()
8721 
    args.read(iprot)
8722 
    iprot.readMessageEnd()
8723 
    result = addOrUpdateSnapdealItem_result()
8724 
    result.success = self._handler.addOrUpdateSnapdealItem(args.snapdealitem)
8725 
    oprot.writeMessageBegin("addOrUpdateSnapdealItem", TMessageType.REPLY, seqid)
8726 
    result.write(oprot)
8727 
    oprot.writeMessageEnd()
8728 
    oprot.trans.flush()
8619 kshitij.so 8729 
 
8739 vikram.rag 8730 
  def process_getSnapdealItem(self, seqid, iprot, oprot):
8731 
    args = getSnapdealItem_args()
8732 
    args.read(iprot)
8733 
    iprot.readMessageEnd()
8734 
    result = getSnapdealItem_result()
8735 
    result.success = self._handler.getSnapdealItem(args.item_id)
8736 
    oprot.writeMessageBegin("getSnapdealItem", TMessageType.REPLY, seqid)
8737 
    result.write(oprot)
8738 
    oprot.writeMessageEnd()
8739 
    oprot.trans.flush()
8740 
 
9242 kshitij.so 8741 
  def process_getSnapdealItemDetails(self, seqid, iprot, oprot):
8742 
    args = getSnapdealItemDetails_args()
8743 
    args.read(iprot)
8744 
    iprot.readMessageEnd()
8745 
    result = getSnapdealItemDetails_result()
8746 
    result.success = self._handler.getSnapdealItemDetails(args.item_id)
8747 
    oprot.writeMessageBegin("getSnapdealItemDetails", TMessageType.REPLY, seqid)
8748 
    result.write(oprot)
8749 
    oprot.writeMessageEnd()
8750 
    oprot.trans.flush()
8751 
 
8739 vikram.rag 8752 
  def process_getAllSnapdealItems(self, seqid, iprot, oprot):
8753 
    args = getAllSnapdealItems_args()
8754 
    args.read(iprot)
8755 
    iprot.readMessageEnd()
8756 
    result = getAllSnapdealItems_result()
8757 
    result.success = self._handler.getAllSnapdealItems()
8758 
    oprot.writeMessageBegin("getAllSnapdealItems", TMessageType.REPLY, seqid)
8759 
    result.write(oprot)
8760 
    oprot.writeMessageEnd()
8761 
    oprot.trans.flush()
8762 
 
9242 kshitij.so 8763 
  def process_getSnapdealItems(self, seqid, iprot, oprot):
8764 
    args = getSnapdealItems_args()
8765 
    args.read(iprot)
8766 
    iprot.readMessageEnd()
8767 
    result = getSnapdealItems_result()
8768 
    result.success = self._handler.getSnapdealItems(args.offset, args.limit)
8769 
    oprot.writeMessageBegin("getSnapdealItems", TMessageType.REPLY, seqid)
8770 
    result.write(oprot)
8771 
    oprot.writeMessageEnd()
8772 
    oprot.trans.flush()
8739 vikram.rag 8773 
 
9242 kshitij.so 8774 
  def process_searchSnapdealItems(self, seqid, iprot, oprot):
8775 
    args = searchSnapdealItems_args()
8776 
    args.read(iprot)
8777 
    iprot.readMessageEnd()
8778 
    result = searchSnapdealItems_result()
8779 
    result.success = self._handler.searchSnapdealItems(args.searchTerm, args.offset, args.limit)
8780 
    oprot.writeMessageBegin("searchSnapdealItems", TMessageType.REPLY, seqid)
8781 
    result.write(oprot)
8782 
    oprot.writeMessageEnd()
8783 
    oprot.trans.flush()
8784 
 
8785 
  def process_getCountForSnapdealItems(self, seqid, iprot, oprot):
8786 
    args = getCountForSnapdealItems_args()
8787 
    args.read(iprot)
8788 
    iprot.readMessageEnd()
8789 
    result = getCountForSnapdealItems_result()
8790 
    result.success = self._handler.getCountForSnapdealItems()
8791 
    oprot.writeMessageBegin("getCountForSnapdealItems", TMessageType.REPLY, seqid)
8792 
    result.write(oprot)
8793 
    oprot.writeMessageEnd()
8794 
    oprot.trans.flush()
8795 
 
8796 
  def process_getSnapdealSearchResultCount(self, seqid, iprot, oprot):
8797 
    args = getSnapdealSearchResultCount_args()
8798 
    args.read(iprot)
8799 
    iprot.readMessageEnd()
8800 
    result = getSnapdealSearchResultCount_result()
8801 
    result.success = self._handler.getSnapdealSearchResultCount(args.searchTerm)
8802 
    oprot.writeMessageBegin("getSnapdealSearchResultCount", TMessageType.REPLY, seqid)
8803 
    result.write(oprot)
8804 
    oprot.writeMessageEnd()
8805 
    oprot.trans.flush()
8806 
 
9299 kshitij.so 8807 
  def process_getPrefferedInsurerForItem(self, seqid, iprot, oprot):
8808 
    args = getPrefferedInsurerForItem_args()
8809 
    args.read(iprot)
8810 
    iprot.readMessageEnd()
8811 
    result = getPrefferedInsurerForItem_result()
8812 
    result.success = self._handler.getPrefferedInsurerForItem(args.itemId, args.insurerType)
8813 
    oprot.writeMessageBegin("getPrefferedInsurerForItem", TMessageType.REPLY, seqid)
8814 
    result.write(oprot)
8815 
    oprot.writeMessageEnd()
8816 
    oprot.trans.flush()
9242 kshitij.so 8817 
 
9456 vikram.rag 8818 
  def process_getSnapdealItembySkuAtSnapdeal(self, seqid, iprot, oprot):
8819 
    args = getSnapdealItembySkuAtSnapdeal_args()
8820 
    args.read(iprot)
8821 
    iprot.readMessageEnd()
8822 
    result = getSnapdealItembySkuAtSnapdeal_result()
8823 
    result.success = self._handler.getSnapdealItembySkuAtSnapdeal(args.skuAtSnapdeal)
8824 
    oprot.writeMessageBegin("getSnapdealItembySkuAtSnapdeal", TMessageType.REPLY, seqid)
8825 
    result.write(oprot)
8826 
    oprot.writeMessageEnd()
8827 
    oprot.trans.flush()
9299 kshitij.so 8828 
 
9621 manish.sha 8829 
  def process_getProductFeedSubmit(self, seqid, iprot, oprot):
8830 
    args = getProductFeedSubmit_args()
8831 
    args.read(iprot)
8832 
    iprot.readMessageEnd()
8833 
    result = getProductFeedSubmit_result()
8834 
    try:
8835 
      result.success = self._handler.getProductFeedSubmit(args.catalogItemId)
8836 
    except CatalogServiceException, cex:
8837 
      result.cex = cex
8838 
    oprot.writeMessageBegin("getProductFeedSubmit", TMessageType.REPLY, seqid)
8839 
    result.write(oprot)
8840 
    oprot.writeMessageEnd()
8841 
    oprot.trans.flush()
9456 vikram.rag 8842 
 
9621 manish.sha 8843 
  def process_addProductFeedSubmit(self, seqid, iprot, oprot):
8844 
    args = addProductFeedSubmit_args()
8845 
    args.read(iprot)
8846 
    iprot.readMessageEnd()
8847 
    result = addProductFeedSubmit_result()
8848 
    try:
8849 
      result.success = self._handler.addProductFeedSubmit(args.productFeedSubmit)
8850 
    except CatalogServiceException, cex:
8851 
      result.cex = cex
8852 
    oprot.writeMessageBegin("addProductFeedSubmit", TMessageType.REPLY, seqid)
8853 
    result.write(oprot)
8854 
    oprot.writeMessageEnd()
8855 
    oprot.trans.flush()
8856 
 
8857 
  def process_updateProductFeedSubmit(self, seqid, iprot, oprot):
8858 
    args = updateProductFeedSubmit_args()
8859 
    args.read(iprot)
8860 
    iprot.readMessageEnd()
8861 
    result = updateProductFeedSubmit_result()
8862 
    try:
8863 
      result.success = self._handler.updateProductFeedSubmit(args.productFeedSubmit)
8864 
    except CatalogServiceException, cex:
8865 
      result.cex = cex
8866 
    oprot.writeMessageBegin("updateProductFeedSubmit", TMessageType.REPLY, seqid)
8867 
    result.write(oprot)
8868 
    oprot.writeMessageEnd()
8869 
    oprot.trans.flush()
8870 
 
8871 
  def process_deleteProductFeedSubmit(self, seqid, iprot, oprot):
8872 
    args = deleteProductFeedSubmit_args()
8873 
    args.read(iprot)
8874 
    iprot.readMessageEnd()
8875 
    result = deleteProductFeedSubmit_result()
8876 
    try:
8877 
      result.success = self._handler.deleteProductFeedSubmit(args.catalogItemId)
8878 
    except CatalogServiceException, cex:
8879 
      result.cex = cex
8880 
    oprot.writeMessageBegin("deleteProductFeedSubmit", TMessageType.REPLY, seqid)
8881 
    result.write(oprot)
8882 
    oprot.writeMessageEnd()
8883 
    oprot.trans.flush()
8884 
 
8885 
  def process_getAllProductFeedSubmit(self, seqid, iprot, oprot):
8886 
    args = getAllProductFeedSubmit_args()
8887 
    args.read(iprot)
8888 
    iprot.readMessageEnd()
8889 
    result = getAllProductFeedSubmit_result()
8890 
    try:
8891 
      result.success = self._handler.getAllProductFeedSubmit()
8892 
    except CatalogServiceException, cex:
8893 
      result.cex = cex
8894 
    oprot.writeMessageBegin("getAllProductFeedSubmit", TMessageType.REPLY, seqid)
8895 
    result.write(oprot)
8896 
    oprot.writeMessageEnd()
8897 
    oprot.trans.flush()
8898 
 
9724 kshitij.so 8899 
  def process_getMarketplacedetailsForItem(self, seqid, iprot, oprot):
8900 
    args = getMarketplacedetailsForItem_args()
8901 
    args.read(iprot)
8902 
    iprot.readMessageEnd()
8903 
    result = getMarketplacedetailsForItem_result()
8904 
    result.success = self._handler.getMarketplacedetailsForItem(args.itemId, args.sourceId)
8905 
    oprot.writeMessageBegin("getMarketplacedetailsForItem", TMessageType.REPLY, seqid)
8906 
    result.write(oprot)
8907 
    oprot.writeMessageEnd()
8908 
    oprot.trans.flush()
9621 manish.sha 8909 
 
9724 kshitij.so 8910 
  def process_updateMarketplaceAttributesForItem(self, seqid, iprot, oprot):
8911 
    args = updateMarketplaceAttributesForItem_args()
8912 
    args.read(iprot)
8913 
    iprot.readMessageEnd()
8914 
    result = updateMarketplaceAttributesForItem_result()
8915 
    result.success = self._handler.updateMarketplaceAttributesForItem(args.marketPlaceItem)
8916 
    oprot.writeMessageBegin("updateMarketplaceAttributesForItem", TMessageType.REPLY, seqid)
8917 
    result.write(oprot)
8918 
    oprot.writeMessageEnd()
8919 
    oprot.trans.flush()
8920 
 
9779 kshitij.so 8921 
  def process_getCostingForMarketplace(self, seqid, iprot, oprot):
8922 
    args = getCostingForMarketplace_args()
8923 
    args.read(iprot)
8924 
    iprot.readMessageEnd()
8925 
    result = getCostingForMarketplace_result()
8926 
    result.success = self._handler.getCostingForMarketplace(args.source, args.item_id)
8927 
    oprot.writeMessageBegin("getCostingForMarketplace", TMessageType.REPLY, seqid)
8928 
    result.write(oprot)
8929 
    oprot.writeMessageEnd()
8930 
    oprot.trans.flush()
8931 
 
9776 vikram.rag 8932 
  def process_getMarketPlaceItemsForPriceUpdate(self, seqid, iprot, oprot):
8933 
    args = getMarketPlaceItemsForPriceUpdate_args()
8934 
    args.read(iprot)
8935 
    iprot.readMessageEnd()
8936 
    result = getMarketPlaceItemsForPriceUpdate_result()
8937 
    result.success = self._handler.getMarketPlaceItemsForPriceUpdate(args.source)
8938 
    oprot.writeMessageBegin("getMarketPlaceItemsForPriceUpdate", TMessageType.REPLY, seqid)
8939 
    result.write(oprot)
8940 
    oprot.writeMessageEnd()
8941 
    oprot.trans.flush()
9724 kshitij.so 8942 
 
9776 vikram.rag 8943 
  def process_updateMarketPlacePriceUpdateStatus(self, seqid, iprot, oprot):
8944 
    args = updateMarketPlacePriceUpdateStatus_args()
8945 
    args.read(iprot)
8946 
    iprot.readMessageEnd()
8947 
    result = updateMarketPlacePriceUpdateStatus_result()
9816 kshitij.so 8948 
    self._handler.updateMarketPlacePriceUpdateStatus(args.skulist, args.timestamp, args.source)
9776 vikram.rag 8949 
    oprot.writeMessageBegin("updateMarketPlacePriceUpdateStatus", TMessageType.REPLY, seqid)
8950 
    result.write(oprot)
8951 
    oprot.writeMessageEnd()
8952 
    oprot.trans.flush()
8953 
 
9861 rajveer 8954 
  def process_updateItemHoldInventory(self, seqid, iprot, oprot):
8955 
    args = updateItemHoldInventory_args()
8956 
    args.read(iprot)
8957 
    iprot.readMessageEnd()
8958 
    result = updateItemHoldInventory_result()
8959 
    self._handler.updateItemHoldInventory(args.itemHoldMap)
8960 
    oprot.writeMessageBegin("updateItemHoldInventory", TMessageType.REPLY, seqid)
8961 
    result.write(oprot)
8962 
    oprot.writeMessageEnd()
8963 
    oprot.trans.flush()
9776 vikram.rag 8964 
 
9895 vikram.rag 8965 
  def process_updateNlcAtMarketplaces(self, seqid, iprot, oprot):
8966 
    args = updateNlcAtMarketplaces_args()
8967 
    args.read(iprot)
8968 
    iprot.readMessageEnd()
8969 
    result = updateNlcAtMarketplaces_result()
8970 
    self._handler.updateNlcAtMarketplaces(args.item_id, args.vendor_id, args.nlc)
8971 
    oprot.writeMessageBegin("updateNlcAtMarketplaces", TMessageType.REPLY, seqid)
8972 
    result.write(oprot)
8973 
    oprot.writeMessageEnd()
8974 
    oprot.trans.flush()
9861 rajveer 8975 
 
9945 vikram.rag 8976 
  def process_getAllFlipkartItems(self, seqid, iprot, oprot):
8977 
    args = getAllFlipkartItems_args()
8978 
    args.read(iprot)
8979 
    iprot.readMessageEnd()
8980 
    result = getAllFlipkartItems_result()
8981 
    result.success = self._handler.getAllFlipkartItems()
8982 
    oprot.writeMessageBegin("getAllFlipkartItems", TMessageType.REPLY, seqid)
8983 
    result.write(oprot)
8984 
    oprot.writeMessageEnd()
8985 
    oprot.trans.flush()
9895 vikram.rag 8986 
 
10097 kshitij.so 8987 
  def process_addOrUpdateFlipkartItem(self, seqid, iprot, oprot):
8988 
    args = addOrUpdateFlipkartItem_args()
8989 
    args.read(iprot)
8990 
    iprot.readMessageEnd()
8991 
    result = addOrUpdateFlipkartItem_result()
8992 
    result.success = self._handler.addOrUpdateFlipkartItem(args.flipkartitem)
8993 
    oprot.writeMessageBegin("addOrUpdateFlipkartItem", TMessageType.REPLY, seqid)
8994 
    result.write(oprot)
8995 
    oprot.writeMessageEnd()
8996 
    oprot.trans.flush()
9945 vikram.rag 8997 
 
10097 kshitij.so 8998 
  def process_getFlipkartItem(self, seqid, iprot, oprot):
8999 
    args = getFlipkartItem_args()
9000 
    args.read(iprot)
9001 
    iprot.readMessageEnd()
9002 
    result = getFlipkartItem_result()
9003 
    result.success = self._handler.getFlipkartItem(args.item_id)
9004 
    oprot.writeMessageBegin("getFlipkartItem", TMessageType.REPLY, seqid)
9005 
    result.write(oprot)
9006 
    oprot.writeMessageEnd()
9007 
    oprot.trans.flush()
9008 
 
9009 
  def process_getFlipkartItemDetails(self, seqid, iprot, oprot):
9010 
    args = getFlipkartItemDetails_args()
9011 
    args.read(iprot)
9012 
    iprot.readMessageEnd()
9013 
    result = getFlipkartItemDetails_result()
9014 
    result.success = self._handler.getFlipkartItemDetails(args.item_id)
9015 
    oprot.writeMessageBegin("getFlipkartItemDetails", TMessageType.REPLY, seqid)
9016 
    result.write(oprot)
9017 
    oprot.writeMessageEnd()
9018 
    oprot.trans.flush()
9019 
 
9020 
  def process_getFlipkartItems(self, seqid, iprot, oprot):
9021 
    args = getFlipkartItems_args()
9022 
    args.read(iprot)
9023 
    iprot.readMessageEnd()
9024 
    result = getFlipkartItems_result()
9025 
    result.success = self._handler.getFlipkartItems(args.offset, args.limit)
9026 
    oprot.writeMessageBegin("getFlipkartItems", TMessageType.REPLY, seqid)
9027 
    result.write(oprot)
9028 
    oprot.writeMessageEnd()
9029 
    oprot.trans.flush()
9030 
 
9031 
  def process_searchFlipkartItems(self, seqid, iprot, oprot):
9032 
    args = searchFlipkartItems_args()
9033 
    args.read(iprot)
9034 
    iprot.readMessageEnd()
9035 
    result = searchFlipkartItems_result()
9036 
    result.success = self._handler.searchFlipkartItems(args.searchTerm, args.offset, args.limit)
9037 
    oprot.writeMessageBegin("searchFlipkartItems", TMessageType.REPLY, seqid)
9038 
    result.write(oprot)
9039 
    oprot.writeMessageEnd()
9040 
    oprot.trans.flush()
9041 
 
9042 
  def process_getCountForFlipkartItems(self, seqid, iprot, oprot):
9043 
    args = getCountForFlipkartItems_args()
9044 
    args.read(iprot)
9045 
    iprot.readMessageEnd()
9046 
    result = getCountForFlipkartItems_result()
9047 
    result.success = self._handler.getCountForFlipkartItems()
9048 
    oprot.writeMessageBegin("getCountForFlipkartItems", TMessageType.REPLY, seqid)
9049 
    result.write(oprot)
9050 
    oprot.writeMessageEnd()
9051 
    oprot.trans.flush()
9052 
 
9053 
  def process_getFlipkartSearchResultCount(self, seqid, iprot, oprot):
9054 
    args = getFlipkartSearchResultCount_args()
9055 
    args.read(iprot)
9056 
    iprot.readMessageEnd()
9057 
    result = getFlipkartSearchResultCount_result()
9058 
    result.success = self._handler.getFlipkartSearchResultCount(args.searchTerm)
9059 
    oprot.writeMessageBegin("getFlipkartSearchResultCount", TMessageType.REPLY, seqid)
9060 
    result.write(oprot)
9061 
    oprot.writeMessageEnd()
9062 
    oprot.trans.flush()
9063 
 
9064 
  def process_getAllFkItems(self, seqid, iprot, oprot):
9065 
    args = getAllFkItems_args()
9066 
    args.read(iprot)
9067 
    iprot.readMessageEnd()
9068 
    result = getAllFkItems_result()
9069 
    result.success = self._handler.getAllFkItems()
9070 
    oprot.writeMessageBegin("getAllFkItems", TMessageType.REPLY, seqid)
9071 
    result.write(oprot)
9072 
    oprot.writeMessageEnd()
9073 
    oprot.trans.flush()
9074 
 
10140 vikram.rag 9075 
  def process_getFlipkartItemBySkyAtFlipkart(self, seqid, iprot, oprot):
9076 
    args = getFlipkartItemBySkyAtFlipkart_args()
9077 
    args.read(iprot)
9078 
    iprot.readMessageEnd()
9079 
    result = getFlipkartItemBySkyAtFlipkart_result()
9080 
    result.success = self._handler.getFlipkartItemBySkyAtFlipkart(args.sku)
9081 
    oprot.writeMessageBegin("getFlipkartItemBySkyAtFlipkart", TMessageType.REPLY, seqid)
9082 
    result.write(oprot)
9083 
    oprot.writeMessageEnd()
9084 
    oprot.trans.flush()
10097 kshitij.so 9085 
 
11015 kshitij.so 9086 
  def process_getMarketplaceHistory(self, seqid, iprot, oprot):
9087 
    args = getMarketplaceHistory_args()
9088 
    args.read(iprot)
9089 
    iprot.readMessageEnd()
9090 
    result = getMarketplaceHistory_result()
9091 
    result.success = self._handler.getMarketplaceHistory(args.source, args.offset, args.itemId)
9092 
    oprot.writeMessageBegin("getMarketplaceHistory", TMessageType.REPLY, seqid)
9093 
    result.write(oprot)
9094 
    oprot.writeMessageEnd()
9095 
    oprot.trans.flush()
9096 
 
10909 vikram.rag 9097 
  def process_getAllFbbListedItems(self, seqid, iprot, oprot):
9098 
    args = getAllFbbListedItems_args()
9099 
    args.read(iprot)
9100 
    iprot.readMessageEnd()
9101 
    result = getAllFbbListedItems_result()
9102 
    result.success = self._handler.getAllFbbListedItems()
9103 
    oprot.writeMessageBegin("getAllFbbListedItems", TMessageType.REPLY, seqid)
9104 
    result.write(oprot)
9105 
    oprot.writeMessageEnd()
9106 
    oprot.trans.flush()
10140 vikram.rag 9107 
 
10924 vikram.rag 9108 
  def process_getAllFbbPricingItems(self, seqid, iprot, oprot):
9109 
    args = getAllFbbPricingItems_args()
9110 
    args.read(iprot)
9111 
    iprot.readMessageEnd()
9112 
    result = getAllFbbPricingItems_result()
9113 
    result.success = self._handler.getAllFbbPricingItems()
9114 
    oprot.writeMessageBegin("getAllFbbPricingItems", TMessageType.REPLY, seqid)
9115 
    result.write(oprot)
9116 
    oprot.writeMessageEnd()
9117 
    oprot.trans.flush()
10909 vikram.rag 9118 
 
11015 kshitij.so 9119 
  def process_getCountForMarketplaceHistory(self, seqid, iprot, oprot):
9120 
    args = getCountForMarketplaceHistory_args()
9121 
    args.read(iprot)
9122 
    iprot.readMessageEnd()
9123 
    result = getCountForMarketplaceHistory_result()
9124 
    result.success = self._handler.getCountForMarketplaceHistory(args.source, args.itemId)
9125 
    oprot.writeMessageBegin("getCountForMarketplaceHistory", TMessageType.REPLY, seqid)
9126 
    result.write(oprot)
9127 
    oprot.writeMessageEnd()
9128 
    oprot.trans.flush()
10924 vikram.rag 9129 
 
11015 kshitij.so 9130 
  def process_getMarketplaceHistoryByDate(self, seqid, iprot, oprot):
9131 
    args = getMarketplaceHistoryByDate_args()
9132 
    args.read(iprot)
9133 
    iprot.readMessageEnd()
9134 
    result = getMarketplaceHistoryByDate_result()
9135 
    result.success = self._handler.getMarketplaceHistoryByDate(args.source, args.startDate, args.endDate, args.offset, args.limit, args.itemId)
9136 
    oprot.writeMessageBegin("getMarketplaceHistoryByDate", TMessageType.REPLY, seqid)
9137 
    result.write(oprot)
9138 
    oprot.writeMessageEnd()
9139 
    oprot.trans.flush()
9140 
 
11531 vikram.rag 9141 
  def process_getPrivateDealDetails(self, seqid, iprot, oprot):
9142 
    args = getPrivateDealDetails_args()
9143 
    args.read(iprot)
9144 
    iprot.readMessageEnd()
9145 
    result = getPrivateDealDetails_result()
9146 
    result.success = self._handler.getPrivateDealDetails(args.item_id)
9147 
    oprot.writeMessageBegin("getPrivateDealDetails", TMessageType.REPLY, seqid)
9148 
    result.write(oprot)
9149 
    oprot.writeMessageEnd()
9150 
    oprot.trans.flush()
11015 kshitij.so 9151 
 
11531 vikram.rag 9152 
  def process_getPrivateDealItems(self, seqid, iprot, oprot):
9153 
    args = getPrivateDealItems_args()
9154 
    args.read(iprot)
9155 
    iprot.readMessageEnd()
9156 
    result = getPrivateDealItems_result()
9157 
    result.success = self._handler.getPrivateDealItems(args.offset, args.limit)
9158 
    oprot.writeMessageBegin("getPrivateDealItems", TMessageType.REPLY, seqid)
9159 
    result.write(oprot)
9160 
    oprot.writeMessageEnd()
9161 
    oprot.trans.flush()
9162 
 
11592 amit.gupta 9163 
  def process_getAllActivePrivateDeals(self, seqid, iprot, oprot):
9164 
    args = getAllActivePrivateDeals_args()
9165 
    args.read(iprot)
9166 
    iprot.readMessageEnd()
9167 
    result = getAllActivePrivateDeals_result()
11653 amit.gupta 9168 
    result.success = self._handler.getAllActivePrivateDeals(args.itemIds, args.daysDelta)
11592 amit.gupta 9169 
    oprot.writeMessageBegin("getAllActivePrivateDeals", TMessageType.REPLY, seqid)
9170 
    result.write(oprot)
9171 
    oprot.writeMessageEnd()
9172 
    oprot.trans.flush()
9173 
 
11531 vikram.rag 9174 
  def process_addOrUpdatePrivateDeal(self, seqid, iprot, oprot):
9175 
    args = addOrUpdatePrivateDeal_args()
9176 
    args.read(iprot)
9177 
    iprot.readMessageEnd()
9178 
    result = addOrUpdatePrivateDeal_result()
9179 
    result.success = self._handler.addOrUpdatePrivateDeal(args.privateDeal)
9180 
    oprot.writeMessageBegin("addOrUpdatePrivateDeal", TMessageType.REPLY, seqid)
9181 
    result.write(oprot)
9182 
    oprot.writeMessageEnd()
9183 
    oprot.trans.flush()
9184 
 
11635 vikram.rag 9185 
  def process_getPrivateDealsCatalogIds(self, seqid, iprot, oprot):
9186 
    args = getPrivateDealsCatalogIds_args()
9187 
    args.read(iprot)
9188 
    iprot.readMessageEnd()
9189 
    result = getPrivateDealsCatalogIds_result()
9190 
    try:
9191 
      result.success = self._handler.getPrivateDealsCatalogIds(args.beginIndex, args.totalItems)
9192 
    except CatalogServiceException, cex:
9193 
      result.cex = cex
9194 
    oprot.writeMessageBegin("getPrivateDealsCatalogIds", TMessageType.REPLY, seqid)
9195 
    result.write(oprot)
9196 
    oprot.writeMessageEnd()
9197 
    oprot.trans.flush()
11531 vikram.rag 9198 
 
11645 amit.gupta 9199 
  def process_getPrivateDealsCount(self, seqid, iprot, oprot):
9200 
    args = getPrivateDealsCount_args()
9201 
    args.read(iprot)
9202 
    iprot.readMessageEnd()
9203 
    result = getPrivateDealsCount_result()
9204 
    result.success = self._handler.getPrivateDealsCount()
9205 
    oprot.writeMessageBegin("getPrivateDealsCount", TMessageType.REPLY, seqid)
9206 
    result.write(oprot)
9207 
    oprot.writeMessageEnd()
9208 
    oprot.trans.flush()
11635 vikram.rag 9209 
 
11905 kshitij.so 9210 
  def process_getAmazonOutSyncItems(self, seqid, iprot, oprot):
9211 
    args = getAmazonOutSyncItems_args()
9212 
    args.read(iprot)
9213 
    iprot.readMessageEnd()
9214 
    result = getAmazonOutSyncItems_result()
9215 
    result.success = self._handler.getAmazonOutSyncItems(args.item_id)
9216 
    oprot.writeMessageBegin("getAmazonOutSyncItems", TMessageType.REPLY, seqid)
9217 
    result.write(oprot)
9218 
    oprot.writeMessageEnd()
9219 
    oprot.trans.flush()
11645 amit.gupta 9220 
 
11905 kshitij.so 9221 
  def process_getAllPrivateDealsComparison(self, seqid, iprot, oprot):
9222 
    args = getAllPrivateDealsComparison_args()
9223 
    args.read(iprot)
9224 
    iprot.readMessageEnd()
9225 
    result = getAllPrivateDealsComparison_result()
9226 
    result.success = self._handler.getAllPrivateDealsComparison()
9227 
    oprot.writeMessageBegin("getAllPrivateDealsComparison", TMessageType.REPLY, seqid)
9228 
    result.write(oprot)
9229 
    oprot.writeMessageEnd()
9230 
    oprot.trans.flush()
9231 
 
12133 kshitij.so 9232 
  def process_getAllSnapdealMarketplaceItem(self, seqid, iprot, oprot):
9233 
    args = getAllSnapdealMarketplaceItem_args()
9234 
    args.read(iprot)
9235 
    iprot.readMessageEnd()
9236 
    result = getAllSnapdealMarketplaceItem_result()
9237 
    result.success = self._handler.getAllSnapdealMarketplaceItem()
9238 
    oprot.writeMessageBegin("getAllSnapdealMarketplaceItem", TMessageType.REPLY, seqid)
9239 
    result.write(oprot)
9240 
    oprot.writeMessageEnd()
9241 
    oprot.trans.flush()
11905 kshitij.so 9242 
 
12133 kshitij.so 9243 
  def process_getAllFlipkartMarketplaceItem(self, seqid, iprot, oprot):
9244 
    args = getAllFlipkartMarketplaceItem_args()
9245 
    args.read(iprot)
9246 
    iprot.readMessageEnd()
9247 
    result = getAllFlipkartMarketplaceItem_result()
9248 
    result.success = self._handler.getAllFlipkartMarketplaceItem()
9249 
    oprot.writeMessageBegin("getAllFlipkartMarketplaceItem", TMessageType.REPLY, seqid)
9250 
    result.write(oprot)
9251 
    oprot.writeMessageEnd()
9252 
    oprot.trans.flush()
9253 
 
12243 kshitij.so 9254 
  def process_addCompetitorScraping(self, seqid, iprot, oprot):
9255 
    args = addCompetitorScraping_args()
9256 
    args.read(iprot)
9257 
    iprot.readMessageEnd()
9258 
    result = addCompetitorScraping_result()
9259 
    self._handler.addCompetitorScraping(args.competitorPricingMap)
9260 
    oprot.writeMessageBegin("addCompetitorScraping", TMessageType.REPLY, seqid)
9261 
    result.write(oprot)
9262 
    oprot.writeMessageEnd()
9263 
    oprot.trans.flush()
12133 kshitij.so 9264 
 
12243 kshitij.so 9265 
  def process_getPreviousCompetitorScraping(self, seqid, iprot, oprot):
9266 
    args = getPreviousCompetitorScraping_args()
9267 
    args.read(iprot)
9268 
    iprot.readMessageEnd()
9269 
    result = getPreviousCompetitorScraping_result()
9270 
    result.success = self._handler.getPreviousCompetitorScraping(args.delta)
9271 
    oprot.writeMessageBegin("getPreviousCompetitorScraping", TMessageType.REPLY, seqid)
9272 
    result.write(oprot)
9273 
    oprot.writeMessageEnd()
9274 
    oprot.trans.flush()
9275 
 
12256 kshitij.so 9276 
  def process_getUploadResultById(self, seqid, iprot, oprot):
9277 
    args = getUploadResultById_args()
9278 
    args.read(iprot)
9279 
    iprot.readMessageEnd()
9280 
    result = getUploadResultById_result()
9281 
    result.success = self._handler.getUploadResultById(args.uploadId)
9282 
    oprot.writeMessageBegin("getUploadResultById", TMessageType.REPLY, seqid)
9283 
    result.write(oprot)
9284 
    oprot.writeMessageEnd()
9285 
    oprot.trans.flush()
12243 kshitij.so 9286 
 
12363 kshitij.so 9287 
  def process_addAmazonPromotion(self, seqid, iprot, oprot):
9288 
    args = addAmazonPromotion_args()
9289 
    args.read(iprot)
9290 
    iprot.readMessageEnd()
9291 
    result = addAmazonPromotion_result()
12947 kshitij.so 9292 
    try:
9293 
      result.success = self._handler.addAmazonPromotion(args.amazonPromotions)
9294 
    except CatalogServiceException, cex:
9295 
      result.cex = cex
12363 kshitij.so 9296 
    oprot.writeMessageBegin("addAmazonPromotion", TMessageType.REPLY, seqid)
9297 
    result.write(oprot)
9298 
    oprot.writeMessageEnd()
9299 
    oprot.trans.flush()
12256 kshitij.so 9300 
 
12363 kshitij.so 9301 
  def process_getAmazonPromotion(self, seqid, iprot, oprot):
9302 
    args = getAmazonPromotion_args()
9303 
    args.read(iprot)
9304 
    iprot.readMessageEnd()
9305 
    result = getAmazonPromotion_result()
9306 
    result.success = self._handler.getAmazonPromotion(args.startDate, args.endDate)
9307 
    oprot.writeMessageBegin("getAmazonPromotion", TMessageType.REPLY, seqid)
9308 
    result.write(oprot)
9309 
    oprot.writeMessageEnd()
9310 
    oprot.trans.flush()
9311 
 
9312 
  def process_updateAmazonPromotion(self, seqid, iprot, oprot):
9313 
    args = updateAmazonPromotion_args()
9314 
    args.read(iprot)
9315 
    iprot.readMessageEnd()
9316 
    result = updateAmazonPromotion_result()
9317 
    result.success = self._handler.updateAmazonPromotion(args.amazonPromotions)
9318 
    oprot.writeMessageBegin("updateAmazonPromotion", TMessageType.REPLY, seqid)
9319 
    result.write(oprot)
9320 
    oprot.writeMessageEnd()
9321 
    oprot.trans.flush()
9322 
 
12567 amit.gupta 9323 
  def process_markPartiallyActive(self, seqid, iprot, oprot):
9324 
    args = markPartiallyActive_args()
9325 
    args.read(iprot)
9326 
    iprot.readMessageEnd()
9327 
    result = markPartiallyActive_result()
9328 
    result.success = self._handler.markPartiallyActive(args.itemId, args.categoryId)
9329 
    oprot.writeMessageBegin("markPartiallyActive", TMessageType.REPLY, seqid)
9330 
    result.write(oprot)
9331 
    oprot.writeMessageEnd()
9332 
    oprot.trans.flush()
12363 kshitij.so 9333 
 
12567 amit.gupta 9334 
  def process_updateItemStateVat(self, seqid, iprot, oprot):
9335 
    args = updateItemStateVat_args()
9336 
    args.read(iprot)
9337 
    iprot.readMessageEnd()
9338 
    result = updateItemStateVat_result()
9339 
    result.success = self._handler.updateItemStateVat(args.itemId, args.statevat)
9340 
    oprot.writeMessageBegin("updateItemStateVat", TMessageType.REPLY, seqid)
9341 
    result.write(oprot)
9342 
    oprot.writeMessageEnd()
9343 
    oprot.trans.flush()
9344 
 
12620 amit.gupta 9345 
  def process_getExAffiliateItemInfo(self, seqid, iprot, oprot):
9346 
    args = getExAffiliateItemInfo_args()
9347 
    args.read(iprot)
9348 
    iprot.readMessageEnd()
9349 
    result = getExAffiliateItemInfo_result()
9350 
    result.success = self._handler.getExAffiliateItemInfo()
9351 
    oprot.writeMessageBegin("getExAffiliateItemInfo", TMessageType.REPLY, seqid)
9352 
    result.write(oprot)
9353 
    oprot.writeMessageEnd()
9354 
    oprot.trans.flush()
12567 amit.gupta 9355 
 
12888 kshitij.so 9356 
  def process_getAllItemstoListOnFbg(self, seqid, iprot, oprot):
9357 
    args = getAllItemstoListOnFbg_args()
9358 
    args.read(iprot)
9359 
    iprot.readMessageEnd()
9360 
    result = getAllItemstoListOnFbg_result()
9361 
    result.success = self._handler.getAllItemstoListOnFbg()
9362 
    oprot.writeMessageBegin("getAllItemstoListOnFbg", TMessageType.REPLY, seqid)
9363 
    result.write(oprot)
9364 
    oprot.writeMessageEnd()
9365 
    oprot.trans.flush()
12620 amit.gupta 9366 
 
12892 kshitij.so 9367 
  def process_getAllFbgListedItems(self, seqid, iprot, oprot):
9368 
    args = getAllFbgListedItems_args()
9369 
    args.read(iprot)
9370 
    iprot.readMessageEnd()
9371 
    result = getAllFbgListedItems_result()
9372 
    result.success = self._handler.getAllFbgListedItems()
9373 
    oprot.writeMessageBegin("getAllFbgListedItems", TMessageType.REPLY, seqid)
9374 
    result.write(oprot)
9375 
    oprot.writeMessageEnd()
9376 
    oprot.trans.flush()
12888 kshitij.so 9377 
 
13136 amit.gupta 9378 
  def process_checkServices(self, seqid, iprot, oprot):
9379 
    args = checkServices_args()
9380 
    args.read(iprot)
9381 
    iprot.readMessageEnd()
9382 
    result = checkServices_result()
9383 
    try:
9384 
      result.success = self._handler.checkServices(args.lines)
9385 
    except CatalogServiceException, cex:
9386 
      result.cex = cex
9387 
    oprot.writeMessageBegin("checkServices", TMessageType.REPLY, seqid)
9388 
    result.write(oprot)
9389 
    oprot.writeMessageEnd()
9390 
    oprot.trans.flush()
12892 kshitij.so 9391 
 
13709 manish.sha 9392 
  def process_addHsItem(self, seqid, iprot, oprot):
9393 
    args = addHsItem_args()
9394 
    args.read(iprot)
9395 
    iprot.readMessageEnd()
9396 
    result = addHsItem_result()
9397 
    self._handler.addHsItem(args.hsItems)
9398 
    oprot.writeMessageBegin("addHsItem", TMessageType.REPLY, seqid)
9399 
    result.write(oprot)
9400 
    oprot.writeMessageEnd()
9401 
    oprot.trans.flush()
13136 amit.gupta 9402 
 
13709 manish.sha 9403 
  def process_getHsItem(self, seqid, iprot, oprot):
9404 
    args = getHsItem_args()
9405 
    args.read(iprot)
9406 
    iprot.readMessageEnd()
9407 
    result = getHsItem_result()
9408 
    result.success = self._handler.getHsItem(args.hsItemId)
9409 
    oprot.writeMessageBegin("getHsItem", TMessageType.REPLY, seqid)
9410 
    result.write(oprot)
9411 
    oprot.writeMessageEnd()
9412 
    oprot.trans.flush()
9413 
 
9414 
  def process_updateHsItem(self, seqid, iprot, oprot):
9415 
    args = updateHsItem_args()
9416 
    args.read(iprot)
9417 
    iprot.readMessageEnd()
9418 
    result = updateHsItem_result()
9419 
    self._handler.updateHsItem(args.hsItem)
9420 
    oprot.writeMessageBegin("updateHsItem", TMessageType.REPLY, seqid)
9421 
    result.write(oprot)
9422 
    oprot.writeMessageEnd()
9423 
    oprot.trans.flush()
9424 
 
14182 kshitij.so 9425 
  def process_getPricingForDtr(self, seqid, iprot, oprot):
9426 
    args = getPricingForDtr_args()
9427 
    args.read(iprot)
9428 
    iprot.readMessageEnd()
9429 
    result = getPricingForDtr_result()
9430 
    result.success = self._handler.getPricingForDtr(args.catalogItemId)
9431 
    oprot.writeMessageBegin("getPricingForDtr", TMessageType.REPLY, seqid)
9432 
    result.write(oprot)
9433 
    oprot.writeMessageEnd()
9434 
    oprot.trans.flush()
13709 manish.sha 9435 
 
14182 kshitij.so 9436 
 
5944 mandeep.dh 9437 
# HELPER FUNCTIONS AND STRUCTURES
9438 
 
9439 
class addItem_args:
9440 
  """
9441 
  Attributes:
9442 
   - item
9443 
  """
9444 
 
9445 
  thrift_spec = (
9446 
    None, # 0
9447 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
9448 
  )
9449 
 
9450 
  def __init__(self, item=None,):
9451 
    self.item = item
9452 
 
9453 
  def read(self, iprot):
9454 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9455 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9456 
      return
9457 
    iprot.readStructBegin()
9458 
    while True:
9459 
      (fname, ftype, fid) = iprot.readFieldBegin()
9460 
      if ftype == TType.STOP:
9461 
        break
9462 
      if fid == 1:
9463 
        if ftype == TType.STRUCT:
9464 
          self.item = Item()
9465 
          self.item.read(iprot)
9466 
        else:
9467 
          iprot.skip(ftype)
9468 
      else:
9469 
        iprot.skip(ftype)
9470 
      iprot.readFieldEnd()
9471 
    iprot.readStructEnd()
9472 
 
9473 
  def write(self, oprot):
9474 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9475 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9476 
      return
9477 
    oprot.writeStructBegin('addItem_args')
9478 
    if self.item is not None:
9479 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
9480 
      self.item.write(oprot)
9481 
      oprot.writeFieldEnd()
9482 
    oprot.writeFieldStop()
9483 
    oprot.writeStructEnd()
9484 
 
9485 
  def validate(self):
9486 
    return
9487 
 
9488 
 
9489 
  def __repr__(self):
9490 
    L = ['%s=%r' % (key, value)
9491 
      for key, value in self.__dict__.iteritems()]
9492 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9493 
 
9494 
  def __eq__(self, other):
9495 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9496 
 
9497 
  def __ne__(self, other):
9498 
    return not (self == other)
9499 
 
9500 
class addItem_result:
9501 
  """
9502 
  Attributes:
9503 
   - success
9504 
   - cex
9505 
  """
9506 
 
9507 
  thrift_spec = (
9508 
    (0, TType.I64, 'success', None, None, ), # 0
9509 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9510 
  )
9511 
 
9512 
  def __init__(self, success=None, cex=None,):
9513 
    self.success = success
9514 
    self.cex = cex
9515 
 
9516 
  def read(self, iprot):
9517 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9518 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9519 
      return
9520 
    iprot.readStructBegin()
9521 
    while True:
9522 
      (fname, ftype, fid) = iprot.readFieldBegin()
9523 
      if ftype == TType.STOP:
9524 
        break
9525 
      if fid == 0:
9526 
        if ftype == TType.I64:
9527 
          self.success = iprot.readI64();
9528 
        else:
9529 
          iprot.skip(ftype)
9530 
      elif fid == 1:
9531 
        if ftype == TType.STRUCT:
9532 
          self.cex = CatalogServiceException()
9533 
          self.cex.read(iprot)
9534 
        else:
9535 
          iprot.skip(ftype)
9536 
      else:
9537 
        iprot.skip(ftype)
9538 
      iprot.readFieldEnd()
9539 
    iprot.readStructEnd()
9540 
 
9541 
  def write(self, oprot):
9542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9544 
      return
9545 
    oprot.writeStructBegin('addItem_result')
9546 
    if self.success is not None:
9547 
      oprot.writeFieldBegin('success', TType.I64, 0)
9548 
      oprot.writeI64(self.success)
9549 
      oprot.writeFieldEnd()
9550 
    if self.cex is not None:
9551 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9552 
      self.cex.write(oprot)
9553 
      oprot.writeFieldEnd()
9554 
    oprot.writeFieldStop()
9555 
    oprot.writeStructEnd()
9556 
 
9557 
  def validate(self):
9558 
    return
9559 
 
9560 
 
9561 
  def __repr__(self):
9562 
    L = ['%s=%r' % (key, value)
9563 
      for key, value in self.__dict__.iteritems()]
9564 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9565 
 
9566 
  def __eq__(self, other):
9567 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9568 
 
9569 
  def __ne__(self, other):
9570 
    return not (self == other)
9571 
 
9572 
class updateItem_args:
9573 
  """
9574 
  Attributes:
9575 
   - item
9576 
  """
9577 
 
9578 
  thrift_spec = (
9579 
    None, # 0
9580 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
9581 
  )
9582 
 
9583 
  def __init__(self, item=None,):
9584 
    self.item = item
9585 
 
9586 
  def read(self, iprot):
9587 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9588 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9589 
      return
9590 
    iprot.readStructBegin()
9591 
    while True:
9592 
      (fname, ftype, fid) = iprot.readFieldBegin()
9593 
      if ftype == TType.STOP:
9594 
        break
9595 
      if fid == 1:
9596 
        if ftype == TType.STRUCT:
9597 
          self.item = Item()
9598 
          self.item.read(iprot)
9599 
        else:
9600 
          iprot.skip(ftype)
9601 
      else:
9602 
        iprot.skip(ftype)
9603 
      iprot.readFieldEnd()
9604 
    iprot.readStructEnd()
9605 
 
9606 
  def write(self, oprot):
9607 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9608 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9609 
      return
9610 
    oprot.writeStructBegin('updateItem_args')
9611 
    if self.item is not None:
9612 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
9613 
      self.item.write(oprot)
9614 
      oprot.writeFieldEnd()
9615 
    oprot.writeFieldStop()
9616 
    oprot.writeStructEnd()
9617 
 
9618 
  def validate(self):
9619 
    return
9620 
 
9621 
 
9622 
  def __repr__(self):
9623 
    L = ['%s=%r' % (key, value)
9624 
      for key, value in self.__dict__.iteritems()]
9625 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9626 
 
9627 
  def __eq__(self, other):
9628 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9629 
 
9630 
  def __ne__(self, other):
9631 
    return not (self == other)
9632 
 
9633 
class updateItem_result:
9634 
  """
9635 
  Attributes:
9636 
   - success
9637 
   - cex
9638 
  """
9639 
 
9640 
  thrift_spec = (
9641 
    (0, TType.I64, 'success', None, None, ), # 0
9642 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9643 
  )
9644 
 
9645 
  def __init__(self, success=None, cex=None,):
9646 
    self.success = success
9647 
    self.cex = cex
9648 
 
9649 
  def read(self, iprot):
9650 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9651 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9652 
      return
9653 
    iprot.readStructBegin()
9654 
    while True:
9655 
      (fname, ftype, fid) = iprot.readFieldBegin()
9656 
      if ftype == TType.STOP:
9657 
        break
9658 
      if fid == 0:
9659 
        if ftype == TType.I64:
9660 
          self.success = iprot.readI64();
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('updateItem_result')
9679 
    if self.success is not None:
9680 
      oprot.writeFieldBegin('success', TType.I64, 0)
9681 
      oprot.writeI64(self.success)
9682 
      oprot.writeFieldEnd()
9683 
    if self.cex is not None:
9684 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9685 
      self.cex.write(oprot)
9686 
      oprot.writeFieldEnd()
9687 
    oprot.writeFieldStop()
9688 
    oprot.writeStructEnd()
9689 
 
9690 
  def validate(self):
9691 
    return
9692 
 
9693 
 
9694 
  def __repr__(self):
9695 
    L = ['%s=%r' % (key, value)
9696 
      for key, value in self.__dict__.iteritems()]
9697 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9698 
 
9699 
  def __eq__(self, other):
9700 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9701 
 
9702 
  def __ne__(self, other):
9703 
    return not (self == other)
9704 
 
9705 
class isActive_args:
9706 
  """
9707 
  Attributes:
9708 
   - itemId
9709 
  """
9710 
 
9711 
  thrift_spec = (
9712 
    None, # 0
9713 
    (1, TType.I64, 'itemId', None, None, ), # 1
9714 
  )
9715 
 
9716 
  def __init__(self, itemId=None,):
9717 
    self.itemId = itemId
9718 
 
9719 
  def read(self, iprot):
9720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9722 
      return
9723 
    iprot.readStructBegin()
9724 
    while True:
9725 
      (fname, ftype, fid) = iprot.readFieldBegin()
9726 
      if ftype == TType.STOP:
9727 
        break
9728 
      if fid == 1:
9729 
        if ftype == TType.I64:
9730 
          self.itemId = iprot.readI64();
9731 
        else:
9732 
          iprot.skip(ftype)
9733 
      else:
9734 
        iprot.skip(ftype)
9735 
      iprot.readFieldEnd()
9736 
    iprot.readStructEnd()
9737 
 
9738 
  def write(self, oprot):
9739 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9740 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9741 
      return
9742 
    oprot.writeStructBegin('isActive_args')
9743 
    if self.itemId is not None:
9744 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
9745 
      oprot.writeI64(self.itemId)
9746 
      oprot.writeFieldEnd()
9747 
    oprot.writeFieldStop()
9748 
    oprot.writeStructEnd()
9749 
 
9750 
  def validate(self):
9751 
    return
9752 
 
9753 
 
9754 
  def __repr__(self):
9755 
    L = ['%s=%r' % (key, value)
9756 
      for key, value in self.__dict__.iteritems()]
9757 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9758 
 
9759 
  def __eq__(self, other):
9760 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9761 
 
9762 
  def __ne__(self, other):
9763 
    return not (self == other)
9764 
 
9765 
class isActive_result:
9766 
  """
9767 
  Attributes:
9768 
   - success
9769 
   - isex
9770 
  """
9771 
 
9772 
  thrift_spec = (
9773 
    (0, TType.STRUCT, 'success', (ItemShippingInfo, ItemShippingInfo.thrift_spec), None, ), # 0
9774 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9775 
  )
9776 
 
9777 
  def __init__(self, success=None, isex=None,):
9778 
    self.success = success
9779 
    self.isex = isex
9780 
 
9781 
  def read(self, iprot):
9782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9784 
      return
9785 
    iprot.readStructBegin()
9786 
    while True:
9787 
      (fname, ftype, fid) = iprot.readFieldBegin()
9788 
      if ftype == TType.STOP:
9789 
        break
9790 
      if fid == 0:
9791 
        if ftype == TType.STRUCT:
9792 
          self.success = ItemShippingInfo()
9793 
          self.success.read(iprot)
9794 
        else:
9795 
          iprot.skip(ftype)
9796 
      elif fid == 1:
9797 
        if ftype == TType.STRUCT:
9798 
          self.isex = CatalogServiceException()
9799 
          self.isex.read(iprot)
9800 
        else:
9801 
          iprot.skip(ftype)
9802 
      else:
9803 
        iprot.skip(ftype)
9804 
      iprot.readFieldEnd()
9805 
    iprot.readStructEnd()
9806 
 
9807 
  def write(self, oprot):
9808 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9809 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9810 
      return
9811 
    oprot.writeStructBegin('isActive_result')
9812 
    if self.success is not None:
9813 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9814 
      self.success.write(oprot)
9815 
      oprot.writeFieldEnd()
9816 
    if self.isex is not None:
9817 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
9818 
      self.isex.write(oprot)
9819 
      oprot.writeFieldEnd()
9820 
    oprot.writeFieldStop()
9821 
    oprot.writeStructEnd()
9822 
 
9823 
  def validate(self):
9824 
    return
9825 
 
9826 
 
9827 
  def __repr__(self):
9828 
    L = ['%s=%r' % (key, value)
9829 
      for key, value in self.__dict__.iteritems()]
9830 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9831 
 
9832 
  def __eq__(self, other):
9833 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9834 
 
9835 
  def __ne__(self, other):
9836 
    return not (self == other)
9837 
 
7438 amit.gupta 9838 
class getItemsStatus_args:
9839 
  """
9840 
  Attributes:
9841 
   - itemIds
9842 
  """
9843 
 
9844 
  thrift_spec = (
9845 
    None, # 0
9846 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
9847 
  )
9848 
 
9849 
  def __init__(self, itemIds=None,):
9850 
    self.itemIds = itemIds
9851 
 
9852 
  def read(self, iprot):
9853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9855 
      return
9856 
    iprot.readStructBegin()
9857 
    while True:
9858 
      (fname, ftype, fid) = iprot.readFieldBegin()
9859 
      if ftype == TType.STOP:
9860 
        break
9861 
      if fid == 1:
9862 
        if ftype == TType.LIST:
9863 
          self.itemIds = []
8590 kshitij.so 9864 
          (_etype33, _size30) = iprot.readListBegin()
9865 
          for _i34 in xrange(_size30):
9866 
            _elem35 = iprot.readI64();
9867 
            self.itemIds.append(_elem35)
7438 amit.gupta 9868 
          iprot.readListEnd()
9869 
        else:
9870 
          iprot.skip(ftype)
9871 
      else:
9872 
        iprot.skip(ftype)
9873 
      iprot.readFieldEnd()
9874 
    iprot.readStructEnd()
9875 
 
9876 
  def write(self, oprot):
9877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9879 
      return
9880 
    oprot.writeStructBegin('getItemsStatus_args')
9881 
    if self.itemIds is not None:
9882 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
9883 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
8590 kshitij.so 9884 
      for iter36 in self.itemIds:
9885 
        oprot.writeI64(iter36)
7438 amit.gupta 9886 
      oprot.writeListEnd()
9887 
      oprot.writeFieldEnd()
9888 
    oprot.writeFieldStop()
9889 
    oprot.writeStructEnd()
9890 
 
9891 
  def validate(self):
9892 
    return
9893 
 
9894 
 
9895 
  def __repr__(self):
9896 
    L = ['%s=%r' % (key, value)
9897 
      for key, value in self.__dict__.iteritems()]
9898 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9899 
 
9900 
  def __eq__(self, other):
9901 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9902 
 
9903 
  def __ne__(self, other):
9904 
    return not (self == other)
9905 
 
9906 
class getItemsStatus_result:
9907 
  """
9908 
  Attributes:
9909 
   - success
9910 
   - isex
9911 
  """
9912 
 
9913 
  thrift_spec = (
9914 
    (0, TType.MAP, 'success', (TType.I64,None,TType.BOOL,None), None, ), # 0
9915 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9916 
  )
9917 
 
9918 
  def __init__(self, success=None, isex=None,):
9919 
    self.success = success
9920 
    self.isex = isex
9921 
 
9922 
  def read(self, iprot):
9923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9925 
      return
9926 
    iprot.readStructBegin()
9927 
    while True:
9928 
      (fname, ftype, fid) = iprot.readFieldBegin()
9929 
      if ftype == TType.STOP:
9930 
        break
9931 
      if fid == 0:
9932 
        if ftype == TType.MAP:
9933 
          self.success = {}
8590 kshitij.so 9934 
          (_ktype38, _vtype39, _size37 ) = iprot.readMapBegin()
9935 
          for _i41 in xrange(_size37):
9936 
            _key42 = iprot.readI64();
9937 
            _val43 = iprot.readBool();
9938 
            self.success[_key42] = _val43
7438 amit.gupta 9939 
          iprot.readMapEnd()
9940 
        else:
9941 
          iprot.skip(ftype)
9942 
      elif fid == 1:
9943 
        if ftype == TType.STRUCT:
9944 
          self.isex = CatalogServiceException()
9945 
          self.isex.read(iprot)
9946 
        else:
9947 
          iprot.skip(ftype)
9948 
      else:
9949 
        iprot.skip(ftype)
9950 
      iprot.readFieldEnd()
9951 
    iprot.readStructEnd()
9952 
 
9953 
  def write(self, oprot):
9954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9956 
      return
9957 
    oprot.writeStructBegin('getItemsStatus_result')
9958 
    if self.success is not None:
9959 
      oprot.writeFieldBegin('success', TType.MAP, 0)
9960 
      oprot.writeMapBegin(TType.I64, TType.BOOL, len(self.success))
8590 kshitij.so 9961 
      for kiter44,viter45 in self.success.items():
9962 
        oprot.writeI64(kiter44)
9963 
        oprot.writeBool(viter45)
7438 amit.gupta 9964 
      oprot.writeMapEnd()
9965 
      oprot.writeFieldEnd()
9966 
    if self.isex is not None:
9967 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
9968 
      self.isex.write(oprot)
9969 
      oprot.writeFieldEnd()
9970 
    oprot.writeFieldStop()
9971 
    oprot.writeStructEnd()
9972 
 
9973 
  def validate(self):
9974 
    return
9975 
 
9976 
 
9977 
  def __repr__(self):
9978 
    L = ['%s=%r' % (key, value)
9979 
      for key, value in self.__dict__.iteritems()]
9980 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9981 
 
9982 
  def __eq__(self, other):
9983 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9984 
 
9985 
  def __ne__(self, other):
9986 
    return not (self == other)
9987 
 
5944 mandeep.dh 9988 
class getItemStatusDescription_args:
9989 
  """
9990 
  Attributes:
9991 
   - itemId
9992 
  """
9993 
 
9994 
  thrift_spec = (
9995 
    None, # 0
9996 
    (1, TType.I64, 'itemId', None, None, ), # 1
9997 
  )
9998 
 
9999 
  def __init__(self, itemId=None,):
10000 
    self.itemId = itemId
10001 
 
10002 
  def read(self, iprot):
10003 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10004 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10005 
      return
10006 
    iprot.readStructBegin()
10007 
    while True:
10008 
      (fname, ftype, fid) = iprot.readFieldBegin()
10009 
      if ftype == TType.STOP:
10010 
        break
10011 
      if fid == 1:
10012 
        if ftype == TType.I64:
10013 
          self.itemId = iprot.readI64();
10014 
        else:
10015 
          iprot.skip(ftype)
10016 
      else:
10017 
        iprot.skip(ftype)
10018 
      iprot.readFieldEnd()
10019 
    iprot.readStructEnd()
10020 
 
10021 
  def write(self, oprot):
10022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10024 
      return
10025 
    oprot.writeStructBegin('getItemStatusDescription_args')
10026 
    if self.itemId is not None:
10027 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
10028 
      oprot.writeI64(self.itemId)
10029 
      oprot.writeFieldEnd()
10030 
    oprot.writeFieldStop()
10031 
    oprot.writeStructEnd()
10032 
 
10033 
  def validate(self):
10034 
    return
10035 
 
10036 
 
10037 
  def __repr__(self):
10038 
    L = ['%s=%r' % (key, value)
10039 
      for key, value in self.__dict__.iteritems()]
10040 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10041 
 
10042 
  def __eq__(self, other):
10043 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10044 
 
10045 
  def __ne__(self, other):
10046 
    return not (self == other)
10047 
 
10048 
class getItemStatusDescription_result:
10049 
  """
10050 
  Attributes:
10051 
   - success
10052 
   - isex
10053 
  """
10054 
 
10055 
  thrift_spec = (
10056 
    (0, TType.STRING, 'success', None, None, ), # 0
10057 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10058 
  )
10059 
 
10060 
  def __init__(self, success=None, isex=None,):
10061 
    self.success = success
10062 
    self.isex = isex
10063 
 
10064 
  def read(self, iprot):
10065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10067 
      return
10068 
    iprot.readStructBegin()
10069 
    while True:
10070 
      (fname, ftype, fid) = iprot.readFieldBegin()
10071 
      if ftype == TType.STOP:
10072 
        break
10073 
      if fid == 0:
10074 
        if ftype == TType.STRING:
10075 
          self.success = iprot.readString();
10076 
        else:
10077 
          iprot.skip(ftype)
10078 
      elif fid == 1:
10079 
        if ftype == TType.STRUCT:
10080 
          self.isex = CatalogServiceException()
10081 
          self.isex.read(iprot)
10082 
        else:
10083 
          iprot.skip(ftype)
10084 
      else:
10085 
        iprot.skip(ftype)
10086 
      iprot.readFieldEnd()
10087 
    iprot.readStructEnd()
10088 
 
10089 
  def write(self, oprot):
10090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10092 
      return
10093 
    oprot.writeStructBegin('getItemStatusDescription_result')
10094 
    if self.success is not None:
10095 
      oprot.writeFieldBegin('success', TType.STRING, 0)
10096 
      oprot.writeString(self.success)
10097 
      oprot.writeFieldEnd()
10098 
    if self.isex is not None:
10099 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
10100 
      self.isex.write(oprot)
10101 
      oprot.writeFieldEnd()
10102 
    oprot.writeFieldStop()
10103 
    oprot.writeStructEnd()
10104 
 
10105 
  def validate(self):
10106 
    return
10107 
 
10108 
 
10109 
  def __repr__(self):
10110 
    L = ['%s=%r' % (key, value)
10111 
      for key, value in self.__dict__.iteritems()]
10112 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10113 
 
10114 
  def __eq__(self, other):
10115 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10116 
 
10117 
  def __ne__(self, other):
10118 
    return not (self == other)
10119 
 
10120 
class startItemOn_args:
10121 
  """
10122 
  Attributes:
10123 
   - item_id
10124 
   - timestamp
10125 
  """
10126 
 
10127 
  thrift_spec = (
10128 
    None, # 0
10129 
    (1, TType.I64, 'item_id', None, None, ), # 1
10130 
    (2, TType.I64, 'timestamp', None, None, ), # 2
10131 
  )
10132 
 
10133 
  def __init__(self, item_id=None, timestamp=None,):
10134 
    self.item_id = item_id
10135 
    self.timestamp = timestamp
10136 
 
10137 
  def read(self, iprot):
10138 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10139 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10140 
      return
10141 
    iprot.readStructBegin()
10142 
    while True:
10143 
      (fname, ftype, fid) = iprot.readFieldBegin()
10144 
      if ftype == TType.STOP:
10145 
        break
10146 
      if fid == 1:
10147 
        if ftype == TType.I64:
10148 
          self.item_id = iprot.readI64();
10149 
        else:
10150 
          iprot.skip(ftype)
10151 
      elif fid == 2:
10152 
        if ftype == TType.I64:
10153 
          self.timestamp = iprot.readI64();
10154 
        else:
10155 
          iprot.skip(ftype)
10156 
      else:
10157 
        iprot.skip(ftype)
10158 
      iprot.readFieldEnd()
10159 
    iprot.readStructEnd()
10160 
 
10161 
  def write(self, oprot):
10162 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10163 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10164 
      return
10165 
    oprot.writeStructBegin('startItemOn_args')
10166 
    if self.item_id is not None:
10167 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
10168 
      oprot.writeI64(self.item_id)
10169 
      oprot.writeFieldEnd()
10170 
    if self.timestamp is not None:
10171 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
10172 
      oprot.writeI64(self.timestamp)
10173 
      oprot.writeFieldEnd()
10174 
    oprot.writeFieldStop()
10175 
    oprot.writeStructEnd()
10176 
 
10177 
  def validate(self):
10178 
    return
10179 
 
10180 
 
10181 
  def __repr__(self):
10182 
    L = ['%s=%r' % (key, value)
10183 
      for key, value in self.__dict__.iteritems()]
10184 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10185 
 
10186 
  def __eq__(self, other):
10187 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10188 
 
10189 
  def __ne__(self, other):
10190 
    return not (self == other)
10191 
 
10192 
class startItemOn_result:
10193 
  """
10194 
  Attributes:
10195 
   - cex
10196 
  """
10197 
 
10198 
  thrift_spec = (
10199 
    None, # 0
10200 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10201 
  )
10202 
 
10203 
  def __init__(self, cex=None,):
10204 
    self.cex = cex
10205 
 
10206 
  def read(self, iprot):
10207 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10208 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10209 
      return
10210 
    iprot.readStructBegin()
10211 
    while True:
10212 
      (fname, ftype, fid) = iprot.readFieldBegin()
10213 
      if ftype == TType.STOP:
10214 
        break
10215 
      if fid == 1:
10216 
        if ftype == TType.STRUCT:
10217 
          self.cex = CatalogServiceException()
10218 
          self.cex.read(iprot)
10219 
        else:
10220 
          iprot.skip(ftype)
10221 
      else:
10222 
        iprot.skip(ftype)
10223 
      iprot.readFieldEnd()
10224 
    iprot.readStructEnd()
10225 
 
10226 
  def write(self, oprot):
10227 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10228 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10229 
      return
10230 
    oprot.writeStructBegin('startItemOn_result')
10231 
    if self.cex is not None:
10232 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10233 
      self.cex.write(oprot)
10234 
      oprot.writeFieldEnd()
10235 
    oprot.writeFieldStop()
10236 
    oprot.writeStructEnd()
10237 
 
10238 
  def validate(self):
10239 
    return
10240 
 
10241 
 
10242 
  def __repr__(self):
10243 
    L = ['%s=%r' % (key, value)
10244 
      for key, value in self.__dict__.iteritems()]
10245 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10246 
 
10247 
  def __eq__(self, other):
10248 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10249 
 
10250 
  def __ne__(self, other):
10251 
    return not (self == other)
10252 
 
10253 
class retireItemOn_args:
10254 
  """
10255 
  Attributes:
10256 
   - item_id
10257 
   - timestamp
10258 
  """
10259 
 
10260 
  thrift_spec = (
10261 
    None, # 0
10262 
    (1, TType.I64, 'item_id', None, None, ), # 1
10263 
    (2, TType.I64, 'timestamp', None, None, ), # 2
10264 
  )
10265 
 
10266 
  def __init__(self, item_id=None, timestamp=None,):
10267 
    self.item_id = item_id
10268 
    self.timestamp = timestamp
10269 
 
10270 
  def read(self, iprot):
10271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10273 
      return
10274 
    iprot.readStructBegin()
10275 
    while True:
10276 
      (fname, ftype, fid) = iprot.readFieldBegin()
10277 
      if ftype == TType.STOP:
10278 
        break
10279 
      if fid == 1:
10280 
        if ftype == TType.I64:
10281 
          self.item_id = iprot.readI64();
10282 
        else:
10283 
          iprot.skip(ftype)
10284 
      elif fid == 2:
10285 
        if ftype == TType.I64:
10286 
          self.timestamp = iprot.readI64();
10287 
        else:
10288 
          iprot.skip(ftype)
10289 
      else:
10290 
        iprot.skip(ftype)
10291 
      iprot.readFieldEnd()
10292 
    iprot.readStructEnd()
10293 
 
10294 
  def write(self, oprot):
10295 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10296 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10297 
      return
10298 
    oprot.writeStructBegin('retireItemOn_args')
10299 
    if self.item_id is not None:
10300 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
10301 
      oprot.writeI64(self.item_id)
10302 
      oprot.writeFieldEnd()
10303 
    if self.timestamp is not None:
10304 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
10305 
      oprot.writeI64(self.timestamp)
10306 
      oprot.writeFieldEnd()
10307 
    oprot.writeFieldStop()
10308 
    oprot.writeStructEnd()
10309 
 
10310 
  def validate(self):
10311 
    return
10312 
 
10313 
 
10314 
  def __repr__(self):
10315 
    L = ['%s=%r' % (key, value)
10316 
      for key, value in self.__dict__.iteritems()]
10317 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10318 
 
10319 
  def __eq__(self, other):
10320 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10321 
 
10322 
  def __ne__(self, other):
10323 
    return not (self == other)
10324 
 
10325 
class retireItemOn_result:
10326 
  """
10327 
  Attributes:
10328 
   - cex
10329 
  """
10330 
 
10331 
  thrift_spec = (
10332 
    None, # 0
10333 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10334 
  )
10335 
 
10336 
  def __init__(self, cex=None,):
10337 
    self.cex = cex
10338 
 
10339 
  def read(self, iprot):
10340 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10341 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10342 
      return
10343 
    iprot.readStructBegin()
10344 
    while True:
10345 
      (fname, ftype, fid) = iprot.readFieldBegin()
10346 
      if ftype == TType.STOP:
10347 
        break
10348 
      if fid == 1:
10349 
        if ftype == TType.STRUCT:
10350 
          self.cex = CatalogServiceException()
10351 
          self.cex.read(iprot)
10352 
        else:
10353 
          iprot.skip(ftype)
10354 
      else:
10355 
        iprot.skip(ftype)
10356 
      iprot.readFieldEnd()
10357 
    iprot.readStructEnd()
10358 
 
10359 
  def write(self, oprot):
10360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10362 
      return
10363 
    oprot.writeStructBegin('retireItemOn_result')
10364 
    if self.cex is not None:
10365 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10366 
      self.cex.write(oprot)
10367 
      oprot.writeFieldEnd()
10368 
    oprot.writeFieldStop()
10369 
    oprot.writeStructEnd()
10370 
 
10371 
  def validate(self):
10372 
    return
10373 
 
10374 
 
10375 
  def __repr__(self):
10376 
    L = ['%s=%r' % (key, value)
10377 
      for key, value in self.__dict__.iteritems()]
10378 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10379 
 
10380 
  def __eq__(self, other):
10381 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10382 
 
10383 
  def __ne__(self, other):
10384 
    return not (self == other)
10385 
 
10386 
class changeItemStatus_args:
10387 
  """
10388 
  Attributes:
10389 
   - item_id
10390 
   - timestamp
10391 
   - newstatus
10392 
  """
10393 
 
10394 
  thrift_spec = (
10395 
    None, # 0
10396 
    (1, TType.I64, 'item_id', None, None, ), # 1
10397 
    (2, TType.I64, 'timestamp', None, None, ), # 2
10398 
    (3, TType.I32, 'newstatus', None, None, ), # 3
10399 
  )
10400 
 
10401 
  def __init__(self, item_id=None, timestamp=None, newstatus=None,):
10402 
    self.item_id = item_id
10403 
    self.timestamp = timestamp
10404 
    self.newstatus = newstatus
10405 
 
10406 
  def read(self, iprot):
10407 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10408 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10409 
      return
10410 
    iprot.readStructBegin()
10411 
    while True:
10412 
      (fname, ftype, fid) = iprot.readFieldBegin()
10413 
      if ftype == TType.STOP:
10414 
        break
10415 
      if fid == 1:
10416 
        if ftype == TType.I64:
10417 
          self.item_id = iprot.readI64();
10418 
        else:
10419 
          iprot.skip(ftype)
10420 
      elif fid == 2:
10421 
        if ftype == TType.I64:
10422 
          self.timestamp = iprot.readI64();
10423 
        else:
10424 
          iprot.skip(ftype)
10425 
      elif fid == 3:
10426 
        if ftype == TType.I32:
10427 
          self.newstatus = iprot.readI32();
10428 
        else:
10429 
          iprot.skip(ftype)
10430 
      else:
10431 
        iprot.skip(ftype)
10432 
      iprot.readFieldEnd()
10433 
    iprot.readStructEnd()
10434 
 
10435 
  def write(self, oprot):
10436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10438 
      return
10439 
    oprot.writeStructBegin('changeItemStatus_args')
10440 
    if self.item_id is not None:
10441 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
10442 
      oprot.writeI64(self.item_id)
10443 
      oprot.writeFieldEnd()
10444 
    if self.timestamp is not None:
10445 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
10446 
      oprot.writeI64(self.timestamp)
10447 
      oprot.writeFieldEnd()
10448 
    if self.newstatus is not None:
10449 
      oprot.writeFieldBegin('newstatus', TType.I32, 3)
10450 
      oprot.writeI32(self.newstatus)
10451 
      oprot.writeFieldEnd()
10452 
    oprot.writeFieldStop()
10453 
    oprot.writeStructEnd()
10454 
 
10455 
  def validate(self):
10456 
    return
10457 
 
10458 
 
10459 
  def __repr__(self):
10460 
    L = ['%s=%r' % (key, value)
10461 
      for key, value in self.__dict__.iteritems()]
10462 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10463 
 
10464 
  def __eq__(self, other):
10465 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10466 
 
10467 
  def __ne__(self, other):
10468 
    return not (self == other)
10469 
 
10470 
class changeItemStatus_result:
10471 
  """
10472 
  Attributes:
10473 
   - cex
10474 
  """
10475 
 
10476 
  thrift_spec = (
10477 
    None, # 0
10478 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10479 
  )
10480 
 
10481 
  def __init__(self, cex=None,):
10482 
    self.cex = cex
10483 
 
10484 
  def read(self, iprot):
10485 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10486 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10487 
      return
10488 
    iprot.readStructBegin()
10489 
    while True:
10490 
      (fname, ftype, fid) = iprot.readFieldBegin()
10491 
      if ftype == TType.STOP:
10492 
        break
10493 
      if fid == 1:
10494 
        if ftype == TType.STRUCT:
10495 
          self.cex = CatalogServiceException()
10496 
          self.cex.read(iprot)
10497 
        else:
10498 
          iprot.skip(ftype)
10499 
      else:
10500 
        iprot.skip(ftype)
10501 
      iprot.readFieldEnd()
10502 
    iprot.readStructEnd()
10503 
 
10504 
  def write(self, oprot):
10505 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10506 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10507 
      return
10508 
    oprot.writeStructBegin('changeItemStatus_result')
10509 
    if self.cex is not None:
10510 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10511 
      self.cex.write(oprot)
10512 
      oprot.writeFieldEnd()
10513 
    oprot.writeFieldStop()
10514 
    oprot.writeStructEnd()
10515 
 
10516 
  def validate(self):
10517 
    return
10518 
 
10519 
 
10520 
  def __repr__(self):
10521 
    L = ['%s=%r' % (key, value)
10522 
      for key, value in self.__dict__.iteritems()]
10523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10524 
 
10525 
  def __eq__(self, other):
10526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10527 
 
10528 
  def __ne__(self, other):
10529 
    return not (self == other)
10530 
 
10531 
class getItem_args:
10532 
  """
10533 
  Attributes:
10534 
   - item_id
10535 
  """
10536 
 
10537 
  thrift_spec = (
10538 
    None, # 0
10539 
    (1, TType.I64, 'item_id', None, None, ), # 1
10540 
  )
10541 
 
10542 
  def __init__(self, item_id=None,):
10543 
    self.item_id = item_id
10544 
 
10545 
  def read(self, iprot):
10546 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10547 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10548 
      return
10549 
    iprot.readStructBegin()
10550 
    while True:
10551 
      (fname, ftype, fid) = iprot.readFieldBegin()
10552 
      if ftype == TType.STOP:
10553 
        break
10554 
      if fid == 1:
10555 
        if ftype == TType.I64:
10556 
          self.item_id = iprot.readI64();
10557 
        else:
10558 
          iprot.skip(ftype)
10559 
      else:
10560 
        iprot.skip(ftype)
10561 
      iprot.readFieldEnd()
10562 
    iprot.readStructEnd()
10563 
 
10564 
  def write(self, oprot):
10565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10567 
      return
10568 
    oprot.writeStructBegin('getItem_args')
10569 
    if self.item_id is not None:
10570 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
10571 
      oprot.writeI64(self.item_id)
10572 
      oprot.writeFieldEnd()
10573 
    oprot.writeFieldStop()
10574 
    oprot.writeStructEnd()
10575 
 
10576 
  def validate(self):
10577 
    return
10578 
 
10579 
 
10580 
  def __repr__(self):
10581 
    L = ['%s=%r' % (key, value)
10582 
      for key, value in self.__dict__.iteritems()]
10583 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10584 
 
10585 
  def __eq__(self, other):
10586 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10587 
 
10588 
  def __ne__(self, other):
10589 
    return not (self == other)
10590 
 
10591 
class getItem_result:
10592 
  """
10593 
  Attributes:
10594 
   - success
10595 
   - cex
10596 
  """
10597 
 
10598 
  thrift_spec = (
10599 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
10600 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10601 
  )
10602 
 
10603 
  def __init__(self, success=None, cex=None,):
10604 
    self.success = success
10605 
    self.cex = cex
10606 
 
10607 
  def read(self, iprot):
10608 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10609 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10610 
      return
10611 
    iprot.readStructBegin()
10612 
    while True:
10613 
      (fname, ftype, fid) = iprot.readFieldBegin()
10614 
      if ftype == TType.STOP:
10615 
        break
10616 
      if fid == 0:
10617 
        if ftype == TType.STRUCT:
10618 
          self.success = Item()
10619 
          self.success.read(iprot)
10620 
        else:
10621 
          iprot.skip(ftype)
10622 
      elif fid == 1:
10623 
        if ftype == TType.STRUCT:
10624 
          self.cex = CatalogServiceException()
10625 
          self.cex.read(iprot)
10626 
        else:
10627 
          iprot.skip(ftype)
10628 
      else:
10629 
        iprot.skip(ftype)
10630 
      iprot.readFieldEnd()
10631 
    iprot.readStructEnd()
10632 
 
10633 
  def write(self, oprot):
10634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10636 
      return
10637 
    oprot.writeStructBegin('getItem_result')
10638 
    if self.success is not None:
10639 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10640 
      self.success.write(oprot)
10641 
      oprot.writeFieldEnd()
10642 
    if self.cex is not None:
10643 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10644 
      self.cex.write(oprot)
10645 
      oprot.writeFieldEnd()
10646 
    oprot.writeFieldStop()
10647 
    oprot.writeStructEnd()
10648 
 
10649 
  def validate(self):
10650 
    return
10651 
 
10652 
 
10653 
  def __repr__(self):
10654 
    L = ['%s=%r' % (key, value)
10655 
      for key, value in self.__dict__.iteritems()]
10656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10657 
 
10658 
  def __eq__(self, other):
10659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10660 
 
10661 
  def __ne__(self, other):
10662 
    return not (self == other)
10663 
 
13493 amit.gupta 10664 
class getItems_args:
10665 
  """
10666 
  Attributes:
10667 
   - item_ids
10668 
  """
10669 
 
10670 
  thrift_spec = (
10671 
    None, # 0
10672 
    (1, TType.LIST, 'item_ids', (TType.I64,None), None, ), # 1
10673 
  )
10674 
 
10675 
  def __init__(self, item_ids=None,):
10676 
    self.item_ids = item_ids
10677 
 
10678 
  def read(self, iprot):
10679 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10680 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10681 
      return
10682 
    iprot.readStructBegin()
10683 
    while True:
10684 
      (fname, ftype, fid) = iprot.readFieldBegin()
10685 
      if ftype == TType.STOP:
10686 
        break
10687 
      if fid == 1:
10688 
        if ftype == TType.LIST:
10689 
          self.item_ids = []
10690 
          (_etype49, _size46) = iprot.readListBegin()
10691 
          for _i50 in xrange(_size46):
10692 
            _elem51 = iprot.readI64();
10693 
            self.item_ids.append(_elem51)
10694 
          iprot.readListEnd()
10695 
        else:
10696 
          iprot.skip(ftype)
10697 
      else:
10698 
        iprot.skip(ftype)
10699 
      iprot.readFieldEnd()
10700 
    iprot.readStructEnd()
10701 
 
10702 
  def write(self, oprot):
10703 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10704 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10705 
      return
10706 
    oprot.writeStructBegin('getItems_args')
10707 
    if self.item_ids is not None:
10708 
      oprot.writeFieldBegin('item_ids', TType.LIST, 1)
10709 
      oprot.writeListBegin(TType.I64, len(self.item_ids))
10710 
      for iter52 in self.item_ids:
10711 
        oprot.writeI64(iter52)
10712 
      oprot.writeListEnd()
10713 
      oprot.writeFieldEnd()
10714 
    oprot.writeFieldStop()
10715 
    oprot.writeStructEnd()
10716 
 
10717 
  def validate(self):
10718 
    return
10719 
 
10720 
 
10721 
  def __repr__(self):
10722 
    L = ['%s=%r' % (key, value)
10723 
      for key, value in self.__dict__.iteritems()]
10724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10725 
 
10726 
  def __eq__(self, other):
10727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10728 
 
10729 
  def __ne__(self, other):
10730 
    return not (self == other)
10731 
 
10732 
class getItems_result:
10733 
  """
10734 
  Attributes:
10735 
   - success
10736 
   - cex
10737 
  """
10738 
 
10739 
  thrift_spec = (
10740 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10741 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10742 
  )
10743 
 
10744 
  def __init__(self, success=None, cex=None,):
10745 
    self.success = success
10746 
    self.cex = cex
10747 
 
10748 
  def read(self, iprot):
10749 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10750 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10751 
      return
10752 
    iprot.readStructBegin()
10753 
    while True:
10754 
      (fname, ftype, fid) = iprot.readFieldBegin()
10755 
      if ftype == TType.STOP:
10756 
        break
10757 
      if fid == 0:
10758 
        if ftype == TType.MAP:
10759 
          self.success = {}
10760 
          (_ktype54, _vtype55, _size53 ) = iprot.readMapBegin()
10761 
          for _i57 in xrange(_size53):
10762 
            _key58 = iprot.readI64();
10763 
            _val59 = Item()
10764 
            _val59.read(iprot)
10765 
            self.success[_key58] = _val59
10766 
          iprot.readMapEnd()
10767 
        else:
10768 
          iprot.skip(ftype)
10769 
      elif fid == 1:
10770 
        if ftype == TType.STRUCT:
10771 
          self.cex = CatalogServiceException()
10772 
          self.cex.read(iprot)
10773 
        else:
10774 
          iprot.skip(ftype)
10775 
      else:
10776 
        iprot.skip(ftype)
10777 
      iprot.readFieldEnd()
10778 
    iprot.readStructEnd()
10779 
 
10780 
  def write(self, oprot):
10781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10783 
      return
10784 
    oprot.writeStructBegin('getItems_result')
10785 
    if self.success is not None:
10786 
      oprot.writeFieldBegin('success', TType.MAP, 0)
10787 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.success))
10788 
      for kiter60,viter61 in self.success.items():
10789 
        oprot.writeI64(kiter60)
10790 
        viter61.write(oprot)
10791 
      oprot.writeMapEnd()
10792 
      oprot.writeFieldEnd()
10793 
    if self.cex is not None:
10794 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10795 
      self.cex.write(oprot)
10796 
      oprot.writeFieldEnd()
10797 
    oprot.writeFieldStop()
10798 
    oprot.writeStructEnd()
10799 
 
10800 
  def validate(self):
10801 
    return
10802 
 
10803 
 
10804 
  def __repr__(self):
10805 
    L = ['%s=%r' % (key, value)
10806 
      for key, value in self.__dict__.iteritems()]
10807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10808 
 
10809 
  def __eq__(self, other):
10810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10811 
 
10812 
  def __ne__(self, other):
10813 
    return not (self == other)
10814 
 
5944 mandeep.dh 10815 
class getItemsByCatalogId_args:
10816 
  """
10817 
  Attributes:
10818 
   - catalog_item_id
10819 
  """
10820 
 
10821 
  thrift_spec = (
10822 
    None, # 0
10823 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
10824 
  )
10825 
 
10826 
  def __init__(self, catalog_item_id=None,):
10827 
    self.catalog_item_id = catalog_item_id
10828 
 
10829 
  def read(self, iprot):
10830 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10831 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10832 
      return
10833 
    iprot.readStructBegin()
10834 
    while True:
10835 
      (fname, ftype, fid) = iprot.readFieldBegin()
10836 
      if ftype == TType.STOP:
10837 
        break
10838 
      if fid == 1:
10839 
        if ftype == TType.I64:
10840 
          self.catalog_item_id = iprot.readI64();
10841 
        else:
10842 
          iprot.skip(ftype)
10843 
      else:
10844 
        iprot.skip(ftype)
10845 
      iprot.readFieldEnd()
10846 
    iprot.readStructEnd()
10847 
 
10848 
  def write(self, oprot):
10849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10851 
      return
10852 
    oprot.writeStructBegin('getItemsByCatalogId_args')
10853 
    if self.catalog_item_id is not None:
10854 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
10855 
      oprot.writeI64(self.catalog_item_id)
10856 
      oprot.writeFieldEnd()
10857 
    oprot.writeFieldStop()
10858 
    oprot.writeStructEnd()
10859 
 
10860 
  def validate(self):
10861 
    return
10862 
 
10863 
 
10864 
  def __repr__(self):
10865 
    L = ['%s=%r' % (key, value)
10866 
      for key, value in self.__dict__.iteritems()]
10867 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10868 
 
10869 
  def __eq__(self, other):
10870 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10871 
 
10872 
  def __ne__(self, other):
10873 
    return not (self == other)
10874 
 
10875 
class getItemsByCatalogId_result:
10876 
  """
10877 
  Attributes:
10878 
   - success
10879 
   - cex
10880 
  """
10881 
 
10882 
  thrift_spec = (
10883 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10884 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10885 
  )
10886 
 
10887 
  def __init__(self, success=None, cex=None,):
10888 
    self.success = success
10889 
    self.cex = cex
10890 
 
10891 
  def read(self, iprot):
10892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10894 
      return
10895 
    iprot.readStructBegin()
10896 
    while True:
10897 
      (fname, ftype, fid) = iprot.readFieldBegin()
10898 
      if ftype == TType.STOP:
10899 
        break
10900 
      if fid == 0:
10901 
        if ftype == TType.LIST:
10902 
          self.success = []
13493 amit.gupta 10903 
          (_etype65, _size62) = iprot.readListBegin()
10904 
          for _i66 in xrange(_size62):
10905 
            _elem67 = Item()
10906 
            _elem67.read(iprot)
10907 
            self.success.append(_elem67)
5944 mandeep.dh 10908 
          iprot.readListEnd()
10909 
        else:
10910 
          iprot.skip(ftype)
10911 
      elif fid == 1:
10912 
        if ftype == TType.STRUCT:
10913 
          self.cex = CatalogServiceException()
10914 
          self.cex.read(iprot)
10915 
        else:
10916 
          iprot.skip(ftype)
10917 
      else:
10918 
        iprot.skip(ftype)
10919 
      iprot.readFieldEnd()
10920 
    iprot.readStructEnd()
10921 
 
10922 
  def write(self, oprot):
10923 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10924 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10925 
      return
10926 
    oprot.writeStructBegin('getItemsByCatalogId_result')
10927 
    if self.success is not None:
10928 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10929 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 10930 
      for iter68 in self.success:
10931 
        iter68.write(oprot)
5944 mandeep.dh 10932 
      oprot.writeListEnd()
10933 
      oprot.writeFieldEnd()
10934 
    if self.cex is not None:
10935 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10936 
      self.cex.write(oprot)
10937 
      oprot.writeFieldEnd()
10938 
    oprot.writeFieldStop()
10939 
    oprot.writeStructEnd()
10940 
 
10941 
  def validate(self):
10942 
    return
10943 
 
10944 
 
10945 
  def __repr__(self):
10946 
    L = ['%s=%r' % (key, value)
10947 
      for key, value in self.__dict__.iteritems()]
10948 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10949 
 
10950 
  def __eq__(self, other):
10951 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10952 
 
10953 
  def __ne__(self, other):
10954 
    return not (self == other)
10955 
 
10956 
class getValidItemsByCatalogId_args:
10957 
  """
10958 
  Attributes:
10959 
   - catalog_item_id
10960 
  """
10961 
 
10962 
  thrift_spec = (
10963 
    None, # 0
10964 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
10965 
  )
10966 
 
10967 
  def __init__(self, catalog_item_id=None,):
10968 
    self.catalog_item_id = catalog_item_id
10969 
 
10970 
  def read(self, iprot):
10971 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10972 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10973 
      return
10974 
    iprot.readStructBegin()
10975 
    while True:
10976 
      (fname, ftype, fid) = iprot.readFieldBegin()
10977 
      if ftype == TType.STOP:
10978 
        break
10979 
      if fid == 1:
10980 
        if ftype == TType.I64:
10981 
          self.catalog_item_id = iprot.readI64();
10982 
        else:
10983 
          iprot.skip(ftype)
10984 
      else:
10985 
        iprot.skip(ftype)
10986 
      iprot.readFieldEnd()
10987 
    iprot.readStructEnd()
10988 
 
10989 
  def write(self, oprot):
10990 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10991 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10992 
      return
10993 
    oprot.writeStructBegin('getValidItemsByCatalogId_args')
10994 
    if self.catalog_item_id is not None:
10995 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
10996 
      oprot.writeI64(self.catalog_item_id)
10997 
      oprot.writeFieldEnd()
10998 
    oprot.writeFieldStop()
10999 
    oprot.writeStructEnd()
11000 
 
11001 
  def validate(self):
11002 
    return
11003 
 
11004 
 
11005 
  def __repr__(self):
11006 
    L = ['%s=%r' % (key, value)
11007 
      for key, value in self.__dict__.iteritems()]
11008 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11009 
 
11010 
  def __eq__(self, other):
11011 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11012 
 
11013 
  def __ne__(self, other):
11014 
    return not (self == other)
11015 
 
11016 
class getValidItemsByCatalogId_result:
11017 
  """
11018 
  Attributes:
11019 
   - success
11020 
   - cex
11021 
  """
11022 
 
11023 
  thrift_spec = (
11024 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11025 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11026 
  )
11027 
 
11028 
  def __init__(self, success=None, cex=None,):
11029 
    self.success = success
11030 
    self.cex = cex
11031 
 
11032 
  def read(self, iprot):
11033 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11034 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11035 
      return
11036 
    iprot.readStructBegin()
11037 
    while True:
11038 
      (fname, ftype, fid) = iprot.readFieldBegin()
11039 
      if ftype == TType.STOP:
11040 
        break
11041 
      if fid == 0:
11042 
        if ftype == TType.LIST:
11043 
          self.success = []
13493 amit.gupta 11044 
          (_etype72, _size69) = iprot.readListBegin()
11045 
          for _i73 in xrange(_size69):
11046 
            _elem74 = Item()
11047 
            _elem74.read(iprot)
11048 
            self.success.append(_elem74)
5944 mandeep.dh 11049 
          iprot.readListEnd()
11050 
        else:
11051 
          iprot.skip(ftype)
11052 
      elif fid == 1:
11053 
        if ftype == TType.STRUCT:
11054 
          self.cex = CatalogServiceException()
11055 
          self.cex.read(iprot)
11056 
        else:
11057 
          iprot.skip(ftype)
11058 
      else:
11059 
        iprot.skip(ftype)
11060 
      iprot.readFieldEnd()
11061 
    iprot.readStructEnd()
11062 
 
11063 
  def write(self, oprot):
11064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11066 
      return
11067 
    oprot.writeStructBegin('getValidItemsByCatalogId_result')
11068 
    if self.success is not None:
11069 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11070 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 11071 
      for iter75 in self.success:
11072 
        iter75.write(oprot)
5944 mandeep.dh 11073 
      oprot.writeListEnd()
11074 
      oprot.writeFieldEnd()
11075 
    if self.cex is not None:
11076 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11077 
      self.cex.write(oprot)
11078 
      oprot.writeFieldEnd()
11079 
    oprot.writeFieldStop()
11080 
    oprot.writeStructEnd()
11081 
 
11082 
  def validate(self):
11083 
    return
11084 
 
11085 
 
11086 
  def __repr__(self):
11087 
    L = ['%s=%r' % (key, value)
11088 
      for key, value in self.__dict__.iteritems()]
11089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11090 
 
11091 
  def __eq__(self, other):
11092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11093 
 
11094 
  def __ne__(self, other):
11095 
    return not (self == other)
11096 
 
11097 
class getAllItems_args:
11098 
  """
11099 
  Attributes:
11100 
   - isActive
11101 
  """
11102 
 
11103 
  thrift_spec = (
11104 
    None, # 0
11105 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
11106 
  )
11107 
 
11108 
  def __init__(self, isActive=None,):
11109 
    self.isActive = isActive
11110 
 
11111 
  def read(self, iprot):
11112 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11113 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11114 
      return
11115 
    iprot.readStructBegin()
11116 
    while True:
11117 
      (fname, ftype, fid) = iprot.readFieldBegin()
11118 
      if ftype == TType.STOP:
11119 
        break
11120 
      if fid == 1:
11121 
        if ftype == TType.BOOL:
11122 
          self.isActive = iprot.readBool();
11123 
        else:
11124 
          iprot.skip(ftype)
11125 
      else:
11126 
        iprot.skip(ftype)
11127 
      iprot.readFieldEnd()
11128 
    iprot.readStructEnd()
11129 
 
11130 
  def write(self, oprot):
11131 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11132 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11133 
      return
11134 
    oprot.writeStructBegin('getAllItems_args')
11135 
    if self.isActive is not None:
11136 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
11137 
      oprot.writeBool(self.isActive)
11138 
      oprot.writeFieldEnd()
11139 
    oprot.writeFieldStop()
11140 
    oprot.writeStructEnd()
11141 
 
11142 
  def validate(self):
11143 
    return
11144 
 
11145 
 
11146 
  def __repr__(self):
11147 
    L = ['%s=%r' % (key, value)
11148 
      for key, value in self.__dict__.iteritems()]
11149 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11150 
 
11151 
  def __eq__(self, other):
11152 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11153 
 
11154 
  def __ne__(self, other):
11155 
    return not (self == other)
11156 
 
11157 
class getAllItems_result:
11158 
  """
11159 
  Attributes:
11160 
   - success
11161 
   - cex
11162 
  """
11163 
 
11164 
  thrift_spec = (
11165 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11166 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11167 
  )
11168 
 
11169 
  def __init__(self, success=None, cex=None,):
11170 
    self.success = success
11171 
    self.cex = cex
11172 
 
11173 
  def read(self, iprot):
11174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11176 
      return
11177 
    iprot.readStructBegin()
11178 
    while True:
11179 
      (fname, ftype, fid) = iprot.readFieldBegin()
11180 
      if ftype == TType.STOP:
11181 
        break
11182 
      if fid == 0:
11183 
        if ftype == TType.LIST:
11184 
          self.success = []
13493 amit.gupta 11185 
          (_etype79, _size76) = iprot.readListBegin()
11186 
          for _i80 in xrange(_size76):
11187 
            _elem81 = Item()
11188 
            _elem81.read(iprot)
11189 
            self.success.append(_elem81)
5944 mandeep.dh 11190 
          iprot.readListEnd()
11191 
        else:
11192 
          iprot.skip(ftype)
11193 
      elif fid == 1:
11194 
        if ftype == TType.STRUCT:
11195 
          self.cex = CatalogServiceException()
11196 
          self.cex.read(iprot)
11197 
        else:
11198 
          iprot.skip(ftype)
11199 
      else:
11200 
        iprot.skip(ftype)
11201 
      iprot.readFieldEnd()
11202 
    iprot.readStructEnd()
11203 
 
11204 
  def write(self, oprot):
11205 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11206 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11207 
      return
11208 
    oprot.writeStructBegin('getAllItems_result')
11209 
    if self.success is not None:
11210 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11211 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 11212 
      for iter82 in self.success:
11213 
        iter82.write(oprot)
5944 mandeep.dh 11214 
      oprot.writeListEnd()
11215 
      oprot.writeFieldEnd()
11216 
    if self.cex is not None:
11217 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11218 
      self.cex.write(oprot)
11219 
      oprot.writeFieldEnd()
11220 
    oprot.writeFieldStop()
11221 
    oprot.writeStructEnd()
11222 
 
11223 
  def validate(self):
11224 
    return
11225 
 
11226 
 
11227 
  def __repr__(self):
11228 
    L = ['%s=%r' % (key, value)
11229 
      for key, value in self.__dict__.iteritems()]
11230 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11231 
 
11232 
  def __eq__(self, other):
11233 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11234 
 
11235 
  def __ne__(self, other):
11236 
    return not (self == other)
11237 
 
11238 
class getAllItemsByStatus_args:
11239 
  """
11240 
  Attributes:
11241 
   - itemStatus
11242 
  """
11243 
 
11244 
  thrift_spec = (
11245 
    None, # 0
11246 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
11247 
  )
11248 
 
11249 
  def __init__(self, itemStatus=None,):
11250 
    self.itemStatus = itemStatus
11251 
 
11252 
  def read(self, iprot):
11253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11255 
      return
11256 
    iprot.readStructBegin()
11257 
    while True:
11258 
      (fname, ftype, fid) = iprot.readFieldBegin()
11259 
      if ftype == TType.STOP:
11260 
        break
11261 
      if fid == 1:
11262 
        if ftype == TType.I32:
11263 
          self.itemStatus = iprot.readI32();
11264 
        else:
11265 
          iprot.skip(ftype)
11266 
      else:
11267 
        iprot.skip(ftype)
11268 
      iprot.readFieldEnd()
11269 
    iprot.readStructEnd()
11270 
 
11271 
  def write(self, oprot):
11272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11274 
      return
11275 
    oprot.writeStructBegin('getAllItemsByStatus_args')
11276 
    if self.itemStatus is not None:
11277 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
11278 
      oprot.writeI32(self.itemStatus)
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 getAllItemsByStatus_result:
11299 
  """
11300 
  Attributes:
11301 
   - success
11302 
   - cex
11303 
  """
11304 
 
11305 
  thrift_spec = (
11306 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11307 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11308 
  )
11309 
 
11310 
  def __init__(self, success=None, cex=None,):
11311 
    self.success = success
11312 
    self.cex = cex
11313 
 
11314 
  def read(self, iprot):
11315 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11316 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11317 
      return
11318 
    iprot.readStructBegin()
11319 
    while True:
11320 
      (fname, ftype, fid) = iprot.readFieldBegin()
11321 
      if ftype == TType.STOP:
11322 
        break
11323 
      if fid == 0:
11324 
        if ftype == TType.LIST:
11325 
          self.success = []
13493 amit.gupta 11326 
          (_etype86, _size83) = iprot.readListBegin()
11327 
          for _i87 in xrange(_size83):
11328 
            _elem88 = Item()
11329 
            _elem88.read(iprot)
11330 
            self.success.append(_elem88)
5944 mandeep.dh 11331 
          iprot.readListEnd()
11332 
        else:
11333 
          iprot.skip(ftype)
11334 
      elif fid == 1:
11335 
        if ftype == TType.STRUCT:
11336 
          self.cex = CatalogServiceException()
11337 
          self.cex.read(iprot)
11338 
        else:
11339 
          iprot.skip(ftype)
11340 
      else:
11341 
        iprot.skip(ftype)
11342 
      iprot.readFieldEnd()
11343 
    iprot.readStructEnd()
11344 
 
11345 
  def write(self, oprot):
11346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11348 
      return
11349 
    oprot.writeStructBegin('getAllItemsByStatus_result')
11350 
    if self.success is not None:
11351 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11352 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 11353 
      for iter89 in self.success:
11354 
        iter89.write(oprot)
5944 mandeep.dh 11355 
      oprot.writeListEnd()
11356 
      oprot.writeFieldEnd()
11357 
    if self.cex is not None:
11358 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11359 
      self.cex.write(oprot)
11360 
      oprot.writeFieldEnd()
11361 
    oprot.writeFieldStop()
11362 
    oprot.writeStructEnd()
11363 
 
11364 
  def validate(self):
11365 
    return
11366 
 
11367 
 
11368 
  def __repr__(self):
11369 
    L = ['%s=%r' % (key, value)
11370 
      for key, value in self.__dict__.iteritems()]
11371 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11372 
 
11373 
  def __eq__(self, other):
11374 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11375 
 
11376 
  def __ne__(self, other):
11377 
    return not (self == other)
11378 
 
11379 
class markItemAsContentComplete_args:
11380 
  """
11381 
  Attributes:
11382 
   - entityId
11383 
   - category
11384 
   - brand
11385 
   - modelName
11386 
   - modelNumber
9253 rajveer 11387 
   - isAndroid
5944 mandeep.dh 11388 
  """
11389 
 
11390 
  thrift_spec = (
11391 
    None, # 0
11392 
    (1, TType.I64, 'entityId', None, None, ), # 1
11393 
    (2, TType.I64, 'category', None, None, ), # 2
11394 
    (3, TType.STRING, 'brand', None, None, ), # 3
11395 
    (4, TType.STRING, 'modelName', None, None, ), # 4
11396 
    (5, TType.STRING, 'modelNumber', None, None, ), # 5
9253 rajveer 11397 
    (6, TType.BOOL, 'isAndroid', None, None, ), # 6
5944 mandeep.dh 11398 
  )
11399 
 
9253 rajveer 11400 
  def __init__(self, entityId=None, category=None, brand=None, modelName=None, modelNumber=None, isAndroid=None,):
5944 mandeep.dh 11401 
    self.entityId = entityId
11402 
    self.category = category
11403 
    self.brand = brand
11404 
    self.modelName = modelName
11405 
    self.modelNumber = modelNumber
9253 rajveer 11406 
    self.isAndroid = isAndroid
5944 mandeep.dh 11407 
 
11408 
  def read(self, iprot):
11409 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11410 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11411 
      return
11412 
    iprot.readStructBegin()
11413 
    while True:
11414 
      (fname, ftype, fid) = iprot.readFieldBegin()
11415 
      if ftype == TType.STOP:
11416 
        break
11417 
      if fid == 1:
11418 
        if ftype == TType.I64:
11419 
          self.entityId = iprot.readI64();
11420 
        else:
11421 
          iprot.skip(ftype)
11422 
      elif fid == 2:
11423 
        if ftype == TType.I64:
11424 
          self.category = iprot.readI64();
11425 
        else:
11426 
          iprot.skip(ftype)
11427 
      elif fid == 3:
11428 
        if ftype == TType.STRING:
11429 
          self.brand = iprot.readString();
11430 
        else:
11431 
          iprot.skip(ftype)
11432 
      elif fid == 4:
11433 
        if ftype == TType.STRING:
11434 
          self.modelName = iprot.readString();
11435 
        else:
11436 
          iprot.skip(ftype)
11437 
      elif fid == 5:
11438 
        if ftype == TType.STRING:
11439 
          self.modelNumber = iprot.readString();
11440 
        else:
11441 
          iprot.skip(ftype)
9253 rajveer 11442 
      elif fid == 6:
11443 
        if ftype == TType.BOOL:
11444 
          self.isAndroid = iprot.readBool();
11445 
        else:
11446 
          iprot.skip(ftype)
5944 mandeep.dh 11447 
      else:
11448 
        iprot.skip(ftype)
11449 
      iprot.readFieldEnd()
11450 
    iprot.readStructEnd()
11451 
 
11452 
  def write(self, oprot):
11453 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11454 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11455 
      return
11456 
    oprot.writeStructBegin('markItemAsContentComplete_args')
11457 
    if self.entityId is not None:
11458 
      oprot.writeFieldBegin('entityId', TType.I64, 1)
11459 
      oprot.writeI64(self.entityId)
11460 
      oprot.writeFieldEnd()
11461 
    if self.category is not None:
11462 
      oprot.writeFieldBegin('category', TType.I64, 2)
11463 
      oprot.writeI64(self.category)
11464 
      oprot.writeFieldEnd()
11465 
    if self.brand is not None:
11466 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
11467 
      oprot.writeString(self.brand)
11468 
      oprot.writeFieldEnd()
11469 
    if self.modelName is not None:
11470 
      oprot.writeFieldBegin('modelName', TType.STRING, 4)
11471 
      oprot.writeString(self.modelName)
11472 
      oprot.writeFieldEnd()
11473 
    if self.modelNumber is not None:
11474 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 5)
11475 
      oprot.writeString(self.modelNumber)
11476 
      oprot.writeFieldEnd()
9253 rajveer 11477 
    if self.isAndroid is not None:
11478 
      oprot.writeFieldBegin('isAndroid', TType.BOOL, 6)
11479 
      oprot.writeBool(self.isAndroid)
11480 
      oprot.writeFieldEnd()
5944 mandeep.dh 11481 
    oprot.writeFieldStop()
11482 
    oprot.writeStructEnd()
11483 
 
11484 
  def validate(self):
11485 
    return
11486 
 
11487 
 
11488 
  def __repr__(self):
11489 
    L = ['%s=%r' % (key, value)
11490 
      for key, value in self.__dict__.iteritems()]
11491 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11492 
 
11493 
  def __eq__(self, other):
11494 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11495 
 
11496 
  def __ne__(self, other):
11497 
    return not (self == other)
11498 
 
11499 
class markItemAsContentComplete_result:
11500 
  """
11501 
  Attributes:
11502 
   - success
11503 
   - cex
11504 
  """
11505 
 
11506 
  thrift_spec = (
11507 
    (0, TType.BOOL, 'success', None, None, ), # 0
11508 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11509 
  )
11510 
 
11511 
  def __init__(self, success=None, cex=None,):
11512 
    self.success = success
11513 
    self.cex = cex
11514 
 
11515 
  def read(self, iprot):
11516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11518 
      return
11519 
    iprot.readStructBegin()
11520 
    while True:
11521 
      (fname, ftype, fid) = iprot.readFieldBegin()
11522 
      if ftype == TType.STOP:
11523 
        break
11524 
      if fid == 0:
11525 
        if ftype == TType.BOOL:
11526 
          self.success = iprot.readBool();
11527 
        else:
11528 
          iprot.skip(ftype)
11529 
      elif fid == 1:
11530 
        if ftype == TType.STRUCT:
11531 
          self.cex = CatalogServiceException()
11532 
          self.cex.read(iprot)
11533 
        else:
11534 
          iprot.skip(ftype)
11535 
      else:
11536 
        iprot.skip(ftype)
11537 
      iprot.readFieldEnd()
11538 
    iprot.readStructEnd()
11539 
 
11540 
  def write(self, oprot):
11541 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11542 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11543 
      return
11544 
    oprot.writeStructBegin('markItemAsContentComplete_result')
11545 
    if self.success is not None:
11546 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11547 
      oprot.writeBool(self.success)
11548 
      oprot.writeFieldEnd()
11549 
    if self.cex is not None:
11550 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11551 
      self.cex.write(oprot)
11552 
      oprot.writeFieldEnd()
11553 
    oprot.writeFieldStop()
11554 
    oprot.writeStructEnd()
11555 
 
11556 
  def validate(self):
11557 
    return
11558 
 
11559 
 
11560 
  def __repr__(self):
11561 
    L = ['%s=%r' % (key, value)
11562 
      for key, value in self.__dict__.iteritems()]
11563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11564 
 
11565 
  def __eq__(self, other):
11566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11567 
 
11568 
  def __ne__(self, other):
11569 
    return not (self == other)
11570 
 
12567 amit.gupta 11571 
class getVatRates_args:
11572 
  """
11573 
  Attributes:
11574 
   - itemId
11575 
   - categoryId
11576 
  """
11577 
 
11578 
  thrift_spec = (
11579 
    None, # 0
11580 
    (1, TType.I64, 'itemId', None, None, ), # 1
11581 
    (2, TType.I64, 'categoryId', None, None, ), # 2
11582 
  )
11583 
 
11584 
  def __init__(self, itemId=None, categoryId=None,):
11585 
    self.itemId = itemId
11586 
    self.categoryId = categoryId
11587 
 
11588 
  def read(self, iprot):
11589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11591 
      return
11592 
    iprot.readStructBegin()
11593 
    while True:
11594 
      (fname, ftype, fid) = iprot.readFieldBegin()
11595 
      if ftype == TType.STOP:
11596 
        break
11597 
      if fid == 1:
11598 
        if ftype == TType.I64:
11599 
          self.itemId = iprot.readI64();
11600 
        else:
11601 
          iprot.skip(ftype)
11602 
      elif fid == 2:
11603 
        if ftype == TType.I64:
11604 
          self.categoryId = iprot.readI64();
11605 
        else:
11606 
          iprot.skip(ftype)
11607 
      else:
11608 
        iprot.skip(ftype)
11609 
      iprot.readFieldEnd()
11610 
    iprot.readStructEnd()
11611 
 
11612 
  def write(self, oprot):
11613 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11614 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11615 
      return
11616 
    oprot.writeStructBegin('getVatRates_args')
11617 
    if self.itemId is not None:
11618 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11619 
      oprot.writeI64(self.itemId)
11620 
      oprot.writeFieldEnd()
11621 
    if self.categoryId is not None:
11622 
      oprot.writeFieldBegin('categoryId', TType.I64, 2)
11623 
      oprot.writeI64(self.categoryId)
11624 
      oprot.writeFieldEnd()
11625 
    oprot.writeFieldStop()
11626 
    oprot.writeStructEnd()
11627 
 
11628 
  def validate(self):
11629 
    return
11630 
 
11631 
 
11632 
  def __repr__(self):
11633 
    L = ['%s=%r' % (key, value)
11634 
      for key, value in self.__dict__.iteritems()]
11635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11636 
 
11637 
  def __eq__(self, other):
11638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11639 
 
11640 
  def __ne__(self, other):
11641 
    return not (self == other)
11642 
 
11643 
class getVatRates_result:
11644 
  """
11645 
  Attributes:
11646 
   - success
11647 
   - cex
11648 
  """
11649 
 
11650 
  thrift_spec = (
11651 
    (0, TType.MAP, 'success', (TType.I64,None,TType.DOUBLE,None), None, ), # 0
11652 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11653 
  )
11654 
 
11655 
  def __init__(self, success=None, cex=None,):
11656 
    self.success = success
11657 
    self.cex = cex
11658 
 
11659 
  def read(self, iprot):
11660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11662 
      return
11663 
    iprot.readStructBegin()
11664 
    while True:
11665 
      (fname, ftype, fid) = iprot.readFieldBegin()
11666 
      if ftype == TType.STOP:
11667 
        break
11668 
      if fid == 0:
11669 
        if ftype == TType.MAP:
11670 
          self.success = {}
13493 amit.gupta 11671 
          (_ktype91, _vtype92, _size90 ) = iprot.readMapBegin()
11672 
          for _i94 in xrange(_size90):
11673 
            _key95 = iprot.readI64();
11674 
            _val96 = iprot.readDouble();
11675 
            self.success[_key95] = _val96
12567 amit.gupta 11676 
          iprot.readMapEnd()
11677 
        else:
11678 
          iprot.skip(ftype)
11679 
      elif fid == 1:
11680 
        if ftype == TType.STRUCT:
11681 
          self.cex = CatalogServiceException()
11682 
          self.cex.read(iprot)
11683 
        else:
11684 
          iprot.skip(ftype)
11685 
      else:
11686 
        iprot.skip(ftype)
11687 
      iprot.readFieldEnd()
11688 
    iprot.readStructEnd()
11689 
 
11690 
  def write(self, oprot):
11691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11693 
      return
11694 
    oprot.writeStructBegin('getVatRates_result')
11695 
    if self.success is not None:
11696 
      oprot.writeFieldBegin('success', TType.MAP, 0)
11697 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.success))
13493 amit.gupta 11698 
      for kiter97,viter98 in self.success.items():
11699 
        oprot.writeI64(kiter97)
11700 
        oprot.writeDouble(viter98)
12567 amit.gupta 11701 
      oprot.writeMapEnd()
11702 
      oprot.writeFieldEnd()
11703 
    if self.cex is not None:
11704 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11705 
      self.cex.write(oprot)
11706 
      oprot.writeFieldEnd()
11707 
    oprot.writeFieldStop()
11708 
    oprot.writeStructEnd()
11709 
 
11710 
  def validate(self):
11711 
    return
11712 
 
11713 
 
11714 
  def __repr__(self):
11715 
    L = ['%s=%r' % (key, value)
11716 
      for key, value in self.__dict__.iteritems()]
11717 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11718 
 
11719 
  def __eq__(self, other):
11720 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11721 
 
11722 
  def __ne__(self, other):
11723 
    return not (self == other)
11724 
 
5944 mandeep.dh 11725 
class getAllItemsInRange_args:
11726 
  """
11727 
  Attributes:
11728 
   - offset
11729 
   - limit
11730 
  """
11731 
 
11732 
  thrift_spec = (
11733 
    None, # 0
11734 
    (1, TType.I64, 'offset', None, None, ), # 1
11735 
    (2, TType.I64, 'limit', None, None, ), # 2
11736 
  )
11737 
 
11738 
  def __init__(self, offset=None, limit=None,):
11739 
    self.offset = offset
11740 
    self.limit = limit
11741 
 
11742 
  def read(self, iprot):
11743 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11744 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11745 
      return
11746 
    iprot.readStructBegin()
11747 
    while True:
11748 
      (fname, ftype, fid) = iprot.readFieldBegin()
11749 
      if ftype == TType.STOP:
11750 
        break
11751 
      if fid == 1:
11752 
        if ftype == TType.I64:
11753 
          self.offset = iprot.readI64();
11754 
        else:
11755 
          iprot.skip(ftype)
11756 
      elif fid == 2:
11757 
        if ftype == TType.I64:
11758 
          self.limit = iprot.readI64();
11759 
        else:
11760 
          iprot.skip(ftype)
11761 
      else:
11762 
        iprot.skip(ftype)
11763 
      iprot.readFieldEnd()
11764 
    iprot.readStructEnd()
11765 
 
11766 
  def write(self, oprot):
11767 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11768 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11769 
      return
11770 
    oprot.writeStructBegin('getAllItemsInRange_args')
11771 
    if self.offset is not None:
11772 
      oprot.writeFieldBegin('offset', TType.I64, 1)
11773 
      oprot.writeI64(self.offset)
11774 
      oprot.writeFieldEnd()
11775 
    if self.limit is not None:
11776 
      oprot.writeFieldBegin('limit', TType.I64, 2)
11777 
      oprot.writeI64(self.limit)
11778 
      oprot.writeFieldEnd()
11779 
    oprot.writeFieldStop()
11780 
    oprot.writeStructEnd()
11781 
 
11782 
  def validate(self):
11783 
    return
11784 
 
11785 
 
11786 
  def __repr__(self):
11787 
    L = ['%s=%r' % (key, value)
11788 
      for key, value in self.__dict__.iteritems()]
11789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11790 
 
11791 
  def __eq__(self, other):
11792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11793 
 
11794 
  def __ne__(self, other):
11795 
    return not (self == other)
11796 
 
11797 
class getAllItemsInRange_result:
11798 
  """
11799 
  Attributes:
11800 
   - success
11801 
   - cex
11802 
  """
11803 
 
11804 
  thrift_spec = (
11805 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11806 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11807 
  )
11808 
 
11809 
  def __init__(self, success=None, cex=None,):
11810 
    self.success = success
11811 
    self.cex = cex
11812 
 
11813 
  def read(self, iprot):
11814 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11815 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11816 
      return
11817 
    iprot.readStructBegin()
11818 
    while True:
11819 
      (fname, ftype, fid) = iprot.readFieldBegin()
11820 
      if ftype == TType.STOP:
11821 
        break
11822 
      if fid == 0:
11823 
        if ftype == TType.LIST:
11824 
          self.success = []
13493 amit.gupta 11825 
          (_etype102, _size99) = iprot.readListBegin()
11826 
          for _i103 in xrange(_size99):
11827 
            _elem104 = Item()
11828 
            _elem104.read(iprot)
11829 
            self.success.append(_elem104)
5944 mandeep.dh 11830 
          iprot.readListEnd()
11831 
        else:
11832 
          iprot.skip(ftype)
11833 
      elif fid == 1:
11834 
        if ftype == TType.STRUCT:
11835 
          self.cex = CatalogServiceException()
11836 
          self.cex.read(iprot)
11837 
        else:
11838 
          iprot.skip(ftype)
11839 
      else:
11840 
        iprot.skip(ftype)
11841 
      iprot.readFieldEnd()
11842 
    iprot.readStructEnd()
11843 
 
11844 
  def write(self, oprot):
11845 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11846 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11847 
      return
11848 
    oprot.writeStructBegin('getAllItemsInRange_result')
11849 
    if self.success is not None:
11850 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11851 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 11852 
      for iter105 in self.success:
11853 
        iter105.write(oprot)
5944 mandeep.dh 11854 
      oprot.writeListEnd()
11855 
      oprot.writeFieldEnd()
11856 
    if self.cex is not None:
11857 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11858 
      self.cex.write(oprot)
11859 
      oprot.writeFieldEnd()
11860 
    oprot.writeFieldStop()
11861 
    oprot.writeStructEnd()
11862 
 
11863 
  def validate(self):
11864 
    return
11865 
 
11866 
 
11867 
  def __repr__(self):
11868 
    L = ['%s=%r' % (key, value)
11869 
      for key, value in self.__dict__.iteritems()]
11870 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11871 
 
11872 
  def __eq__(self, other):
11873 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11874 
 
11875 
  def __ne__(self, other):
11876 
    return not (self == other)
11877 
 
11878 
class getAllItemsByStatusInRange_args:
11879 
  """
11880 
  Attributes:
11881 
   - itemStatus
11882 
   - offset
11883 
   - limit
11884 
  """
11885 
 
11886 
  thrift_spec = (
11887 
    None, # 0
11888 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
11889 
    (2, TType.I64, 'offset', None, None, ), # 2
11890 
    (3, TType.I64, 'limit', None, None, ), # 3
11891 
  )
11892 
 
11893 
  def __init__(self, itemStatus=None, offset=None, limit=None,):
11894 
    self.itemStatus = itemStatus
11895 
    self.offset = offset
11896 
    self.limit = limit
11897 
 
11898 
  def read(self, iprot):
11899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11901 
      return
11902 
    iprot.readStructBegin()
11903 
    while True:
11904 
      (fname, ftype, fid) = iprot.readFieldBegin()
11905 
      if ftype == TType.STOP:
11906 
        break
11907 
      if fid == 1:
11908 
        if ftype == TType.I32:
11909 
          self.itemStatus = iprot.readI32();
11910 
        else:
11911 
          iprot.skip(ftype)
11912 
      elif fid == 2:
11913 
        if ftype == TType.I64:
11914 
          self.offset = iprot.readI64();
11915 
        else:
11916 
          iprot.skip(ftype)
11917 
      elif fid == 3:
11918 
        if ftype == TType.I64:
11919 
          self.limit = iprot.readI64();
11920 
        else:
11921 
          iprot.skip(ftype)
11922 
      else:
11923 
        iprot.skip(ftype)
11924 
      iprot.readFieldEnd()
11925 
    iprot.readStructEnd()
11926 
 
11927 
  def write(self, oprot):
11928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11930 
      return
11931 
    oprot.writeStructBegin('getAllItemsByStatusInRange_args')
11932 
    if self.itemStatus is not None:
11933 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
11934 
      oprot.writeI32(self.itemStatus)
11935 
      oprot.writeFieldEnd()
11936 
    if self.offset is not None:
11937 
      oprot.writeFieldBegin('offset', TType.I64, 2)
11938 
      oprot.writeI64(self.offset)
11939 
      oprot.writeFieldEnd()
11940 
    if self.limit is not None:
11941 
      oprot.writeFieldBegin('limit', TType.I64, 3)
11942 
      oprot.writeI64(self.limit)
11943 
      oprot.writeFieldEnd()
11944 
    oprot.writeFieldStop()
11945 
    oprot.writeStructEnd()
11946 
 
11947 
  def validate(self):
11948 
    return
11949 
 
11950 
 
11951 
  def __repr__(self):
11952 
    L = ['%s=%r' % (key, value)
11953 
      for key, value in self.__dict__.iteritems()]
11954 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11955 
 
11956 
  def __eq__(self, other):
11957 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11958 
 
11959 
  def __ne__(self, other):
11960 
    return not (self == other)
11961 
 
11962 
class getAllItemsByStatusInRange_result:
11963 
  """
11964 
  Attributes:
11965 
   - success
11966 
   - cex
11967 
  """
11968 
 
11969 
  thrift_spec = (
11970 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11971 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11972 
  )
11973 
 
11974 
  def __init__(self, success=None, cex=None,):
11975 
    self.success = success
11976 
    self.cex = cex
11977 
 
11978 
  def read(self, iprot):
11979 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11980 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11981 
      return
11982 
    iprot.readStructBegin()
11983 
    while True:
11984 
      (fname, ftype, fid) = iprot.readFieldBegin()
11985 
      if ftype == TType.STOP:
11986 
        break
11987 
      if fid == 0:
11988 
        if ftype == TType.LIST:
11989 
          self.success = []
13493 amit.gupta 11990 
          (_etype109, _size106) = iprot.readListBegin()
11991 
          for _i110 in xrange(_size106):
11992 
            _elem111 = Item()
11993 
            _elem111.read(iprot)
11994 
            self.success.append(_elem111)
5944 mandeep.dh 11995 
          iprot.readListEnd()
11996 
        else:
11997 
          iprot.skip(ftype)
11998 
      elif fid == 1:
11999 
        if ftype == TType.STRUCT:
12000 
          self.cex = CatalogServiceException()
12001 
          self.cex.read(iprot)
12002 
        else:
12003 
          iprot.skip(ftype)
12004 
      else:
12005 
        iprot.skip(ftype)
12006 
      iprot.readFieldEnd()
12007 
    iprot.readStructEnd()
12008 
 
12009 
  def write(self, oprot):
12010 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12011 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12012 
      return
12013 
    oprot.writeStructBegin('getAllItemsByStatusInRange_result')
12014 
    if self.success is not None:
12015 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12016 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 12017 
      for iter112 in self.success:
12018 
        iter112.write(oprot)
5944 mandeep.dh 12019 
      oprot.writeListEnd()
12020 
      oprot.writeFieldEnd()
12021 
    if self.cex is not None:
12022 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
12023 
      self.cex.write(oprot)
12024 
      oprot.writeFieldEnd()
12025 
    oprot.writeFieldStop()
12026 
    oprot.writeStructEnd()
12027 
 
12028 
  def validate(self):
12029 
    return
12030 
 
12031 
 
12032 
  def __repr__(self):
12033 
    L = ['%s=%r' % (key, value)
12034 
      for key, value in self.__dict__.iteritems()]
12035 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12036 
 
12037 
  def __eq__(self, other):
12038 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12039 
 
12040 
  def __ne__(self, other):
12041 
    return not (self == other)
12042 
 
12043 
class getItemCountByStatus_args:
12044 
  """
12045 
  Attributes:
12046 
   - useStatus
12047 
   - itemStatus
12048 
  """
12049 
 
12050 
  thrift_spec = (
12051 
    None, # 0
12052 
    (1, TType.BOOL, 'useStatus', None, None, ), # 1
12053 
    (2, TType.I32, 'itemStatus', None, None, ), # 2
12054 
  )
12055 
 
12056 
  def __init__(self, useStatus=None, itemStatus=None,):
12057 
    self.useStatus = useStatus
12058 
    self.itemStatus = itemStatus
12059 
 
12060 
  def read(self, iprot):
12061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12063 
      return
12064 
    iprot.readStructBegin()
12065 
    while True:
12066 
      (fname, ftype, fid) = iprot.readFieldBegin()
12067 
      if ftype == TType.STOP:
12068 
        break
12069 
      if fid == 1:
12070 
        if ftype == TType.BOOL:
12071 
          self.useStatus = iprot.readBool();
12072 
        else:
12073 
          iprot.skip(ftype)
12074 
      elif fid == 2:
12075 
        if ftype == TType.I32:
12076 
          self.itemStatus = iprot.readI32();
12077 
        else:
12078 
          iprot.skip(ftype)
12079 
      else:
12080 
        iprot.skip(ftype)
12081 
      iprot.readFieldEnd()
12082 
    iprot.readStructEnd()
12083 
 
12084 
  def write(self, oprot):
12085 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12086 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12087 
      return
12088 
    oprot.writeStructBegin('getItemCountByStatus_args')
12089 
    if self.useStatus is not None:
12090 
      oprot.writeFieldBegin('useStatus', TType.BOOL, 1)
12091 
      oprot.writeBool(self.useStatus)
12092 
      oprot.writeFieldEnd()
12093 
    if self.itemStatus is not None:
12094 
      oprot.writeFieldBegin('itemStatus', TType.I32, 2)
12095 
      oprot.writeI32(self.itemStatus)
12096 
      oprot.writeFieldEnd()
12097 
    oprot.writeFieldStop()
12098 
    oprot.writeStructEnd()
12099 
 
12100 
  def validate(self):
12101 
    return
12102 
 
12103 
 
12104 
  def __repr__(self):
12105 
    L = ['%s=%r' % (key, value)
12106 
      for key, value in self.__dict__.iteritems()]
12107 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12108 
 
12109 
  def __eq__(self, other):
12110 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12111 
 
12112 
  def __ne__(self, other):
12113 
    return not (self == other)
12114 
 
12115 
class getItemCountByStatus_result:
12116 
  """
12117 
  Attributes:
12118 
   - success
12119 
  """
12120 
 
12121 
  thrift_spec = (
12122 
    (0, TType.I32, 'success', None, None, ), # 0
12123 
  )
12124 
 
12125 
  def __init__(self, success=None,):
12126 
    self.success = success
12127 
 
12128 
  def read(self, iprot):
12129 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12130 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12131 
      return
12132 
    iprot.readStructBegin()
12133 
    while True:
12134 
      (fname, ftype, fid) = iprot.readFieldBegin()
12135 
      if ftype == TType.STOP:
12136 
        break
12137 
      if fid == 0:
12138 
        if ftype == TType.I32:
12139 
          self.success = iprot.readI32();
12140 
        else:
12141 
          iprot.skip(ftype)
12142 
      else:
12143 
        iprot.skip(ftype)
12144 
      iprot.readFieldEnd()
12145 
    iprot.readStructEnd()
12146 
 
12147 
  def write(self, oprot):
12148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12150 
      return
12151 
    oprot.writeStructBegin('getItemCountByStatus_result')
12152 
    if self.success is not None:
12153 
      oprot.writeFieldBegin('success', TType.I32, 0)
12154 
      oprot.writeI32(self.success)
12155 
      oprot.writeFieldEnd()
12156 
    oprot.writeFieldStop()
12157 
    oprot.writeStructEnd()
12158 
 
12159 
  def validate(self):
12160 
    return
12161 
 
12162 
 
12163 
  def __repr__(self):
12164 
    L = ['%s=%r' % (key, value)
12165 
      for key, value in self.__dict__.iteritems()]
12166 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12167 
 
12168 
  def __eq__(self, other):
12169 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12170 
 
12171 
  def __ne__(self, other):
12172 
    return not (self == other)
12173 
 
12174 
class getBestSellers_args:
12175 
 
12176 
  thrift_spec = (
12177 
  )
12178 
 
12179 
  def read(self, iprot):
12180 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12181 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12182 
      return
12183 
    iprot.readStructBegin()
12184 
    while True:
12185 
      (fname, ftype, fid) = iprot.readFieldBegin()
12186 
      if ftype == TType.STOP:
12187 
        break
12188 
      else:
12189 
        iprot.skip(ftype)
12190 
      iprot.readFieldEnd()
12191 
    iprot.readStructEnd()
12192 
 
12193 
  def write(self, oprot):
12194 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12195 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12196 
      return
12197 
    oprot.writeStructBegin('getBestSellers_args')
12198 
    oprot.writeFieldStop()
12199 
    oprot.writeStructEnd()
12200 
 
12201 
  def validate(self):
12202 
    return
12203 
 
12204 
 
12205 
  def __repr__(self):
12206 
    L = ['%s=%r' % (key, value)
12207 
      for key, value in self.__dict__.iteritems()]
12208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12209 
 
12210 
  def __eq__(self, other):
12211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12212 
 
12213 
  def __ne__(self, other):
12214 
    return not (self == other)
12215 
 
12216 
class getBestSellers_result:
12217 
  """
12218 
  Attributes:
12219 
   - success
12220 
   - isex
12221 
  """
12222 
 
12223 
  thrift_spec = (
12224 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12225 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12226 
  )
12227 
 
12228 
  def __init__(self, success=None, isex=None,):
12229 
    self.success = success
12230 
    self.isex = isex
12231 
 
12232 
  def read(self, iprot):
12233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12235 
      return
12236 
    iprot.readStructBegin()
12237 
    while True:
12238 
      (fname, ftype, fid) = iprot.readFieldBegin()
12239 
      if ftype == TType.STOP:
12240 
        break
12241 
      if fid == 0:
12242 
        if ftype == TType.LIST:
12243 
          self.success = []
13493 amit.gupta 12244 
          (_etype116, _size113) = iprot.readListBegin()
12245 
          for _i117 in xrange(_size113):
12246 
            _elem118 = Item()
12247 
            _elem118.read(iprot)
12248 
            self.success.append(_elem118)
5944 mandeep.dh 12249 
          iprot.readListEnd()
12250 
        else:
12251 
          iprot.skip(ftype)
12252 
      elif fid == 1:
12253 
        if ftype == TType.STRUCT:
12254 
          self.isex = CatalogServiceException()
12255 
          self.isex.read(iprot)
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('getBestSellers_result')
12268 
    if self.success is not None:
12269 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12270 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 12271 
      for iter119 in self.success:
12272 
        iter119.write(oprot)
5944 mandeep.dh 12273 
      oprot.writeListEnd()
12274 
      oprot.writeFieldEnd()
12275 
    if self.isex is not None:
12276 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
12277 
      self.isex.write(oprot)
12278 
      oprot.writeFieldEnd()
12279 
    oprot.writeFieldStop()
12280 
    oprot.writeStructEnd()
12281 
 
12282 
  def validate(self):
12283 
    return
12284 
 
12285 
 
12286 
  def __repr__(self):
12287 
    L = ['%s=%r' % (key, value)
12288 
      for key, value in self.__dict__.iteritems()]
12289 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12290 
 
12291 
  def __eq__(self, other):
12292 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12293 
 
12294 
  def __ne__(self, other):
12295 
    return not (self == other)
12296 
 
12297 
class getBestSellersCatalogIds_args:
12298 
  """
12299 
  Attributes:
12300 
   - beginIndex
12301 
   - totalItems
12302 
   - brand
12303 
   - category
12304 
  """
12305 
 
12306 
  thrift_spec = (
12307 
    None, # 0
12308 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
12309 
    (2, TType.I64, 'totalItems', None, None, ), # 2
12310 
    (3, TType.STRING, 'brand', None, None, ), # 3
12311 
    (4, TType.I64, 'category', None, None, ), # 4
12312 
  )
12313 
 
12314 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
12315 
    self.beginIndex = beginIndex
12316 
    self.totalItems = totalItems
12317 
    self.brand = brand
12318 
    self.category = category
12319 
 
12320 
  def read(self, iprot):
12321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12323 
      return
12324 
    iprot.readStructBegin()
12325 
    while True:
12326 
      (fname, ftype, fid) = iprot.readFieldBegin()
12327 
      if ftype == TType.STOP:
12328 
        break
12329 
      if fid == 1:
12330 
        if ftype == TType.I64:
12331 
          self.beginIndex = iprot.readI64();
12332 
        else:
12333 
          iprot.skip(ftype)
12334 
      elif fid == 2:
12335 
        if ftype == TType.I64:
12336 
          self.totalItems = iprot.readI64();
12337 
        else:
12338 
          iprot.skip(ftype)
12339 
      elif fid == 3:
12340 
        if ftype == TType.STRING:
12341 
          self.brand = iprot.readString();
12342 
        else:
12343 
          iprot.skip(ftype)
12344 
      elif fid == 4:
12345 
        if ftype == TType.I64:
12346 
          self.category = iprot.readI64();
12347 
        else:
12348 
          iprot.skip(ftype)
12349 
      else:
12350 
        iprot.skip(ftype)
12351 
      iprot.readFieldEnd()
12352 
    iprot.readStructEnd()
12353 
 
12354 
  def write(self, oprot):
12355 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12356 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12357 
      return
12358 
    oprot.writeStructBegin('getBestSellersCatalogIds_args')
12359 
    if self.beginIndex is not None:
12360 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
12361 
      oprot.writeI64(self.beginIndex)
12362 
      oprot.writeFieldEnd()
12363 
    if self.totalItems is not None:
12364 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
12365 
      oprot.writeI64(self.totalItems)
12366 
      oprot.writeFieldEnd()
12367 
    if self.brand is not None:
12368 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
12369 
      oprot.writeString(self.brand)
12370 
      oprot.writeFieldEnd()
12371 
    if self.category is not None:
12372 
      oprot.writeFieldBegin('category', TType.I64, 4)
12373 
      oprot.writeI64(self.category)
12374 
      oprot.writeFieldEnd()
12375 
    oprot.writeFieldStop()
12376 
    oprot.writeStructEnd()
12377 
 
12378 
  def validate(self):
12379 
    return
12380 
 
12381 
 
12382 
  def __repr__(self):
12383 
    L = ['%s=%r' % (key, value)
12384 
      for key, value in self.__dict__.iteritems()]
12385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12386 
 
12387 
  def __eq__(self, other):
12388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12389 
 
12390 
  def __ne__(self, other):
12391 
    return not (self == other)
12392 
 
12393 
class getBestSellersCatalogIds_result:
12394 
  """
12395 
  Attributes:
12396 
   - success
12397 
   - cex
12398 
  """
12399 
 
12400 
  thrift_spec = (
12401 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12402 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12403 
  )
12404 
 
12405 
  def __init__(self, success=None, cex=None,):
12406 
    self.success = success
12407 
    self.cex = cex
12408 
 
12409 
  def read(self, iprot):
12410 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12411 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12412 
      return
12413 
    iprot.readStructBegin()
12414 
    while True:
12415 
      (fname, ftype, fid) = iprot.readFieldBegin()
12416 
      if ftype == TType.STOP:
12417 
        break
12418 
      if fid == 0:
12419 
        if ftype == TType.LIST:
12420 
          self.success = []
13493 amit.gupta 12421 
          (_etype123, _size120) = iprot.readListBegin()
12422 
          for _i124 in xrange(_size120):
12423 
            _elem125 = iprot.readI64();
12424 
            self.success.append(_elem125)
5944 mandeep.dh 12425 
          iprot.readListEnd()
12426 
        else:
12427 
          iprot.skip(ftype)
12428 
      elif fid == 1:
12429 
        if ftype == TType.STRUCT:
12430 
          self.cex = CatalogServiceException()
12431 
          self.cex.read(iprot)
12432 
        else:
12433 
          iprot.skip(ftype)
12434 
      else:
12435 
        iprot.skip(ftype)
12436 
      iprot.readFieldEnd()
12437 
    iprot.readStructEnd()
12438 
 
12439 
  def write(self, oprot):
12440 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12441 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12442 
      return
12443 
    oprot.writeStructBegin('getBestSellersCatalogIds_result')
12444 
    if self.success is not None:
12445 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12446 
      oprot.writeListBegin(TType.I64, len(self.success))
13493 amit.gupta 12447 
      for iter126 in self.success:
12448 
        oprot.writeI64(iter126)
5944 mandeep.dh 12449 
      oprot.writeListEnd()
12450 
      oprot.writeFieldEnd()
12451 
    if self.cex is not None:
12452 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
12453 
      self.cex.write(oprot)
12454 
      oprot.writeFieldEnd()
12455 
    oprot.writeFieldStop()
12456 
    oprot.writeStructEnd()
12457 
 
12458 
  def validate(self):
12459 
    return
12460 
 
12461 
 
12462 
  def __repr__(self):
12463 
    L = ['%s=%r' % (key, value)
12464 
      for key, value in self.__dict__.iteritems()]
12465 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12466 
 
12467 
  def __eq__(self, other):
12468 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12469 
 
12470 
  def __ne__(self, other):
12471 
    return not (self == other)
12472 
 
12473 
class getBestSellersCount_args:
12474 
 
12475 
  thrift_spec = (
12476 
  )
12477 
 
12478 
  def read(self, iprot):
12479 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12480 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12481 
      return
12482 
    iprot.readStructBegin()
12483 
    while True:
12484 
      (fname, ftype, fid) = iprot.readFieldBegin()
12485 
      if ftype == TType.STOP:
12486 
        break
12487 
      else:
12488 
        iprot.skip(ftype)
12489 
      iprot.readFieldEnd()
12490 
    iprot.readStructEnd()
12491 
 
12492 
  def write(self, oprot):
12493 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12494 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12495 
      return
12496 
    oprot.writeStructBegin('getBestSellersCount_args')
12497 
    oprot.writeFieldStop()
12498 
    oprot.writeStructEnd()
12499 
 
12500 
  def validate(self):
12501 
    return
12502 
 
12503 
 
12504 
  def __repr__(self):
12505 
    L = ['%s=%r' % (key, value)
12506 
      for key, value in self.__dict__.iteritems()]
12507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12508 
 
12509 
  def __eq__(self, other):
12510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12511 
 
12512 
  def __ne__(self, other):
12513 
    return not (self == other)
12514 
 
12515 
class getBestSellersCount_result:
12516 
  """
12517 
  Attributes:
12518 
   - success
12519 
   - cex
12520 
  """
12521 
 
12522 
  thrift_spec = (
12523 
    (0, TType.I64, 'success', None, None, ), # 0
12524 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12525 
  )
12526 
 
12527 
  def __init__(self, success=None, cex=None,):
12528 
    self.success = success
12529 
    self.cex = cex
12530 
 
12531 
  def read(self, iprot):
12532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12534 
      return
12535 
    iprot.readStructBegin()
12536 
    while True:
12537 
      (fname, ftype, fid) = iprot.readFieldBegin()
12538 
      if ftype == TType.STOP:
12539 
        break
12540 
      if fid == 0:
12541 
        if ftype == TType.I64:
12542 
          self.success = iprot.readI64();
12543 
        else:
12544 
          iprot.skip(ftype)
12545 
      elif fid == 1:
12546 
        if ftype == TType.STRUCT:
12547 
          self.cex = CatalogServiceException()
12548 
          self.cex.read(iprot)
12549 
        else:
12550 
          iprot.skip(ftype)
12551 
      else:
12552 
        iprot.skip(ftype)
12553 
      iprot.readFieldEnd()
12554 
    iprot.readStructEnd()
12555 
 
12556 
  def write(self, oprot):
12557 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12558 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12559 
      return
12560 
    oprot.writeStructBegin('getBestSellersCount_result')
12561 
    if self.success is not None:
12562 
      oprot.writeFieldBegin('success', TType.I64, 0)
12563 
      oprot.writeI64(self.success)
12564 
      oprot.writeFieldEnd()
12565 
    if self.cex is not None:
12566 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
12567 
      self.cex.write(oprot)
12568 
      oprot.writeFieldEnd()
12569 
    oprot.writeFieldStop()
12570 
    oprot.writeStructEnd()
12571 
 
12572 
  def validate(self):
12573 
    return
12574 
 
12575 
 
12576 
  def __repr__(self):
12577 
    L = ['%s=%r' % (key, value)
12578 
      for key, value in self.__dict__.iteritems()]
12579 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12580 
 
12581 
  def __eq__(self, other):
12582 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12583 
 
12584 
  def __ne__(self, other):
12585 
    return not (self == other)
12586 
 
12587 
class getBestDeals_args:
12588 
 
12589 
  thrift_spec = (
12590 
  )
12591 
 
12592 
  def read(self, iprot):
12593 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12594 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12595 
      return
12596 
    iprot.readStructBegin()
12597 
    while True:
12598 
      (fname, ftype, fid) = iprot.readFieldBegin()
12599 
      if ftype == TType.STOP:
12600 
        break
12601 
      else:
12602 
        iprot.skip(ftype)
12603 
      iprot.readFieldEnd()
12604 
    iprot.readStructEnd()
12605 
 
12606 
  def write(self, oprot):
12607 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12608 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12609 
      return
12610 
    oprot.writeStructBegin('getBestDeals_args')
12611 
    oprot.writeFieldStop()
12612 
    oprot.writeStructEnd()
12613 
 
12614 
  def validate(self):
12615 
    return
12616 
 
12617 
 
12618 
  def __repr__(self):
12619 
    L = ['%s=%r' % (key, value)
12620 
      for key, value in self.__dict__.iteritems()]
12621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12622 
 
12623 
  def __eq__(self, other):
12624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12625 
 
12626 
  def __ne__(self, other):
12627 
    return not (self == other)
12628 
 
12629 
class getBestDeals_result:
12630 
  """
12631 
  Attributes:
12632 
   - success
12633 
   - isex
12634 
  """
12635 
 
12636 
  thrift_spec = (
12637 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12638 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12639 
  )
12640 
 
12641 
  def __init__(self, success=None, isex=None,):
12642 
    self.success = success
12643 
    self.isex = isex
12644 
 
12645 
  def read(self, iprot):
12646 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12647 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12648 
      return
12649 
    iprot.readStructBegin()
12650 
    while True:
12651 
      (fname, ftype, fid) = iprot.readFieldBegin()
12652 
      if ftype == TType.STOP:
12653 
        break
12654 
      if fid == 0:
12655 
        if ftype == TType.LIST:
12656 
          self.success = []
13493 amit.gupta 12657 
          (_etype130, _size127) = iprot.readListBegin()
12658 
          for _i131 in xrange(_size127):
12659 
            _elem132 = Item()
12660 
            _elem132.read(iprot)
12661 
            self.success.append(_elem132)
5944 mandeep.dh 12662 
          iprot.readListEnd()
12663 
        else:
12664 
          iprot.skip(ftype)
12665 
      elif fid == 1:
12666 
        if ftype == TType.STRUCT:
12667 
          self.isex = CatalogServiceException()
12668 
          self.isex.read(iprot)
12669 
        else:
12670 
          iprot.skip(ftype)
12671 
      else:
12672 
        iprot.skip(ftype)
12673 
      iprot.readFieldEnd()
12674 
    iprot.readStructEnd()
12675 
 
12676 
  def write(self, oprot):
12677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12679 
      return
12680 
    oprot.writeStructBegin('getBestDeals_result')
12681 
    if self.success is not None:
12682 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12683 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 12684 
      for iter133 in self.success:
12685 
        iter133.write(oprot)
5944 mandeep.dh 12686 
      oprot.writeListEnd()
12687 
      oprot.writeFieldEnd()
12688 
    if self.isex is not None:
12689 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
12690 
      self.isex.write(oprot)
12691 
      oprot.writeFieldEnd()
12692 
    oprot.writeFieldStop()
12693 
    oprot.writeStructEnd()
12694 
 
12695 
  def validate(self):
12696 
    return
12697 
 
12698 
 
12699 
  def __repr__(self):
12700 
    L = ['%s=%r' % (key, value)
12701 
      for key, value in self.__dict__.iteritems()]
12702 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12703 
 
12704 
  def __eq__(self, other):
12705 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12706 
 
12707 
  def __ne__(self, other):
12708 
    return not (self == other)
12709 
 
12710 
class getBestDealsCatalogIds_args:
12711 
  """
12712 
  Attributes:
12713 
   - beginIndex
12714 
   - totalItems
12715 
   - brand
12716 
   - category
12717 
  """
12718 
 
12719 
  thrift_spec = (
12720 
    None, # 0
12721 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
12722 
    (2, TType.I64, 'totalItems', None, None, ), # 2
12723 
    (3, TType.STRING, 'brand', None, None, ), # 3
12724 
    (4, TType.I64, 'category', None, None, ), # 4
12725 
  )
12726 
 
12727 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
12728 
    self.beginIndex = beginIndex
12729 
    self.totalItems = totalItems
12730 
    self.brand = brand
12731 
    self.category = category
12732 
 
12733 
  def read(self, iprot):
12734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12736 
      return
12737 
    iprot.readStructBegin()
12738 
    while True:
12739 
      (fname, ftype, fid) = iprot.readFieldBegin()
12740 
      if ftype == TType.STOP:
12741 
        break
12742 
      if fid == 1:
12743 
        if ftype == TType.I64:
12744 
          self.beginIndex = iprot.readI64();
12745 
        else:
12746 
          iprot.skip(ftype)
12747 
      elif fid == 2:
12748 
        if ftype == TType.I64:
12749 
          self.totalItems = iprot.readI64();
12750 
        else:
12751 
          iprot.skip(ftype)
12752 
      elif fid == 3:
12753 
        if ftype == TType.STRING:
12754 
          self.brand = iprot.readString();
12755 
        else:
12756 
          iprot.skip(ftype)
12757 
      elif fid == 4:
12758 
        if ftype == TType.I64:
12759 
          self.category = iprot.readI64();
12760 
        else:
12761 
          iprot.skip(ftype)
12762 
      else:
12763 
        iprot.skip(ftype)
12764 
      iprot.readFieldEnd()
12765 
    iprot.readStructEnd()
12766 
 
12767 
  def write(self, oprot):
12768 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12769 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12770 
      return
12771 
    oprot.writeStructBegin('getBestDealsCatalogIds_args')
12772 
    if self.beginIndex is not None:
12773 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
12774 
      oprot.writeI64(self.beginIndex)
12775 
      oprot.writeFieldEnd()
12776 
    if self.totalItems is not None:
12777 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
12778 
      oprot.writeI64(self.totalItems)
12779 
      oprot.writeFieldEnd()
12780 
    if self.brand is not None:
12781 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
12782 
      oprot.writeString(self.brand)
12783 
      oprot.writeFieldEnd()
12784 
    if self.category is not None:
12785 
      oprot.writeFieldBegin('category', TType.I64, 4)
12786 
      oprot.writeI64(self.category)
12787 
      oprot.writeFieldEnd()
12788 
    oprot.writeFieldStop()
12789 
    oprot.writeStructEnd()
12790 
 
12791 
  def validate(self):
12792 
    return
12793 
 
12794 
 
12795 
  def __repr__(self):
12796 
    L = ['%s=%r' % (key, value)
12797 
      for key, value in self.__dict__.iteritems()]
12798 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12799 
 
12800 
  def __eq__(self, other):
12801 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12802 
 
12803 
  def __ne__(self, other):
12804 
    return not (self == other)
12805 
 
12806 
class getBestDealsCatalogIds_result:
12807 
  """
12808 
  Attributes:
12809 
   - success
12810 
   - cex
12811 
  """
12812 
 
12813 
  thrift_spec = (
12814 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12815 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12816 
  )
12817 
 
12818 
  def __init__(self, success=None, cex=None,):
12819 
    self.success = success
12820 
    self.cex = cex
12821 
 
12822 
  def read(self, iprot):
12823 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12824 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12825 
      return
12826 
    iprot.readStructBegin()
12827 
    while True:
12828 
      (fname, ftype, fid) = iprot.readFieldBegin()
12829 
      if ftype == TType.STOP:
12830 
        break
12831 
      if fid == 0:
12832 
        if ftype == TType.LIST:
12833 
          self.success = []
13493 amit.gupta 12834 
          (_etype137, _size134) = iprot.readListBegin()
12835 
          for _i138 in xrange(_size134):
12836 
            _elem139 = iprot.readI64();
12837 
            self.success.append(_elem139)
5944 mandeep.dh 12838 
          iprot.readListEnd()
12839 
        else:
12840 
          iprot.skip(ftype)
12841 
      elif fid == 1:
12842 
        if ftype == TType.STRUCT:
12843 
          self.cex = CatalogServiceException()
12844 
          self.cex.read(iprot)
12845 
        else:
12846 
          iprot.skip(ftype)
12847 
      else:
12848 
        iprot.skip(ftype)
12849 
      iprot.readFieldEnd()
12850 
    iprot.readStructEnd()
12851 
 
12852 
  def write(self, oprot):
12853 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12854 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12855 
      return
12856 
    oprot.writeStructBegin('getBestDealsCatalogIds_result')
12857 
    if self.success is not None:
12858 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12859 
      oprot.writeListBegin(TType.I64, len(self.success))
13493 amit.gupta 12860 
      for iter140 in self.success:
12861 
        oprot.writeI64(iter140)
5944 mandeep.dh 12862 
      oprot.writeListEnd()
12863 
      oprot.writeFieldEnd()
12864 
    if self.cex is not None:
12865 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
12866 
      self.cex.write(oprot)
12867 
      oprot.writeFieldEnd()
12868 
    oprot.writeFieldStop()
12869 
    oprot.writeStructEnd()
12870 
 
12871 
  def validate(self):
12872 
    return
12873 
 
12874 
 
12875 
  def __repr__(self):
12876 
    L = ['%s=%r' % (key, value)
12877 
      for key, value in self.__dict__.iteritems()]
12878 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12879 
 
12880 
  def __eq__(self, other):
12881 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12882 
 
12883 
  def __ne__(self, other):
12884 
    return not (self == other)
12885 
 
12886 
class getBestDealsCount_args:
12887 
 
12888 
  thrift_spec = (
12889 
  )
12890 
 
12891 
  def read(self, iprot):
12892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12894 
      return
12895 
    iprot.readStructBegin()
12896 
    while True:
12897 
      (fname, ftype, fid) = iprot.readFieldBegin()
12898 
      if ftype == TType.STOP:
12899 
        break
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('getBestDealsCount_args')
12910 
    oprot.writeFieldStop()
12911 
    oprot.writeStructEnd()
12912 
 
12913 
  def validate(self):
12914 
    return
12915 
 
12916 
 
12917 
  def __repr__(self):
12918 
    L = ['%s=%r' % (key, value)
12919 
      for key, value in self.__dict__.iteritems()]
12920 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12921 
 
12922 
  def __eq__(self, other):
12923 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12924 
 
12925 
  def __ne__(self, other):
12926 
    return not (self == other)
12927 
 
12928 
class getBestDealsCount_result:
12929 
  """
12930 
  Attributes:
12931 
   - success
12932 
   - cex
12933 
  """
12934 
 
12935 
  thrift_spec = (
12936 
    (0, TType.I64, 'success', None, None, ), # 0
12937 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12938 
  )
12939 
 
12940 
  def __init__(self, success=None, cex=None,):
12941 
    self.success = success
12942 
    self.cex = cex
12943 
 
12944 
  def read(self, iprot):
12945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12947 
      return
12948 
    iprot.readStructBegin()
12949 
    while True:
12950 
      (fname, ftype, fid) = iprot.readFieldBegin()
12951 
      if ftype == TType.STOP:
12952 
        break
12953 
      if fid == 0:
12954 
        if ftype == TType.I64:
12955 
          self.success = iprot.readI64();
12956 
        else:
12957 
          iprot.skip(ftype)
12958 
      elif fid == 1:
12959 
        if ftype == TType.STRUCT:
12960 
          self.cex = CatalogServiceException()
12961 
          self.cex.read(iprot)
12962 
        else:
12963 
          iprot.skip(ftype)
12964 
      else:
12965 
        iprot.skip(ftype)
12966 
      iprot.readFieldEnd()
12967 
    iprot.readStructEnd()
12968 
 
12969 
  def write(self, oprot):
12970 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12971 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12972 
      return
12973 
    oprot.writeStructBegin('getBestDealsCount_result')
12974 
    if self.success is not None:
12975 
      oprot.writeFieldBegin('success', TType.I64, 0)
12976 
      oprot.writeI64(self.success)
12977 
      oprot.writeFieldEnd()
12978 
    if self.cex is not None:
12979 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
12980 
      self.cex.write(oprot)
12981 
      oprot.writeFieldEnd()
12982 
    oprot.writeFieldStop()
12983 
    oprot.writeStructEnd()
12984 
 
12985 
  def validate(self):
12986 
    return
12987 
 
12988 
 
12989 
  def __repr__(self):
12990 
    L = ['%s=%r' % (key, value)
12991 
      for key, value in self.__dict__.iteritems()]
12992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12993 
 
12994 
  def __eq__(self, other):
12995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12996 
 
12997 
  def __ne__(self, other):
12998 
    return not (self == other)
12999 
 
13000 
class getComingSoon_args:
13001 
 
13002 
  thrift_spec = (
13003 
  )
13004 
 
13005 
  def read(self, iprot):
13006 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13007 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13008 
      return
13009 
    iprot.readStructBegin()
13010 
    while True:
13011 
      (fname, ftype, fid) = iprot.readFieldBegin()
13012 
      if ftype == TType.STOP:
13013 
        break
13014 
      else:
13015 
        iprot.skip(ftype)
13016 
      iprot.readFieldEnd()
13017 
    iprot.readStructEnd()
13018 
 
13019 
  def write(self, oprot):
13020 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13021 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13022 
      return
13023 
    oprot.writeStructBegin('getComingSoon_args')
13024 
    oprot.writeFieldStop()
13025 
    oprot.writeStructEnd()
13026 
 
13027 
  def validate(self):
13028 
    return
13029 
 
13030 
 
13031 
  def __repr__(self):
13032 
    L = ['%s=%r' % (key, value)
13033 
      for key, value in self.__dict__.iteritems()]
13034 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13035 
 
13036 
  def __eq__(self, other):
13037 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13038 
 
13039 
  def __ne__(self, other):
13040 
    return not (self == other)
13041 
 
13042 
class getComingSoon_result:
13043 
  """
13044 
  Attributes:
13045 
   - success
13046 
   - isex
13047 
  """
13048 
 
13049 
  thrift_spec = (
13050 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
13051 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13052 
  )
13053 
 
13054 
  def __init__(self, success=None, isex=None,):
13055 
    self.success = success
13056 
    self.isex = isex
13057 
 
13058 
  def read(self, iprot):
13059 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13060 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13061 
      return
13062 
    iprot.readStructBegin()
13063 
    while True:
13064 
      (fname, ftype, fid) = iprot.readFieldBegin()
13065 
      if ftype == TType.STOP:
13066 
        break
13067 
      if fid == 0:
13068 
        if ftype == TType.LIST:
13069 
          self.success = []
13493 amit.gupta 13070 
          (_etype144, _size141) = iprot.readListBegin()
13071 
          for _i145 in xrange(_size141):
13072 
            _elem146 = Item()
13073 
            _elem146.read(iprot)
13074 
            self.success.append(_elem146)
5944 mandeep.dh 13075 
          iprot.readListEnd()
13076 
        else:
13077 
          iprot.skip(ftype)
13078 
      elif fid == 1:
13079 
        if ftype == TType.STRUCT:
13080 
          self.isex = CatalogServiceException()
13081 
          self.isex.read(iprot)
13082 
        else:
13083 
          iprot.skip(ftype)
13084 
      else:
13085 
        iprot.skip(ftype)
13086 
      iprot.readFieldEnd()
13087 
    iprot.readStructEnd()
13088 
 
13089 
  def write(self, oprot):
13090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13092 
      return
13093 
    oprot.writeStructBegin('getComingSoon_result')
13094 
    if self.success is not None:
13095 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13096 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 13097 
      for iter147 in self.success:
13098 
        iter147.write(oprot)
5944 mandeep.dh 13099 
      oprot.writeListEnd()
13100 
      oprot.writeFieldEnd()
13101 
    if self.isex is not None:
13102 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
13103 
      self.isex.write(oprot)
13104 
      oprot.writeFieldEnd()
13105 
    oprot.writeFieldStop()
13106 
    oprot.writeStructEnd()
13107 
 
13108 
  def validate(self):
13109 
    return
13110 
 
13111 
 
13112 
  def __repr__(self):
13113 
    L = ['%s=%r' % (key, value)
13114 
      for key, value in self.__dict__.iteritems()]
13115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13116 
 
13117 
  def __eq__(self, other):
13118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13119 
 
13120 
  def __ne__(self, other):
13121 
    return not (self == other)
13122 
 
13123 
class getComingSoonCatalogIds_args:
13124 
  """
13125 
  Attributes:
13126 
   - beginIndex
13127 
   - totalItems
13128 
   - brand
13129 
   - category
13130 
  """
13131 
 
13132 
  thrift_spec = (
13133 
    None, # 0
13134 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
13135 
    (2, TType.I64, 'totalItems', None, None, ), # 2
13136 
    (3, TType.STRING, 'brand', None, None, ), # 3
13137 
    (4, TType.I64, 'category', None, None, ), # 4
13138 
  )
13139 
 
13140 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
13141 
    self.beginIndex = beginIndex
13142 
    self.totalItems = totalItems
13143 
    self.brand = brand
13144 
    self.category = category
13145 
 
13146 
  def read(self, iprot):
13147 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13148 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13149 
      return
13150 
    iprot.readStructBegin()
13151 
    while True:
13152 
      (fname, ftype, fid) = iprot.readFieldBegin()
13153 
      if ftype == TType.STOP:
13154 
        break
13155 
      if fid == 1:
13156 
        if ftype == TType.I64:
13157 
          self.beginIndex = iprot.readI64();
13158 
        else:
13159 
          iprot.skip(ftype)
13160 
      elif fid == 2:
13161 
        if ftype == TType.I64:
13162 
          self.totalItems = iprot.readI64();
13163 
        else:
13164 
          iprot.skip(ftype)
13165 
      elif fid == 3:
13166 
        if ftype == TType.STRING:
13167 
          self.brand = iprot.readString();
13168 
        else:
13169 
          iprot.skip(ftype)
13170 
      elif fid == 4:
13171 
        if ftype == TType.I64:
13172 
          self.category = iprot.readI64();
13173 
        else:
13174 
          iprot.skip(ftype)
13175 
      else:
13176 
        iprot.skip(ftype)
13177 
      iprot.readFieldEnd()
13178 
    iprot.readStructEnd()
13179 
 
13180 
  def write(self, oprot):
13181 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13182 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13183 
      return
13184 
    oprot.writeStructBegin('getComingSoonCatalogIds_args')
13185 
    if self.beginIndex is not None:
13186 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
13187 
      oprot.writeI64(self.beginIndex)
13188 
      oprot.writeFieldEnd()
13189 
    if self.totalItems is not None:
13190 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
13191 
      oprot.writeI64(self.totalItems)
13192 
      oprot.writeFieldEnd()
13193 
    if self.brand is not None:
13194 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
13195 
      oprot.writeString(self.brand)
13196 
      oprot.writeFieldEnd()
13197 
    if self.category is not None:
13198 
      oprot.writeFieldBegin('category', TType.I64, 4)
13199 
      oprot.writeI64(self.category)
13200 
      oprot.writeFieldEnd()
13201 
    oprot.writeFieldStop()
13202 
    oprot.writeStructEnd()
13203 
 
13204 
  def validate(self):
13205 
    return
13206 
 
13207 
 
13208 
  def __repr__(self):
13209 
    L = ['%s=%r' % (key, value)
13210 
      for key, value in self.__dict__.iteritems()]
13211 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13212 
 
13213 
  def __eq__(self, other):
13214 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13215 
 
13216 
  def __ne__(self, other):
13217 
    return not (self == other)
13218 
 
13219 
class getComingSoonCatalogIds_result:
13220 
  """
13221 
  Attributes:
13222 
   - success
13223 
   - cex
13224 
  """
13225 
 
13226 
  thrift_spec = (
13227 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
13228 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13229 
  )
13230 
 
13231 
  def __init__(self, success=None, cex=None,):
13232 
    self.success = success
13233 
    self.cex = cex
13234 
 
13235 
  def read(self, iprot):
13236 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13237 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13238 
      return
13239 
    iprot.readStructBegin()
13240 
    while True:
13241 
      (fname, ftype, fid) = iprot.readFieldBegin()
13242 
      if ftype == TType.STOP:
13243 
        break
13244 
      if fid == 0:
13245 
        if ftype == TType.LIST:
13246 
          self.success = []
13493 amit.gupta 13247 
          (_etype151, _size148) = iprot.readListBegin()
13248 
          for _i152 in xrange(_size148):
13249 
            _elem153 = iprot.readI64();
13250 
            self.success.append(_elem153)
5944 mandeep.dh 13251 
          iprot.readListEnd()
13252 
        else:
13253 
          iprot.skip(ftype)
13254 
      elif fid == 1:
13255 
        if ftype == TType.STRUCT:
13256 
          self.cex = CatalogServiceException()
13257 
          self.cex.read(iprot)
13258 
        else:
13259 
          iprot.skip(ftype)
13260 
      else:
13261 
        iprot.skip(ftype)
13262 
      iprot.readFieldEnd()
13263 
    iprot.readStructEnd()
13264 
 
13265 
  def write(self, oprot):
13266 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13267 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13268 
      return
13269 
    oprot.writeStructBegin('getComingSoonCatalogIds_result')
13270 
    if self.success is not None:
13271 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13272 
      oprot.writeListBegin(TType.I64, len(self.success))
13493 amit.gupta 13273 
      for iter154 in self.success:
13274 
        oprot.writeI64(iter154)
5944 mandeep.dh 13275 
      oprot.writeListEnd()
13276 
      oprot.writeFieldEnd()
13277 
    if self.cex is not None:
13278 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13279 
      self.cex.write(oprot)
13280 
      oprot.writeFieldEnd()
13281 
    oprot.writeFieldStop()
13282 
    oprot.writeStructEnd()
13283 
 
13284 
  def validate(self):
13285 
    return
13286 
 
13287 
 
13288 
  def __repr__(self):
13289 
    L = ['%s=%r' % (key, value)
13290 
      for key, value in self.__dict__.iteritems()]
13291 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13292 
 
13293 
  def __eq__(self, other):
13294 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13295 
 
13296 
  def __ne__(self, other):
13297 
    return not (self == other)
13298 
 
13299 
class getComingSoonCount_args:
13300 
 
13301 
  thrift_spec = (
13302 
  )
13303 
 
13304 
  def read(self, iprot):
13305 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13306 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13307 
      return
13308 
    iprot.readStructBegin()
13309 
    while True:
13310 
      (fname, ftype, fid) = iprot.readFieldBegin()
13311 
      if ftype == TType.STOP:
13312 
        break
13313 
      else:
13314 
        iprot.skip(ftype)
13315 
      iprot.readFieldEnd()
13316 
    iprot.readStructEnd()
13317 
 
13318 
  def write(self, oprot):
13319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13321 
      return
13322 
    oprot.writeStructBegin('getComingSoonCount_args')
13323 
    oprot.writeFieldStop()
13324 
    oprot.writeStructEnd()
13325 
 
13326 
  def validate(self):
13327 
    return
13328 
 
13329 
 
13330 
  def __repr__(self):
13331 
    L = ['%s=%r' % (key, value)
13332 
      for key, value in self.__dict__.iteritems()]
13333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13334 
 
13335 
  def __eq__(self, other):
13336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13337 
 
13338 
  def __ne__(self, other):
13339 
    return not (self == other)
13340 
 
13341 
class getComingSoonCount_result:
13342 
  """
13343 
  Attributes:
13344 
   - success
13345 
   - cex
13346 
  """
13347 
 
13348 
  thrift_spec = (
13349 
    (0, TType.I64, 'success', None, None, ), # 0
13350 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13351 
  )
13352 
 
13353 
  def __init__(self, success=None, cex=None,):
13354 
    self.success = success
13355 
    self.cex = cex
13356 
 
13357 
  def read(self, iprot):
13358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13360 
      return
13361 
    iprot.readStructBegin()
13362 
    while True:
13363 
      (fname, ftype, fid) = iprot.readFieldBegin()
13364 
      if ftype == TType.STOP:
13365 
        break
13366 
      if fid == 0:
13367 
        if ftype == TType.I64:
13368 
          self.success = iprot.readI64();
13369 
        else:
13370 
          iprot.skip(ftype)
13371 
      elif fid == 1:
13372 
        if ftype == TType.STRUCT:
13373 
          self.cex = CatalogServiceException()
13374 
          self.cex.read(iprot)
13375 
        else:
13376 
          iprot.skip(ftype)
13377 
      else:
13378 
        iprot.skip(ftype)
13379 
      iprot.readFieldEnd()
13380 
    iprot.readStructEnd()
13381 
 
13382 
  def write(self, oprot):
13383 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13384 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13385 
      return
13386 
    oprot.writeStructBegin('getComingSoonCount_result')
13387 
    if self.success is not None:
13388 
      oprot.writeFieldBegin('success', TType.I64, 0)
13389 
      oprot.writeI64(self.success)
13390 
      oprot.writeFieldEnd()
13391 
    if self.cex is not None:
13392 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13393 
      self.cex.write(oprot)
13394 
      oprot.writeFieldEnd()
13395 
    oprot.writeFieldStop()
13396 
    oprot.writeStructEnd()
13397 
 
13398 
  def validate(self):
13399 
    return
13400 
 
13401 
 
13402 
  def __repr__(self):
13403 
    L = ['%s=%r' % (key, value)
13404 
      for key, value in self.__dict__.iteritems()]
13405 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13406 
 
13407 
  def __eq__(self, other):
13408 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13409 
 
13410 
  def __ne__(self, other):
13411 
    return not (self == other)
13412 
 
13413 
class getLatestArrivals_args:
13414 
 
13415 
  thrift_spec = (
13416 
  )
13417 
 
13418 
  def read(self, iprot):
13419 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13420 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13421 
      return
13422 
    iprot.readStructBegin()
13423 
    while True:
13424 
      (fname, ftype, fid) = iprot.readFieldBegin()
13425 
      if ftype == TType.STOP:
13426 
        break
13427 
      else:
13428 
        iprot.skip(ftype)
13429 
      iprot.readFieldEnd()
13430 
    iprot.readStructEnd()
13431 
 
13432 
  def write(self, oprot):
13433 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13434 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13435 
      return
13436 
    oprot.writeStructBegin('getLatestArrivals_args')
13437 
    oprot.writeFieldStop()
13438 
    oprot.writeStructEnd()
13439 
 
13440 
  def validate(self):
13441 
    return
13442 
 
13443 
 
13444 
  def __repr__(self):
13445 
    L = ['%s=%r' % (key, value)
13446 
      for key, value in self.__dict__.iteritems()]
13447 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13448 
 
13449 
  def __eq__(self, other):
13450 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13451 
 
13452 
  def __ne__(self, other):
13453 
    return not (self == other)
13454 
 
13455 
class getLatestArrivals_result:
13456 
  """
13457 
  Attributes:
13458 
   - success
13459 
   - isex
13460 
  """
13461 
 
13462 
  thrift_spec = (
13463 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
13464 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13465 
  )
13466 
 
13467 
  def __init__(self, success=None, isex=None,):
13468 
    self.success = success
13469 
    self.isex = isex
13470 
 
13471 
  def read(self, iprot):
13472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13474 
      return
13475 
    iprot.readStructBegin()
13476 
    while True:
13477 
      (fname, ftype, fid) = iprot.readFieldBegin()
13478 
      if ftype == TType.STOP:
13479 
        break
13480 
      if fid == 0:
13481 
        if ftype == TType.LIST:
13482 
          self.success = []
13493 amit.gupta 13483 
          (_etype158, _size155) = iprot.readListBegin()
13484 
          for _i159 in xrange(_size155):
13485 
            _elem160 = Item()
13486 
            _elem160.read(iprot)
13487 
            self.success.append(_elem160)
5944 mandeep.dh 13488 
          iprot.readListEnd()
13489 
        else:
13490 
          iprot.skip(ftype)
13491 
      elif fid == 1:
13492 
        if ftype == TType.STRUCT:
13493 
          self.isex = CatalogServiceException()
13494 
          self.isex.read(iprot)
13495 
        else:
13496 
          iprot.skip(ftype)
13497 
      else:
13498 
        iprot.skip(ftype)
13499 
      iprot.readFieldEnd()
13500 
    iprot.readStructEnd()
13501 
 
13502 
  def write(self, oprot):
13503 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13504 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13505 
      return
13506 
    oprot.writeStructBegin('getLatestArrivals_result')
13507 
    if self.success is not None:
13508 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13509 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 13510 
      for iter161 in self.success:
13511 
        iter161.write(oprot)
5944 mandeep.dh 13512 
      oprot.writeListEnd()
13513 
      oprot.writeFieldEnd()
13514 
    if self.isex is not None:
13515 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
13516 
      self.isex.write(oprot)
13517 
      oprot.writeFieldEnd()
13518 
    oprot.writeFieldStop()
13519 
    oprot.writeStructEnd()
13520 
 
13521 
  def validate(self):
13522 
    return
13523 
 
13524 
 
13525 
  def __repr__(self):
13526 
    L = ['%s=%r' % (key, value)
13527 
      for key, value in self.__dict__.iteritems()]
13528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13529 
 
13530 
  def __eq__(self, other):
13531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13532 
 
13533 
  def __ne__(self, other):
13534 
    return not (self == other)
13535 
 
13536 
class getLatestArrivalsCatalogIds_args:
13537 
  """
13538 
  Attributes:
13539 
   - beginIndex
13540 
   - totalItems
13541 
   - brand
13542 
   - categories
13543 
  """
13544 
 
13545 
  thrift_spec = (
13546 
    None, # 0
13547 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
13548 
    (2, TType.I64, 'totalItems', None, None, ), # 2
13549 
    (3, TType.STRING, 'brand', None, None, ), # 3
13550 
    (4, TType.LIST, 'categories', (TType.I64,None), None, ), # 4
13551 
  )
13552 
 
13553 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, categories=None,):
13554 
    self.beginIndex = beginIndex
13555 
    self.totalItems = totalItems
13556 
    self.brand = brand
13557 
    self.categories = categories
13558 
 
13559 
  def read(self, iprot):
13560 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13561 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13562 
      return
13563 
    iprot.readStructBegin()
13564 
    while True:
13565 
      (fname, ftype, fid) = iprot.readFieldBegin()
13566 
      if ftype == TType.STOP:
13567 
        break
13568 
      if fid == 1:
13569 
        if ftype == TType.I64:
13570 
          self.beginIndex = iprot.readI64();
13571 
        else:
13572 
          iprot.skip(ftype)
13573 
      elif fid == 2:
13574 
        if ftype == TType.I64:
13575 
          self.totalItems = iprot.readI64();
13576 
        else:
13577 
          iprot.skip(ftype)
13578 
      elif fid == 3:
13579 
        if ftype == TType.STRING:
13580 
          self.brand = iprot.readString();
13581 
        else:
13582 
          iprot.skip(ftype)
13583 
      elif fid == 4:
13584 
        if ftype == TType.LIST:
13585 
          self.categories = []
13493 amit.gupta 13586 
          (_etype165, _size162) = iprot.readListBegin()
13587 
          for _i166 in xrange(_size162):
13588 
            _elem167 = iprot.readI64();
13589 
            self.categories.append(_elem167)
5944 mandeep.dh 13590 
          iprot.readListEnd()
13591 
        else:
13592 
          iprot.skip(ftype)
13593 
      else:
13594 
        iprot.skip(ftype)
13595 
      iprot.readFieldEnd()
13596 
    iprot.readStructEnd()
13597 
 
13598 
  def write(self, oprot):
13599 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13600 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13601 
      return
13602 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_args')
13603 
    if self.beginIndex is not None:
13604 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
13605 
      oprot.writeI64(self.beginIndex)
13606 
      oprot.writeFieldEnd()
13607 
    if self.totalItems is not None:
13608 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
13609 
      oprot.writeI64(self.totalItems)
13610 
      oprot.writeFieldEnd()
13611 
    if self.brand is not None:
13612 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
13613 
      oprot.writeString(self.brand)
13614 
      oprot.writeFieldEnd()
13615 
    if self.categories is not None:
13616 
      oprot.writeFieldBegin('categories', TType.LIST, 4)
13617 
      oprot.writeListBegin(TType.I64, len(self.categories))
13493 amit.gupta 13618 
      for iter168 in self.categories:
13619 
        oprot.writeI64(iter168)
5944 mandeep.dh 13620 
      oprot.writeListEnd()
13621 
      oprot.writeFieldEnd()
13622 
    oprot.writeFieldStop()
13623 
    oprot.writeStructEnd()
13624 
 
13625 
  def validate(self):
13626 
    return
13627 
 
13628 
 
13629 
  def __repr__(self):
13630 
    L = ['%s=%r' % (key, value)
13631 
      for key, value in self.__dict__.iteritems()]
13632 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13633 
 
13634 
  def __eq__(self, other):
13635 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13636 
 
13637 
  def __ne__(self, other):
13638 
    return not (self == other)
13639 
 
13640 
class getLatestArrivalsCatalogIds_result:
13641 
  """
13642 
  Attributes:
13643 
   - success
13644 
   - cex
13645 
  """
13646 
 
13647 
  thrift_spec = (
13648 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
13649 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13650 
  )
13651 
 
13652 
  def __init__(self, success=None, cex=None,):
13653 
    self.success = success
13654 
    self.cex = cex
13655 
 
13656 
  def read(self, iprot):
13657 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13658 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13659 
      return
13660 
    iprot.readStructBegin()
13661 
    while True:
13662 
      (fname, ftype, fid) = iprot.readFieldBegin()
13663 
      if ftype == TType.STOP:
13664 
        break
13665 
      if fid == 0:
13666 
        if ftype == TType.LIST:
13667 
          self.success = []
13493 amit.gupta 13668 
          (_etype172, _size169) = iprot.readListBegin()
13669 
          for _i173 in xrange(_size169):
13670 
            _elem174 = iprot.readI64();
13671 
            self.success.append(_elem174)
5944 mandeep.dh 13672 
          iprot.readListEnd()
13673 
        else:
13674 
          iprot.skip(ftype)
13675 
      elif fid == 1:
13676 
        if ftype == TType.STRUCT:
13677 
          self.cex = CatalogServiceException()
13678 
          self.cex.read(iprot)
13679 
        else:
13680 
          iprot.skip(ftype)
13681 
      else:
13682 
        iprot.skip(ftype)
13683 
      iprot.readFieldEnd()
13684 
    iprot.readStructEnd()
13685 
 
13686 
  def write(self, oprot):
13687 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13688 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13689 
      return
13690 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_result')
13691 
    if self.success is not None:
13692 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13693 
      oprot.writeListBegin(TType.I64, len(self.success))
13493 amit.gupta 13694 
      for iter175 in self.success:
13695 
        oprot.writeI64(iter175)
5944 mandeep.dh 13696 
      oprot.writeListEnd()
13697 
      oprot.writeFieldEnd()
13698 
    if self.cex is not None:
13699 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13700 
      self.cex.write(oprot)
13701 
      oprot.writeFieldEnd()
13702 
    oprot.writeFieldStop()
13703 
    oprot.writeStructEnd()
13704 
 
13705 
  def validate(self):
13706 
    return
13707 
 
13708 
 
13709 
  def __repr__(self):
13710 
    L = ['%s=%r' % (key, value)
13711 
      for key, value in self.__dict__.iteritems()]
13712 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13713 
 
13714 
  def __eq__(self, other):
13715 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13716 
 
13717 
  def __ne__(self, other):
13718 
    return not (self == other)
13719 
 
13720 
class getLatestArrivalsCount_args:
13721 
 
13722 
  thrift_spec = (
13723 
  )
13724 
 
13725 
  def read(self, iprot):
13726 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13727 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13728 
      return
13729 
    iprot.readStructBegin()
13730 
    while True:
13731 
      (fname, ftype, fid) = iprot.readFieldBegin()
13732 
      if ftype == TType.STOP:
13733 
        break
13734 
      else:
13735 
        iprot.skip(ftype)
13736 
      iprot.readFieldEnd()
13737 
    iprot.readStructEnd()
13738 
 
13739 
  def write(self, oprot):
13740 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13741 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13742 
      return
13743 
    oprot.writeStructBegin('getLatestArrivalsCount_args')
13744 
    oprot.writeFieldStop()
13745 
    oprot.writeStructEnd()
13746 
 
13747 
  def validate(self):
13748 
    return
13749 
 
13750 
 
13751 
  def __repr__(self):
13752 
    L = ['%s=%r' % (key, value)
13753 
      for key, value in self.__dict__.iteritems()]
13754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13755 
 
13756 
  def __eq__(self, other):
13757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13758 
 
13759 
  def __ne__(self, other):
13760 
    return not (self == other)
13761 
 
13762 
class getLatestArrivalsCount_result:
13763 
  """
13764 
  Attributes:
13765 
   - success
13766 
   - cex
13767 
  """
13768 
 
13769 
  thrift_spec = (
13770 
    (0, TType.I64, 'success', None, None, ), # 0
13771 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13772 
  )
13773 
 
13774 
  def __init__(self, success=None, cex=None,):
13775 
    self.success = success
13776 
    self.cex = cex
13777 
 
13778 
  def read(self, iprot):
13779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13781 
      return
13782 
    iprot.readStructBegin()
13783 
    while True:
13784 
      (fname, ftype, fid) = iprot.readFieldBegin()
13785 
      if ftype == TType.STOP:
13786 
        break
13787 
      if fid == 0:
13788 
        if ftype == TType.I64:
13789 
          self.success = iprot.readI64();
13790 
        else:
13791 
          iprot.skip(ftype)
13792 
      elif fid == 1:
13793 
        if ftype == TType.STRUCT:
13794 
          self.cex = CatalogServiceException()
13795 
          self.cex.read(iprot)
13796 
        else:
13797 
          iprot.skip(ftype)
13798 
      else:
13799 
        iprot.skip(ftype)
13800 
      iprot.readFieldEnd()
13801 
    iprot.readStructEnd()
13802 
 
13803 
  def write(self, oprot):
13804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13806 
      return
13807 
    oprot.writeStructBegin('getLatestArrivalsCount_result')
13808 
    if self.success is not None:
13809 
      oprot.writeFieldBegin('success', TType.I64, 0)
13810 
      oprot.writeI64(self.success)
13811 
      oprot.writeFieldEnd()
13812 
    if self.cex is not None:
13813 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13814 
      self.cex.write(oprot)
13815 
      oprot.writeFieldEnd()
13816 
    oprot.writeFieldStop()
13817 
    oprot.writeStructEnd()
13818 
 
13819 
  def validate(self):
13820 
    return
13821 
 
13822 
 
13823 
  def __repr__(self):
13824 
    L = ['%s=%r' % (key, value)
13825 
      for key, value in self.__dict__.iteritems()]
13826 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13827 
 
13828 
  def __eq__(self, other):
13829 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13830 
 
13831 
  def __ne__(self, other):
13832 
    return not (self == other)
13833 
 
13834 
class generateNewEntityID_args:
13835 
 
13836 
  thrift_spec = (
13837 
  )
13838 
 
13839 
  def read(self, iprot):
13840 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13841 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13842 
      return
13843 
    iprot.readStructBegin()
13844 
    while True:
13845 
      (fname, ftype, fid) = iprot.readFieldBegin()
13846 
      if ftype == TType.STOP:
13847 
        break
13848 
      else:
13849 
        iprot.skip(ftype)
13850 
      iprot.readFieldEnd()
13851 
    iprot.readStructEnd()
13852 
 
13853 
  def write(self, oprot):
13854 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13855 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13856 
      return
13857 
    oprot.writeStructBegin('generateNewEntityID_args')
13858 
    oprot.writeFieldStop()
13859 
    oprot.writeStructEnd()
13860 
 
13861 
  def validate(self):
13862 
    return
13863 
 
13864 
 
13865 
  def __repr__(self):
13866 
    L = ['%s=%r' % (key, value)
13867 
      for key, value in self.__dict__.iteritems()]
13868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13869 
 
13870 
  def __eq__(self, other):
13871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13872 
 
13873 
  def __ne__(self, other):
13874 
    return not (self == other)
13875 
 
13876 
class generateNewEntityID_result:
13877 
  """
13878 
  Attributes:
13879 
   - success
13880 
  """
13881 
 
13882 
  thrift_spec = (
13883 
    (0, TType.I64, 'success', None, None, ), # 0
13884 
  )
13885 
 
13886 
  def __init__(self, success=None,):
13887 
    self.success = success
13888 
 
13889 
  def read(self, iprot):
13890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13892 
      return
13893 
    iprot.readStructBegin()
13894 
    while True:
13895 
      (fname, ftype, fid) = iprot.readFieldBegin()
13896 
      if ftype == TType.STOP:
13897 
        break
13898 
      if fid == 0:
13899 
        if ftype == TType.I64:
13900 
          self.success = iprot.readI64();
13901 
        else:
13902 
          iprot.skip(ftype)
13903 
      else:
13904 
        iprot.skip(ftype)
13905 
      iprot.readFieldEnd()
13906 
    iprot.readStructEnd()
13907 
 
13908 
  def write(self, oprot):
13909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13911 
      return
13912 
    oprot.writeStructBegin('generateNewEntityID_result')
13913 
    if self.success is not None:
13914 
      oprot.writeFieldBegin('success', TType.I64, 0)
13915 
      oprot.writeI64(self.success)
13916 
      oprot.writeFieldEnd()
13917 
    oprot.writeFieldStop()
13918 
    oprot.writeStructEnd()
13919 
 
13920 
  def validate(self):
13921 
    return
13922 
 
13923 
 
13924 
  def __repr__(self):
13925 
    L = ['%s=%r' % (key, value)
13926 
      for key, value in self.__dict__.iteritems()]
13927 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13928 
 
13929 
  def __eq__(self, other):
13930 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13931 
 
13932 
  def __ne__(self, other):
13933 
    return not (self == other)
13934 
 
13935 
class addCategory_args:
13936 
  """
13937 
  Attributes:
13938 
   - category
13939 
  """
13940 
 
13941 
  thrift_spec = (
13942 
    None, # 0
13943 
    (1, TType.STRUCT, 'category', (Category, Category.thrift_spec), None, ), # 1
13944 
  )
13945 
 
13946 
  def __init__(self, category=None,):
13947 
    self.category = category
13948 
 
13949 
  def read(self, iprot):
13950 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13951 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13952 
      return
13953 
    iprot.readStructBegin()
13954 
    while True:
13955 
      (fname, ftype, fid) = iprot.readFieldBegin()
13956 
      if ftype == TType.STOP:
13957 
        break
13958 
      if fid == 1:
13959 
        if ftype == TType.STRUCT:
13960 
          self.category = Category()
13961 
          self.category.read(iprot)
13962 
        else:
13963 
          iprot.skip(ftype)
13964 
      else:
13965 
        iprot.skip(ftype)
13966 
      iprot.readFieldEnd()
13967 
    iprot.readStructEnd()
13968 
 
13969 
  def write(self, oprot):
13970 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13971 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13972 
      return
13973 
    oprot.writeStructBegin('addCategory_args')
13974 
    if self.category is not None:
13975 
      oprot.writeFieldBegin('category', TType.STRUCT, 1)
13976 
      self.category.write(oprot)
13977 
      oprot.writeFieldEnd()
13978 
    oprot.writeFieldStop()
13979 
    oprot.writeStructEnd()
13980 
 
13981 
  def validate(self):
13982 
    return
13983 
 
13984 
 
13985 
  def __repr__(self):
13986 
    L = ['%s=%r' % (key, value)
13987 
      for key, value in self.__dict__.iteritems()]
13988 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13989 
 
13990 
  def __eq__(self, other):
13991 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13992 
 
13993 
  def __ne__(self, other):
13994 
    return not (self == other)
13995 
 
13996 
class addCategory_result:
13997 
  """
13998 
  Attributes:
13999 
   - success
14000 
  """
14001 
 
14002 
  thrift_spec = (
14003 
    (0, TType.BOOL, 'success', None, None, ), # 0
14004 
  )
14005 
 
14006 
  def __init__(self, success=None,):
14007 
    self.success = success
14008 
 
14009 
  def read(self, iprot):
14010 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14011 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14012 
      return
14013 
    iprot.readStructBegin()
14014 
    while True:
14015 
      (fname, ftype, fid) = iprot.readFieldBegin()
14016 
      if ftype == TType.STOP:
14017 
        break
14018 
      if fid == 0:
14019 
        if ftype == TType.BOOL:
14020 
          self.success = iprot.readBool();
14021 
        else:
14022 
          iprot.skip(ftype)
14023 
      else:
14024 
        iprot.skip(ftype)
14025 
      iprot.readFieldEnd()
14026 
    iprot.readStructEnd()
14027 
 
14028 
  def write(self, oprot):
14029 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14030 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14031 
      return
14032 
    oprot.writeStructBegin('addCategory_result')
14033 
    if self.success is not None:
14034 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14035 
      oprot.writeBool(self.success)
14036 
      oprot.writeFieldEnd()
14037 
    oprot.writeFieldStop()
14038 
    oprot.writeStructEnd()
14039 
 
14040 
  def validate(self):
14041 
    return
14042 
 
14043 
 
14044 
  def __repr__(self):
14045 
    L = ['%s=%r' % (key, value)
14046 
      for key, value in self.__dict__.iteritems()]
14047 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14048 
 
14049 
  def __eq__(self, other):
14050 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14051 
 
14052 
  def __ne__(self, other):
14053 
    return not (self == other)
14054 
 
14055 
class getCategory_args:
14056 
  """
14057 
  Attributes:
14058 
   - id
14059 
  """
14060 
 
14061 
  thrift_spec = (
14062 
    None, # 0
14063 
    (1, TType.I64, 'id', None, None, ), # 1
14064 
  )
14065 
 
14066 
  def __init__(self, id=None,):
14067 
    self.id = id
14068 
 
14069 
  def read(self, iprot):
14070 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14071 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14072 
      return
14073 
    iprot.readStructBegin()
14074 
    while True:
14075 
      (fname, ftype, fid) = iprot.readFieldBegin()
14076 
      if ftype == TType.STOP:
14077 
        break
14078 
      if fid == 1:
14079 
        if ftype == TType.I64:
14080 
          self.id = iprot.readI64();
14081 
        else:
14082 
          iprot.skip(ftype)
14083 
      else:
14084 
        iprot.skip(ftype)
14085 
      iprot.readFieldEnd()
14086 
    iprot.readStructEnd()
14087 
 
14088 
  def write(self, oprot):
14089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14091 
      return
14092 
    oprot.writeStructBegin('getCategory_args')
14093 
    if self.id is not None:
14094 
      oprot.writeFieldBegin('id', TType.I64, 1)
14095 
      oprot.writeI64(self.id)
14096 
      oprot.writeFieldEnd()
14097 
    oprot.writeFieldStop()
14098 
    oprot.writeStructEnd()
14099 
 
14100 
  def validate(self):
14101 
    return
14102 
 
14103 
 
14104 
  def __repr__(self):
14105 
    L = ['%s=%r' % (key, value)
14106 
      for key, value in self.__dict__.iteritems()]
14107 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14108 
 
14109 
  def __eq__(self, other):
14110 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14111 
 
14112 
  def __ne__(self, other):
14113 
    return not (self == other)
14114 
 
14115 
class getCategory_result:
14116 
  """
14117 
  Attributes:
14118 
   - success
14119 
  """
14120 
 
14121 
  thrift_spec = (
14122 
    (0, TType.STRUCT, 'success', (Category, Category.thrift_spec), None, ), # 0
14123 
  )
14124 
 
14125 
  def __init__(self, success=None,):
14126 
    self.success = success
14127 
 
14128 
  def read(self, iprot):
14129 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14130 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14131 
      return
14132 
    iprot.readStructBegin()
14133 
    while True:
14134 
      (fname, ftype, fid) = iprot.readFieldBegin()
14135 
      if ftype == TType.STOP:
14136 
        break
14137 
      if fid == 0:
14138 
        if ftype == TType.STRUCT:
14139 
          self.success = Category()
14140 
          self.success.read(iprot)
14141 
        else:
14142 
          iprot.skip(ftype)
14143 
      else:
14144 
        iprot.skip(ftype)
14145 
      iprot.readFieldEnd()
14146 
    iprot.readStructEnd()
14147 
 
14148 
  def write(self, oprot):
14149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14151 
      return
14152 
    oprot.writeStructBegin('getCategory_result')
14153 
    if self.success is not None:
14154 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14155 
      self.success.write(oprot)
14156 
      oprot.writeFieldEnd()
14157 
    oprot.writeFieldStop()
14158 
    oprot.writeStructEnd()
14159 
 
14160 
  def validate(self):
14161 
    return
14162 
 
14163 
 
14164 
  def __repr__(self):
14165 
    L = ['%s=%r' % (key, value)
14166 
      for key, value in self.__dict__.iteritems()]
14167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14168 
 
14169 
  def __eq__(self, other):
14170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14171 
 
14172 
  def __ne__(self, other):
14173 
    return not (self == other)
14174 
 
14175 
class getAllCategories_args:
14176 
 
14177 
  thrift_spec = (
14178 
  )
14179 
 
14180 
  def read(self, iprot):
14181 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14182 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14183 
      return
14184 
    iprot.readStructBegin()
14185 
    while True:
14186 
      (fname, ftype, fid) = iprot.readFieldBegin()
14187 
      if ftype == TType.STOP:
14188 
        break
14189 
      else:
14190 
        iprot.skip(ftype)
14191 
      iprot.readFieldEnd()
14192 
    iprot.readStructEnd()
14193 
 
14194 
  def write(self, oprot):
14195 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14196 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14197 
      return
14198 
    oprot.writeStructBegin('getAllCategories_args')
14199 
    oprot.writeFieldStop()
14200 
    oprot.writeStructEnd()
14201 
 
14202 
  def validate(self):
14203 
    return
14204 
 
14205 
 
14206 
  def __repr__(self):
14207 
    L = ['%s=%r' % (key, value)
14208 
      for key, value in self.__dict__.iteritems()]
14209 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14210 
 
14211 
  def __eq__(self, other):
14212 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14213 
 
14214 
  def __ne__(self, other):
14215 
    return not (self == other)
14216 
 
14217 
class getAllCategories_result:
14218 
  """
14219 
  Attributes:
14220 
   - success
14221 
  """
14222 
 
14223 
  thrift_spec = (
14224 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
14225 
  )
14226 
 
14227 
  def __init__(self, success=None,):
14228 
    self.success = success
14229 
 
14230 
  def read(self, iprot):
14231 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14232 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14233 
      return
14234 
    iprot.readStructBegin()
14235 
    while True:
14236 
      (fname, ftype, fid) = iprot.readFieldBegin()
14237 
      if ftype == TType.STOP:
14238 
        break
14239 
      if fid == 0:
14240 
        if ftype == TType.LIST:
14241 
          self.success = []
13493 amit.gupta 14242 
          (_etype179, _size176) = iprot.readListBegin()
14243 
          for _i180 in xrange(_size176):
14244 
            _elem181 = Category()
14245 
            _elem181.read(iprot)
14246 
            self.success.append(_elem181)
5944 mandeep.dh 14247 
          iprot.readListEnd()
14248 
        else:
14249 
          iprot.skip(ftype)
14250 
      else:
14251 
        iprot.skip(ftype)
14252 
      iprot.readFieldEnd()
14253 
    iprot.readStructEnd()
14254 
 
14255 
  def write(self, oprot):
14256 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14257 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14258 
      return
14259 
    oprot.writeStructBegin('getAllCategories_result')
14260 
    if self.success is not None:
14261 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14262 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 14263 
      for iter182 in self.success:
14264 
        iter182.write(oprot)
5944 mandeep.dh 14265 
      oprot.writeListEnd()
14266 
      oprot.writeFieldEnd()
14267 
    oprot.writeFieldStop()
14268 
    oprot.writeStructEnd()
14269 
 
14270 
  def validate(self):
14271 
    return
14272 
 
14273 
 
14274 
  def __repr__(self):
14275 
    L = ['%s=%r' % (key, value)
14276 
      for key, value in self.__dict__.iteritems()]
14277 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14278 
 
14279 
  def __eq__(self, other):
14280 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14281 
 
14282 
  def __ne__(self, other):
14283 
    return not (self == other)
14284 
 
14285 
class getAllSimilarItems_args:
14286 
  """
14287 
  Attributes:
14288 
   - itemId
14289 
  """
14290 
 
14291 
  thrift_spec = (
14292 
    None, # 0
14293 
    (1, TType.I64, 'itemId', None, None, ), # 1
14294 
  )
14295 
 
14296 
  def __init__(self, itemId=None,):
14297 
    self.itemId = itemId
14298 
 
14299 
  def read(self, iprot):
14300 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14301 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14302 
      return
14303 
    iprot.readStructBegin()
14304 
    while True:
14305 
      (fname, ftype, fid) = iprot.readFieldBegin()
14306 
      if ftype == TType.STOP:
14307 
        break
14308 
      if fid == 1:
14309 
        if ftype == TType.I64:
14310 
          self.itemId = iprot.readI64();
14311 
        else:
14312 
          iprot.skip(ftype)
14313 
      else:
14314 
        iprot.skip(ftype)
14315 
      iprot.readFieldEnd()
14316 
    iprot.readStructEnd()
14317 
 
14318 
  def write(self, oprot):
14319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14321 
      return
14322 
    oprot.writeStructBegin('getAllSimilarItems_args')
14323 
    if self.itemId is not None:
14324 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14325 
      oprot.writeI64(self.itemId)
14326 
      oprot.writeFieldEnd()
14327 
    oprot.writeFieldStop()
14328 
    oprot.writeStructEnd()
14329 
 
14330 
  def validate(self):
14331 
    return
14332 
 
14333 
 
14334 
  def __repr__(self):
14335 
    L = ['%s=%r' % (key, value)
14336 
      for key, value in self.__dict__.iteritems()]
14337 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14338 
 
14339 
  def __eq__(self, other):
14340 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14341 
 
14342 
  def __ne__(self, other):
14343 
    return not (self == other)
14344 
 
14345 
class getAllSimilarItems_result:
14346 
  """
14347 
  Attributes:
14348 
   - success
14349 
  """
14350 
 
14351 
  thrift_spec = (
14352 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
14353 
  )
14354 
 
14355 
  def __init__(self, success=None,):
14356 
    self.success = success
14357 
 
14358 
  def read(self, iprot):
14359 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14360 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14361 
      return
14362 
    iprot.readStructBegin()
14363 
    while True:
14364 
      (fname, ftype, fid) = iprot.readFieldBegin()
14365 
      if ftype == TType.STOP:
14366 
        break
14367 
      if fid == 0:
14368 
        if ftype == TType.LIST:
14369 
          self.success = []
13493 amit.gupta 14370 
          (_etype186, _size183) = iprot.readListBegin()
14371 
          for _i187 in xrange(_size183):
14372 
            _elem188 = Item()
14373 
            _elem188.read(iprot)
14374 
            self.success.append(_elem188)
5944 mandeep.dh 14375 
          iprot.readListEnd()
14376 
        else:
14377 
          iprot.skip(ftype)
14378 
      else:
14379 
        iprot.skip(ftype)
14380 
      iprot.readFieldEnd()
14381 
    iprot.readStructEnd()
14382 
 
14383 
  def write(self, oprot):
14384 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14385 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14386 
      return
14387 
    oprot.writeStructBegin('getAllSimilarItems_result')
14388 
    if self.success is not None:
14389 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14390 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 14391 
      for iter189 in self.success:
14392 
        iter189.write(oprot)
5944 mandeep.dh 14393 
      oprot.writeListEnd()
14394 
      oprot.writeFieldEnd()
14395 
    oprot.writeFieldStop()
14396 
    oprot.writeStructEnd()
14397 
 
14398 
  def validate(self):
14399 
    return
14400 
 
14401 
 
14402 
  def __repr__(self):
14403 
    L = ['%s=%r' % (key, value)
14404 
      for key, value in self.__dict__.iteritems()]
14405 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14406 
 
14407 
  def __eq__(self, other):
14408 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14409 
 
14410 
  def __ne__(self, other):
14411 
    return not (self == other)
14412 
 
14413 
class addSimilarItem_args:
14414 
  """
14415 
  Attributes:
14416 
   - itemId
14417 
   - catalogItemId
14418 
  """
14419 
 
14420 
  thrift_spec = (
14421 
    None, # 0
14422 
    (1, TType.I64, 'itemId', None, None, ), # 1
14423 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
14424 
  )
14425 
 
14426 
  def __init__(self, itemId=None, catalogItemId=None,):
14427 
    self.itemId = itemId
14428 
    self.catalogItemId = catalogItemId
14429 
 
14430 
  def read(self, iprot):
14431 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14432 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14433 
      return
14434 
    iprot.readStructBegin()
14435 
    while True:
14436 
      (fname, ftype, fid) = iprot.readFieldBegin()
14437 
      if ftype == TType.STOP:
14438 
        break
14439 
      if fid == 1:
14440 
        if ftype == TType.I64:
14441 
          self.itemId = iprot.readI64();
14442 
        else:
14443 
          iprot.skip(ftype)
14444 
      elif fid == 2:
14445 
        if ftype == TType.I64:
14446 
          self.catalogItemId = iprot.readI64();
14447 
        else:
14448 
          iprot.skip(ftype)
14449 
      else:
14450 
        iprot.skip(ftype)
14451 
      iprot.readFieldEnd()
14452 
    iprot.readStructEnd()
14453 
 
14454 
  def write(self, oprot):
14455 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14456 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14457 
      return
14458 
    oprot.writeStructBegin('addSimilarItem_args')
14459 
    if self.itemId is not None:
14460 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14461 
      oprot.writeI64(self.itemId)
14462 
      oprot.writeFieldEnd()
14463 
    if self.catalogItemId is not None:
14464 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
14465 
      oprot.writeI64(self.catalogItemId)
14466 
      oprot.writeFieldEnd()
14467 
    oprot.writeFieldStop()
14468 
    oprot.writeStructEnd()
14469 
 
14470 
  def validate(self):
14471 
    return
14472 
 
14473 
 
14474 
  def __repr__(self):
14475 
    L = ['%s=%r' % (key, value)
14476 
      for key, value in self.__dict__.iteritems()]
14477 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14478 
 
14479 
  def __eq__(self, other):
14480 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14481 
 
14482 
  def __ne__(self, other):
14483 
    return not (self == other)
14484 
 
14485 
class addSimilarItem_result:
14486 
  """
14487 
  Attributes:
14488 
   - success
14489 
   - cex
14490 
  """
14491 
 
14492 
  thrift_spec = (
14493 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
14494 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14495 
  )
14496 
 
14497 
  def __init__(self, success=None, cex=None,):
14498 
    self.success = success
14499 
    self.cex = cex
14500 
 
14501 
  def read(self, iprot):
14502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14504 
      return
14505 
    iprot.readStructBegin()
14506 
    while True:
14507 
      (fname, ftype, fid) = iprot.readFieldBegin()
14508 
      if ftype == TType.STOP:
14509 
        break
14510 
      if fid == 0:
14511 
        if ftype == TType.STRUCT:
14512 
          self.success = Item()
14513 
          self.success.read(iprot)
14514 
        else:
14515 
          iprot.skip(ftype)
14516 
      elif fid == 1:
14517 
        if ftype == TType.STRUCT:
14518 
          self.cex = CatalogServiceException()
14519 
          self.cex.read(iprot)
14520 
        else:
14521 
          iprot.skip(ftype)
14522 
      else:
14523 
        iprot.skip(ftype)
14524 
      iprot.readFieldEnd()
14525 
    iprot.readStructEnd()
14526 
 
14527 
  def write(self, oprot):
14528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14530 
      return
14531 
    oprot.writeStructBegin('addSimilarItem_result')
14532 
    if self.success is not None:
14533 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14534 
      self.success.write(oprot)
14535 
      oprot.writeFieldEnd()
14536 
    if self.cex is not None:
14537 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14538 
      self.cex.write(oprot)
14539 
      oprot.writeFieldEnd()
14540 
    oprot.writeFieldStop()
14541 
    oprot.writeStructEnd()
14542 
 
14543 
  def validate(self):
14544 
    return
14545 
 
14546 
 
14547 
  def __repr__(self):
14548 
    L = ['%s=%r' % (key, value)
14549 
      for key, value in self.__dict__.iteritems()]
14550 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14551 
 
14552 
  def __eq__(self, other):
14553 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14554 
 
14555 
  def __ne__(self, other):
14556 
    return not (self == other)
14557 
 
6512 kshitij.so 14558 
class addTag_args:
14559 
  """
14560 
  Attributes:
14561 
   - displayName
14562 
   - itemId
14563 
  """
14564 
 
14565 
  thrift_spec = (
14566 
    None, # 0
14567 
    (1, TType.STRING, 'displayName', None, None, ), # 1
14568 
    (2, TType.I64, 'itemId', None, None, ), # 2
14569 
  )
14570 
 
14571 
  def __init__(self, displayName=None, itemId=None,):
14572 
    self.displayName = displayName
14573 
    self.itemId = itemId
14574 
 
14575 
  def read(self, iprot):
14576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14578 
      return
14579 
    iprot.readStructBegin()
14580 
    while True:
14581 
      (fname, ftype, fid) = iprot.readFieldBegin()
14582 
      if ftype == TType.STOP:
14583 
        break
14584 
      if fid == 1:
14585 
        if ftype == TType.STRING:
14586 
          self.displayName = iprot.readString();
14587 
        else:
14588 
          iprot.skip(ftype)
14589 
      elif fid == 2:
14590 
        if ftype == TType.I64:
14591 
          self.itemId = iprot.readI64();
14592 
        else:
14593 
          iprot.skip(ftype)
14594 
      else:
14595 
        iprot.skip(ftype)
14596 
      iprot.readFieldEnd()
14597 
    iprot.readStructEnd()
14598 
 
14599 
  def write(self, oprot):
14600 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14601 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14602 
      return
14603 
    oprot.writeStructBegin('addTag_args')
14604 
    if self.displayName is not None:
14605 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
14606 
      oprot.writeString(self.displayName)
14607 
      oprot.writeFieldEnd()
14608 
    if self.itemId is not None:
14609 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14610 
      oprot.writeI64(self.itemId)
14611 
      oprot.writeFieldEnd()
14612 
    oprot.writeFieldStop()
14613 
    oprot.writeStructEnd()
14614 
 
14615 
  def validate(self):
14616 
    return
14617 
 
14618 
 
14619 
  def __repr__(self):
14620 
    L = ['%s=%r' % (key, value)
14621 
      for key, value in self.__dict__.iteritems()]
14622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14623 
 
14624 
  def __eq__(self, other):
14625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14626 
 
14627 
  def __ne__(self, other):
14628 
    return not (self == other)
14629 
 
14630 
class addTag_result:
14631 
  """
14632 
  Attributes:
14633 
   - success
14634 
  """
14635 
 
14636 
  thrift_spec = (
14637 
    (0, TType.BOOL, 'success', None, None, ), # 0
14638 
  )
14639 
 
14640 
  def __init__(self, success=None,):
14641 
    self.success = success
14642 
 
14643 
  def read(self, iprot):
14644 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14645 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14646 
      return
14647 
    iprot.readStructBegin()
14648 
    while True:
14649 
      (fname, ftype, fid) = iprot.readFieldBegin()
14650 
      if ftype == TType.STOP:
14651 
        break
14652 
      if fid == 0:
14653 
        if ftype == TType.BOOL:
14654 
          self.success = iprot.readBool();
14655 
        else:
14656 
          iprot.skip(ftype)
14657 
      else:
14658 
        iprot.skip(ftype)
14659 
      iprot.readFieldEnd()
14660 
    iprot.readStructEnd()
14661 
 
14662 
  def write(self, oprot):
14663 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14664 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14665 
      return
14666 
    oprot.writeStructBegin('addTag_result')
14667 
    if self.success is not None:
14668 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14669 
      oprot.writeBool(self.success)
14670 
      oprot.writeFieldEnd()
14671 
    oprot.writeFieldStop()
14672 
    oprot.writeStructEnd()
14673 
 
14674 
  def validate(self):
14675 
    return
14676 
 
14677 
 
14678 
  def __repr__(self):
14679 
    L = ['%s=%r' % (key, value)
14680 
      for key, value in self.__dict__.iteritems()]
14681 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14682 
 
14683 
  def __eq__(self, other):
14684 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14685 
 
14686 
  def __ne__(self, other):
14687 
    return not (self == other)
14688 
 
14689 
class deleteEntityTag_args:
14690 
  """
14691 
  Attributes:
14692 
   - displayName
14693 
   - itemId
14694 
  """
14695 
 
14696 
  thrift_spec = (
14697 
    None, # 0
14698 
    (1, TType.STRING, 'displayName', None, None, ), # 1
14699 
    (2, TType.I64, 'itemId', None, None, ), # 2
14700 
  )
14701 
 
14702 
  def __init__(self, displayName=None, itemId=None,):
14703 
    self.displayName = displayName
14704 
    self.itemId = itemId
14705 
 
14706 
  def read(self, iprot):
14707 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14708 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14709 
      return
14710 
    iprot.readStructBegin()
14711 
    while True:
14712 
      (fname, ftype, fid) = iprot.readFieldBegin()
14713 
      if ftype == TType.STOP:
14714 
        break
14715 
      if fid == 1:
14716 
        if ftype == TType.STRING:
14717 
          self.displayName = iprot.readString();
14718 
        else:
14719 
          iprot.skip(ftype)
14720 
      elif fid == 2:
14721 
        if ftype == TType.I64:
14722 
          self.itemId = iprot.readI64();
14723 
        else:
14724 
          iprot.skip(ftype)
14725 
      else:
14726 
        iprot.skip(ftype)
14727 
      iprot.readFieldEnd()
14728 
    iprot.readStructEnd()
14729 
 
14730 
  def write(self, oprot):
14731 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14732 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14733 
      return
14734 
    oprot.writeStructBegin('deleteEntityTag_args')
14735 
    if self.displayName is not None:
14736 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
14737 
      oprot.writeString(self.displayName)
14738 
      oprot.writeFieldEnd()
14739 
    if self.itemId is not None:
14740 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14741 
      oprot.writeI64(self.itemId)
14742 
      oprot.writeFieldEnd()
14743 
    oprot.writeFieldStop()
14744 
    oprot.writeStructEnd()
14745 
 
14746 
  def validate(self):
14747 
    return
14748 
 
14749 
 
14750 
  def __repr__(self):
14751 
    L = ['%s=%r' % (key, value)
14752 
      for key, value in self.__dict__.iteritems()]
14753 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14754 
 
14755 
  def __eq__(self, other):
14756 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14757 
 
14758 
  def __ne__(self, other):
14759 
    return not (self == other)
14760 
 
14761 
class deleteEntityTag_result:
14762 
  """
14763 
  Attributes:
14764 
   - success
14765 
  """
14766 
 
14767 
  thrift_spec = (
14768 
    (0, TType.BOOL, 'success', None, None, ), # 0
14769 
  )
14770 
 
14771 
  def __init__(self, success=None,):
14772 
    self.success = success
14773 
 
14774 
  def read(self, iprot):
14775 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14776 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14777 
      return
14778 
    iprot.readStructBegin()
14779 
    while True:
14780 
      (fname, ftype, fid) = iprot.readFieldBegin()
14781 
      if ftype == TType.STOP:
14782 
        break
14783 
      if fid == 0:
14784 
        if ftype == TType.BOOL:
14785 
          self.success = iprot.readBool();
14786 
        else:
14787 
          iprot.skip(ftype)
14788 
      else:
14789 
        iprot.skip(ftype)
14790 
      iprot.readFieldEnd()
14791 
    iprot.readStructEnd()
14792 
 
14793 
  def write(self, oprot):
14794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14796 
      return
14797 
    oprot.writeStructBegin('deleteEntityTag_result')
14798 
    if self.success is not None:
14799 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14800 
      oprot.writeBool(self.success)
14801 
      oprot.writeFieldEnd()
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 deleteTag_args:
14821 
  """
14822 
  Attributes:
14823 
   - displayName
14824 
  """
14825 
 
14826 
  thrift_spec = (
14827 
    None, # 0
14828 
    (1, TType.STRING, 'displayName', None, None, ), # 1
14829 
  )
14830 
 
14831 
  def __init__(self, displayName=None,):
14832 
    self.displayName = displayName
14833 
 
14834 
  def read(self, iprot):
14835 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14836 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14837 
      return
14838 
    iprot.readStructBegin()
14839 
    while True:
14840 
      (fname, ftype, fid) = iprot.readFieldBegin()
14841 
      if ftype == TType.STOP:
14842 
        break
14843 
      if fid == 1:
14844 
        if ftype == TType.STRING:
14845 
          self.displayName = iprot.readString();
14846 
        else:
14847 
          iprot.skip(ftype)
14848 
      else:
14849 
        iprot.skip(ftype)
14850 
      iprot.readFieldEnd()
14851 
    iprot.readStructEnd()
14852 
 
14853 
  def write(self, oprot):
14854 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14855 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14856 
      return
14857 
    oprot.writeStructBegin('deleteTag_args')
14858 
    if self.displayName is not None:
14859 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
14860 
      oprot.writeString(self.displayName)
14861 
      oprot.writeFieldEnd()
14862 
    oprot.writeFieldStop()
14863 
    oprot.writeStructEnd()
14864 
 
14865 
  def validate(self):
14866 
    return
14867 
 
14868 
 
14869 
  def __repr__(self):
14870 
    L = ['%s=%r' % (key, value)
14871 
      for key, value in self.__dict__.iteritems()]
14872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14873 
 
14874 
  def __eq__(self, other):
14875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14876 
 
14877 
  def __ne__(self, other):
14878 
    return not (self == other)
14879 
 
14880 
class deleteTag_result:
14881 
  """
14882 
  Attributes:
14883 
   - success
14884 
  """
14885 
 
14886 
  thrift_spec = (
14887 
    (0, TType.BOOL, 'success', None, None, ), # 0
14888 
  )
14889 
 
14890 
  def __init__(self, success=None,):
14891 
    self.success = success
14892 
 
14893 
  def read(self, iprot):
14894 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14895 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14896 
      return
14897 
    iprot.readStructBegin()
14898 
    while True:
14899 
      (fname, ftype, fid) = iprot.readFieldBegin()
14900 
      if ftype == TType.STOP:
14901 
        break
14902 
      if fid == 0:
14903 
        if ftype == TType.BOOL:
14904 
          self.success = iprot.readBool();
14905 
        else:
14906 
          iprot.skip(ftype)
14907 
      else:
14908 
        iprot.skip(ftype)
14909 
      iprot.readFieldEnd()
14910 
    iprot.readStructEnd()
14911 
 
14912 
  def write(self, oprot):
14913 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14914 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14915 
      return
14916 
    oprot.writeStructBegin('deleteTag_result')
14917 
    if self.success is not None:
14918 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14919 
      oprot.writeBool(self.success)
14920 
      oprot.writeFieldEnd()
14921 
    oprot.writeFieldStop()
14922 
    oprot.writeStructEnd()
14923 
 
14924 
  def validate(self):
14925 
    return
14926 
 
14927 
 
14928 
  def __repr__(self):
14929 
    L = ['%s=%r' % (key, value)
14930 
      for key, value in self.__dict__.iteritems()]
14931 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14932 
 
14933 
  def __eq__(self, other):
14934 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14935 
 
14936 
  def __ne__(self, other):
14937 
    return not (self == other)
14938 
 
14939 
class getAllTags_args:
14940 
 
14941 
  thrift_spec = (
14942 
  )
14943 
 
14944 
  def read(self, iprot):
14945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14947 
      return
14948 
    iprot.readStructBegin()
14949 
    while True:
14950 
      (fname, ftype, fid) = iprot.readFieldBegin()
14951 
      if ftype == TType.STOP:
14952 
        break
14953 
      else:
14954 
        iprot.skip(ftype)
14955 
      iprot.readFieldEnd()
14956 
    iprot.readStructEnd()
14957 
 
14958 
  def write(self, oprot):
14959 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14960 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14961 
      return
14962 
    oprot.writeStructBegin('getAllTags_args')
14963 
    oprot.writeFieldStop()
14964 
    oprot.writeStructEnd()
14965 
 
14966 
  def validate(self):
14967 
    return
14968 
 
14969 
 
14970 
  def __repr__(self):
14971 
    L = ['%s=%r' % (key, value)
14972 
      for key, value in self.__dict__.iteritems()]
14973 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14974 
 
14975 
  def __eq__(self, other):
14976 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14977 
 
14978 
  def __ne__(self, other):
14979 
    return not (self == other)
14980 
 
14981 
class getAllTags_result:
14982 
  """
14983 
  Attributes:
14984 
   - success
14985 
  """
14986 
 
14987 
  thrift_spec = (
14988 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
14989 
  )
14990 
 
14991 
  def __init__(self, success=None,):
14992 
    self.success = success
14993 
 
14994 
  def read(self, iprot):
14995 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14996 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14997 
      return
14998 
    iprot.readStructBegin()
14999 
    while True:
15000 
      (fname, ftype, fid) = iprot.readFieldBegin()
15001 
      if ftype == TType.STOP:
15002 
        break
15003 
      if fid == 0:
15004 
        if ftype == TType.LIST:
15005 
          self.success = []
13493 amit.gupta 15006 
          (_etype193, _size190) = iprot.readListBegin()
15007 
          for _i194 in xrange(_size190):
15008 
            _elem195 = iprot.readString();
15009 
            self.success.append(_elem195)
6512 kshitij.so 15010 
          iprot.readListEnd()
15011 
        else:
15012 
          iprot.skip(ftype)
15013 
      else:
15014 
        iprot.skip(ftype)
15015 
      iprot.readFieldEnd()
15016 
    iprot.readStructEnd()
15017 
 
15018 
  def write(self, oprot):
15019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15021 
      return
15022 
    oprot.writeStructBegin('getAllTags_result')
15023 
    if self.success is not None:
15024 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15025 
      oprot.writeListBegin(TType.STRING, len(self.success))
13493 amit.gupta 15026 
      for iter196 in self.success:
15027 
        oprot.writeString(iter196)
6512 kshitij.so 15028 
      oprot.writeListEnd()
15029 
      oprot.writeFieldEnd()
15030 
    oprot.writeFieldStop()
15031 
    oprot.writeStructEnd()
15032 
 
15033 
  def validate(self):
15034 
    return
15035 
 
15036 
 
15037 
  def __repr__(self):
15038 
    L = ['%s=%r' % (key, value)
15039 
      for key, value in self.__dict__.iteritems()]
15040 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15041 
 
15042 
  def __eq__(self, other):
15043 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15044 
 
15045 
  def __ne__(self, other):
15046 
    return not (self == other)
15047 
 
15048 
class getAllEntitiesByTagName_args:
15049 
  """
15050 
  Attributes:
15051 
   - displayName
15052 
  """
15053 
 
15054 
  thrift_spec = (
15055 
    None, # 0
15056 
    (1, TType.STRING, 'displayName', None, None, ), # 1
15057 
  )
15058 
 
15059 
  def __init__(self, displayName=None,):
15060 
    self.displayName = displayName
15061 
 
15062 
  def read(self, iprot):
15063 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15064 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15065 
      return
15066 
    iprot.readStructBegin()
15067 
    while True:
15068 
      (fname, ftype, fid) = iprot.readFieldBegin()
15069 
      if ftype == TType.STOP:
15070 
        break
15071 
      if fid == 1:
15072 
        if ftype == TType.STRING:
15073 
          self.displayName = iprot.readString();
15074 
        else:
15075 
          iprot.skip(ftype)
15076 
      else:
15077 
        iprot.skip(ftype)
15078 
      iprot.readFieldEnd()
15079 
    iprot.readStructEnd()
15080 
 
15081 
  def write(self, oprot):
15082 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15083 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15084 
      return
15085 
    oprot.writeStructBegin('getAllEntitiesByTagName_args')
15086 
    if self.displayName is not None:
15087 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
15088 
      oprot.writeString(self.displayName)
15089 
      oprot.writeFieldEnd()
15090 
    oprot.writeFieldStop()
15091 
    oprot.writeStructEnd()
15092 
 
15093 
  def validate(self):
15094 
    return
15095 
 
15096 
 
15097 
  def __repr__(self):
15098 
    L = ['%s=%r' % (key, value)
15099 
      for key, value in self.__dict__.iteritems()]
15100 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15101 
 
15102 
  def __eq__(self, other):
15103 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15104 
 
15105 
  def __ne__(self, other):
15106 
    return not (self == other)
15107 
 
15108 
class getAllEntitiesByTagName_result:
15109 
  """
15110 
  Attributes:
15111 
   - success
15112 
  """
15113 
 
15114 
  thrift_spec = (
15115 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
15116 
  )
15117 
 
15118 
  def __init__(self, success=None,):
15119 
    self.success = success
15120 
 
15121 
  def read(self, iprot):
15122 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15123 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15124 
      return
15125 
    iprot.readStructBegin()
15126 
    while True:
15127 
      (fname, ftype, fid) = iprot.readFieldBegin()
15128 
      if ftype == TType.STOP:
15129 
        break
15130 
      if fid == 0:
15131 
        if ftype == TType.LIST:
15132 
          self.success = []
13493 amit.gupta 15133 
          (_etype200, _size197) = iprot.readListBegin()
15134 
          for _i201 in xrange(_size197):
15135 
            _elem202 = iprot.readI64();
15136 
            self.success.append(_elem202)
6512 kshitij.so 15137 
          iprot.readListEnd()
15138 
        else:
15139 
          iprot.skip(ftype)
15140 
      else:
15141 
        iprot.skip(ftype)
15142 
      iprot.readFieldEnd()
15143 
    iprot.readStructEnd()
15144 
 
15145 
  def write(self, oprot):
15146 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15147 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15148 
      return
15149 
    oprot.writeStructBegin('getAllEntitiesByTagName_result')
15150 
    if self.success is not None:
15151 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15152 
      oprot.writeListBegin(TType.I64, len(self.success))
13493 amit.gupta 15153 
      for iter203 in self.success:
15154 
        oprot.writeI64(iter203)
6512 kshitij.so 15155 
      oprot.writeListEnd()
15156 
      oprot.writeFieldEnd()
15157 
    oprot.writeFieldStop()
15158 
    oprot.writeStructEnd()
15159 
 
15160 
  def validate(self):
15161 
    return
15162 
 
15163 
 
15164 
  def __repr__(self):
15165 
    L = ['%s=%r' % (key, value)
15166 
      for key, value in self.__dict__.iteritems()]
15167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15168 
 
15169 
  def __eq__(self, other):
15170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15171 
 
15172 
  def __ne__(self, other):
15173 
    return not (self == other)
15174 
 
6845 amit.gupta 15175 
class getAllEntityTags_args:
15176 
 
15177 
  thrift_spec = (
15178 
  )
15179 
 
15180 
  def read(self, iprot):
15181 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15182 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15183 
      return
15184 
    iprot.readStructBegin()
15185 
    while True:
15186 
      (fname, ftype, fid) = iprot.readFieldBegin()
15187 
      if ftype == TType.STOP:
15188 
        break
15189 
      else:
15190 
        iprot.skip(ftype)
15191 
      iprot.readFieldEnd()
15192 
    iprot.readStructEnd()
15193 
 
15194 
  def write(self, oprot):
15195 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15196 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15197 
      return
15198 
    oprot.writeStructBegin('getAllEntityTags_args')
15199 
    oprot.writeFieldStop()
15200 
    oprot.writeStructEnd()
15201 
 
15202 
  def validate(self):
15203 
    return
15204 
 
15205 
 
15206 
  def __repr__(self):
15207 
    L = ['%s=%r' % (key, value)
15208 
      for key, value in self.__dict__.iteritems()]
15209 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15210 
 
15211 
  def __eq__(self, other):
15212 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15213 
 
15214 
  def __ne__(self, other):
15215 
    return not (self == other)
15216 
 
15217 
class getAllEntityTags_result:
15218 
  """
15219 
  Attributes:
15220 
   - success
15221 
  """
15222 
 
15223 
  thrift_spec = (
15224 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRING,None)), None, ), # 0
15225 
  )
15226 
 
15227 
  def __init__(self, success=None,):
15228 
    self.success = success
15229 
 
15230 
  def read(self, iprot):
15231 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15232 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15233 
      return
15234 
    iprot.readStructBegin()
15235 
    while True:
15236 
      (fname, ftype, fid) = iprot.readFieldBegin()
15237 
      if ftype == TType.STOP:
15238 
        break
15239 
      if fid == 0:
15240 
        if ftype == TType.MAP:
15241 
          self.success = {}
13493 amit.gupta 15242 
          (_ktype205, _vtype206, _size204 ) = iprot.readMapBegin()
15243 
          for _i208 in xrange(_size204):
15244 
            _key209 = iprot.readI64();
15245 
            _val210 = []
15246 
            (_etype214, _size211) = iprot.readListBegin()
15247 
            for _i215 in xrange(_size211):
15248 
              _elem216 = iprot.readString();
15249 
              _val210.append(_elem216)
6845 amit.gupta 15250 
            iprot.readListEnd()
13493 amit.gupta 15251 
            self.success[_key209] = _val210
6845 amit.gupta 15252 
          iprot.readMapEnd()
15253 
        else:
15254 
          iprot.skip(ftype)
15255 
      else:
15256 
        iprot.skip(ftype)
15257 
      iprot.readFieldEnd()
15258 
    iprot.readStructEnd()
15259 
 
15260 
  def write(self, oprot):
15261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15263 
      return
15264 
    oprot.writeStructBegin('getAllEntityTags_result')
15265 
    if self.success is not None:
15266 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15267 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
13493 amit.gupta 15268 
      for kiter217,viter218 in self.success.items():
15269 
        oprot.writeI64(kiter217)
15270 
        oprot.writeListBegin(TType.STRING, len(viter218))
15271 
        for iter219 in viter218:
15272 
          oprot.writeString(iter219)
6845 amit.gupta 15273 
        oprot.writeListEnd()
15274 
      oprot.writeMapEnd()
15275 
      oprot.writeFieldEnd()
15276 
    oprot.writeFieldStop()
15277 
    oprot.writeStructEnd()
15278 
 
15279 
  def validate(self):
15280 
    return
15281 
 
15282 
 
15283 
  def __repr__(self):
15284 
    L = ['%s=%r' % (key, value)
15285 
      for key, value in self.__dict__.iteritems()]
15286 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15287 
 
15288 
  def __eq__(self, other):
15289 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15290 
 
15291 
  def __ne__(self, other):
15292 
    return not (self == other)
15293 
 
6850 kshitij.so 15294 
class addBanner_args:
15295 
  """
15296 
  Attributes:
8590 kshitij.so 15297 
   - bannerCongregate
6850 kshitij.so 15298 
  """
15299 
 
15300 
  thrift_spec = (
15301 
    None, # 0
8590 kshitij.so 15302 
    (1, TType.STRUCT, 'bannerCongregate', (BannerCongregate, BannerCongregate.thrift_spec), None, ), # 1
6850 kshitij.so 15303 
  )
15304 
 
8590 kshitij.so 15305 
  def __init__(self, bannerCongregate=None,):
15306 
    self.bannerCongregate = bannerCongregate
6850 kshitij.so 15307 
 
15308 
  def read(self, iprot):
15309 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15310 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15311 
      return
15312 
    iprot.readStructBegin()
15313 
    while True:
15314 
      (fname, ftype, fid) = iprot.readFieldBegin()
15315 
      if ftype == TType.STOP:
15316 
        break
15317 
      if fid == 1:
8579 kshitij.so 15318 
        if ftype == TType.STRUCT:
8590 kshitij.so 15319 
          self.bannerCongregate = BannerCongregate()
15320 
          self.bannerCongregate.read(iprot)
6850 kshitij.so 15321 
        else:
15322 
          iprot.skip(ftype)
8579 kshitij.so 15323 
      else:
15324 
        iprot.skip(ftype)
15325 
      iprot.readFieldEnd()
15326 
    iprot.readStructEnd()
15327 
 
15328 
  def write(self, oprot):
15329 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15330 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15331 
      return
15332 
    oprot.writeStructBegin('addBanner_args')
8590 kshitij.so 15333 
    if self.bannerCongregate is not None:
15334 
      oprot.writeFieldBegin('bannerCongregate', TType.STRUCT, 1)
15335 
      self.bannerCongregate.write(oprot)
8579 kshitij.so 15336 
      oprot.writeFieldEnd()
15337 
    oprot.writeFieldStop()
15338 
    oprot.writeStructEnd()
15339 
 
15340 
  def validate(self):
15341 
    return
15342 
 
15343 
 
15344 
  def __repr__(self):
15345 
    L = ['%s=%r' % (key, value)
15346 
      for key, value in self.__dict__.iteritems()]
15347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15348 
 
15349 
  def __eq__(self, other):
15350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15351 
 
15352 
  def __ne__(self, other):
15353 
    return not (self == other)
15354 
 
15355 
class addBanner_result:
10097 kshitij.so 15356 
  """
15357 
  Attributes:
15358 
   - success
15359 
  """
8579 kshitij.so 15360 
 
15361 
  thrift_spec = (
10097 kshitij.so 15362 
    (0, TType.BOOL, 'success', None, None, ), # 0
8579 kshitij.so 15363 
  )
15364 
 
10097 kshitij.so 15365 
  def __init__(self, success=None,):
15366 
    self.success = success
15367 
 
8579 kshitij.so 15368 
  def read(self, iprot):
15369 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15370 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15371 
      return
15372 
    iprot.readStructBegin()
15373 
    while True:
15374 
      (fname, ftype, fid) = iprot.readFieldBegin()
15375 
      if ftype == TType.STOP:
15376 
        break
10097 kshitij.so 15377 
      if fid == 0:
15378 
        if ftype == TType.BOOL:
15379 
          self.success = iprot.readBool();
15380 
        else:
15381 
          iprot.skip(ftype)
8579 kshitij.so 15382 
      else:
15383 
        iprot.skip(ftype)
15384 
      iprot.readFieldEnd()
15385 
    iprot.readStructEnd()
15386 
 
15387 
  def write(self, oprot):
15388 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15389 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15390 
      return
15391 
    oprot.writeStructBegin('addBanner_result')
10097 kshitij.so 15392 
    if self.success is not None:
15393 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15394 
      oprot.writeBool(self.success)
15395 
      oprot.writeFieldEnd()
8579 kshitij.so 15396 
    oprot.writeFieldStop()
15397 
    oprot.writeStructEnd()
15398 
 
15399 
  def validate(self):
15400 
    return
15401 
 
15402 
 
15403 
  def __repr__(self):
15404 
    L = ['%s=%r' % (key, value)
15405 
      for key, value in self.__dict__.iteritems()]
15406 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15407 
 
15408 
  def __eq__(self, other):
15409 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15410 
 
15411 
  def __ne__(self, other):
15412 
    return not (self == other)
15413 
 
15414 
class updateBanner_args:
15415 
  """
15416 
  Attributes:
15417 
   - banner
15418 
  """
15419 
 
15420 
  thrift_spec = (
15421 
    None, # 0
15422 
    (1, TType.STRUCT, 'banner', (Banner, Banner.thrift_spec), None, ), # 1
15423 
  )
15424 
 
15425 
  def __init__(self, banner=None,):
15426 
    self.banner = banner
15427 
 
15428 
  def read(self, iprot):
15429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15431 
      return
15432 
    iprot.readStructBegin()
15433 
    while True:
15434 
      (fname, ftype, fid) = iprot.readFieldBegin()
15435 
      if ftype == TType.STOP:
15436 
        break
15437 
      if fid == 1:
15438 
        if ftype == TType.STRUCT:
15439 
          self.banner = Banner()
15440 
          self.banner.read(iprot)
6850 kshitij.so 15441 
        else:
15442 
          iprot.skip(ftype)
15443 
      else:
15444 
        iprot.skip(ftype)
15445 
      iprot.readFieldEnd()
15446 
    iprot.readStructEnd()
15447 
 
15448 
  def write(self, oprot):
15449 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15450 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15451 
      return
8579 kshitij.so 15452 
    oprot.writeStructBegin('updateBanner_args')
15453 
    if self.banner is not None:
15454 
      oprot.writeFieldBegin('banner', TType.STRUCT, 1)
15455 
      self.banner.write(oprot)
6850 kshitij.so 15456 
      oprot.writeFieldEnd()
15457 
    oprot.writeFieldStop()
15458 
    oprot.writeStructEnd()
15459 
 
15460 
  def validate(self):
15461 
    return
15462 
 
15463 
 
15464 
  def __repr__(self):
15465 
    L = ['%s=%r' % (key, value)
15466 
      for key, value in self.__dict__.iteritems()]
15467 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15468 
 
15469 
  def __eq__(self, other):
15470 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15471 
 
15472 
  def __ne__(self, other):
15473 
    return not (self == other)
15474 
 
8579 kshitij.so 15475 
class updateBanner_result:
6850 kshitij.so 15476 
  """
15477 
  Attributes:
15478 
   - success
15479 
  """
15480 
 
15481 
  thrift_spec = (
15482 
    (0, TType.BOOL, 'success', None, None, ), # 0
15483 
  )
15484 
 
15485 
  def __init__(self, success=None,):
15486 
    self.success = success
15487 
 
15488 
  def read(self, iprot):
15489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15491 
      return
15492 
    iprot.readStructBegin()
15493 
    while True:
15494 
      (fname, ftype, fid) = iprot.readFieldBegin()
15495 
      if ftype == TType.STOP:
15496 
        break
15497 
      if fid == 0:
15498 
        if ftype == TType.BOOL:
15499 
          self.success = iprot.readBool();
15500 
        else:
15501 
          iprot.skip(ftype)
15502 
      else:
15503 
        iprot.skip(ftype)
15504 
      iprot.readFieldEnd()
15505 
    iprot.readStructEnd()
15506 
 
15507 
  def write(self, oprot):
15508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15510 
      return
8579 kshitij.so 15511 
    oprot.writeStructBegin('updateBanner_result')
6850 kshitij.so 15512 
    if self.success is not None:
15513 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15514 
      oprot.writeBool(self.success)
15515 
      oprot.writeFieldEnd()
15516 
    oprot.writeFieldStop()
15517 
    oprot.writeStructEnd()
15518 
 
15519 
  def validate(self):
15520 
    return
15521 
 
15522 
 
15523 
  def __repr__(self):
15524 
    L = ['%s=%r' % (key, value)
15525 
      for key, value in self.__dict__.iteritems()]
15526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15527 
 
15528 
  def __eq__(self, other):
15529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15530 
 
15531 
  def __ne__(self, other):
15532 
    return not (self == other)
15533 
 
15534 
class getAllBanners_args:
15535 
 
15536 
  thrift_spec = (
15537 
  )
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 
      else:
15549 
        iprot.skip(ftype)
15550 
      iprot.readFieldEnd()
15551 
    iprot.readStructEnd()
15552 
 
15553 
  def write(self, oprot):
15554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15556 
      return
15557 
    oprot.writeStructBegin('getAllBanners_args')
15558 
    oprot.writeFieldStop()
15559 
    oprot.writeStructEnd()
15560 
 
15561 
  def validate(self):
15562 
    return
15563 
 
15564 
 
15565 
  def __repr__(self):
15566 
    L = ['%s=%r' % (key, value)
15567 
      for key, value in self.__dict__.iteritems()]
15568 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15569 
 
15570 
  def __eq__(self, other):
15571 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15572 
 
15573 
  def __ne__(self, other):
15574 
    return not (self == other)
15575 
 
15576 
class getAllBanners_result:
15577 
  """
15578 
  Attributes:
15579 
   - success
15580 
  """
15581 
 
15582 
  thrift_spec = (
8579 kshitij.so 15583 
    (0, TType.LIST, 'success', (TType.STRUCT,(Banner, Banner.thrift_spec)), None, ), # 0
6850 kshitij.so 15584 
  )
15585 
 
15586 
  def __init__(self, success=None,):
15587 
    self.success = success
15588 
 
15589 
  def read(self, iprot):
15590 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15591 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15592 
      return
15593 
    iprot.readStructBegin()
15594 
    while True:
15595 
      (fname, ftype, fid) = iprot.readFieldBegin()
15596 
      if ftype == TType.STOP:
15597 
        break
15598 
      if fid == 0:
15599 
        if ftype == TType.LIST:
15600 
          self.success = []
13493 amit.gupta 15601 
          (_etype223, _size220) = iprot.readListBegin()
15602 
          for _i224 in xrange(_size220):
15603 
            _elem225 = Banner()
15604 
            _elem225.read(iprot)
15605 
            self.success.append(_elem225)
6850 kshitij.so 15606 
          iprot.readListEnd()
15607 
        else:
15608 
          iprot.skip(ftype)
15609 
      else:
15610 
        iprot.skip(ftype)
15611 
      iprot.readFieldEnd()
15612 
    iprot.readStructEnd()
15613 
 
15614 
  def write(self, oprot):
15615 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15616 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15617 
      return
15618 
    oprot.writeStructBegin('getAllBanners_result')
15619 
    if self.success is not None:
15620 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8579 kshitij.so 15621 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 15622 
      for iter226 in self.success:
15623 
        iter226.write(oprot)
6850 kshitij.so 15624 
      oprot.writeListEnd()
15625 
      oprot.writeFieldEnd()
15626 
    oprot.writeFieldStop()
15627 
    oprot.writeStructEnd()
15628 
 
15629 
  def validate(self):
15630 
    return
15631 
 
15632 
 
15633 
  def __repr__(self):
15634 
    L = ['%s=%r' % (key, value)
15635 
      for key, value in self.__dict__.iteritems()]
15636 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15637 
 
15638 
  def __eq__(self, other):
15639 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15640 
 
15641 
  def __ne__(self, other):
15642 
    return not (self == other)
15643 
 
15644 
class deleteBanner_args:
15645 
  """
15646 
  Attributes:
15647 
   - bannerName
9155 kshitij.so 15648 
   - bannerType
6850 kshitij.so 15649 
  """
15650 
 
15651 
  thrift_spec = (
15652 
    None, # 0
15653 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 15654 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6850 kshitij.so 15655 
  )
15656 
 
9155 kshitij.so 15657 
  def __init__(self, bannerName=None, bannerType=None,):
6850 kshitij.so 15658 
    self.bannerName = bannerName
9155 kshitij.so 15659 
    self.bannerType = bannerType
6850 kshitij.so 15660 
 
15661 
  def read(self, iprot):
15662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15664 
      return
15665 
    iprot.readStructBegin()
15666 
    while True:
15667 
      (fname, ftype, fid) = iprot.readFieldBegin()
15668 
      if ftype == TType.STOP:
15669 
        break
15670 
      if fid == 1:
15671 
        if ftype == TType.STRING:
15672 
          self.bannerName = iprot.readString();
15673 
        else:
15674 
          iprot.skip(ftype)
9155 kshitij.so 15675 
      elif fid == 2:
15676 
        if ftype == TType.I32:
15677 
          self.bannerType = iprot.readI32();
15678 
        else:
15679 
          iprot.skip(ftype)
6850 kshitij.so 15680 
      else:
15681 
        iprot.skip(ftype)
15682 
      iprot.readFieldEnd()
15683 
    iprot.readStructEnd()
15684 
 
15685 
  def write(self, oprot):
15686 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15687 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15688 
      return
15689 
    oprot.writeStructBegin('deleteBanner_args')
15690 
    if self.bannerName is not None:
15691 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
15692 
      oprot.writeString(self.bannerName)
15693 
      oprot.writeFieldEnd()
9155 kshitij.so 15694 
    if self.bannerType is not None:
15695 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
15696 
      oprot.writeI32(self.bannerType)
15697 
      oprot.writeFieldEnd()
6850 kshitij.so 15698 
    oprot.writeFieldStop()
15699 
    oprot.writeStructEnd()
15700 
 
15701 
  def validate(self):
15702 
    return
15703 
 
15704 
 
15705 
  def __repr__(self):
15706 
    L = ['%s=%r' % (key, value)
15707 
      for key, value in self.__dict__.iteritems()]
15708 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15709 
 
15710 
  def __eq__(self, other):
15711 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15712 
 
15713 
  def __ne__(self, other):
15714 
    return not (self == other)
15715 
 
15716 
class deleteBanner_result:
15717 
  """
15718 
  Attributes:
15719 
   - success
15720 
  """
15721 
 
15722 
  thrift_spec = (
15723 
    (0, TType.BOOL, 'success', None, None, ), # 0
15724 
  )
15725 
 
15726 
  def __init__(self, success=None,):
15727 
    self.success = success
15728 
 
15729 
  def read(self, iprot):
15730 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15731 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15732 
      return
15733 
    iprot.readStructBegin()
15734 
    while True:
15735 
      (fname, ftype, fid) = iprot.readFieldBegin()
15736 
      if ftype == TType.STOP:
15737 
        break
15738 
      if fid == 0:
15739 
        if ftype == TType.BOOL:
15740 
          self.success = iprot.readBool();
15741 
        else:
15742 
          iprot.skip(ftype)
15743 
      else:
15744 
        iprot.skip(ftype)
15745 
      iprot.readFieldEnd()
15746 
    iprot.readStructEnd()
15747 
 
15748 
  def write(self, oprot):
15749 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15750 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15751 
      return
15752 
    oprot.writeStructBegin('deleteBanner_result')
15753 
    if self.success is not None:
15754 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15755 
      oprot.writeBool(self.success)
15756 
      oprot.writeFieldEnd()
15757 
    oprot.writeFieldStop()
15758 
    oprot.writeStructEnd()
15759 
 
15760 
  def validate(self):
15761 
    return
15762 
 
15763 
 
15764 
  def __repr__(self):
15765 
    L = ['%s=%r' % (key, value)
15766 
      for key, value in self.__dict__.iteritems()]
15767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15768 
 
15769 
  def __eq__(self, other):
15770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15771 
 
15772 
  def __ne__(self, other):
15773 
    return not (self == other)
15774 
 
15775 
class getBannerDetails_args:
15776 
  """
15777 
  Attributes:
15778 
   - bannerName
9155 kshitij.so 15779 
   - bannerType
6850 kshitij.so 15780 
  """
15781 
 
15782 
  thrift_spec = (
15783 
    None, # 0
15784 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 15785 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6850 kshitij.so 15786 
  )
15787 
 
9155 kshitij.so 15788 
  def __init__(self, bannerName=None, bannerType=None,):
6850 kshitij.so 15789 
    self.bannerName = bannerName
9155 kshitij.so 15790 
    self.bannerType = bannerType
6850 kshitij.so 15791 
 
15792 
  def read(self, iprot):
15793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15795 
      return
15796 
    iprot.readStructBegin()
15797 
    while True:
15798 
      (fname, ftype, fid) = iprot.readFieldBegin()
15799 
      if ftype == TType.STOP:
15800 
        break
15801 
      if fid == 1:
15802 
        if ftype == TType.STRING:
15803 
          self.bannerName = iprot.readString();
15804 
        else:
15805 
          iprot.skip(ftype)
9155 kshitij.so 15806 
      elif fid == 2:
15807 
        if ftype == TType.I32:
15808 
          self.bannerType = iprot.readI32();
15809 
        else:
15810 
          iprot.skip(ftype)
6850 kshitij.so 15811 
      else:
15812 
        iprot.skip(ftype)
15813 
      iprot.readFieldEnd()
15814 
    iprot.readStructEnd()
15815 
 
15816 
  def write(self, oprot):
15817 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15818 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15819 
      return
15820 
    oprot.writeStructBegin('getBannerDetails_args')
15821 
    if self.bannerName is not None:
15822 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
15823 
      oprot.writeString(self.bannerName)
15824 
      oprot.writeFieldEnd()
9155 kshitij.so 15825 
    if self.bannerType is not None:
15826 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
15827 
      oprot.writeI32(self.bannerType)
15828 
      oprot.writeFieldEnd()
6850 kshitij.so 15829 
    oprot.writeFieldStop()
15830 
    oprot.writeStructEnd()
15831 
 
15832 
  def validate(self):
15833 
    return
15834 
 
15835 
 
15836 
  def __repr__(self):
15837 
    L = ['%s=%r' % (key, value)
15838 
      for key, value in self.__dict__.iteritems()]
15839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15840 
 
15841 
  def __eq__(self, other):
15842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15843 
 
15844 
  def __ne__(self, other):
15845 
    return not (self == other)
15846 
 
15847 
class getBannerDetails_result:
15848 
  """
15849 
  Attributes:
15850 
   - success
15851 
  """
15852 
 
15853 
  thrift_spec = (
15854 
    (0, TType.STRUCT, 'success', (Banner, Banner.thrift_spec), None, ), # 0
15855 
  )
15856 
 
15857 
  def __init__(self, success=None,):
15858 
    self.success = success
15859 
 
15860 
  def read(self, iprot):
15861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15863 
      return
15864 
    iprot.readStructBegin()
15865 
    while True:
15866 
      (fname, ftype, fid) = iprot.readFieldBegin()
15867 
      if ftype == TType.STOP:
15868 
        break
15869 
      if fid == 0:
15870 
        if ftype == TType.STRUCT:
15871 
          self.success = Banner()
15872 
          self.success.read(iprot)
15873 
        else:
15874 
          iprot.skip(ftype)
15875 
      else:
15876 
        iprot.skip(ftype)
15877 
      iprot.readFieldEnd()
15878 
    iprot.readStructEnd()
15879 
 
15880 
  def write(self, oprot):
15881 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15882 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15883 
      return
15884 
    oprot.writeStructBegin('getBannerDetails_result')
15885 
    if self.success is not None:
15886 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15887 
      self.success.write(oprot)
15888 
      oprot.writeFieldEnd()
15889 
    oprot.writeFieldStop()
15890 
    oprot.writeStructEnd()
15891 
 
15892 
  def validate(self):
15893 
    return
15894 
 
15895 
 
15896 
  def __repr__(self):
15897 
    L = ['%s=%r' % (key, value)
15898 
      for key, value in self.__dict__.iteritems()]
15899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15900 
 
15901 
  def __eq__(self, other):
15902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15903 
 
15904 
  def __ne__(self, other):
15905 
    return not (self == other)
15906 
 
15907 
class getActiveBanners_args:
15908 
 
15909 
  thrift_spec = (
15910 
  )
15911 
 
15912 
  def read(self, iprot):
15913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15915 
      return
15916 
    iprot.readStructBegin()
15917 
    while True:
15918 
      (fname, ftype, fid) = iprot.readFieldBegin()
15919 
      if ftype == TType.STOP:
15920 
        break
15921 
      else:
15922 
        iprot.skip(ftype)
15923 
      iprot.readFieldEnd()
15924 
    iprot.readStructEnd()
15925 
 
15926 
  def write(self, oprot):
15927 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15928 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15929 
      return
15930 
    oprot.writeStructBegin('getActiveBanners_args')
15931 
    oprot.writeFieldStop()
15932 
    oprot.writeStructEnd()
15933 
 
15934 
  def validate(self):
15935 
    return
15936 
 
15937 
 
15938 
  def __repr__(self):
15939 
    L = ['%s=%r' % (key, value)
15940 
      for key, value in self.__dict__.iteritems()]
15941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15942 
 
15943 
  def __eq__(self, other):
15944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15945 
 
15946 
  def __ne__(self, other):
15947 
    return not (self == other)
15948 
 
15949 
class getActiveBanners_result:
15950 
  """
15951 
  Attributes:
15952 
   - success
15953 
  """
15954 
 
15955 
  thrift_spec = (
8579 kshitij.so 15956 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
6850 kshitij.so 15957 
  )
15958 
 
15959 
  def __init__(self, success=None,):
15960 
    self.success = success
15961 
 
15962 
  def read(self, iprot):
15963 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15964 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15965 
      return
15966 
    iprot.readStructBegin()
15967 
    while True:
15968 
      (fname, ftype, fid) = iprot.readFieldBegin()
15969 
      if ftype == TType.STOP:
15970 
        break
15971 
      if fid == 0:
8579 kshitij.so 15972 
        if ftype == TType.MAP:
15973 
          self.success = {}
13493 amit.gupta 15974 
          (_ktype228, _vtype229, _size227 ) = iprot.readMapBegin()
15975 
          for _i231 in xrange(_size227):
15976 
            _key232 = iprot.readString();
15977 
            _val233 = []
15978 
            (_etype237, _size234) = iprot.readListBegin()
15979 
            for _i238 in xrange(_size234):
15980 
              _elem239 = Banner()
15981 
              _elem239.read(iprot)
15982 
              _val233.append(_elem239)
8579 kshitij.so 15983 
            iprot.readListEnd()
13493 amit.gupta 15984 
            self.success[_key232] = _val233
8579 kshitij.so 15985 
          iprot.readMapEnd()
6850 kshitij.so 15986 
        else:
15987 
          iprot.skip(ftype)
15988 
      else:
15989 
        iprot.skip(ftype)
15990 
      iprot.readFieldEnd()
15991 
    iprot.readStructEnd()
15992 
 
15993 
  def write(self, oprot):
15994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15996 
      return
15997 
    oprot.writeStructBegin('getActiveBanners_result')
15998 
    if self.success is not None:
8579 kshitij.so 15999 
      oprot.writeFieldBegin('success', TType.MAP, 0)
16000 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
13493 amit.gupta 16001 
      for kiter240,viter241 in self.success.items():
16002 
        oprot.writeString(kiter240)
16003 
        oprot.writeListBegin(TType.STRUCT, len(viter241))
16004 
        for iter242 in viter241:
16005 
          iter242.write(oprot)
8579 kshitij.so 16006 
        oprot.writeListEnd()
16007 
      oprot.writeMapEnd()
6850 kshitij.so 16008 
      oprot.writeFieldEnd()
16009 
    oprot.writeFieldStop()
16010 
    oprot.writeStructEnd()
16011 
 
16012 
  def validate(self):
16013 
    return
16014 
 
16015 
 
16016 
  def __repr__(self):
16017 
    L = ['%s=%r' % (key, value)
16018 
      for key, value in self.__dict__.iteritems()]
16019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16020 
 
16021 
  def __eq__(self, other):
16022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16023 
 
16024 
  def __ne__(self, other):
16025 
    return not (self == other)
16026 
 
6849 kshitij.so 16027 
class addBannerMap_args:
16028 
  """
16029 
  Attributes:
8579 kshitij.so 16030 
   - bannerMaps
6849 kshitij.so 16031 
  """
16032 
 
16033 
  thrift_spec = (
16034 
    None, # 0
8579 kshitij.so 16035 
    (1, TType.LIST, 'bannerMaps', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 1
6849 kshitij.so 16036 
  )
16037 
 
8579 kshitij.so 16038 
  def __init__(self, bannerMaps=None,):
16039 
    self.bannerMaps = bannerMaps
6849 kshitij.so 16040 
 
16041 
  def read(self, iprot):
16042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16044 
      return
16045 
    iprot.readStructBegin()
16046 
    while True:
16047 
      (fname, ftype, fid) = iprot.readFieldBegin()
16048 
      if ftype == TType.STOP:
16049 
        break
16050 
      if fid == 1:
8579 kshitij.so 16051 
        if ftype == TType.LIST:
16052 
          self.bannerMaps = []
13493 amit.gupta 16053 
          (_etype246, _size243) = iprot.readListBegin()
16054 
          for _i247 in xrange(_size243):
16055 
            _elem248 = BannerMap()
16056 
            _elem248.read(iprot)
16057 
            self.bannerMaps.append(_elem248)
8579 kshitij.so 16058 
          iprot.readListEnd()
6849 kshitij.so 16059 
        else:
16060 
          iprot.skip(ftype)
8579 kshitij.so 16061 
      else:
16062 
        iprot.skip(ftype)
16063 
      iprot.readFieldEnd()
16064 
    iprot.readStructEnd()
16065 
 
16066 
  def write(self, oprot):
16067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16069 
      return
16070 
    oprot.writeStructBegin('addBannerMap_args')
16071 
    if self.bannerMaps is not None:
16072 
      oprot.writeFieldBegin('bannerMaps', TType.LIST, 1)
16073 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerMaps))
13493 amit.gupta 16074 
      for iter249 in self.bannerMaps:
16075 
        iter249.write(oprot)
8579 kshitij.so 16076 
      oprot.writeListEnd()
16077 
      oprot.writeFieldEnd()
16078 
    oprot.writeFieldStop()
16079 
    oprot.writeStructEnd()
16080 
 
16081 
  def validate(self):
16082 
    return
16083 
 
16084 
 
16085 
  def __repr__(self):
16086 
    L = ['%s=%r' % (key, value)
16087 
      for key, value in self.__dict__.iteritems()]
16088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16089 
 
16090 
  def __eq__(self, other):
16091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16092 
 
16093 
  def __ne__(self, other):
16094 
    return not (self == other)
16095 
 
16096 
class addBannerMap_result:
16097 
  """
16098 
  Attributes:
16099 
   - success
16100 
  """
16101 
 
16102 
  thrift_spec = (
16103 
    (0, TType.BOOL, 'success', None, None, ), # 0
16104 
  )
16105 
 
16106 
  def __init__(self, success=None,):
16107 
    self.success = success
16108 
 
16109 
  def read(self, iprot):
16110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16112 
      return
16113 
    iprot.readStructBegin()
16114 
    while True:
16115 
      (fname, ftype, fid) = iprot.readFieldBegin()
16116 
      if ftype == TType.STOP:
16117 
        break
16118 
      if fid == 0:
16119 
        if ftype == TType.BOOL:
16120 
          self.success = iprot.readBool();
6849 kshitij.so 16121 
        else:
16122 
          iprot.skip(ftype)
8579 kshitij.so 16123 
      else:
16124 
        iprot.skip(ftype)
16125 
      iprot.readFieldEnd()
16126 
    iprot.readStructEnd()
16127 
 
16128 
  def write(self, oprot):
16129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16131 
      return
16132 
    oprot.writeStructBegin('addBannerMap_result')
16133 
    if self.success is not None:
16134 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16135 
      oprot.writeBool(self.success)
16136 
      oprot.writeFieldEnd()
16137 
    oprot.writeFieldStop()
16138 
    oprot.writeStructEnd()
16139 
 
16140 
  def validate(self):
16141 
    return
16142 
 
16143 
 
16144 
  def __repr__(self):
16145 
    L = ['%s=%r' % (key, value)
16146 
      for key, value in self.__dict__.iteritems()]
16147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16148 
 
16149 
  def __eq__(self, other):
16150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16151 
 
16152 
  def __ne__(self, other):
16153 
    return not (self == other)
16154 
 
16155 
class updateBannerMap_args:
16156 
  """
16157 
  Attributes:
16158 
   - bannerMap
16159 
  """
16160 
 
16161 
  thrift_spec = (
16162 
    None, # 0
16163 
    (1, TType.STRUCT, 'bannerMap', (BannerMap, BannerMap.thrift_spec), None, ), # 1
16164 
  )
16165 
 
16166 
  def __init__(self, bannerMap=None,):
16167 
    self.bannerMap = bannerMap
16168 
 
16169 
  def read(self, iprot):
16170 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16171 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16172 
      return
16173 
    iprot.readStructBegin()
16174 
    while True:
16175 
      (fname, ftype, fid) = iprot.readFieldBegin()
16176 
      if ftype == TType.STOP:
16177 
        break
16178 
      if fid == 1:
16179 
        if ftype == TType.STRUCT:
16180 
          self.bannerMap = BannerMap()
16181 
          self.bannerMap.read(iprot)
6849 kshitij.so 16182 
        else:
16183 
          iprot.skip(ftype)
16184 
      else:
16185 
        iprot.skip(ftype)
16186 
      iprot.readFieldEnd()
16187 
    iprot.readStructEnd()
16188 
 
16189 
  def write(self, oprot):
16190 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16191 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16192 
      return
8579 kshitij.so 16193 
    oprot.writeStructBegin('updateBannerMap_args')
16194 
    if self.bannerMap is not None:
16195 
      oprot.writeFieldBegin('bannerMap', TType.STRUCT, 1)
16196 
      self.bannerMap.write(oprot)
6849 kshitij.so 16197 
      oprot.writeFieldEnd()
16198 
    oprot.writeFieldStop()
16199 
    oprot.writeStructEnd()
16200 
 
16201 
  def validate(self):
16202 
    return
16203 
 
16204 
 
16205 
  def __repr__(self):
16206 
    L = ['%s=%r' % (key, value)
16207 
      for key, value in self.__dict__.iteritems()]
16208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16209 
 
16210 
  def __eq__(self, other):
16211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16212 
 
16213 
  def __ne__(self, other):
16214 
    return not (self == other)
16215 
 
8579 kshitij.so 16216 
class updateBannerMap_result:
6849 kshitij.so 16217 
  """
16218 
  Attributes:
16219 
   - success
16220 
  """
16221 
 
16222 
  thrift_spec = (
16223 
    (0, TType.BOOL, 'success', None, None, ), # 0
16224 
  )
16225 
 
16226 
  def __init__(self, success=None,):
16227 
    self.success = success
16228 
 
16229 
  def read(self, iprot):
16230 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16231 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16232 
      return
16233 
    iprot.readStructBegin()
16234 
    while True:
16235 
      (fname, ftype, fid) = iprot.readFieldBegin()
16236 
      if ftype == TType.STOP:
16237 
        break
16238 
      if fid == 0:
16239 
        if ftype == TType.BOOL:
16240 
          self.success = iprot.readBool();
16241 
        else:
16242 
          iprot.skip(ftype)
16243 
      else:
16244 
        iprot.skip(ftype)
16245 
      iprot.readFieldEnd()
16246 
    iprot.readStructEnd()
16247 
 
16248 
  def write(self, oprot):
16249 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16250 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16251 
      return
8579 kshitij.so 16252 
    oprot.writeStructBegin('updateBannerMap_result')
6849 kshitij.so 16253 
    if self.success is not None:
16254 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16255 
      oprot.writeBool(self.success)
16256 
      oprot.writeFieldEnd()
16257 
    oprot.writeFieldStop()
16258 
    oprot.writeStructEnd()
16259 
 
16260 
  def validate(self):
16261 
    return
16262 
 
16263 
 
16264 
  def __repr__(self):
16265 
    L = ['%s=%r' % (key, value)
16266 
      for key, value in self.__dict__.iteritems()]
16267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16268 
 
16269 
  def __eq__(self, other):
16270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16271 
 
16272 
  def __ne__(self, other):
16273 
    return not (self == other)
16274 
 
16275 
class deleteBannerMap_args:
16276 
  """
16277 
  Attributes:
16278 
   - bannerName
16279 
  """
16280 
 
16281 
  thrift_spec = (
16282 
    None, # 0
16283 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
16284 
  )
16285 
 
16286 
  def __init__(self, bannerName=None,):
16287 
    self.bannerName = bannerName
16288 
 
16289 
  def read(self, iprot):
16290 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16291 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16292 
      return
16293 
    iprot.readStructBegin()
16294 
    while True:
16295 
      (fname, ftype, fid) = iprot.readFieldBegin()
16296 
      if ftype == TType.STOP:
16297 
        break
16298 
      if fid == 1:
16299 
        if ftype == TType.STRING:
16300 
          self.bannerName = iprot.readString();
16301 
        else:
16302 
          iprot.skip(ftype)
16303 
      else:
16304 
        iprot.skip(ftype)
16305 
      iprot.readFieldEnd()
16306 
    iprot.readStructEnd()
16307 
 
16308 
  def write(self, oprot):
16309 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16310 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16311 
      return
16312 
    oprot.writeStructBegin('deleteBannerMap_args')
16313 
    if self.bannerName is not None:
16314 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
16315 
      oprot.writeString(self.bannerName)
16316 
      oprot.writeFieldEnd()
16317 
    oprot.writeFieldStop()
16318 
    oprot.writeStructEnd()
16319 
 
16320 
  def validate(self):
16321 
    return
16322 
 
16323 
 
16324 
  def __repr__(self):
16325 
    L = ['%s=%r' % (key, value)
16326 
      for key, value in self.__dict__.iteritems()]
16327 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16328 
 
16329 
  def __eq__(self, other):
16330 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16331 
 
16332 
  def __ne__(self, other):
16333 
    return not (self == other)
16334 
 
16335 
class deleteBannerMap_result:
16336 
  """
16337 
  Attributes:
16338 
   - success
16339 
  """
16340 
 
16341 
  thrift_spec = (
16342 
    (0, TType.BOOL, 'success', None, None, ), # 0
16343 
  )
16344 
 
16345 
  def __init__(self, success=None,):
16346 
    self.success = success
16347 
 
16348 
  def read(self, iprot):
16349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16351 
      return
16352 
    iprot.readStructBegin()
16353 
    while True:
16354 
      (fname, ftype, fid) = iprot.readFieldBegin()
16355 
      if ftype == TType.STOP:
16356 
        break
16357 
      if fid == 0:
16358 
        if ftype == TType.BOOL:
16359 
          self.success = iprot.readBool();
16360 
        else:
16361 
          iprot.skip(ftype)
16362 
      else:
16363 
        iprot.skip(ftype)
16364 
      iprot.readFieldEnd()
16365 
    iprot.readStructEnd()
16366 
 
16367 
  def write(self, oprot):
16368 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16369 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16370 
      return
16371 
    oprot.writeStructBegin('deleteBannerMap_result')
16372 
    if self.success is not None:
16373 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16374 
      oprot.writeBool(self.success)
16375 
      oprot.writeFieldEnd()
16376 
    oprot.writeFieldStop()
16377 
    oprot.writeStructEnd()
16378 
 
16379 
  def validate(self):
16380 
    return
16381 
 
16382 
 
16383 
  def __repr__(self):
16384 
    L = ['%s=%r' % (key, value)
16385 
      for key, value in self.__dict__.iteritems()]
16386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16387 
 
16388 
  def __eq__(self, other):
16389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16390 
 
16391 
  def __ne__(self, other):
16392 
    return not (self == other)
16393 
 
16394 
class getBannerMapDetails_args:
16395 
  """
16396 
  Attributes:
16397 
   - bannerName
9155 kshitij.so 16398 
   - bannerType
6849 kshitij.so 16399 
  """
16400 
 
16401 
  thrift_spec = (
16402 
    None, # 0
16403 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 16404 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6849 kshitij.so 16405 
  )
16406 
 
9155 kshitij.so 16407 
  def __init__(self, bannerName=None, bannerType=None,):
6849 kshitij.so 16408 
    self.bannerName = bannerName
9155 kshitij.so 16409 
    self.bannerType = bannerType
6849 kshitij.so 16410 
 
16411 
  def read(self, iprot):
16412 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16413 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16414 
      return
16415 
    iprot.readStructBegin()
16416 
    while True:
16417 
      (fname, ftype, fid) = iprot.readFieldBegin()
16418 
      if ftype == TType.STOP:
16419 
        break
16420 
      if fid == 1:
16421 
        if ftype == TType.STRING:
16422 
          self.bannerName = iprot.readString();
16423 
        else:
16424 
          iprot.skip(ftype)
9155 kshitij.so 16425 
      elif fid == 2:
16426 
        if ftype == TType.I32:
16427 
          self.bannerType = iprot.readI32();
16428 
        else:
16429 
          iprot.skip(ftype)
6849 kshitij.so 16430 
      else:
16431 
        iprot.skip(ftype)
16432 
      iprot.readFieldEnd()
16433 
    iprot.readStructEnd()
16434 
 
16435 
  def write(self, oprot):
16436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16438 
      return
16439 
    oprot.writeStructBegin('getBannerMapDetails_args')
16440 
    if self.bannerName is not None:
16441 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
16442 
      oprot.writeString(self.bannerName)
16443 
      oprot.writeFieldEnd()
9155 kshitij.so 16444 
    if self.bannerType is not None:
16445 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
16446 
      oprot.writeI32(self.bannerType)
16447 
      oprot.writeFieldEnd()
6849 kshitij.so 16448 
    oprot.writeFieldStop()
16449 
    oprot.writeStructEnd()
16450 
 
16451 
  def validate(self):
16452 
    return
16453 
 
16454 
 
16455 
  def __repr__(self):
16456 
    L = ['%s=%r' % (key, value)
16457 
      for key, value in self.__dict__.iteritems()]
16458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16459 
 
16460 
  def __eq__(self, other):
16461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16462 
 
16463 
  def __ne__(self, other):
16464 
    return not (self == other)
16465 
 
16466 
class getBannerMapDetails_result:
16467 
  """
16468 
  Attributes:
16469 
   - success
16470 
  """
16471 
 
16472 
  thrift_spec = (
16473 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 0
16474 
  )
16475 
 
16476 
  def __init__(self, success=None,):
16477 
    self.success = success
16478 
 
16479 
  def read(self, iprot):
16480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16482 
      return
16483 
    iprot.readStructBegin()
16484 
    while True:
16485 
      (fname, ftype, fid) = iprot.readFieldBegin()
16486 
      if ftype == TType.STOP:
16487 
        break
16488 
      if fid == 0:
16489 
        if ftype == TType.LIST:
16490 
          self.success = []
13493 amit.gupta 16491 
          (_etype253, _size250) = iprot.readListBegin()
16492 
          for _i254 in xrange(_size250):
16493 
            _elem255 = BannerMap()
16494 
            _elem255.read(iprot)
16495 
            self.success.append(_elem255)
6849 kshitij.so 16496 
          iprot.readListEnd()
16497 
        else:
16498 
          iprot.skip(ftype)
16499 
      else:
16500 
        iprot.skip(ftype)
16501 
      iprot.readFieldEnd()
16502 
    iprot.readStructEnd()
16503 
 
16504 
  def write(self, oprot):
16505 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16506 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16507 
      return
16508 
    oprot.writeStructBegin('getBannerMapDetails_result')
16509 
    if self.success is not None:
16510 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16511 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 16512 
      for iter256 in self.success:
16513 
        iter256.write(oprot)
6849 kshitij.so 16514 
      oprot.writeListEnd()
16515 
      oprot.writeFieldEnd()
16516 
    oprot.writeFieldStop()
16517 
    oprot.writeStructEnd()
16518 
 
16519 
  def validate(self):
16520 
    return
16521 
 
16522 
 
16523 
  def __repr__(self):
16524 
    L = ['%s=%r' % (key, value)
16525 
      for key, value in self.__dict__.iteritems()]
16526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16527 
 
16528 
  def __eq__(self, other):
16529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16530 
 
16531 
  def __ne__(self, other):
16532 
    return not (self == other)
16533 
 
8579 kshitij.so 16534 
class addBannerUri_args:
16535 
  """
16536 
  Attributes:
16537 
   - bannerUriMappings
16538 
  """
16539 
 
16540 
  thrift_spec = (
16541 
    None, # 0
16542 
    (1, TType.LIST, 'bannerUriMappings', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 1
16543 
  )
16544 
 
16545 
  def __init__(self, bannerUriMappings=None,):
16546 
    self.bannerUriMappings = bannerUriMappings
16547 
 
16548 
  def read(self, iprot):
16549 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16550 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16551 
      return
16552 
    iprot.readStructBegin()
16553 
    while True:
16554 
      (fname, ftype, fid) = iprot.readFieldBegin()
16555 
      if ftype == TType.STOP:
16556 
        break
16557 
      if fid == 1:
16558 
        if ftype == TType.LIST:
16559 
          self.bannerUriMappings = []
13493 amit.gupta 16560 
          (_etype260, _size257) = iprot.readListBegin()
16561 
          for _i261 in xrange(_size257):
16562 
            _elem262 = BannerUriMapping()
16563 
            _elem262.read(iprot)
16564 
            self.bannerUriMappings.append(_elem262)
8579 kshitij.so 16565 
          iprot.readListEnd()
16566 
        else:
16567 
          iprot.skip(ftype)
16568 
      else:
16569 
        iprot.skip(ftype)
16570 
      iprot.readFieldEnd()
16571 
    iprot.readStructEnd()
16572 
 
16573 
  def write(self, oprot):
16574 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16575 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16576 
      return
16577 
    oprot.writeStructBegin('addBannerUri_args')
16578 
    if self.bannerUriMappings is not None:
16579 
      oprot.writeFieldBegin('bannerUriMappings', TType.LIST, 1)
16580 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerUriMappings))
13493 amit.gupta 16581 
      for iter263 in self.bannerUriMappings:
16582 
        iter263.write(oprot)
8579 kshitij.so 16583 
      oprot.writeListEnd()
16584 
      oprot.writeFieldEnd()
16585 
    oprot.writeFieldStop()
16586 
    oprot.writeStructEnd()
16587 
 
16588 
  def validate(self):
16589 
    return
16590 
 
16591 
 
16592 
  def __repr__(self):
16593 
    L = ['%s=%r' % (key, value)
16594 
      for key, value in self.__dict__.iteritems()]
16595 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16596 
 
16597 
  def __eq__(self, other):
16598 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16599 
 
16600 
  def __ne__(self, other):
16601 
    return not (self == other)
16602 
 
16603 
class addBannerUri_result:
16604 
 
16605 
  thrift_spec = (
16606 
  )
16607 
 
16608 
  def read(self, iprot):
16609 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16610 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16611 
      return
16612 
    iprot.readStructBegin()
16613 
    while True:
16614 
      (fname, ftype, fid) = iprot.readFieldBegin()
16615 
      if ftype == TType.STOP:
16616 
        break
16617 
      else:
16618 
        iprot.skip(ftype)
16619 
      iprot.readFieldEnd()
16620 
    iprot.readStructEnd()
16621 
 
16622 
  def write(self, oprot):
16623 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16624 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16625 
      return
16626 
    oprot.writeStructBegin('addBannerUri_result')
16627 
    oprot.writeFieldStop()
16628 
    oprot.writeStructEnd()
16629 
 
16630 
  def validate(self):
16631 
    return
16632 
 
16633 
 
16634 
  def __repr__(self):
16635 
    L = ['%s=%r' % (key, value)
16636 
      for key, value in self.__dict__.iteritems()]
16637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16638 
 
16639 
  def __eq__(self, other):
16640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16641 
 
16642 
  def __ne__(self, other):
16643 
    return not (self == other)
16644 
 
16645 
class getUriMapping_args:
16646 
  """
16647 
  Attributes:
16648 
   - bannerName
9155 kshitij.so 16649 
   - bannerType
8579 kshitij.so 16650 
  """
16651 
 
16652 
  thrift_spec = (
16653 
    None, # 0
16654 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 16655 
    (2, TType.I32, 'bannerType', None, None, ), # 2
8579 kshitij.so 16656 
  )
16657 
 
9155 kshitij.so 16658 
  def __init__(self, bannerName=None, bannerType=None,):
8579 kshitij.so 16659 
    self.bannerName = bannerName
9155 kshitij.so 16660 
    self.bannerType = bannerType
8579 kshitij.so 16661 
 
16662 
  def read(self, iprot):
16663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16665 
      return
16666 
    iprot.readStructBegin()
16667 
    while True:
16668 
      (fname, ftype, fid) = iprot.readFieldBegin()
16669 
      if ftype == TType.STOP:
16670 
        break
16671 
      if fid == 1:
16672 
        if ftype == TType.STRING:
16673 
          self.bannerName = iprot.readString();
16674 
        else:
16675 
          iprot.skip(ftype)
9155 kshitij.so 16676 
      elif fid == 2:
16677 
        if ftype == TType.I32:
16678 
          self.bannerType = iprot.readI32();
16679 
        else:
16680 
          iprot.skip(ftype)
8579 kshitij.so 16681 
      else:
16682 
        iprot.skip(ftype)
16683 
      iprot.readFieldEnd()
16684 
    iprot.readStructEnd()
16685 
 
16686 
  def write(self, oprot):
16687 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16688 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16689 
      return
16690 
    oprot.writeStructBegin('getUriMapping_args')
16691 
    if self.bannerName is not None:
16692 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
16693 
      oprot.writeString(self.bannerName)
16694 
      oprot.writeFieldEnd()
9155 kshitij.so 16695 
    if self.bannerType is not None:
16696 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
16697 
      oprot.writeI32(self.bannerType)
16698 
      oprot.writeFieldEnd()
8579 kshitij.so 16699 
    oprot.writeFieldStop()
16700 
    oprot.writeStructEnd()
16701 
 
16702 
  def validate(self):
16703 
    return
16704 
 
16705 
 
16706 
  def __repr__(self):
16707 
    L = ['%s=%r' % (key, value)
16708 
      for key, value in self.__dict__.iteritems()]
16709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16710 
 
16711 
  def __eq__(self, other):
16712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16713 
 
16714 
  def __ne__(self, other):
16715 
    return not (self == other)
16716 
 
16717 
class getUriMapping_result:
16718 
  """
16719 
  Attributes:
16720 
   - success
16721 
  """
16722 
 
16723 
  thrift_spec = (
16724 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 0
16725 
  )
16726 
 
16727 
  def __init__(self, success=None,):
16728 
    self.success = success
16729 
 
16730 
  def read(self, iprot):
16731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16733 
      return
16734 
    iprot.readStructBegin()
16735 
    while True:
16736 
      (fname, ftype, fid) = iprot.readFieldBegin()
16737 
      if ftype == TType.STOP:
16738 
        break
16739 
      if fid == 0:
16740 
        if ftype == TType.LIST:
16741 
          self.success = []
13493 amit.gupta 16742 
          (_etype267, _size264) = iprot.readListBegin()
16743 
          for _i268 in xrange(_size264):
16744 
            _elem269 = BannerUriMapping()
16745 
            _elem269.read(iprot)
16746 
            self.success.append(_elem269)
8579 kshitij.so 16747 
          iprot.readListEnd()
16748 
        else:
16749 
          iprot.skip(ftype)
16750 
      else:
16751 
        iprot.skip(ftype)
16752 
      iprot.readFieldEnd()
16753 
    iprot.readStructEnd()
16754 
 
16755 
  def write(self, oprot):
16756 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16757 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16758 
      return
16759 
    oprot.writeStructBegin('getUriMapping_result')
16760 
    if self.success is not None:
16761 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16762 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 16763 
      for iter270 in self.success:
16764 
        iter270.write(oprot)
8579 kshitij.so 16765 
      oprot.writeListEnd()
16766 
      oprot.writeFieldEnd()
16767 
    oprot.writeFieldStop()
16768 
    oprot.writeStructEnd()
16769 
 
16770 
  def validate(self):
16771 
    return
16772 
 
16773 
 
16774 
  def __repr__(self):
16775 
    L = ['%s=%r' % (key, value)
16776 
      for key, value in self.__dict__.iteritems()]
16777 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16778 
 
16779 
  def __eq__(self, other):
16780 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16781 
 
16782 
  def __ne__(self, other):
16783 
    return not (self == other)
16784 
 
16785 
class addCampaign_args:
16786 
  """
16787 
  Attributes:
16788 
   - campaign
16789 
  """
16790 
 
16791 
  thrift_spec = (
16792 
    None, # 0
16793 
    (1, TType.STRUCT, 'campaign', (Campaign, Campaign.thrift_spec), None, ), # 1
16794 
  )
16795 
 
16796 
  def __init__(self, campaign=None,):
16797 
    self.campaign = campaign
16798 
 
16799 
  def read(self, iprot):
16800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16802 
      return
16803 
    iprot.readStructBegin()
16804 
    while True:
16805 
      (fname, ftype, fid) = iprot.readFieldBegin()
16806 
      if ftype == TType.STOP:
16807 
        break
16808 
      if fid == 1:
16809 
        if ftype == TType.STRUCT:
16810 
          self.campaign = Campaign()
16811 
          self.campaign.read(iprot)
16812 
        else:
16813 
          iprot.skip(ftype)
16814 
      else:
16815 
        iprot.skip(ftype)
16816 
      iprot.readFieldEnd()
16817 
    iprot.readStructEnd()
16818 
 
16819 
  def write(self, oprot):
16820 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16821 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16822 
      return
16823 
    oprot.writeStructBegin('addCampaign_args')
16824 
    if self.campaign is not None:
16825 
      oprot.writeFieldBegin('campaign', TType.STRUCT, 1)
16826 
      self.campaign.write(oprot)
16827 
      oprot.writeFieldEnd()
16828 
    oprot.writeFieldStop()
16829 
    oprot.writeStructEnd()
16830 
 
16831 
  def validate(self):
16832 
    return
16833 
 
16834 
 
16835 
  def __repr__(self):
16836 
    L = ['%s=%r' % (key, value)
16837 
      for key, value in self.__dict__.iteritems()]
16838 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16839 
 
16840 
  def __eq__(self, other):
16841 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16842 
 
16843 
  def __ne__(self, other):
16844 
    return not (self == other)
16845 
 
16846 
class addCampaign_result:
16847 
 
16848 
  thrift_spec = (
16849 
  )
16850 
 
16851 
  def read(self, iprot):
16852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16854 
      return
16855 
    iprot.readStructBegin()
16856 
    while True:
16857 
      (fname, ftype, fid) = iprot.readFieldBegin()
16858 
      if ftype == TType.STOP:
16859 
        break
16860 
      else:
16861 
        iprot.skip(ftype)
16862 
      iprot.readFieldEnd()
16863 
    iprot.readStructEnd()
16864 
 
16865 
  def write(self, oprot):
16866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16868 
      return
16869 
    oprot.writeStructBegin('addCampaign_result')
16870 
    oprot.writeFieldStop()
16871 
    oprot.writeStructEnd()
16872 
 
16873 
  def validate(self):
16874 
    return
16875 
 
16876 
 
16877 
  def __repr__(self):
16878 
    L = ['%s=%r' % (key, value)
16879 
      for key, value in self.__dict__.iteritems()]
16880 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16881 
 
16882 
  def __eq__(self, other):
16883 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16884 
 
16885 
  def __ne__(self, other):
16886 
    return not (self == other)
16887 
 
16888 
class getCampaigns_args:
16889 
  """
16890 
  Attributes:
16891 
   - campaignName
16892 
  """
16893 
 
16894 
  thrift_spec = (
16895 
    None, # 0
16896 
    (1, TType.STRING, 'campaignName', None, None, ), # 1
16897 
  )
16898 
 
16899 
  def __init__(self, campaignName=None,):
16900 
    self.campaignName = campaignName
16901 
 
16902 
  def read(self, iprot):
16903 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16904 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16905 
      return
16906 
    iprot.readStructBegin()
16907 
    while True:
16908 
      (fname, ftype, fid) = iprot.readFieldBegin()
16909 
      if ftype == TType.STOP:
16910 
        break
16911 
      if fid == 1:
16912 
        if ftype == TType.STRING:
16913 
          self.campaignName = iprot.readString();
16914 
        else:
16915 
          iprot.skip(ftype)
16916 
      else:
16917 
        iprot.skip(ftype)
16918 
      iprot.readFieldEnd()
16919 
    iprot.readStructEnd()
16920 
 
16921 
  def write(self, oprot):
16922 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16923 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16924 
      return
16925 
    oprot.writeStructBegin('getCampaigns_args')
16926 
    if self.campaignName is not None:
16927 
      oprot.writeFieldBegin('campaignName', TType.STRING, 1)
16928 
      oprot.writeString(self.campaignName)
16929 
      oprot.writeFieldEnd()
16930 
    oprot.writeFieldStop()
16931 
    oprot.writeStructEnd()
16932 
 
16933 
  def validate(self):
16934 
    return
16935 
 
16936 
 
16937 
  def __repr__(self):
16938 
    L = ['%s=%r' % (key, value)
16939 
      for key, value in self.__dict__.iteritems()]
16940 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16941 
 
16942 
  def __eq__(self, other):
16943 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16944 
 
16945 
  def __ne__(self, other):
16946 
    return not (self == other)
16947 
 
16948 
class getCampaigns_result:
16949 
  """
16950 
  Attributes:
16951 
   - success
16952 
  """
16953 
 
16954 
  thrift_spec = (
16955 
    (0, TType.LIST, 'success', (TType.STRUCT,(Campaign, Campaign.thrift_spec)), None, ), # 0
16956 
  )
16957 
 
16958 
  def __init__(self, success=None,):
16959 
    self.success = success
16960 
 
16961 
  def read(self, iprot):
16962 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16963 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16964 
      return
16965 
    iprot.readStructBegin()
16966 
    while True:
16967 
      (fname, ftype, fid) = iprot.readFieldBegin()
16968 
      if ftype == TType.STOP:
16969 
        break
16970 
      if fid == 0:
16971 
        if ftype == TType.LIST:
16972 
          self.success = []
13493 amit.gupta 16973 
          (_etype274, _size271) = iprot.readListBegin()
16974 
          for _i275 in xrange(_size271):
16975 
            _elem276 = Campaign()
16976 
            _elem276.read(iprot)
16977 
            self.success.append(_elem276)
8579 kshitij.so 16978 
          iprot.readListEnd()
16979 
        else:
16980 
          iprot.skip(ftype)
16981 
      else:
16982 
        iprot.skip(ftype)
16983 
      iprot.readFieldEnd()
16984 
    iprot.readStructEnd()
16985 
 
16986 
  def write(self, oprot):
16987 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16988 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16989 
      return
16990 
    oprot.writeStructBegin('getCampaigns_result')
16991 
    if self.success is not None:
16992 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16993 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 16994 
      for iter277 in self.success:
16995 
        iter277.write(oprot)
8579 kshitij.so 16996 
      oprot.writeListEnd()
16997 
      oprot.writeFieldEnd()
16998 
    oprot.writeFieldStop()
16999 
    oprot.writeStructEnd()
17000 
 
17001 
  def validate(self):
17002 
    return
17003 
 
17004 
 
17005 
  def __repr__(self):
17006 
    L = ['%s=%r' % (key, value)
17007 
      for key, value in self.__dict__.iteritems()]
17008 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17009 
 
17010 
  def __eq__(self, other):
17011 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17012 
 
17013 
  def __ne__(self, other):
17014 
    return not (self == other)
17015 
 
17016 
class deleteCampaign_args:
17017 
  """
17018 
  Attributes:
17019 
   - campaignId
17020 
  """
17021 
 
17022 
  thrift_spec = (
17023 
    None, # 0
17024 
    (1, TType.I64, 'campaignId', None, None, ), # 1
17025 
  )
17026 
 
17027 
  def __init__(self, campaignId=None,):
17028 
    self.campaignId = campaignId
17029 
 
17030 
  def read(self, iprot):
17031 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17032 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17033 
      return
17034 
    iprot.readStructBegin()
17035 
    while True:
17036 
      (fname, ftype, fid) = iprot.readFieldBegin()
17037 
      if ftype == TType.STOP:
17038 
        break
17039 
      if fid == 1:
17040 
        if ftype == TType.I64:
17041 
          self.campaignId = iprot.readI64();
17042 
        else:
17043 
          iprot.skip(ftype)
17044 
      else:
17045 
        iprot.skip(ftype)
17046 
      iprot.readFieldEnd()
17047 
    iprot.readStructEnd()
17048 
 
17049 
  def write(self, oprot):
17050 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17051 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17052 
      return
17053 
    oprot.writeStructBegin('deleteCampaign_args')
17054 
    if self.campaignId is not None:
17055 
      oprot.writeFieldBegin('campaignId', TType.I64, 1)
17056 
      oprot.writeI64(self.campaignId)
17057 
      oprot.writeFieldEnd()
17058 
    oprot.writeFieldStop()
17059 
    oprot.writeStructEnd()
17060 
 
17061 
  def validate(self):
17062 
    return
17063 
 
17064 
 
17065 
  def __repr__(self):
17066 
    L = ['%s=%r' % (key, value)
17067 
      for key, value in self.__dict__.iteritems()]
17068 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17069 
 
17070 
  def __eq__(self, other):
17071 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17072 
 
17073 
  def __ne__(self, other):
17074 
    return not (self == other)
17075 
 
17076 
class deleteCampaign_result:
17077 
 
17078 
  thrift_spec = (
17079 
  )
17080 
 
17081 
  def read(self, iprot):
17082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17084 
      return
17085 
    iprot.readStructBegin()
17086 
    while True:
17087 
      (fname, ftype, fid) = iprot.readFieldBegin()
17088 
      if ftype == TType.STOP:
17089 
        break
17090 
      else:
17091 
        iprot.skip(ftype)
17092 
      iprot.readFieldEnd()
17093 
    iprot.readStructEnd()
17094 
 
17095 
  def write(self, oprot):
17096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17098 
      return
17099 
    oprot.writeStructBegin('deleteCampaign_result')
17100 
    oprot.writeFieldStop()
17101 
    oprot.writeStructEnd()
17102 
 
17103 
  def validate(self):
17104 
    return
17105 
 
17106 
 
17107 
  def __repr__(self):
17108 
    L = ['%s=%r' % (key, value)
17109 
      for key, value in self.__dict__.iteritems()]
17110 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17111 
 
17112 
  def __eq__(self, other):
17113 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17114 
 
17115 
  def __ne__(self, other):
17116 
    return not (self == other)
17117 
 
17118 
class getAllCampaigns_args:
17119 
 
17120 
  thrift_spec = (
17121 
  )
17122 
 
17123 
  def read(self, iprot):
17124 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17125 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17126 
      return
17127 
    iprot.readStructBegin()
17128 
    while True:
17129 
      (fname, ftype, fid) = iprot.readFieldBegin()
17130 
      if ftype == TType.STOP:
17131 
        break
17132 
      else:
17133 
        iprot.skip(ftype)
17134 
      iprot.readFieldEnd()
17135 
    iprot.readStructEnd()
17136 
 
17137 
  def write(self, oprot):
17138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17140 
      return
17141 
    oprot.writeStructBegin('getAllCampaigns_args')
17142 
    oprot.writeFieldStop()
17143 
    oprot.writeStructEnd()
17144 
 
17145 
  def validate(self):
17146 
    return
17147 
 
17148 
 
17149 
  def __repr__(self):
17150 
    L = ['%s=%r' % (key, value)
17151 
      for key, value in self.__dict__.iteritems()]
17152 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17153 
 
17154 
  def __eq__(self, other):
17155 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17156 
 
17157 
  def __ne__(self, other):
17158 
    return not (self == other)
17159 
 
17160 
class getAllCampaigns_result:
17161 
  """
17162 
  Attributes:
17163 
   - success
17164 
  """
17165 
 
17166 
  thrift_spec = (
17167 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
17168 
  )
17169 
 
17170 
  def __init__(self, success=None,):
17171 
    self.success = success
17172 
 
17173 
  def read(self, iprot):
17174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17176 
      return
17177 
    iprot.readStructBegin()
17178 
    while True:
17179 
      (fname, ftype, fid) = iprot.readFieldBegin()
17180 
      if ftype == TType.STOP:
17181 
        break
17182 
      if fid == 0:
17183 
        if ftype == TType.LIST:
17184 
          self.success = []
13493 amit.gupta 17185 
          (_etype281, _size278) = iprot.readListBegin()
17186 
          for _i282 in xrange(_size278):
17187 
            _elem283 = iprot.readString();
17188 
            self.success.append(_elem283)
8579 kshitij.so 17189 
          iprot.readListEnd()
17190 
        else:
17191 
          iprot.skip(ftype)
17192 
      else:
17193 
        iprot.skip(ftype)
17194 
      iprot.readFieldEnd()
17195 
    iprot.readStructEnd()
17196 
 
17197 
  def write(self, oprot):
17198 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17199 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17200 
      return
17201 
    oprot.writeStructBegin('getAllCampaigns_result')
17202 
    if self.success is not None:
17203 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17204 
      oprot.writeListBegin(TType.STRING, len(self.success))
13493 amit.gupta 17205 
      for iter284 in self.success:
17206 
        oprot.writeString(iter284)
8579 kshitij.so 17207 
      oprot.writeListEnd()
17208 
      oprot.writeFieldEnd()
17209 
    oprot.writeFieldStop()
17210 
    oprot.writeStructEnd()
17211 
 
17212 
  def validate(self):
17213 
    return
17214 
 
17215 
 
17216 
  def __repr__(self):
17217 
    L = ['%s=%r' % (key, value)
17218 
      for key, value in self.__dict__.iteritems()]
17219 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17220 
 
17221 
  def __eq__(self, other):
17222 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17223 
 
17224 
  def __ne__(self, other):
17225 
    return not (self == other)
17226 
 
9155 kshitij.so 17227 
class getActiveBannersForMobileSite_args:
17228 
 
17229 
  thrift_spec = (
17230 
  )
17231 
 
17232 
  def read(self, iprot):
17233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17235 
      return
17236 
    iprot.readStructBegin()
17237 
    while True:
17238 
      (fname, ftype, fid) = iprot.readFieldBegin()
17239 
      if ftype == TType.STOP:
17240 
        break
17241 
      else:
17242 
        iprot.skip(ftype)
17243 
      iprot.readFieldEnd()
17244 
    iprot.readStructEnd()
17245 
 
17246 
  def write(self, oprot):
17247 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17248 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17249 
      return
17250 
    oprot.writeStructBegin('getActiveBannersForMobileSite_args')
17251 
    oprot.writeFieldStop()
17252 
    oprot.writeStructEnd()
17253 
 
17254 
  def validate(self):
17255 
    return
17256 
 
17257 
 
17258 
  def __repr__(self):
17259 
    L = ['%s=%r' % (key, value)
17260 
      for key, value in self.__dict__.iteritems()]
17261 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17262 
 
17263 
  def __eq__(self, other):
17264 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17265 
 
17266 
  def __ne__(self, other):
17267 
    return not (self == other)
17268 
 
17269 
class getActiveBannersForMobileSite_result:
17270 
  """
17271 
  Attributes:
17272 
   - success
17273 
  """
17274 
 
17275 
  thrift_spec = (
17276 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
17277 
  )
17278 
 
17279 
  def __init__(self, success=None,):
17280 
    self.success = success
17281 
 
17282 
  def read(self, iprot):
17283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17285 
      return
17286 
    iprot.readStructBegin()
17287 
    while True:
17288 
      (fname, ftype, fid) = iprot.readFieldBegin()
17289 
      if ftype == TType.STOP:
17290 
        break
17291 
      if fid == 0:
17292 
        if ftype == TType.MAP:
17293 
          self.success = {}
13493 amit.gupta 17294 
          (_ktype286, _vtype287, _size285 ) = iprot.readMapBegin()
17295 
          for _i289 in xrange(_size285):
17296 
            _key290 = iprot.readString();
17297 
            _val291 = []
17298 
            (_etype295, _size292) = iprot.readListBegin()
17299 
            for _i296 in xrange(_size292):
17300 
              _elem297 = Banner()
17301 
              _elem297.read(iprot)
17302 
              _val291.append(_elem297)
9155 kshitij.so 17303 
            iprot.readListEnd()
13493 amit.gupta 17304 
            self.success[_key290] = _val291
9155 kshitij.so 17305 
          iprot.readMapEnd()
17306 
        else:
17307 
          iprot.skip(ftype)
17308 
      else:
17309 
        iprot.skip(ftype)
17310 
      iprot.readFieldEnd()
17311 
    iprot.readStructEnd()
17312 
 
17313 
  def write(self, oprot):
17314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17316 
      return
17317 
    oprot.writeStructBegin('getActiveBannersForMobileSite_result')
17318 
    if self.success is not None:
17319 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17320 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
13493 amit.gupta 17321 
      for kiter298,viter299 in self.success.items():
17322 
        oprot.writeString(kiter298)
17323 
        oprot.writeListBegin(TType.STRUCT, len(viter299))
17324 
        for iter300 in viter299:
17325 
          iter300.write(oprot)
9155 kshitij.so 17326 
        oprot.writeListEnd()
17327 
      oprot.writeMapEnd()
17328 
      oprot.writeFieldEnd()
17329 
    oprot.writeFieldStop()
17330 
    oprot.writeStructEnd()
17331 
 
17332 
  def validate(self):
17333 
    return
17334 
 
17335 
 
17336 
  def __repr__(self):
17337 
    L = ['%s=%r' % (key, value)
17338 
      for key, value in self.__dict__.iteritems()]
17339 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17340 
 
17341 
  def __eq__(self, other):
17342 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17343 
 
17344 
  def __ne__(self, other):
17345 
    return not (self == other)
17346 
 
5944 mandeep.dh 17347 
class deleteSimilarItem_args:
17348 
  """
17349 
  Attributes:
17350 
   - itemId
17351 
   - catalogItemId
17352 
  """
17353 
 
17354 
  thrift_spec = (
17355 
    None, # 0
17356 
    (1, TType.I64, 'itemId', None, None, ), # 1
17357 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
17358 
  )
17359 
 
17360 
  def __init__(self, itemId=None, catalogItemId=None,):
17361 
    self.itemId = itemId
17362 
    self.catalogItemId = catalogItemId
17363 
 
17364 
  def read(self, iprot):
17365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17367 
      return
17368 
    iprot.readStructBegin()
17369 
    while True:
17370 
      (fname, ftype, fid) = iprot.readFieldBegin()
17371 
      if ftype == TType.STOP:
17372 
        break
17373 
      if fid == 1:
17374 
        if ftype == TType.I64:
17375 
          self.itemId = iprot.readI64();
17376 
        else:
17377 
          iprot.skip(ftype)
17378 
      elif fid == 2:
17379 
        if ftype == TType.I64:
17380 
          self.catalogItemId = iprot.readI64();
17381 
        else:
17382 
          iprot.skip(ftype)
17383 
      else:
17384 
        iprot.skip(ftype)
17385 
      iprot.readFieldEnd()
17386 
    iprot.readStructEnd()
17387 
 
17388 
  def write(self, oprot):
17389 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17390 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17391 
      return
17392 
    oprot.writeStructBegin('deleteSimilarItem_args')
17393 
    if self.itemId is not None:
17394 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17395 
      oprot.writeI64(self.itemId)
17396 
      oprot.writeFieldEnd()
17397 
    if self.catalogItemId is not None:
17398 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
17399 
      oprot.writeI64(self.catalogItemId)
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 deleteSimilarItem_result:
17420 
  """
17421 
  Attributes:
17422 
   - success
17423 
   - cex
17424 
  """
17425 
 
17426 
  thrift_spec = (
17427 
    (0, TType.BOOL, 'success', None, None, ), # 0
17428 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17429 
  )
17430 
 
17431 
  def __init__(self, success=None, cex=None,):
17432 
    self.success = success
17433 
    self.cex = cex
17434 
 
17435 
  def read(self, iprot):
17436 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17437 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17438 
      return
17439 
    iprot.readStructBegin()
17440 
    while True:
17441 
      (fname, ftype, fid) = iprot.readFieldBegin()
17442 
      if ftype == TType.STOP:
17443 
        break
17444 
      if fid == 0:
17445 
        if ftype == TType.BOOL:
17446 
          self.success = iprot.readBool();
17447 
        else:
17448 
          iprot.skip(ftype)
17449 
      elif fid == 1:
17450 
        if ftype == TType.STRUCT:
17451 
          self.cex = CatalogServiceException()
17452 
          self.cex.read(iprot)
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('deleteSimilarItem_result')
17465 
    if self.success is not None:
17466 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17467 
      oprot.writeBool(self.success)
17468 
      oprot.writeFieldEnd()
17469 
    if self.cex is not None:
17470 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17471 
      self.cex.write(oprot)
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 checkSimilarItem_args:
17492 
  """
17493 
  Attributes:
17494 
   - brand
17495 
   - modelNumber
17496 
   - modelName
17497 
   - color
17498 
  """
17499 
 
17500 
  thrift_spec = (
17501 
    None, # 0
17502 
    (1, TType.STRING, 'brand', None, None, ), # 1
17503 
    (2, TType.STRING, 'modelNumber', None, None, ), # 2
17504 
    (3, TType.STRING, 'modelName', None, None, ), # 3
17505 
    (4, TType.STRING, 'color', None, None, ), # 4
17506 
  )
17507 
 
17508 
  def __init__(self, brand=None, modelNumber=None, modelName=None, color=None,):
17509 
    self.brand = brand
17510 
    self.modelNumber = modelNumber
17511 
    self.modelName = modelName
17512 
    self.color = color
17513 
 
17514 
  def read(self, iprot):
17515 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17516 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17517 
      return
17518 
    iprot.readStructBegin()
17519 
    while True:
17520 
      (fname, ftype, fid) = iprot.readFieldBegin()
17521 
      if ftype == TType.STOP:
17522 
        break
17523 
      if fid == 1:
17524 
        if ftype == TType.STRING:
17525 
          self.brand = iprot.readString();
17526 
        else:
17527 
          iprot.skip(ftype)
17528 
      elif fid == 2:
17529 
        if ftype == TType.STRING:
17530 
          self.modelNumber = iprot.readString();
17531 
        else:
17532 
          iprot.skip(ftype)
17533 
      elif fid == 3:
17534 
        if ftype == TType.STRING:
17535 
          self.modelName = iprot.readString();
17536 
        else:
17537 
          iprot.skip(ftype)
17538 
      elif fid == 4:
17539 
        if ftype == TType.STRING:
17540 
          self.color = iprot.readString();
17541 
        else:
17542 
          iprot.skip(ftype)
17543 
      else:
17544 
        iprot.skip(ftype)
17545 
      iprot.readFieldEnd()
17546 
    iprot.readStructEnd()
17547 
 
17548 
  def write(self, oprot):
17549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17551 
      return
17552 
    oprot.writeStructBegin('checkSimilarItem_args')
17553 
    if self.brand is not None:
17554 
      oprot.writeFieldBegin('brand', TType.STRING, 1)
17555 
      oprot.writeString(self.brand)
17556 
      oprot.writeFieldEnd()
17557 
    if self.modelNumber is not None:
17558 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 2)
17559 
      oprot.writeString(self.modelNumber)
17560 
      oprot.writeFieldEnd()
17561 
    if self.modelName is not None:
17562 
      oprot.writeFieldBegin('modelName', TType.STRING, 3)
17563 
      oprot.writeString(self.modelName)
17564 
      oprot.writeFieldEnd()
17565 
    if self.color is not None:
17566 
      oprot.writeFieldBegin('color', TType.STRING, 4)
17567 
      oprot.writeString(self.color)
17568 
      oprot.writeFieldEnd()
17569 
    oprot.writeFieldStop()
17570 
    oprot.writeStructEnd()
17571 
 
17572 
  def validate(self):
17573 
    return
17574 
 
17575 
 
17576 
  def __repr__(self):
17577 
    L = ['%s=%r' % (key, value)
17578 
      for key, value in self.__dict__.iteritems()]
17579 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17580 
 
17581 
  def __eq__(self, other):
17582 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17583 
 
17584 
  def __ne__(self, other):
17585 
    return not (self == other)
17586 
 
17587 
class checkSimilarItem_result:
17588 
  """
17589 
  Attributes:
17590 
   - success
17591 
  """
17592 
 
17593 
  thrift_spec = (
17594 
    (0, TType.I64, 'success', None, None, ), # 0
17595 
  )
17596 
 
17597 
  def __init__(self, success=None,):
17598 
    self.success = success
17599 
 
17600 
  def read(self, iprot):
17601 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17602 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17603 
      return
17604 
    iprot.readStructBegin()
17605 
    while True:
17606 
      (fname, ftype, fid) = iprot.readFieldBegin()
17607 
      if ftype == TType.STOP:
17608 
        break
17609 
      if fid == 0:
17610 
        if ftype == TType.I64:
17611 
          self.success = iprot.readI64();
17612 
        else:
17613 
          iprot.skip(ftype)
17614 
      else:
17615 
        iprot.skip(ftype)
17616 
      iprot.readFieldEnd()
17617 
    iprot.readStructEnd()
17618 
 
17619 
  def write(self, oprot):
17620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17622 
      return
17623 
    oprot.writeStructBegin('checkSimilarItem_result')
17624 
    if self.success is not None:
17625 
      oprot.writeFieldBegin('success', TType.I64, 0)
17626 
      oprot.writeI64(self.success)
17627 
      oprot.writeFieldEnd()
17628 
    oprot.writeFieldStop()
17629 
    oprot.writeStructEnd()
17630 
 
17631 
  def validate(self):
17632 
    return
17633 
 
17634 
 
17635 
  def __repr__(self):
17636 
    L = ['%s=%r' % (key, value)
17637 
      for key, value in self.__dict__.iteritems()]
17638 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17639 
 
17640 
  def __eq__(self, other):
17641 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17642 
 
17643 
  def __ne__(self, other):
17644 
    return not (self == other)
17645 
 
17646 
class validateRiskyStatus_args:
17647 
  """
17648 
  Attributes:
17649 
   - itemId
17650 
  """
17651 
 
17652 
  thrift_spec = (
17653 
    None, # 0
17654 
    (1, TType.I64, 'itemId', None, None, ), # 1
17655 
  )
17656 
 
17657 
  def __init__(self, itemId=None,):
17658 
    self.itemId = itemId
17659 
 
17660 
  def read(self, iprot):
17661 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17662 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17663 
      return
17664 
    iprot.readStructBegin()
17665 
    while True:
17666 
      (fname, ftype, fid) = iprot.readFieldBegin()
17667 
      if ftype == TType.STOP:
17668 
        break
17669 
      if fid == 1:
17670 
        if ftype == TType.I64:
17671 
          self.itemId = iprot.readI64();
17672 
        else:
17673 
          iprot.skip(ftype)
17674 
      else:
17675 
        iprot.skip(ftype)
17676 
      iprot.readFieldEnd()
17677 
    iprot.readStructEnd()
17678 
 
17679 
  def write(self, oprot):
17680 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17681 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17682 
      return
17683 
    oprot.writeStructBegin('validateRiskyStatus_args')
17684 
    if self.itemId is not None:
17685 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17686 
      oprot.writeI64(self.itemId)
17687 
      oprot.writeFieldEnd()
17688 
    oprot.writeFieldStop()
17689 
    oprot.writeStructEnd()
17690 
 
17691 
  def validate(self):
17692 
    return
17693 
 
17694 
 
17695 
  def __repr__(self):
17696 
    L = ['%s=%r' % (key, value)
17697 
      for key, value in self.__dict__.iteritems()]
17698 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17699 
 
17700 
  def __eq__(self, other):
17701 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17702 
 
17703 
  def __ne__(self, other):
17704 
    return not (self == other)
17705 
 
17706 
class validateRiskyStatus_result:
17707 
 
17708 
  thrift_spec = (
17709 
  )
17710 
 
17711 
  def read(self, iprot):
17712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17714 
      return
17715 
    iprot.readStructBegin()
17716 
    while True:
17717 
      (fname, ftype, fid) = iprot.readFieldBegin()
17718 
      if ftype == TType.STOP:
17719 
        break
17720 
      else:
17721 
        iprot.skip(ftype)
17722 
      iprot.readFieldEnd()
17723 
    iprot.readStructEnd()
17724 
 
17725 
  def write(self, oprot):
17726 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17727 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17728 
      return
17729 
    oprot.writeStructBegin('validateRiskyStatus_result')
17730 
    oprot.writeFieldStop()
17731 
    oprot.writeStructEnd()
17732 
 
17733 
  def validate(self):
17734 
    return
17735 
 
17736 
 
17737 
  def __repr__(self):
17738 
    L = ['%s=%r' % (key, value)
17739 
      for key, value in self.__dict__.iteritems()]
17740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17741 
 
17742 
  def __eq__(self, other):
17743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17744 
 
17745 
  def __ne__(self, other):
17746 
    return not (self == other)
17747 
 
17748 
class changeItemRiskyFlag_args:
17749 
  """
17750 
  Attributes:
17751 
   - itemId
17752 
   - risky
17753 
  """
17754 
 
17755 
  thrift_spec = (
17756 
    None, # 0
17757 
    (1, TType.I64, 'itemId', None, None, ), # 1
17758 
    (2, TType.BOOL, 'risky', None, None, ), # 2
17759 
  )
17760 
 
17761 
  def __init__(self, itemId=None, risky=None,):
17762 
    self.itemId = itemId
17763 
    self.risky = risky
17764 
 
17765 
  def read(self, iprot):
17766 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17767 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17768 
      return
17769 
    iprot.readStructBegin()
17770 
    while True:
17771 
      (fname, ftype, fid) = iprot.readFieldBegin()
17772 
      if ftype == TType.STOP:
17773 
        break
17774 
      if fid == 1:
17775 
        if ftype == TType.I64:
17776 
          self.itemId = iprot.readI64();
17777 
        else:
17778 
          iprot.skip(ftype)
17779 
      elif fid == 2:
17780 
        if ftype == TType.BOOL:
17781 
          self.risky = iprot.readBool();
17782 
        else:
17783 
          iprot.skip(ftype)
17784 
      else:
17785 
        iprot.skip(ftype)
17786 
      iprot.readFieldEnd()
17787 
    iprot.readStructEnd()
17788 
 
17789 
  def write(self, oprot):
17790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17792 
      return
17793 
    oprot.writeStructBegin('changeItemRiskyFlag_args')
17794 
    if self.itemId is not None:
17795 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17796 
      oprot.writeI64(self.itemId)
17797 
      oprot.writeFieldEnd()
17798 
    if self.risky is not None:
17799 
      oprot.writeFieldBegin('risky', TType.BOOL, 2)
17800 
      oprot.writeBool(self.risky)
17801 
      oprot.writeFieldEnd()
17802 
    oprot.writeFieldStop()
17803 
    oprot.writeStructEnd()
17804 
 
17805 
  def validate(self):
17806 
    return
17807 
 
17808 
 
17809 
  def __repr__(self):
17810 
    L = ['%s=%r' % (key, value)
17811 
      for key, value in self.__dict__.iteritems()]
17812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17813 
 
17814 
  def __eq__(self, other):
17815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17816 
 
17817 
  def __ne__(self, other):
17818 
    return not (self == other)
17819 
 
17820 
class changeItemRiskyFlag_result:
17821 
 
17822 
  thrift_spec = (
17823 
  )
17824 
 
17825 
  def read(self, iprot):
17826 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17827 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17828 
      return
17829 
    iprot.readStructBegin()
17830 
    while True:
17831 
      (fname, ftype, fid) = iprot.readFieldBegin()
17832 
      if ftype == TType.STOP:
17833 
        break
17834 
      else:
17835 
        iprot.skip(ftype)
17836 
      iprot.readFieldEnd()
17837 
    iprot.readStructEnd()
17838 
 
17839 
  def write(self, oprot):
17840 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17841 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17842 
      return
17843 
    oprot.writeStructBegin('changeItemRiskyFlag_result')
17844 
    oprot.writeFieldStop()
17845 
    oprot.writeStructEnd()
17846 
 
17847 
  def validate(self):
17848 
    return
17849 
 
17850 
 
17851 
  def __repr__(self):
17852 
    L = ['%s=%r' % (key, value)
17853 
      for key, value in self.__dict__.iteritems()]
17854 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17855 
 
17856 
  def __eq__(self, other):
17857 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17858 
 
17859 
  def __ne__(self, other):
17860 
    return not (self == other)
17861 
 
17862 
class getItemsByRiskyFlag_args:
17863 
 
17864 
  thrift_spec = (
17865 
  )
17866 
 
17867 
  def read(self, iprot):
17868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17870 
      return
17871 
    iprot.readStructBegin()
17872 
    while True:
17873 
      (fname, ftype, fid) = iprot.readFieldBegin()
17874 
      if ftype == TType.STOP:
17875 
        break
17876 
      else:
17877 
        iprot.skip(ftype)
17878 
      iprot.readFieldEnd()
17879 
    iprot.readStructEnd()
17880 
 
17881 
  def write(self, oprot):
17882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17884 
      return
17885 
    oprot.writeStructBegin('getItemsByRiskyFlag_args')
17886 
    oprot.writeFieldStop()
17887 
    oprot.writeStructEnd()
17888 
 
17889 
  def validate(self):
17890 
    return
17891 
 
17892 
 
17893 
  def __repr__(self):
17894 
    L = ['%s=%r' % (key, value)
17895 
      for key, value in self.__dict__.iteritems()]
17896 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17897 
 
17898 
  def __eq__(self, other):
17899 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17900 
 
17901 
  def __ne__(self, other):
17902 
    return not (self == other)
17903 
 
17904 
class getItemsByRiskyFlag_result:
17905 
  """
17906 
  Attributes:
17907 
   - success
17908 
  """
17909 
 
17910 
  thrift_spec = (
17911 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
17912 
  )
17913 
 
17914 
  def __init__(self, success=None,):
17915 
    self.success = success
17916 
 
17917 
  def read(self, iprot):
17918 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17919 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17920 
      return
17921 
    iprot.readStructBegin()
17922 
    while True:
17923 
      (fname, ftype, fid) = iprot.readFieldBegin()
17924 
      if ftype == TType.STOP:
17925 
        break
17926 
      if fid == 0:
17927 
        if ftype == TType.LIST:
17928 
          self.success = []
13493 amit.gupta 17929 
          (_etype304, _size301) = iprot.readListBegin()
17930 
          for _i305 in xrange(_size301):
17931 
            _elem306 = Item()
17932 
            _elem306.read(iprot)
17933 
            self.success.append(_elem306)
5944 mandeep.dh 17934 
          iprot.readListEnd()
17935 
        else:
17936 
          iprot.skip(ftype)
17937 
      else:
17938 
        iprot.skip(ftype)
17939 
      iprot.readFieldEnd()
17940 
    iprot.readStructEnd()
17941 
 
17942 
  def write(self, oprot):
17943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17945 
      return
17946 
    oprot.writeStructBegin('getItemsByRiskyFlag_result')
17947 
    if self.success is not None:
17948 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17949 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 17950 
      for iter307 in self.success:
17951 
        iter307.write(oprot)
5944 mandeep.dh 17952 
      oprot.writeListEnd()
17953 
      oprot.writeFieldEnd()
17954 
    oprot.writeFieldStop()
17955 
    oprot.writeStructEnd()
17956 
 
17957 
  def validate(self):
17958 
    return
17959 
 
17960 
 
17961 
  def __repr__(self):
17962 
    L = ['%s=%r' % (key, value)
17963 
      for key, value in self.__dict__.iteritems()]
17964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17965 
 
17966 
  def __eq__(self, other):
17967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17968 
 
17969 
  def __ne__(self, other):
17970 
    return not (self == other)
17971 
 
17972 
class getItemsForMasterSheet_args:
17973 
  """
17974 
  Attributes:
17975 
   - category
17976 
   - brand
17977 
  """
17978 
 
17979 
  thrift_spec = (
17980 
    None, # 0
17981 
    (1, TType.STRING, 'category', None, None, ), # 1
17982 
    (2, TType.STRING, 'brand', None, None, ), # 2
17983 
  )
17984 
 
17985 
  def __init__(self, category=None, brand=None,):
17986 
    self.category = category
17987 
    self.brand = brand
17988 
 
17989 
  def read(self, iprot):
17990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17992 
      return
17993 
    iprot.readStructBegin()
17994 
    while True:
17995 
      (fname, ftype, fid) = iprot.readFieldBegin()
17996 
      if ftype == TType.STOP:
17997 
        break
17998 
      if fid == 1:
17999 
        if ftype == TType.STRING:
18000 
          self.category = iprot.readString();
18001 
        else:
18002 
          iprot.skip(ftype)
18003 
      elif fid == 2:
18004 
        if ftype == TType.STRING:
18005 
          self.brand = iprot.readString();
18006 
        else:
18007 
          iprot.skip(ftype)
18008 
      else:
18009 
        iprot.skip(ftype)
18010 
      iprot.readFieldEnd()
18011 
    iprot.readStructEnd()
18012 
 
18013 
  def write(self, oprot):
18014 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18015 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18016 
      return
18017 
    oprot.writeStructBegin('getItemsForMasterSheet_args')
18018 
    if self.category is not None:
18019 
      oprot.writeFieldBegin('category', TType.STRING, 1)
18020 
      oprot.writeString(self.category)
18021 
      oprot.writeFieldEnd()
18022 
    if self.brand is not None:
18023 
      oprot.writeFieldBegin('brand', TType.STRING, 2)
18024 
      oprot.writeString(self.brand)
18025 
      oprot.writeFieldEnd()
18026 
    oprot.writeFieldStop()
18027 
    oprot.writeStructEnd()
18028 
 
18029 
  def validate(self):
18030 
    return
18031 
 
18032 
 
18033 
  def __repr__(self):
18034 
    L = ['%s=%r' % (key, value)
18035 
      for key, value in self.__dict__.iteritems()]
18036 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18037 
 
18038 
  def __eq__(self, other):
18039 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18040 
 
18041 
  def __ne__(self, other):
18042 
    return not (self == other)
18043 
 
18044 
class getItemsForMasterSheet_result:
18045 
  """
18046 
  Attributes:
18047 
   - success
18048 
  """
18049 
 
18050 
  thrift_spec = (
18051 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
18052 
  )
18053 
 
18054 
  def __init__(self, success=None,):
18055 
    self.success = success
18056 
 
18057 
  def read(self, iprot):
18058 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18059 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18060 
      return
18061 
    iprot.readStructBegin()
18062 
    while True:
18063 
      (fname, ftype, fid) = iprot.readFieldBegin()
18064 
      if ftype == TType.STOP:
18065 
        break
18066 
      if fid == 0:
18067 
        if ftype == TType.LIST:
18068 
          self.success = []
13493 amit.gupta 18069 
          (_etype311, _size308) = iprot.readListBegin()
18070 
          for _i312 in xrange(_size308):
18071 
            _elem313 = Item()
18072 
            _elem313.read(iprot)
18073 
            self.success.append(_elem313)
5944 mandeep.dh 18074 
          iprot.readListEnd()
18075 
        else:
18076 
          iprot.skip(ftype)
18077 
      else:
18078 
        iprot.skip(ftype)
18079 
      iprot.readFieldEnd()
18080 
    iprot.readStructEnd()
18081 
 
18082 
  def write(self, oprot):
18083 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18084 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18085 
      return
18086 
    oprot.writeStructBegin('getItemsForMasterSheet_result')
18087 
    if self.success is not None:
18088 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18089 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 18090 
      for iter314 in self.success:
18091 
        iter314.write(oprot)
5944 mandeep.dh 18092 
      oprot.writeListEnd()
18093 
      oprot.writeFieldEnd()
18094 
    oprot.writeFieldStop()
18095 
    oprot.writeStructEnd()
18096 
 
18097 
  def validate(self):
18098 
    return
18099 
 
18100 
 
18101 
  def __repr__(self):
18102 
    L = ['%s=%r' % (key, value)
18103 
      for key, value in self.__dict__.iteritems()]
18104 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18105 
 
18106 
  def __eq__(self, other):
18107 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18108 
 
18109 
  def __ne__(self, other):
18110 
    return not (self == other)
18111 
 
18112 
class getSimilarItemsCatalogIds_args:
18113 
  """
18114 
  Attributes:
18115 
   - beginIndex
18116 
   - totalItems
18117 
   - itemId
18118 
  """
18119 
 
18120 
  thrift_spec = (
18121 
    None, # 0
18122 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
18123 
    (2, TType.I64, 'totalItems', None, None, ), # 2
18124 
    (3, TType.I64, 'itemId', None, None, ), # 3
18125 
  )
18126 
 
18127 
  def __init__(self, beginIndex=None, totalItems=None, itemId=None,):
18128 
    self.beginIndex = beginIndex
18129 
    self.totalItems = totalItems
18130 
    self.itemId = itemId
18131 
 
18132 
  def read(self, iprot):
18133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18135 
      return
18136 
    iprot.readStructBegin()
18137 
    while True:
18138 
      (fname, ftype, fid) = iprot.readFieldBegin()
18139 
      if ftype == TType.STOP:
18140 
        break
18141 
      if fid == 1:
18142 
        if ftype == TType.I64:
18143 
          self.beginIndex = iprot.readI64();
18144 
        else:
18145 
          iprot.skip(ftype)
18146 
      elif fid == 2:
18147 
        if ftype == TType.I64:
18148 
          self.totalItems = iprot.readI64();
18149 
        else:
18150 
          iprot.skip(ftype)
18151 
      elif fid == 3:
18152 
        if ftype == TType.I64:
18153 
          self.itemId = iprot.readI64();
18154 
        else:
18155 
          iprot.skip(ftype)
18156 
      else:
18157 
        iprot.skip(ftype)
18158 
      iprot.readFieldEnd()
18159 
    iprot.readStructEnd()
18160 
 
18161 
  def write(self, oprot):
18162 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18163 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18164 
      return
18165 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_args')
18166 
    if self.beginIndex is not None:
18167 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
18168 
      oprot.writeI64(self.beginIndex)
18169 
      oprot.writeFieldEnd()
18170 
    if self.totalItems is not None:
18171 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
18172 
      oprot.writeI64(self.totalItems)
18173 
      oprot.writeFieldEnd()
18174 
    if self.itemId is not None:
18175 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
18176 
      oprot.writeI64(self.itemId)
18177 
      oprot.writeFieldEnd()
18178 
    oprot.writeFieldStop()
18179 
    oprot.writeStructEnd()
18180 
 
18181 
  def validate(self):
18182 
    return
18183 
 
18184 
 
18185 
  def __repr__(self):
18186 
    L = ['%s=%r' % (key, value)
18187 
      for key, value in self.__dict__.iteritems()]
18188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18189 
 
18190 
  def __eq__(self, other):
18191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18192 
 
18193 
  def __ne__(self, other):
18194 
    return not (self == other)
18195 
 
18196 
class getSimilarItemsCatalogIds_result:
18197 
  """
18198 
  Attributes:
18199 
   - success
18200 
  """
18201 
 
18202 
  thrift_spec = (
18203 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
18204 
  )
18205 
 
18206 
  def __init__(self, success=None,):
18207 
    self.success = success
18208 
 
18209 
  def read(self, iprot):
18210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18212 
      return
18213 
    iprot.readStructBegin()
18214 
    while True:
18215 
      (fname, ftype, fid) = iprot.readFieldBegin()
18216 
      if ftype == TType.STOP:
18217 
        break
18218 
      if fid == 0:
18219 
        if ftype == TType.LIST:
18220 
          self.success = []
13493 amit.gupta 18221 
          (_etype318, _size315) = iprot.readListBegin()
18222 
          for _i319 in xrange(_size315):
18223 
            _elem320 = iprot.readI64();
18224 
            self.success.append(_elem320)
5944 mandeep.dh 18225 
          iprot.readListEnd()
18226 
        else:
18227 
          iprot.skip(ftype)
18228 
      else:
18229 
        iprot.skip(ftype)
18230 
      iprot.readFieldEnd()
18231 
    iprot.readStructEnd()
18232 
 
18233 
  def write(self, oprot):
18234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18236 
      return
18237 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_result')
18238 
    if self.success is not None:
18239 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18240 
      oprot.writeListBegin(TType.I64, len(self.success))
13493 amit.gupta 18241 
      for iter321 in self.success:
18242 
        oprot.writeI64(iter321)
5944 mandeep.dh 18243 
      oprot.writeListEnd()
18244 
      oprot.writeFieldEnd()
18245 
    oprot.writeFieldStop()
18246 
    oprot.writeStructEnd()
18247 
 
18248 
  def validate(self):
18249 
    return
18250 
 
18251 
 
18252 
  def __repr__(self):
18253 
    L = ['%s=%r' % (key, value)
18254 
      for key, value in self.__dict__.iteritems()]
18255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18256 
 
18257 
  def __eq__(self, other):
18258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18259 
 
18260 
  def __ne__(self, other):
18261 
    return not (self == other)
18262 
 
18263 
class addProductNotification_args:
18264 
  """
18265 
  Attributes:
18266 
   - itemId
18267 
   - email
18268 
  """
18269 
 
18270 
  thrift_spec = None
18271 
  def __init__(self, itemId=None, email=None,):
18272 
    self.itemId = itemId
18273 
    self.email = email
18274 
 
18275 
  def read(self, iprot):
18276 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18277 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18278 
      return
18279 
    iprot.readStructBegin()
18280 
    while True:
18281 
      (fname, ftype, fid) = iprot.readFieldBegin()
18282 
      if ftype == TType.STOP:
18283 
        break
18284 
      if fid == -1:
18285 
        if ftype == TType.I64:
18286 
          self.itemId = iprot.readI64();
18287 
        else:
18288 
          iprot.skip(ftype)
18289 
      elif fid == -2:
18290 
        if ftype == TType.STRING:
18291 
          self.email = iprot.readString();
18292 
        else:
18293 
          iprot.skip(ftype)
18294 
      else:
18295 
        iprot.skip(ftype)
18296 
      iprot.readFieldEnd()
18297 
    iprot.readStructEnd()
18298 
 
18299 
  def write(self, oprot):
18300 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18301 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18302 
      return
18303 
    oprot.writeStructBegin('addProductNotification_args')
18304 
    if self.email is not None:
18305 
      oprot.writeFieldBegin('email', TType.STRING, -2)
18306 
      oprot.writeString(self.email)
18307 
      oprot.writeFieldEnd()
18308 
    if self.itemId is not None:
18309 
      oprot.writeFieldBegin('itemId', TType.I64, -1)
18310 
      oprot.writeI64(self.itemId)
18311 
      oprot.writeFieldEnd()
18312 
    oprot.writeFieldStop()
18313 
    oprot.writeStructEnd()
18314 
 
18315 
  def validate(self):
18316 
    return
18317 
 
18318 
 
18319 
  def __repr__(self):
18320 
    L = ['%s=%r' % (key, value)
18321 
      for key, value in self.__dict__.iteritems()]
18322 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18323 
 
18324 
  def __eq__(self, other):
18325 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18326 
 
18327 
  def __ne__(self, other):
18328 
    return not (self == other)
18329 
 
18330 
class addProductNotification_result:
18331 
  """
18332 
  Attributes:
18333 
   - success
18334 
  """
18335 
 
18336 
  thrift_spec = (
18337 
    (0, TType.BOOL, 'success', None, None, ), # 0
18338 
  )
18339 
 
18340 
  def __init__(self, success=None,):
18341 
    self.success = success
18342 
 
18343 
  def read(self, iprot):
18344 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18345 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18346 
      return
18347 
    iprot.readStructBegin()
18348 
    while True:
18349 
      (fname, ftype, fid) = iprot.readFieldBegin()
18350 
      if ftype == TType.STOP:
18351 
        break
18352 
      if fid == 0:
18353 
        if ftype == TType.BOOL:
18354 
          self.success = iprot.readBool();
18355 
        else:
18356 
          iprot.skip(ftype)
18357 
      else:
18358 
        iprot.skip(ftype)
18359 
      iprot.readFieldEnd()
18360 
    iprot.readStructEnd()
18361 
 
18362 
  def write(self, oprot):
18363 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18364 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18365 
      return
18366 
    oprot.writeStructBegin('addProductNotification_result')
18367 
    if self.success is not None:
18368 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18369 
      oprot.writeBool(self.success)
18370 
      oprot.writeFieldEnd()
18371 
    oprot.writeFieldStop()
18372 
    oprot.writeStructEnd()
18373 
 
18374 
  def validate(self):
18375 
    return
18376 
 
18377 
 
18378 
  def __repr__(self):
18379 
    L = ['%s=%r' % (key, value)
18380 
      for key, value in self.__dict__.iteritems()]
18381 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18382 
 
18383 
  def __eq__(self, other):
18384 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18385 
 
18386 
  def __ne__(self, other):
18387 
    return not (self == other)
18388 
 
18389 
class sendProductNotifications_args:
18390 
 
18391 
  thrift_spec = (
18392 
  )
18393 
 
18394 
  def read(self, iprot):
18395 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18396 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18397 
      return
18398 
    iprot.readStructBegin()
18399 
    while True:
18400 
      (fname, ftype, fid) = iprot.readFieldBegin()
18401 
      if ftype == TType.STOP:
18402 
        break
18403 
      else:
18404 
        iprot.skip(ftype)
18405 
      iprot.readFieldEnd()
18406 
    iprot.readStructEnd()
18407 
 
18408 
  def write(self, oprot):
18409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18411 
      return
18412 
    oprot.writeStructBegin('sendProductNotifications_args')
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 sendProductNotifications_result:
18432 
  """
18433 
  Attributes:
18434 
   - success
18435 
  """
18436 
 
18437 
  thrift_spec = (
18438 
    (0, TType.BOOL, 'success', None, None, ), # 0
18439 
  )
18440 
 
18441 
  def __init__(self, success=None,):
18442 
    self.success = success
18443 
 
18444 
  def read(self, iprot):
18445 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18446 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18447 
      return
18448 
    iprot.readStructBegin()
18449 
    while True:
18450 
      (fname, ftype, fid) = iprot.readFieldBegin()
18451 
      if ftype == TType.STOP:
18452 
        break
18453 
      if fid == 0:
18454 
        if ftype == TType.BOOL:
18455 
          self.success = iprot.readBool();
18456 
        else:
18457 
          iprot.skip(ftype)
18458 
      else:
18459 
        iprot.skip(ftype)
18460 
      iprot.readFieldEnd()
18461 
    iprot.readStructEnd()
18462 
 
18463 
  def write(self, oprot):
18464 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18465 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18466 
      return
18467 
    oprot.writeStructBegin('sendProductNotifications_result')
18468 
    if self.success is not None:
18469 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18470 
      oprot.writeBool(self.success)
18471 
      oprot.writeFieldEnd()
18472 
    oprot.writeFieldStop()
18473 
    oprot.writeStructEnd()
18474 
 
18475 
  def validate(self):
18476 
    return
18477 
 
18478 
 
18479 
  def __repr__(self):
18480 
    L = ['%s=%r' % (key, value)
18481 
      for key, value in self.__dict__.iteritems()]
18482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18483 
 
18484 
  def __eq__(self, other):
18485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18486 
 
18487 
  def __ne__(self, other):
18488 
    return not (self == other)
18489 
 
18490 
class getAllBrandsByCategory_args:
18491 
  """
18492 
  Attributes:
18493 
   - categoryId
18494 
  """
18495 
 
18496 
  thrift_spec = (
18497 
    None, # 0
18498 
    (1, TType.I64, 'categoryId', None, None, ), # 1
18499 
  )
18500 
 
18501 
  def __init__(self, categoryId=None,):
18502 
    self.categoryId = categoryId
18503 
 
18504 
  def read(self, iprot):
18505 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18506 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18507 
      return
18508 
    iprot.readStructBegin()
18509 
    while True:
18510 
      (fname, ftype, fid) = iprot.readFieldBegin()
18511 
      if ftype == TType.STOP:
18512 
        break
18513 
      if fid == 1:
18514 
        if ftype == TType.I64:
18515 
          self.categoryId = iprot.readI64();
18516 
        else:
18517 
          iprot.skip(ftype)
18518 
      else:
18519 
        iprot.skip(ftype)
18520 
      iprot.readFieldEnd()
18521 
    iprot.readStructEnd()
18522 
 
18523 
  def write(self, oprot):
18524 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18525 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18526 
      return
18527 
    oprot.writeStructBegin('getAllBrandsByCategory_args')
18528 
    if self.categoryId is not None:
18529 
      oprot.writeFieldBegin('categoryId', TType.I64, 1)
18530 
      oprot.writeI64(self.categoryId)
18531 
      oprot.writeFieldEnd()
18532 
    oprot.writeFieldStop()
18533 
    oprot.writeStructEnd()
18534 
 
18535 
  def validate(self):
18536 
    return
18537 
 
18538 
 
18539 
  def __repr__(self):
18540 
    L = ['%s=%r' % (key, value)
18541 
      for key, value in self.__dict__.iteritems()]
18542 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18543 
 
18544 
  def __eq__(self, other):
18545 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18546 
 
18547 
  def __ne__(self, other):
18548 
    return not (self == other)
18549 
 
18550 
class getAllBrandsByCategory_result:
18551 
  """
18552 
  Attributes:
18553 
   - success
18554 
  """
18555 
 
18556 
  thrift_spec = (
18557 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
18558 
  )
18559 
 
18560 
  def __init__(self, success=None,):
18561 
    self.success = success
18562 
 
18563 
  def read(self, iprot):
18564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18566 
      return
18567 
    iprot.readStructBegin()
18568 
    while True:
18569 
      (fname, ftype, fid) = iprot.readFieldBegin()
18570 
      if ftype == TType.STOP:
18571 
        break
18572 
      if fid == 0:
18573 
        if ftype == TType.LIST:
18574 
          self.success = []
13493 amit.gupta 18575 
          (_etype325, _size322) = iprot.readListBegin()
18576 
          for _i326 in xrange(_size322):
18577 
            _elem327 = iprot.readString();
18578 
            self.success.append(_elem327)
5944 mandeep.dh 18579 
          iprot.readListEnd()
18580 
        else:
18581 
          iprot.skip(ftype)
18582 
      else:
18583 
        iprot.skip(ftype)
18584 
      iprot.readFieldEnd()
18585 
    iprot.readStructEnd()
18586 
 
18587 
  def write(self, oprot):
18588 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18589 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18590 
      return
18591 
    oprot.writeStructBegin('getAllBrandsByCategory_result')
18592 
    if self.success is not None:
18593 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18594 
      oprot.writeListBegin(TType.STRING, len(self.success))
13493 amit.gupta 18595 
      for iter328 in self.success:
18596 
        oprot.writeString(iter328)
5944 mandeep.dh 18597 
      oprot.writeListEnd()
18598 
      oprot.writeFieldEnd()
18599 
    oprot.writeFieldStop()
18600 
    oprot.writeStructEnd()
18601 
 
18602 
  def validate(self):
18603 
    return
18604 
 
18605 
 
18606 
  def __repr__(self):
18607 
    L = ['%s=%r' % (key, value)
18608 
      for key, value in self.__dict__.iteritems()]
18609 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18610 
 
18611 
  def __eq__(self, other):
18612 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18613 
 
18614 
  def __ne__(self, other):
18615 
    return not (self == other)
18616 
 
18617 
class getAllBrands_args:
18618 
 
18619 
  thrift_spec = (
18620 
  )
18621 
 
18622 
  def read(self, iprot):
18623 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18624 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18625 
      return
18626 
    iprot.readStructBegin()
18627 
    while True:
18628 
      (fname, ftype, fid) = iprot.readFieldBegin()
18629 
      if ftype == TType.STOP:
18630 
        break
18631 
      else:
18632 
        iprot.skip(ftype)
18633 
      iprot.readFieldEnd()
18634 
    iprot.readStructEnd()
18635 
 
18636 
  def write(self, oprot):
18637 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18638 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18639 
      return
18640 
    oprot.writeStructBegin('getAllBrands_args')
18641 
    oprot.writeFieldStop()
18642 
    oprot.writeStructEnd()
18643 
 
18644 
  def validate(self):
18645 
    return
18646 
 
18647 
 
18648 
  def __repr__(self):
18649 
    L = ['%s=%r' % (key, value)
18650 
      for key, value in self.__dict__.iteritems()]
18651 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18652 
 
18653 
  def __eq__(self, other):
18654 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18655 
 
18656 
  def __ne__(self, other):
18657 
    return not (self == other)
18658 
 
18659 
class getAllBrands_result:
18660 
  """
18661 
  Attributes:
18662 
   - success
18663 
  """
18664 
 
18665 
  thrift_spec = (
18666 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
18667 
  )
18668 
 
18669 
  def __init__(self, success=None,):
18670 
    self.success = success
18671 
 
18672 
  def read(self, iprot):
18673 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18674 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18675 
      return
18676 
    iprot.readStructBegin()
18677 
    while True:
18678 
      (fname, ftype, fid) = iprot.readFieldBegin()
18679 
      if ftype == TType.STOP:
18680 
        break
18681 
      if fid == 0:
18682 
        if ftype == TType.LIST:
18683 
          self.success = []
13493 amit.gupta 18684 
          (_etype332, _size329) = iprot.readListBegin()
18685 
          for _i333 in xrange(_size329):
18686 
            _elem334 = iprot.readString();
18687 
            self.success.append(_elem334)
5944 mandeep.dh 18688 
          iprot.readListEnd()
18689 
        else:
18690 
          iprot.skip(ftype)
18691 
      else:
18692 
        iprot.skip(ftype)
18693 
      iprot.readFieldEnd()
18694 
    iprot.readStructEnd()
18695 
 
18696 
  def write(self, oprot):
18697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18699 
      return
18700 
    oprot.writeStructBegin('getAllBrands_result')
18701 
    if self.success is not None:
18702 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18703 
      oprot.writeListBegin(TType.STRING, len(self.success))
13493 amit.gupta 18704 
      for iter335 in self.success:
18705 
        oprot.writeString(iter335)
5944 mandeep.dh 18706 
      oprot.writeListEnd()
18707 
      oprot.writeFieldEnd()
18708 
    oprot.writeFieldStop()
18709 
    oprot.writeStructEnd()
18710 
 
18711 
  def validate(self):
18712 
    return
18713 
 
18714 
 
18715 
  def __repr__(self):
18716 
    L = ['%s=%r' % (key, value)
18717 
      for key, value in self.__dict__.iteritems()]
18718 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18719 
 
18720 
  def __eq__(self, other):
18721 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18722 
 
18723 
  def __ne__(self, other):
18724 
    return not (self == other)
18725 
 
18726 
class getAllSources_args:
18727 
 
18728 
  thrift_spec = (
18729 
  )
18730 
 
18731 
  def read(self, iprot):
18732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18734 
      return
18735 
    iprot.readStructBegin()
18736 
    while True:
18737 
      (fname, ftype, fid) = iprot.readFieldBegin()
18738 
      if ftype == TType.STOP:
18739 
        break
18740 
      else:
18741 
        iprot.skip(ftype)
18742 
      iprot.readFieldEnd()
18743 
    iprot.readStructEnd()
18744 
 
18745 
  def write(self, oprot):
18746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18748 
      return
18749 
    oprot.writeStructBegin('getAllSources_args')
18750 
    oprot.writeFieldStop()
18751 
    oprot.writeStructEnd()
18752 
 
18753 
  def validate(self):
18754 
    return
18755 
 
18756 
 
18757 
  def __repr__(self):
18758 
    L = ['%s=%r' % (key, value)
18759 
      for key, value in self.__dict__.iteritems()]
18760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18761 
 
18762 
  def __eq__(self, other):
18763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18764 
 
18765 
  def __ne__(self, other):
18766 
    return not (self == other)
18767 
 
18768 
class getAllSources_result:
18769 
  """
18770 
  Attributes:
18771 
   - success
18772 
  """
18773 
 
18774 
  thrift_spec = (
18775 
    (0, TType.LIST, 'success', (TType.STRUCT,(Source, Source.thrift_spec)), None, ), # 0
18776 
  )
18777 
 
18778 
  def __init__(self, success=None,):
18779 
    self.success = success
18780 
 
18781 
  def read(self, iprot):
18782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18784 
      return
18785 
    iprot.readStructBegin()
18786 
    while True:
18787 
      (fname, ftype, fid) = iprot.readFieldBegin()
18788 
      if ftype == TType.STOP:
18789 
        break
18790 
      if fid == 0:
18791 
        if ftype == TType.LIST:
18792 
          self.success = []
13493 amit.gupta 18793 
          (_etype339, _size336) = iprot.readListBegin()
18794 
          for _i340 in xrange(_size336):
18795 
            _elem341 = Source()
18796 
            _elem341.read(iprot)
18797 
            self.success.append(_elem341)
5944 mandeep.dh 18798 
          iprot.readListEnd()
18799 
        else:
18800 
          iprot.skip(ftype)
18801 
      else:
18802 
        iprot.skip(ftype)
18803 
      iprot.readFieldEnd()
18804 
    iprot.readStructEnd()
18805 
 
18806 
  def write(self, oprot):
18807 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18808 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18809 
      return
18810 
    oprot.writeStructBegin('getAllSources_result')
18811 
    if self.success is not None:
18812 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18813 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 18814 
      for iter342 in self.success:
18815 
        iter342.write(oprot)
5944 mandeep.dh 18816 
      oprot.writeListEnd()
18817 
      oprot.writeFieldEnd()
18818 
    oprot.writeFieldStop()
18819 
    oprot.writeStructEnd()
18820 
 
18821 
  def validate(self):
18822 
    return
18823 
 
18824 
 
18825 
  def __repr__(self):
18826 
    L = ['%s=%r' % (key, value)
18827 
      for key, value in self.__dict__.iteritems()]
18828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18829 
 
18830 
  def __eq__(self, other):
18831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18832 
 
18833 
  def __ne__(self, other):
18834 
    return not (self == other)
18835 
 
18836 
class getItemPricingBySource_args:
18837 
  """
18838 
  Attributes:
18839 
   - itemId
18840 
   - sourceId
18841 
  """
18842 
 
18843 
  thrift_spec = (
18844 
    None, # 0
18845 
    (1, TType.I64, 'itemId', None, None, ), # 1
18846 
    (2, TType.I64, 'sourceId', None, None, ), # 2
18847 
  )
18848 
 
18849 
  def __init__(self, itemId=None, sourceId=None,):
18850 
    self.itemId = itemId
18851 
    self.sourceId = sourceId
18852 
 
18853 
  def read(self, iprot):
18854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18856 
      return
18857 
    iprot.readStructBegin()
18858 
    while True:
18859 
      (fname, ftype, fid) = iprot.readFieldBegin()
18860 
      if ftype == TType.STOP:
18861 
        break
18862 
      if fid == 1:
18863 
        if ftype == TType.I64:
18864 
          self.itemId = iprot.readI64();
18865 
        else:
18866 
          iprot.skip(ftype)
18867 
      elif fid == 2:
18868 
        if ftype == TType.I64:
18869 
          self.sourceId = iprot.readI64();
18870 
        else:
18871 
          iprot.skip(ftype)
18872 
      else:
18873 
        iprot.skip(ftype)
18874 
      iprot.readFieldEnd()
18875 
    iprot.readStructEnd()
18876 
 
18877 
  def write(self, oprot):
18878 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18879 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18880 
      return
18881 
    oprot.writeStructBegin('getItemPricingBySource_args')
18882 
    if self.itemId is not None:
18883 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18884 
      oprot.writeI64(self.itemId)
18885 
      oprot.writeFieldEnd()
18886 
    if self.sourceId is not None:
18887 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
18888 
      oprot.writeI64(self.sourceId)
18889 
      oprot.writeFieldEnd()
18890 
    oprot.writeFieldStop()
18891 
    oprot.writeStructEnd()
18892 
 
18893 
  def validate(self):
18894 
    return
18895 
 
18896 
 
18897 
  def __repr__(self):
18898 
    L = ['%s=%r' % (key, value)
18899 
      for key, value in self.__dict__.iteritems()]
18900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18901 
 
18902 
  def __eq__(self, other):
18903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18904 
 
18905 
  def __ne__(self, other):
18906 
    return not (self == other)
18907 
 
18908 
class getItemPricingBySource_result:
18909 
  """
18910 
  Attributes:
18911 
   - success
18912 
   - cex
18913 
  """
18914 
 
18915 
  thrift_spec = (
18916 
    (0, TType.STRUCT, 'success', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 0
18917 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
18918 
  )
18919 
 
18920 
  def __init__(self, success=None, cex=None,):
18921 
    self.success = success
18922 
    self.cex = cex
18923 
 
18924 
  def read(self, iprot):
18925 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18926 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18927 
      return
18928 
    iprot.readStructBegin()
18929 
    while True:
18930 
      (fname, ftype, fid) = iprot.readFieldBegin()
18931 
      if ftype == TType.STOP:
18932 
        break
18933 
      if fid == 0:
18934 
        if ftype == TType.STRUCT:
18935 
          self.success = SourceItemPricing()
18936 
          self.success.read(iprot)
18937 
        else:
18938 
          iprot.skip(ftype)
18939 
      elif fid == 1:
18940 
        if ftype == TType.STRUCT:
18941 
          self.cex = CatalogServiceException()
18942 
          self.cex.read(iprot)
18943 
        else:
18944 
          iprot.skip(ftype)
18945 
      else:
18946 
        iprot.skip(ftype)
18947 
      iprot.readFieldEnd()
18948 
    iprot.readStructEnd()
18949 
 
18950 
  def write(self, oprot):
18951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18953 
      return
18954 
    oprot.writeStructBegin('getItemPricingBySource_result')
18955 
    if self.success is not None:
18956 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18957 
      self.success.write(oprot)
18958 
      oprot.writeFieldEnd()
18959 
    if self.cex is not None:
18960 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
18961 
      self.cex.write(oprot)
18962 
      oprot.writeFieldEnd()
18963 
    oprot.writeFieldStop()
18964 
    oprot.writeStructEnd()
18965 
 
18966 
  def validate(self):
18967 
    return
18968 
 
18969 
 
18970 
  def __repr__(self):
18971 
    L = ['%s=%r' % (key, value)
18972 
      for key, value in self.__dict__.iteritems()]
18973 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18974 
 
18975 
  def __eq__(self, other):
18976 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18977 
 
18978 
  def __ne__(self, other):
18979 
    return not (self == other)
18980 
 
18981 
class addSourceItemPricing_args:
18982 
  """
18983 
  Attributes:
18984 
   - sourceItemPricing
18985 
  """
18986 
 
18987 
  thrift_spec = (
18988 
    None, # 0
18989 
    (1, TType.STRUCT, 'sourceItemPricing', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 1
18990 
  )
18991 
 
18992 
  def __init__(self, sourceItemPricing=None,):
18993 
    self.sourceItemPricing = sourceItemPricing
18994 
 
18995 
  def read(self, iprot):
18996 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18997 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18998 
      return
18999 
    iprot.readStructBegin()
19000 
    while True:
19001 
      (fname, ftype, fid) = iprot.readFieldBegin()
19002 
      if ftype == TType.STOP:
19003 
        break
19004 
      if fid == 1:
19005 
        if ftype == TType.STRUCT:
19006 
          self.sourceItemPricing = SourceItemPricing()
19007 
          self.sourceItemPricing.read(iprot)
19008 
        else:
19009 
          iprot.skip(ftype)
19010 
      else:
19011 
        iprot.skip(ftype)
19012 
      iprot.readFieldEnd()
19013 
    iprot.readStructEnd()
19014 
 
19015 
  def write(self, oprot):
19016 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19017 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19018 
      return
19019 
    oprot.writeStructBegin('addSourceItemPricing_args')
19020 
    if self.sourceItemPricing is not None:
19021 
      oprot.writeFieldBegin('sourceItemPricing', TType.STRUCT, 1)
19022 
      self.sourceItemPricing.write(oprot)
19023 
      oprot.writeFieldEnd()
19024 
    oprot.writeFieldStop()
19025 
    oprot.writeStructEnd()
19026 
 
19027 
  def validate(self):
19028 
    return
19029 
 
19030 
 
19031 
  def __repr__(self):
19032 
    L = ['%s=%r' % (key, value)
19033 
      for key, value in self.__dict__.iteritems()]
19034 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19035 
 
19036 
  def __eq__(self, other):
19037 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19038 
 
19039 
  def __ne__(self, other):
19040 
    return not (self == other)
19041 
 
19042 
class addSourceItemPricing_result:
19043 
  """
19044 
  Attributes:
19045 
   - cex
19046 
  """
19047 
 
19048 
  thrift_spec = (
19049 
    None, # 0
19050 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
19051 
  )
19052 
 
19053 
  def __init__(self, cex=None,):
19054 
    self.cex = cex
19055 
 
19056 
  def read(self, iprot):
19057 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19058 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19059 
      return
19060 
    iprot.readStructBegin()
19061 
    while True:
19062 
      (fname, ftype, fid) = iprot.readFieldBegin()
19063 
      if ftype == TType.STOP:
19064 
        break
19065 
      if fid == 1:
19066 
        if ftype == TType.STRUCT:
19067 
          self.cex = CatalogServiceException()
19068 
          self.cex.read(iprot)
19069 
        else:
19070 
          iprot.skip(ftype)
19071 
      else:
19072 
        iprot.skip(ftype)
19073 
      iprot.readFieldEnd()
19074 
    iprot.readStructEnd()
19075 
 
19076 
  def write(self, oprot):
19077 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19078 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19079 
      return
19080 
    oprot.writeStructBegin('addSourceItemPricing_result')
19081 
    if self.cex is not None:
19082 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
19083 
      self.cex.write(oprot)
19084 
      oprot.writeFieldEnd()
19085 
    oprot.writeFieldStop()
19086 
    oprot.writeStructEnd()
19087 
 
19088 
  def validate(self):
19089 
    return
19090 
 
19091 
 
19092 
  def __repr__(self):
19093 
    L = ['%s=%r' % (key, value)
19094 
      for key, value in self.__dict__.iteritems()]
19095 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19096 
 
19097 
  def __eq__(self, other):
19098 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19099 
 
19100 
  def __ne__(self, other):
19101 
    return not (self == other)
19102 
 
19103 
class getAllSourcePricing_args:
19104 
  """
19105 
  Attributes:
19106 
   - itemId
19107 
  """
19108 
 
19109 
  thrift_spec = (
19110 
    None, # 0
19111 
    (1, TType.I64, 'itemId', None, None, ), # 1
19112 
  )
19113 
 
19114 
  def __init__(self, itemId=None,):
19115 
    self.itemId = itemId
19116 
 
19117 
  def read(self, iprot):
19118 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19119 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19120 
      return
19121 
    iprot.readStructBegin()
19122 
    while True:
19123 
      (fname, ftype, fid) = iprot.readFieldBegin()
19124 
      if ftype == TType.STOP:
19125 
        break
19126 
      if fid == 1:
19127 
        if ftype == TType.I64:
19128 
          self.itemId = iprot.readI64();
19129 
        else:
19130 
          iprot.skip(ftype)
19131 
      else:
19132 
        iprot.skip(ftype)
19133 
      iprot.readFieldEnd()
19134 
    iprot.readStructEnd()
19135 
 
19136 
  def write(self, oprot):
19137 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19138 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19139 
      return
19140 
    oprot.writeStructBegin('getAllSourcePricing_args')
19141 
    if self.itemId is not None:
19142 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19143 
      oprot.writeI64(self.itemId)
19144 
      oprot.writeFieldEnd()
19145 
    oprot.writeFieldStop()
19146 
    oprot.writeStructEnd()
19147 
 
19148 
  def validate(self):
19149 
    return
19150 
 
19151 
 
19152 
  def __repr__(self):
19153 
    L = ['%s=%r' % (key, value)
19154 
      for key, value in self.__dict__.iteritems()]
19155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19156 
 
19157 
  def __eq__(self, other):
19158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19159 
 
19160 
  def __ne__(self, other):
19161 
    return not (self == other)
19162 
 
19163 
class getAllSourcePricing_result:
19164 
  """
19165 
  Attributes:
19166 
   - success
19167 
   - cex
19168 
  """
19169 
 
19170 
  thrift_spec = (
19171 
    (0, TType.LIST, 'success', (TType.STRUCT,(SourceItemPricing, SourceItemPricing.thrift_spec)), None, ), # 0
19172 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
19173 
  )
19174 
 
19175 
  def __init__(self, success=None, cex=None,):
19176 
    self.success = success
19177 
    self.cex = cex
19178 
 
19179 
  def read(self, iprot):
19180 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19181 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19182 
      return
19183 
    iprot.readStructBegin()
19184 
    while True:
19185 
      (fname, ftype, fid) = iprot.readFieldBegin()
19186 
      if ftype == TType.STOP:
19187 
        break
19188 
      if fid == 0:
19189 
        if ftype == TType.LIST:
19190 
          self.success = []
13493 amit.gupta 19191 
          (_etype346, _size343) = iprot.readListBegin()
19192 
          for _i347 in xrange(_size343):
19193 
            _elem348 = SourceItemPricing()
19194 
            _elem348.read(iprot)
19195 
            self.success.append(_elem348)
5944 mandeep.dh 19196 
          iprot.readListEnd()
19197 
        else:
19198 
          iprot.skip(ftype)
19199 
      elif fid == 1:
19200 
        if ftype == TType.STRUCT:
19201 
          self.cex = CatalogServiceException()
19202 
          self.cex.read(iprot)
19203 
        else:
19204 
          iprot.skip(ftype)
19205 
      else:
19206 
        iprot.skip(ftype)
19207 
      iprot.readFieldEnd()
19208 
    iprot.readStructEnd()
19209 
 
19210 
  def write(self, oprot):
19211 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19212 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19213 
      return
19214 
    oprot.writeStructBegin('getAllSourcePricing_result')
19215 
    if self.success is not None:
19216 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19217 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 19218 
      for iter349 in self.success:
19219 
        iter349.write(oprot)
5944 mandeep.dh 19220 
      oprot.writeListEnd()
19221 
      oprot.writeFieldEnd()
19222 
    if self.cex is not None:
19223 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
19224 
      self.cex.write(oprot)
19225 
      oprot.writeFieldEnd()
19226 
    oprot.writeFieldStop()
19227 
    oprot.writeStructEnd()
19228 
 
19229 
  def validate(self):
19230 
    return
19231 
 
19232 
 
19233 
  def __repr__(self):
19234 
    L = ['%s=%r' % (key, value)
19235 
      for key, value in self.__dict__.iteritems()]
19236 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19237 
 
19238 
  def __eq__(self, other):
19239 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19240 
 
19241 
  def __ne__(self, other):
19242 
    return not (self == other)
19243 
 
19244 
class getItemForSource_args:
19245 
  """
19246 
  Attributes:
19247 
   - item_id
19248 
   - sourceId
19249 
  """
19250 
 
19251 
  thrift_spec = (
19252 
    None, # 0
19253 
    (1, TType.I64, 'item_id', None, None, ), # 1
19254 
    (2, TType.I64, 'sourceId', None, None, ), # 2
19255 
  )
19256 
 
19257 
  def __init__(self, item_id=None, sourceId=None,):
19258 
    self.item_id = item_id
19259 
    self.sourceId = sourceId
19260 
 
19261 
  def read(self, iprot):
19262 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19263 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19264 
      return
19265 
    iprot.readStructBegin()
19266 
    while True:
19267 
      (fname, ftype, fid) = iprot.readFieldBegin()
19268 
      if ftype == TType.STOP:
19269 
        break
19270 
      if fid == 1:
19271 
        if ftype == TType.I64:
19272 
          self.item_id = iprot.readI64();
19273 
        else:
19274 
          iprot.skip(ftype)
19275 
      elif fid == 2:
19276 
        if ftype == TType.I64:
19277 
          self.sourceId = iprot.readI64();
19278 
        else:
19279 
          iprot.skip(ftype)
19280 
      else:
19281 
        iprot.skip(ftype)
19282 
      iprot.readFieldEnd()
19283 
    iprot.readStructEnd()
19284 
 
19285 
  def write(self, oprot):
19286 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19287 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19288 
      return
19289 
    oprot.writeStructBegin('getItemForSource_args')
19290 
    if self.item_id is not None:
19291 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
19292 
      oprot.writeI64(self.item_id)
19293 
      oprot.writeFieldEnd()
19294 
    if self.sourceId is not None:
19295 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
19296 
      oprot.writeI64(self.sourceId)
19297 
      oprot.writeFieldEnd()
19298 
    oprot.writeFieldStop()
19299 
    oprot.writeStructEnd()
19300 
 
19301 
  def validate(self):
19302 
    return
19303 
 
19304 
 
19305 
  def __repr__(self):
19306 
    L = ['%s=%r' % (key, value)
19307 
      for key, value in self.__dict__.iteritems()]
19308 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19309 
 
19310 
  def __eq__(self, other):
19311 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19312 
 
19313 
  def __ne__(self, other):
19314 
    return not (self == other)
19315 
 
19316 
class getItemForSource_result:
19317 
  """
19318 
  Attributes:
19319 
   - success
19320 
   - cex
19321 
  """
19322 
 
19323 
  thrift_spec = (
19324 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
19325 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
19326 
  )
19327 
 
19328 
  def __init__(self, success=None, cex=None,):
19329 
    self.success = success
19330 
    self.cex = cex
19331 
 
19332 
  def read(self, iprot):
19333 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19334 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19335 
      return
19336 
    iprot.readStructBegin()
19337 
    while True:
19338 
      (fname, ftype, fid) = iprot.readFieldBegin()
19339 
      if ftype == TType.STOP:
19340 
        break
19341 
      if fid == 0:
19342 
        if ftype == TType.STRUCT:
19343 
          self.success = Item()
19344 
          self.success.read(iprot)
19345 
        else:
19346 
          iprot.skip(ftype)
19347 
      elif fid == 1:
19348 
        if ftype == TType.STRUCT:
19349 
          self.cex = CatalogServiceException()
19350 
          self.cex.read(iprot)
19351 
        else:
19352 
          iprot.skip(ftype)
19353 
      else:
19354 
        iprot.skip(ftype)
19355 
      iprot.readFieldEnd()
19356 
    iprot.readStructEnd()
19357 
 
19358 
  def write(self, oprot):
19359 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19360 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19361 
      return
19362 
    oprot.writeStructBegin('getItemForSource_result')
19363 
    if self.success is not None:
19364 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19365 
      self.success.write(oprot)
19366 
      oprot.writeFieldEnd()
19367 
    if self.cex is not None:
19368 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
19369 
      self.cex.write(oprot)
19370 
      oprot.writeFieldEnd()
19371 
    oprot.writeFieldStop()
19372 
    oprot.writeStructEnd()
19373 
 
19374 
  def validate(self):
19375 
    return
19376 
 
19377 
 
19378 
  def __repr__(self):
19379 
    L = ['%s=%r' % (key, value)
19380 
      for key, value in self.__dict__.iteritems()]
19381 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19382 
 
19383 
  def __eq__(self, other):
19384 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19385 
 
19386 
  def __ne__(self, other):
19387 
    return not (self == other)
19388 
 
19389 
class searchItemsInRange_args:
19390 
  """
19391 
  Attributes:
19392 
   - searchTerms
19393 
   - offset
19394 
   - limit
19395 
  """
19396 
 
19397 
  thrift_spec = (
19398 
    None, # 0
19399 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
19400 
    (2, TType.I64, 'offset', None, None, ), # 2
19401 
    (3, TType.I64, 'limit', None, None, ), # 3
19402 
  )
19403 
 
19404 
  def __init__(self, searchTerms=None, offset=None, limit=None,):
19405 
    self.searchTerms = searchTerms
19406 
    self.offset = offset
19407 
    self.limit = limit
19408 
 
19409 
  def read(self, iprot):
19410 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19411 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19412 
      return
19413 
    iprot.readStructBegin()
19414 
    while True:
19415 
      (fname, ftype, fid) = iprot.readFieldBegin()
19416 
      if ftype == TType.STOP:
19417 
        break
19418 
      if fid == 1:
19419 
        if ftype == TType.LIST:
19420 
          self.searchTerms = []
13493 amit.gupta 19421 
          (_etype353, _size350) = iprot.readListBegin()
19422 
          for _i354 in xrange(_size350):
19423 
            _elem355 = iprot.readString();
19424 
            self.searchTerms.append(_elem355)
5944 mandeep.dh 19425 
          iprot.readListEnd()
19426 
        else:
19427 
          iprot.skip(ftype)
19428 
      elif fid == 2:
19429 
        if ftype == TType.I64:
19430 
          self.offset = iprot.readI64();
19431 
        else:
19432 
          iprot.skip(ftype)
19433 
      elif fid == 3:
19434 
        if ftype == TType.I64:
19435 
          self.limit = iprot.readI64();
19436 
        else:
19437 
          iprot.skip(ftype)
19438 
      else:
19439 
        iprot.skip(ftype)
19440 
      iprot.readFieldEnd()
19441 
    iprot.readStructEnd()
19442 
 
19443 
  def write(self, oprot):
19444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19446 
      return
19447 
    oprot.writeStructBegin('searchItemsInRange_args')
19448 
    if self.searchTerms is not None:
19449 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
19450 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
13493 amit.gupta 19451 
      for iter356 in self.searchTerms:
19452 
        oprot.writeString(iter356)
5944 mandeep.dh 19453 
      oprot.writeListEnd()
19454 
      oprot.writeFieldEnd()
19455 
    if self.offset is not None:
19456 
      oprot.writeFieldBegin('offset', TType.I64, 2)
19457 
      oprot.writeI64(self.offset)
19458 
      oprot.writeFieldEnd()
19459 
    if self.limit is not None:
19460 
      oprot.writeFieldBegin('limit', TType.I64, 3)
19461 
      oprot.writeI64(self.limit)
19462 
      oprot.writeFieldEnd()
19463 
    oprot.writeFieldStop()
19464 
    oprot.writeStructEnd()
19465 
 
19466 
  def validate(self):
19467 
    return
19468 
 
19469 
 
19470 
  def __repr__(self):
19471 
    L = ['%s=%r' % (key, value)
19472 
      for key, value in self.__dict__.iteritems()]
19473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19474 
 
19475 
  def __eq__(self, other):
19476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19477 
 
19478 
  def __ne__(self, other):
19479 
    return not (self == other)
19480 
 
19481 
class searchItemsInRange_result:
19482 
  """
19483 
  Attributes:
19484 
   - success
19485 
  """
19486 
 
19487 
  thrift_spec = (
19488 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
19489 
  )
19490 
 
19491 
  def __init__(self, success=None,):
19492 
    self.success = success
19493 
 
19494 
  def read(self, iprot):
19495 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19496 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19497 
      return
19498 
    iprot.readStructBegin()
19499 
    while True:
19500 
      (fname, ftype, fid) = iprot.readFieldBegin()
19501 
      if ftype == TType.STOP:
19502 
        break
19503 
      if fid == 0:
19504 
        if ftype == TType.LIST:
19505 
          self.success = []
13493 amit.gupta 19506 
          (_etype360, _size357) = iprot.readListBegin()
19507 
          for _i361 in xrange(_size357):
19508 
            _elem362 = Item()
19509 
            _elem362.read(iprot)
19510 
            self.success.append(_elem362)
5944 mandeep.dh 19511 
          iprot.readListEnd()
19512 
        else:
19513 
          iprot.skip(ftype)
19514 
      else:
19515 
        iprot.skip(ftype)
19516 
      iprot.readFieldEnd()
19517 
    iprot.readStructEnd()
19518 
 
19519 
  def write(self, oprot):
19520 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19521 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19522 
      return
19523 
    oprot.writeStructBegin('searchItemsInRange_result')
19524 
    if self.success is not None:
19525 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19526 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 19527 
      for iter363 in self.success:
19528 
        iter363.write(oprot)
5944 mandeep.dh 19529 
      oprot.writeListEnd()
19530 
      oprot.writeFieldEnd()
19531 
    oprot.writeFieldStop()
19532 
    oprot.writeStructEnd()
19533 
 
19534 
  def validate(self):
19535 
    return
19536 
 
19537 
 
19538 
  def __repr__(self):
19539 
    L = ['%s=%r' % (key, value)
19540 
      for key, value in self.__dict__.iteritems()]
19541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19542 
 
19543 
  def __eq__(self, other):
19544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19545 
 
19546 
  def __ne__(self, other):
19547 
    return not (self == other)
19548 
 
19549 
class getSearchResultCount_args:
19550 
  """
19551 
  Attributes:
19552 
   - searchTerms
19553 
  """
19554 
 
19555 
  thrift_spec = (
19556 
    None, # 0
19557 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
19558 
  )
19559 
 
19560 
  def __init__(self, searchTerms=None,):
19561 
    self.searchTerms = searchTerms
19562 
 
19563 
  def read(self, iprot):
19564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19566 
      return
19567 
    iprot.readStructBegin()
19568 
    while True:
19569 
      (fname, ftype, fid) = iprot.readFieldBegin()
19570 
      if ftype == TType.STOP:
19571 
        break
19572 
      if fid == 1:
19573 
        if ftype == TType.LIST:
19574 
          self.searchTerms = []
13493 amit.gupta 19575 
          (_etype367, _size364) = iprot.readListBegin()
19576 
          for _i368 in xrange(_size364):
19577 
            _elem369 = iprot.readString();
19578 
            self.searchTerms.append(_elem369)
5944 mandeep.dh 19579 
          iprot.readListEnd()
19580 
        else:
19581 
          iprot.skip(ftype)
19582 
      else:
19583 
        iprot.skip(ftype)
19584 
      iprot.readFieldEnd()
19585 
    iprot.readStructEnd()
19586 
 
19587 
  def write(self, oprot):
19588 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19589 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19590 
      return
19591 
    oprot.writeStructBegin('getSearchResultCount_args')
19592 
    if self.searchTerms is not None:
19593 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
19594 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
13493 amit.gupta 19595 
      for iter370 in self.searchTerms:
19596 
        oprot.writeString(iter370)
5944 mandeep.dh 19597 
      oprot.writeListEnd()
19598 
      oprot.writeFieldEnd()
19599 
    oprot.writeFieldStop()
19600 
    oprot.writeStructEnd()
19601 
 
19602 
  def validate(self):
19603 
    return
19604 
 
19605 
 
19606 
  def __repr__(self):
19607 
    L = ['%s=%r' % (key, value)
19608 
      for key, value in self.__dict__.iteritems()]
19609 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19610 
 
19611 
  def __eq__(self, other):
19612 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19613 
 
19614 
  def __ne__(self, other):
19615 
    return not (self == other)
19616 
 
19617 
class getSearchResultCount_result:
19618 
  """
19619 
  Attributes:
19620 
   - success
19621 
  """
19622 
 
19623 
  thrift_spec = (
19624 
    (0, TType.I32, 'success', None, None, ), # 0
19625 
  )
19626 
 
19627 
  def __init__(self, success=None,):
19628 
    self.success = success
19629 
 
19630 
  def read(self, iprot):
19631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19633 
      return
19634 
    iprot.readStructBegin()
19635 
    while True:
19636 
      (fname, ftype, fid) = iprot.readFieldBegin()
19637 
      if ftype == TType.STOP:
19638 
        break
19639 
      if fid == 0:
19640 
        if ftype == TType.I32:
19641 
          self.success = iprot.readI32();
19642 
        else:
19643 
          iprot.skip(ftype)
19644 
      else:
19645 
        iprot.skip(ftype)
19646 
      iprot.readFieldEnd()
19647 
    iprot.readStructEnd()
19648 
 
19649 
  def write(self, oprot):
19650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19652 
      return
19653 
    oprot.writeStructBegin('getSearchResultCount_result')
19654 
    if self.success is not None:
19655 
      oprot.writeFieldBegin('success', TType.I32, 0)
19656 
      oprot.writeI32(self.success)
19657 
      oprot.writeFieldEnd()
19658 
    oprot.writeFieldStop()
19659 
    oprot.writeStructEnd()
19660 
 
19661 
  def validate(self):
19662 
    return
19663 
 
19664 
 
19665 
  def __repr__(self):
19666 
    L = ['%s=%r' % (key, value)
19667 
      for key, value in self.__dict__.iteritems()]
19668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19669 
 
19670 
  def __eq__(self, other):
19671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19672 
 
19673 
  def __ne__(self, other):
19674 
    return not (self == other)
19675 
 
19676 
class getProductNotifications_args:
19677 
  """
19678 
  Attributes:
19679 
   - startDateTime
19680 
  """
19681 
 
19682 
  thrift_spec = (
19683 
    None, # 0
19684 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
19685 
  )
19686 
 
19687 
  def __init__(self, startDateTime=None,):
19688 
    self.startDateTime = startDateTime
19689 
 
19690 
  def read(self, iprot):
19691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19693 
      return
19694 
    iprot.readStructBegin()
19695 
    while True:
19696 
      (fname, ftype, fid) = iprot.readFieldBegin()
19697 
      if ftype == TType.STOP:
19698 
        break
19699 
      if fid == 1:
19700 
        if ftype == TType.I64:
19701 
          self.startDateTime = iprot.readI64();
19702 
        else:
19703 
          iprot.skip(ftype)
19704 
      else:
19705 
        iprot.skip(ftype)
19706 
      iprot.readFieldEnd()
19707 
    iprot.readStructEnd()
19708 
 
19709 
  def write(self, oprot):
19710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19712 
      return
19713 
    oprot.writeStructBegin('getProductNotifications_args')
19714 
    if self.startDateTime is not None:
19715 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
19716 
      oprot.writeI64(self.startDateTime)
19717 
      oprot.writeFieldEnd()
19718 
    oprot.writeFieldStop()
19719 
    oprot.writeStructEnd()
19720 
 
19721 
  def validate(self):
19722 
    return
19723 
 
19724 
 
19725 
  def __repr__(self):
19726 
    L = ['%s=%r' % (key, value)
19727 
      for key, value in self.__dict__.iteritems()]
19728 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19729 
 
19730 
  def __eq__(self, other):
19731 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19732 
 
19733 
  def __ne__(self, other):
19734 
    return not (self == other)
19735 
 
19736 
class getProductNotifications_result:
19737 
  """
19738 
  Attributes:
19739 
   - success
19740 
  """
19741 
 
19742 
  thrift_spec = (
19743 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequest, ProductNotificationRequest.thrift_spec)), None, ), # 0
19744 
  )
19745 
 
19746 
  def __init__(self, success=None,):
19747 
    self.success = success
19748 
 
19749 
  def read(self, iprot):
19750 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19751 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19752 
      return
19753 
    iprot.readStructBegin()
19754 
    while True:
19755 
      (fname, ftype, fid) = iprot.readFieldBegin()
19756 
      if ftype == TType.STOP:
19757 
        break
19758 
      if fid == 0:
19759 
        if ftype == TType.LIST:
19760 
          self.success = []
13493 amit.gupta 19761 
          (_etype374, _size371) = iprot.readListBegin()
19762 
          for _i375 in xrange(_size371):
19763 
            _elem376 = ProductNotificationRequest()
19764 
            _elem376.read(iprot)
19765 
            self.success.append(_elem376)
5944 mandeep.dh 19766 
          iprot.readListEnd()
19767 
        else:
19768 
          iprot.skip(ftype)
19769 
      else:
19770 
        iprot.skip(ftype)
19771 
      iprot.readFieldEnd()
19772 
    iprot.readStructEnd()
19773 
 
19774 
  def write(self, oprot):
19775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19777 
      return
19778 
    oprot.writeStructBegin('getProductNotifications_result')
19779 
    if self.success is not None:
19780 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19781 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 19782 
      for iter377 in self.success:
19783 
        iter377.write(oprot)
5944 mandeep.dh 19784 
      oprot.writeListEnd()
19785 
      oprot.writeFieldEnd()
19786 
    oprot.writeFieldStop()
19787 
    oprot.writeStructEnd()
19788 
 
19789 
  def validate(self):
19790 
    return
19791 
 
19792 
 
19793 
  def __repr__(self):
19794 
    L = ['%s=%r' % (key, value)
19795 
      for key, value in self.__dict__.iteritems()]
19796 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19797 
 
19798 
  def __eq__(self, other):
19799 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19800 
 
19801 
  def __ne__(self, other):
19802 
    return not (self == other)
19803 
 
19804 
class getProductNotificationRequestCount_args:
19805 
  """
19806 
  Attributes:
19807 
   - startDateTime
7897 amar.kumar 19808 
   - categoryId
5944 mandeep.dh 19809 
  """
19810 
 
19811 
  thrift_spec = (
19812 
    None, # 0
19813 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
7897 amar.kumar 19814 
    (2, TType.I64, 'categoryId', None, None, ), # 2
5944 mandeep.dh 19815 
  )
19816 
 
7897 amar.kumar 19817 
  def __init__(self, startDateTime=None, categoryId=None,):
5944 mandeep.dh 19818 
    self.startDateTime = startDateTime
7897 amar.kumar 19819 
    self.categoryId = categoryId
5944 mandeep.dh 19820 
 
19821 
  def read(self, iprot):
19822 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19823 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19824 
      return
19825 
    iprot.readStructBegin()
19826 
    while True:
19827 
      (fname, ftype, fid) = iprot.readFieldBegin()
19828 
      if ftype == TType.STOP:
19829 
        break
19830 
      if fid == 1:
19831 
        if ftype == TType.I64:
19832 
          self.startDateTime = iprot.readI64();
19833 
        else:
19834 
          iprot.skip(ftype)
7897 amar.kumar 19835 
      elif fid == 2:
19836 
        if ftype == TType.I64:
19837 
          self.categoryId = iprot.readI64();
19838 
        else:
19839 
          iprot.skip(ftype)
5944 mandeep.dh 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('getProductNotificationRequestCount_args')
19850 
    if self.startDateTime is not None:
19851 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
19852 
      oprot.writeI64(self.startDateTime)
19853 
      oprot.writeFieldEnd()
7897 amar.kumar 19854 
    if self.categoryId is not None:
19855 
      oprot.writeFieldBegin('categoryId', TType.I64, 2)
19856 
      oprot.writeI64(self.categoryId)
19857 
      oprot.writeFieldEnd()
5944 mandeep.dh 19858 
    oprot.writeFieldStop()
19859 
    oprot.writeStructEnd()
19860 
 
19861 
  def validate(self):
19862 
    return
19863 
 
19864 
 
19865 
  def __repr__(self):
19866 
    L = ['%s=%r' % (key, value)
19867 
      for key, value in self.__dict__.iteritems()]
19868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19869 
 
19870 
  def __eq__(self, other):
19871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19872 
 
19873 
  def __ne__(self, other):
19874 
    return not (self == other)
19875 
 
19876 
class getProductNotificationRequestCount_result:
19877 
  """
19878 
  Attributes:
19879 
   - success
19880 
  """
19881 
 
19882 
  thrift_spec = (
19883 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequestCount, ProductNotificationRequestCount.thrift_spec)), None, ), # 0
19884 
  )
19885 
 
19886 
  def __init__(self, success=None,):
19887 
    self.success = success
19888 
 
19889 
  def read(self, iprot):
19890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19892 
      return
19893 
    iprot.readStructBegin()
19894 
    while True:
19895 
      (fname, ftype, fid) = iprot.readFieldBegin()
19896 
      if ftype == TType.STOP:
19897 
        break
19898 
      if fid == 0:
19899 
        if ftype == TType.LIST:
19900 
          self.success = []
13493 amit.gupta 19901 
          (_etype381, _size378) = iprot.readListBegin()
19902 
          for _i382 in xrange(_size378):
19903 
            _elem383 = ProductNotificationRequestCount()
19904 
            _elem383.read(iprot)
19905 
            self.success.append(_elem383)
5944 mandeep.dh 19906 
          iprot.readListEnd()
19907 
        else:
19908 
          iprot.skip(ftype)
19909 
      else:
19910 
        iprot.skip(ftype)
19911 
      iprot.readFieldEnd()
19912 
    iprot.readStructEnd()
19913 
 
19914 
  def write(self, oprot):
19915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19917 
      return
19918 
    oprot.writeStructBegin('getProductNotificationRequestCount_result')
19919 
    if self.success is not None:
19920 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19921 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 19922 
      for iter384 in self.success:
19923 
        iter384.write(oprot)
5944 mandeep.dh 19924 
      oprot.writeListEnd()
19925 
      oprot.writeFieldEnd()
19926 
    oprot.writeFieldStop()
19927 
    oprot.writeStructEnd()
19928 
 
19929 
  def validate(self):
19930 
    return
19931 
 
19932 
 
19933 
  def __repr__(self):
19934 
    L = ['%s=%r' % (key, value)
19935 
      for key, value in self.__dict__.iteritems()]
19936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19937 
 
19938 
  def __eq__(self, other):
19939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19940 
 
19941 
  def __ne__(self, other):
19942 
    return not (self == other)
19943 
 
19944 
class addAuthorizationLog_args:
19945 
  """
19946 
  Attributes:
19947 
   - itemId
19948 
   - username
19949 
   - reason
19950 
  """
19951 
 
19952 
  thrift_spec = (
19953 
    None, # 0
19954 
    (1, TType.I64, 'itemId', None, None, ), # 1
19955 
    (2, TType.STRING, 'username', None, None, ), # 2
19956 
    (3, TType.STRING, 'reason', None, None, ), # 3
19957 
  )
19958 
 
19959 
  def __init__(self, itemId=None, username=None, reason=None,):
19960 
    self.itemId = itemId
19961 
    self.username = username
19962 
    self.reason = reason
19963 
 
19964 
  def read(self, iprot):
19965 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19966 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19967 
      return
19968 
    iprot.readStructBegin()
19969 
    while True:
19970 
      (fname, ftype, fid) = iprot.readFieldBegin()
19971 
      if ftype == TType.STOP:
19972 
        break
19973 
      if fid == 1:
19974 
        if ftype == TType.I64:
19975 
          self.itemId = iprot.readI64();
19976 
        else:
19977 
          iprot.skip(ftype)
19978 
      elif fid == 2:
19979 
        if ftype == TType.STRING:
19980 
          self.username = iprot.readString();
19981 
        else:
19982 
          iprot.skip(ftype)
19983 
      elif fid == 3:
19984 
        if ftype == TType.STRING:
19985 
          self.reason = iprot.readString();
19986 
        else:
19987 
          iprot.skip(ftype)
19988 
      else:
19989 
        iprot.skip(ftype)
19990 
      iprot.readFieldEnd()
19991 
    iprot.readStructEnd()
19992 
 
19993 
  def write(self, oprot):
19994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19996 
      return
19997 
    oprot.writeStructBegin('addAuthorizationLog_args')
19998 
    if self.itemId is not None:
19999 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20000 
      oprot.writeI64(self.itemId)
20001 
      oprot.writeFieldEnd()
20002 
    if self.username is not None:
20003 
      oprot.writeFieldBegin('username', TType.STRING, 2)
20004 
      oprot.writeString(self.username)
20005 
      oprot.writeFieldEnd()
20006 
    if self.reason is not None:
20007 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
20008 
      oprot.writeString(self.reason)
20009 
      oprot.writeFieldEnd()
20010 
    oprot.writeFieldStop()
20011 
    oprot.writeStructEnd()
20012 
 
20013 
  def validate(self):
20014 
    return
20015 
 
20016 
 
20017 
  def __repr__(self):
20018 
    L = ['%s=%r' % (key, value)
20019 
      for key, value in self.__dict__.iteritems()]
20020 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20021 
 
20022 
  def __eq__(self, other):
20023 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20024 
 
20025 
  def __ne__(self, other):
20026 
    return not (self == other)
20027 
 
20028 
class addAuthorizationLog_result:
20029 
  """
20030 
  Attributes:
20031 
   - success
20032 
   - cex
20033 
  """
20034 
 
20035 
  thrift_spec = (
20036 
    (0, TType.BOOL, 'success', None, None, ), # 0
20037 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
20038 
  )
20039 
 
20040 
  def __init__(self, success=None, cex=None,):
20041 
    self.success = success
20042 
    self.cex = cex
20043 
 
20044 
  def read(self, iprot):
20045 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20046 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20047 
      return
20048 
    iprot.readStructBegin()
20049 
    while True:
20050 
      (fname, ftype, fid) = iprot.readFieldBegin()
20051 
      if ftype == TType.STOP:
20052 
        break
20053 
      if fid == 0:
20054 
        if ftype == TType.BOOL:
20055 
          self.success = iprot.readBool();
20056 
        else:
20057 
          iprot.skip(ftype)
20058 
      elif fid == 1:
20059 
        if ftype == TType.STRUCT:
20060 
          self.cex = CatalogServiceException()
20061 
          self.cex.read(iprot)
20062 
        else:
20063 
          iprot.skip(ftype)
20064 
      else:
20065 
        iprot.skip(ftype)
20066 
      iprot.readFieldEnd()
20067 
    iprot.readStructEnd()
20068 
 
20069 
  def write(self, oprot):
20070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20072 
      return
20073 
    oprot.writeStructBegin('addAuthorizationLog_result')
20074 
    if self.success is not None:
20075 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20076 
      oprot.writeBool(self.success)
20077 
      oprot.writeFieldEnd()
20078 
    if self.cex is not None:
20079 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
20080 
      self.cex.write(oprot)
20081 
      oprot.writeFieldEnd()
20082 
    oprot.writeFieldStop()
20083 
    oprot.writeStructEnd()
20084 
 
20085 
  def validate(self):
20086 
    return
20087 
 
20088 
 
20089 
  def __repr__(self):
20090 
    L = ['%s=%r' % (key, value)
20091 
      for key, value in self.__dict__.iteritems()]
20092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20093 
 
20094 
  def __eq__(self, other):
20095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20096 
 
20097 
  def __ne__(self, other):
20098 
    return not (self == other)
20099 
 
20100 
class addupdateVoucherForItem_args:
20101 
  """
20102 
  Attributes:
20103 
   - catalog_item_id
20104 
   - voucherType
20105 
   - voucherAmount
20106 
  """
20107 
 
20108 
  thrift_spec = (
20109 
    None, # 0
20110 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
20111 
    (2, TType.I64, 'voucherType', None, None, ), # 2
20112 
    (3, TType.I64, 'voucherAmount', None, None, ), # 3
20113 
  )
20114 
 
20115 
  def __init__(self, catalog_item_id=None, voucherType=None, voucherAmount=None,):
20116 
    self.catalog_item_id = catalog_item_id
20117 
    self.voucherType = voucherType
20118 
    self.voucherAmount = voucherAmount
20119 
 
20120 
  def read(self, iprot):
20121 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20122 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20123 
      return
20124 
    iprot.readStructBegin()
20125 
    while True:
20126 
      (fname, ftype, fid) = iprot.readFieldBegin()
20127 
      if ftype == TType.STOP:
20128 
        break
20129 
      if fid == 1:
20130 
        if ftype == TType.I64:
20131 
          self.catalog_item_id = iprot.readI64();
20132 
        else:
20133 
          iprot.skip(ftype)
20134 
      elif fid == 2:
20135 
        if ftype == TType.I64:
20136 
          self.voucherType = iprot.readI64();
20137 
        else:
20138 
          iprot.skip(ftype)
20139 
      elif fid == 3:
20140 
        if ftype == TType.I64:
20141 
          self.voucherAmount = iprot.readI64();
20142 
        else:
20143 
          iprot.skip(ftype)
20144 
      else:
20145 
        iprot.skip(ftype)
20146 
      iprot.readFieldEnd()
20147 
    iprot.readStructEnd()
20148 
 
20149 
  def write(self, oprot):
20150 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20151 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20152 
      return
20153 
    oprot.writeStructBegin('addupdateVoucherForItem_args')
20154 
    if self.catalog_item_id is not None:
20155 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
20156 
      oprot.writeI64(self.catalog_item_id)
20157 
      oprot.writeFieldEnd()
20158 
    if self.voucherType is not None:
20159 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
20160 
      oprot.writeI64(self.voucherType)
20161 
      oprot.writeFieldEnd()
20162 
    if self.voucherAmount is not None:
20163 
      oprot.writeFieldBegin('voucherAmount', TType.I64, 3)
20164 
      oprot.writeI64(self.voucherAmount)
20165 
      oprot.writeFieldEnd()
20166 
    oprot.writeFieldStop()
20167 
    oprot.writeStructEnd()
20168 
 
20169 
  def validate(self):
20170 
    return
20171 
 
20172 
 
20173 
  def __repr__(self):
20174 
    L = ['%s=%r' % (key, value)
20175 
      for key, value in self.__dict__.iteritems()]
20176 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20177 
 
20178 
  def __eq__(self, other):
20179 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20180 
 
20181 
  def __ne__(self, other):
20182 
    return not (self == other)
20183 
 
20184 
class addupdateVoucherForItem_result:
20185 
  """
20186 
  Attributes:
20187 
   - success
20188 
   - cex
20189 
  """
20190 
 
20191 
  thrift_spec = (
20192 
    (0, TType.BOOL, 'success', None, None, ), # 0
20193 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
20194 
  )
20195 
 
20196 
  def __init__(self, success=None, cex=None,):
20197 
    self.success = success
20198 
    self.cex = cex
20199 
 
20200 
  def read(self, iprot):
20201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20203 
      return
20204 
    iprot.readStructBegin()
20205 
    while True:
20206 
      (fname, ftype, fid) = iprot.readFieldBegin()
20207 
      if ftype == TType.STOP:
20208 
        break
20209 
      if fid == 0:
20210 
        if ftype == TType.BOOL:
20211 
          self.success = iprot.readBool();
20212 
        else:
20213 
          iprot.skip(ftype)
20214 
      elif fid == 1:
20215 
        if ftype == TType.STRUCT:
20216 
          self.cex = CatalogServiceException()
20217 
          self.cex.read(iprot)
20218 
        else:
20219 
          iprot.skip(ftype)
20220 
      else:
20221 
        iprot.skip(ftype)
20222 
      iprot.readFieldEnd()
20223 
    iprot.readStructEnd()
20224 
 
20225 
  def write(self, oprot):
20226 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20227 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20228 
      return
20229 
    oprot.writeStructBegin('addupdateVoucherForItem_result')
20230 
    if self.success is not None:
20231 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20232 
      oprot.writeBool(self.success)
20233 
      oprot.writeFieldEnd()
20234 
    if self.cex is not None:
20235 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
20236 
      self.cex.write(oprot)
20237 
      oprot.writeFieldEnd()
20238 
    oprot.writeFieldStop()
20239 
    oprot.writeStructEnd()
20240 
 
20241 
  def validate(self):
20242 
    return
20243 
 
20244 
 
20245 
  def __repr__(self):
20246 
    L = ['%s=%r' % (key, value)
20247 
      for key, value in self.__dict__.iteritems()]
20248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20249 
 
20250 
  def __eq__(self, other):
20251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20252 
 
20253 
  def __ne__(self, other):
20254 
    return not (self == other)
20255 
 
20256 
class deleteVoucherForItem_args:
20257 
  """
20258 
  Attributes:
20259 
   - catalog_item_id
20260 
   - voucherType
20261 
  """
20262 
 
20263 
  thrift_spec = (
20264 
    None, # 0
20265 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
20266 
    (2, TType.I64, 'voucherType', None, None, ), # 2
20267 
  )
20268 
 
20269 
  def __init__(self, catalog_item_id=None, voucherType=None,):
20270 
    self.catalog_item_id = catalog_item_id
20271 
    self.voucherType = voucherType
20272 
 
20273 
  def read(self, iprot):
20274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20276 
      return
20277 
    iprot.readStructBegin()
20278 
    while True:
20279 
      (fname, ftype, fid) = iprot.readFieldBegin()
20280 
      if ftype == TType.STOP:
20281 
        break
20282 
      if fid == 1:
20283 
        if ftype == TType.I64:
20284 
          self.catalog_item_id = iprot.readI64();
20285 
        else:
20286 
          iprot.skip(ftype)
20287 
      elif fid == 2:
20288 
        if ftype == TType.I64:
20289 
          self.voucherType = iprot.readI64();
20290 
        else:
20291 
          iprot.skip(ftype)
20292 
      else:
20293 
        iprot.skip(ftype)
20294 
      iprot.readFieldEnd()
20295 
    iprot.readStructEnd()
20296 
 
20297 
  def write(self, oprot):
20298 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20299 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20300 
      return
20301 
    oprot.writeStructBegin('deleteVoucherForItem_args')
20302 
    if self.catalog_item_id is not None:
20303 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
20304 
      oprot.writeI64(self.catalog_item_id)
20305 
      oprot.writeFieldEnd()
20306 
    if self.voucherType is not None:
20307 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
20308 
      oprot.writeI64(self.voucherType)
20309 
      oprot.writeFieldEnd()
20310 
    oprot.writeFieldStop()
20311 
    oprot.writeStructEnd()
20312 
 
20313 
  def validate(self):
20314 
    return
20315 
 
20316 
 
20317 
  def __repr__(self):
20318 
    L = ['%s=%r' % (key, value)
20319 
      for key, value in self.__dict__.iteritems()]
20320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20321 
 
20322 
  def __eq__(self, other):
20323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20324 
 
20325 
  def __ne__(self, other):
20326 
    return not (self == other)
20327 
 
20328 
class deleteVoucherForItem_result:
20329 
  """
20330 
  Attributes:
20331 
   - success
20332 
   - cex
20333 
  """
20334 
 
20335 
  thrift_spec = (
20336 
    (0, TType.BOOL, 'success', None, None, ), # 0
20337 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
20338 
  )
20339 
 
20340 
  def __init__(self, success=None, cex=None,):
20341 
    self.success = success
20342 
    self.cex = cex
20343 
 
20344 
  def read(self, iprot):
20345 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20346 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20347 
      return
20348 
    iprot.readStructBegin()
20349 
    while True:
20350 
      (fname, ftype, fid) = iprot.readFieldBegin()
20351 
      if ftype == TType.STOP:
20352 
        break
20353 
      if fid == 0:
20354 
        if ftype == TType.BOOL:
20355 
          self.success = iprot.readBool();
20356 
        else:
20357 
          iprot.skip(ftype)
20358 
      elif fid == 1:
20359 
        if ftype == TType.STRUCT:
20360 
          self.cex = CatalogServiceException()
20361 
          self.cex.read(iprot)
20362 
        else:
20363 
          iprot.skip(ftype)
20364 
      else:
20365 
        iprot.skip(ftype)
20366 
      iprot.readFieldEnd()
20367 
    iprot.readStructEnd()
20368 
 
20369 
  def write(self, oprot):
20370 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20371 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20372 
      return
20373 
    oprot.writeStructBegin('deleteVoucherForItem_result')
20374 
    if self.success is not None:
20375 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20376 
      oprot.writeBool(self.success)
20377 
      oprot.writeFieldEnd()
20378 
    if self.cex is not None:
20379 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
20380 
      self.cex.write(oprot)
20381 
      oprot.writeFieldEnd()
20382 
    oprot.writeFieldStop()
20383 
    oprot.writeStructEnd()
20384 
 
20385 
  def validate(self):
20386 
    return
20387 
 
20388 
 
20389 
  def __repr__(self):
20390 
    L = ['%s=%r' % (key, value)
20391 
      for key, value in self.__dict__.iteritems()]
20392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20393 
 
20394 
  def __eq__(self, other):
20395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20396 
 
20397 
  def __ne__(self, other):
20398 
    return not (self == other)
20399 
 
20400 
class getVoucherAmount_args:
20401 
  """
20402 
  Attributes:
20403 
   - itemId
20404 
   - voucherType
20405 
  """
20406 
 
20407 
  thrift_spec = (
20408 
    None, # 0
20409 
    (1, TType.I64, 'itemId', None, None, ), # 1
20410 
    (2, TType.I64, 'voucherType', None, None, ), # 2
20411 
  )
20412 
 
20413 
  def __init__(self, itemId=None, voucherType=None,):
20414 
    self.itemId = itemId
20415 
    self.voucherType = voucherType
20416 
 
20417 
  def read(self, iprot):
20418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20420 
      return
20421 
    iprot.readStructBegin()
20422 
    while True:
20423 
      (fname, ftype, fid) = iprot.readFieldBegin()
20424 
      if ftype == TType.STOP:
20425 
        break
20426 
      if fid == 1:
20427 
        if ftype == TType.I64:
20428 
          self.itemId = iprot.readI64();
20429 
        else:
20430 
          iprot.skip(ftype)
20431 
      elif fid == 2:
20432 
        if ftype == TType.I64:
20433 
          self.voucherType = iprot.readI64();
20434 
        else:
20435 
          iprot.skip(ftype)
20436 
      else:
20437 
        iprot.skip(ftype)
20438 
      iprot.readFieldEnd()
20439 
    iprot.readStructEnd()
20440 
 
20441 
  def write(self, oprot):
20442 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20443 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20444 
      return
20445 
    oprot.writeStructBegin('getVoucherAmount_args')
20446 
    if self.itemId is not None:
20447 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20448 
      oprot.writeI64(self.itemId)
20449 
      oprot.writeFieldEnd()
20450 
    if self.voucherType is not None:
20451 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
20452 
      oprot.writeI64(self.voucherType)
20453 
      oprot.writeFieldEnd()
20454 
    oprot.writeFieldStop()
20455 
    oprot.writeStructEnd()
20456 
 
20457 
  def validate(self):
20458 
    return
20459 
 
20460 
 
20461 
  def __repr__(self):
20462 
    L = ['%s=%r' % (key, value)
20463 
      for key, value in self.__dict__.iteritems()]
20464 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20465 
 
20466 
  def __eq__(self, other):
20467 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20468 
 
20469 
  def __ne__(self, other):
20470 
    return not (self == other)
20471 
 
20472 
class getVoucherAmount_result:
20473 
  """
20474 
  Attributes:
20475 
   - success
20476 
  """
20477 
 
20478 
  thrift_spec = (
20479 
    (0, TType.I64, 'success', None, None, ), # 0
20480 
  )
20481 
 
20482 
  def __init__(self, success=None,):
20483 
    self.success = success
20484 
 
20485 
  def read(self, iprot):
20486 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20487 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20488 
      return
20489 
    iprot.readStructBegin()
20490 
    while True:
20491 
      (fname, ftype, fid) = iprot.readFieldBegin()
20492 
      if ftype == TType.STOP:
20493 
        break
20494 
      if fid == 0:
20495 
        if ftype == TType.I64:
20496 
          self.success = iprot.readI64();
20497 
        else:
20498 
          iprot.skip(ftype)
20499 
      else:
20500 
        iprot.skip(ftype)
20501 
      iprot.readFieldEnd()
20502 
    iprot.readStructEnd()
20503 
 
20504 
  def write(self, oprot):
20505 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20506 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20507 
      return
20508 
    oprot.writeStructBegin('getVoucherAmount_result')
20509 
    if self.success is not None:
20510 
      oprot.writeFieldBegin('success', TType.I64, 0)
20511 
      oprot.writeI64(self.success)
20512 
      oprot.writeFieldEnd()
20513 
    oprot.writeFieldStop()
20514 
    oprot.writeStructEnd()
20515 
 
20516 
  def validate(self):
20517 
    return
20518 
 
20519 
 
20520 
  def __repr__(self):
20521 
    L = ['%s=%r' % (key, value)
20522 
      for key, value in self.__dict__.iteritems()]
20523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20524 
 
20525 
  def __eq__(self, other):
20526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20527 
 
20528 
  def __ne__(self, other):
20529 
    return not (self == other)
20530 
 
20531 
class getAllItemVouchers_args:
20532 
  """
20533 
  Attributes:
20534 
   - itemId
20535 
  """
20536 
 
20537 
  thrift_spec = (
20538 
    None, # 0
20539 
    (1, TType.I64, 'itemId', None, None, ), # 1
20540 
  )
20541 
 
20542 
  def __init__(self, itemId=None,):
20543 
    self.itemId = itemId
20544 
 
20545 
  def read(self, iprot):
20546 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20547 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20548 
      return
20549 
    iprot.readStructBegin()
20550 
    while True:
20551 
      (fname, ftype, fid) = iprot.readFieldBegin()
20552 
      if ftype == TType.STOP:
20553 
        break
20554 
      if fid == 1:
20555 
        if ftype == TType.I64:
20556 
          self.itemId = iprot.readI64();
20557 
        else:
20558 
          iprot.skip(ftype)
20559 
      else:
20560 
        iprot.skip(ftype)
20561 
      iprot.readFieldEnd()
20562 
    iprot.readStructEnd()
20563 
 
20564 
  def write(self, oprot):
20565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20567 
      return
20568 
    oprot.writeStructBegin('getAllItemVouchers_args')
20569 
    if self.itemId is not None:
20570 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20571 
      oprot.writeI64(self.itemId)
20572 
      oprot.writeFieldEnd()
20573 
    oprot.writeFieldStop()
20574 
    oprot.writeStructEnd()
20575 
 
20576 
  def validate(self):
20577 
    return
20578 
 
20579 
 
20580 
  def __repr__(self):
20581 
    L = ['%s=%r' % (key, value)
20582 
      for key, value in self.__dict__.iteritems()]
20583 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20584 
 
20585 
  def __eq__(self, other):
20586 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20587 
 
20588 
  def __ne__(self, other):
20589 
    return not (self == other)
20590 
 
20591 
class getAllItemVouchers_result:
20592 
  """
20593 
  Attributes:
20594 
   - success
20595 
  """
20596 
 
20597 
  thrift_spec = (
20598 
    (0, TType.LIST, 'success', (TType.STRUCT,(VoucherItemMapping, VoucherItemMapping.thrift_spec)), None, ), # 0
20599 
  )
20600 
 
20601 
  def __init__(self, success=None,):
20602 
    self.success = success
20603 
 
20604 
  def read(self, iprot):
20605 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20606 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20607 
      return
20608 
    iprot.readStructBegin()
20609 
    while True:
20610 
      (fname, ftype, fid) = iprot.readFieldBegin()
20611 
      if ftype == TType.STOP:
20612 
        break
20613 
      if fid == 0:
20614 
        if ftype == TType.LIST:
20615 
          self.success = []
13493 amit.gupta 20616 
          (_etype388, _size385) = iprot.readListBegin()
20617 
          for _i389 in xrange(_size385):
20618 
            _elem390 = VoucherItemMapping()
20619 
            _elem390.read(iprot)
20620 
            self.success.append(_elem390)
5944 mandeep.dh 20621 
          iprot.readListEnd()
20622 
        else:
20623 
          iprot.skip(ftype)
20624 
      else:
20625 
        iprot.skip(ftype)
20626 
      iprot.readFieldEnd()
20627 
    iprot.readStructEnd()
20628 
 
20629 
  def write(self, oprot):
20630 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20631 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20632 
      return
20633 
    oprot.writeStructBegin('getAllItemVouchers_result')
20634 
    if self.success is not None:
20635 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20636 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 20637 
      for iter391 in self.success:
20638 
        iter391.write(oprot)
5944 mandeep.dh 20639 
      oprot.writeListEnd()
20640 
      oprot.writeFieldEnd()
20641 
    oprot.writeFieldStop()
20642 
    oprot.writeStructEnd()
20643 
 
20644 
  def validate(self):
20645 
    return
20646 
 
20647 
 
20648 
  def __repr__(self):
20649 
    L = ['%s=%r' % (key, value)
20650 
      for key, value in self.__dict__.iteritems()]
20651 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20652 
 
20653 
  def __eq__(self, other):
20654 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20655 
 
20656 
  def __ne__(self, other):
20657 
    return not (self == other)
20658 
 
20659 
class isValidCatalogItemId_args:
20660 
  """
20661 
  Attributes:
20662 
   - catalog_item_id
20663 
  """
20664 
 
20665 
  thrift_spec = (
20666 
    None, # 0
20667 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
20668 
  )
20669 
 
20670 
  def __init__(self, catalog_item_id=None,):
20671 
    self.catalog_item_id = catalog_item_id
20672 
 
20673 
  def read(self, iprot):
20674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20676 
      return
20677 
    iprot.readStructBegin()
20678 
    while True:
20679 
      (fname, ftype, fid) = iprot.readFieldBegin()
20680 
      if ftype == TType.STOP:
20681 
        break
20682 
      if fid == 1:
20683 
        if ftype == TType.I64:
20684 
          self.catalog_item_id = iprot.readI64();
20685 
        else:
20686 
          iprot.skip(ftype)
20687 
      else:
20688 
        iprot.skip(ftype)
20689 
      iprot.readFieldEnd()
20690 
    iprot.readStructEnd()
20691 
 
20692 
  def write(self, oprot):
20693 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20694 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20695 
      return
20696 
    oprot.writeStructBegin('isValidCatalogItemId_args')
20697 
    if self.catalog_item_id is not None:
20698 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
20699 
      oprot.writeI64(self.catalog_item_id)
20700 
      oprot.writeFieldEnd()
20701 
    oprot.writeFieldStop()
20702 
    oprot.writeStructEnd()
20703 
 
20704 
  def validate(self):
20705 
    return
20706 
 
20707 
 
20708 
  def __repr__(self):
20709 
    L = ['%s=%r' % (key, value)
20710 
      for key, value in self.__dict__.iteritems()]
20711 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20712 
 
20713 
  def __eq__(self, other):
20714 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20715 
 
20716 
  def __ne__(self, other):
20717 
    return not (self == other)
20718 
 
20719 
class isValidCatalogItemId_result:
20720 
  """
20721 
  Attributes:
20722 
   - success
20723 
  """
20724 
 
20725 
  thrift_spec = (
20726 
    (0, TType.BOOL, 'success', None, None, ), # 0
20727 
  )
20728 
 
20729 
  def __init__(self, success=None,):
20730 
    self.success = success
20731 
 
20732 
  def read(self, iprot):
20733 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20734 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20735 
      return
20736 
    iprot.readStructBegin()
20737 
    while True:
20738 
      (fname, ftype, fid) = iprot.readFieldBegin()
20739 
      if ftype == TType.STOP:
20740 
        break
20741 
      if fid == 0:
20742 
        if ftype == TType.BOOL:
20743 
          self.success = iprot.readBool();
20744 
        else:
20745 
          iprot.skip(ftype)
20746 
      else:
20747 
        iprot.skip(ftype)
20748 
      iprot.readFieldEnd()
20749 
    iprot.readStructEnd()
20750 
 
20751 
  def write(self, oprot):
20752 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20753 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20754 
      return
20755 
    oprot.writeStructBegin('isValidCatalogItemId_result')
20756 
    if self.success is not None:
20757 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20758 
      oprot.writeBool(self.success)
20759 
      oprot.writeFieldEnd()
20760 
    oprot.writeFieldStop()
20761 
    oprot.writeStructEnd()
20762 
 
20763 
  def validate(self):
20764 
    return
20765 
 
20766 
 
20767 
  def __repr__(self):
20768 
    L = ['%s=%r' % (key, value)
20769 
      for key, value in self.__dict__.iteritems()]
20770 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20771 
 
20772 
  def __eq__(self, other):
20773 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20774 
 
20775 
  def __ne__(self, other):
20776 
    return not (self == other)
6039 amit.gupta 20777 
 
20778 
class getVatPercentageForItem_args:
20779 
  """
20780 
  Attributes:
20781 
   - itemId
7330 amit.gupta 20782 
   - stateId
6039 amit.gupta 20783 
   - price
20784 
  """
20785 
 
20786 
  thrift_spec = (
20787 
    None, # 0
20788 
    (1, TType.I64, 'itemId', None, None, ), # 1
7330 amit.gupta 20789 
    (2, TType.I64, 'stateId', None, None, ), # 2
20790 
    (3, TType.DOUBLE, 'price', None, None, ), # 3
6039 amit.gupta 20791 
  )
20792 
 
7330 amit.gupta 20793 
  def __init__(self, itemId=None, stateId=None, price=None,):
6039 amit.gupta 20794 
    self.itemId = itemId
7330 amit.gupta 20795 
    self.stateId = stateId
6039 amit.gupta 20796 
    self.price = price
20797 
 
20798 
  def read(self, iprot):
20799 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20800 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20801 
      return
20802 
    iprot.readStructBegin()
20803 
    while True:
20804 
      (fname, ftype, fid) = iprot.readFieldBegin()
20805 
      if ftype == TType.STOP:
20806 
        break
20807 
      if fid == 1:
20808 
        if ftype == TType.I64:
20809 
          self.itemId = iprot.readI64();
20810 
        else:
20811 
          iprot.skip(ftype)
20812 
      elif fid == 2:
7330 amit.gupta 20813 
        if ftype == TType.I64:
20814 
          self.stateId = iprot.readI64();
20815 
        else:
20816 
          iprot.skip(ftype)
20817 
      elif fid == 3:
6039 amit.gupta 20818 
        if ftype == TType.DOUBLE:
20819 
          self.price = iprot.readDouble();
20820 
        else:
20821 
          iprot.skip(ftype)
20822 
      else:
20823 
        iprot.skip(ftype)
20824 
      iprot.readFieldEnd()
20825 
    iprot.readStructEnd()
20826 
 
20827 
  def write(self, oprot):
20828 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20829 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20830 
      return
20831 
    oprot.writeStructBegin('getVatPercentageForItem_args')
20832 
    if self.itemId is not None:
20833 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20834 
      oprot.writeI64(self.itemId)
20835 
      oprot.writeFieldEnd()
7330 amit.gupta 20836 
    if self.stateId is not None:
20837 
      oprot.writeFieldBegin('stateId', TType.I64, 2)
20838 
      oprot.writeI64(self.stateId)
20839 
      oprot.writeFieldEnd()
6039 amit.gupta 20840 
    if self.price is not None:
7330 amit.gupta 20841 
      oprot.writeFieldBegin('price', TType.DOUBLE, 3)
6039 amit.gupta 20842 
      oprot.writeDouble(self.price)
20843 
      oprot.writeFieldEnd()
20844 
    oprot.writeFieldStop()
20845 
    oprot.writeStructEnd()
20846 
 
20847 
  def validate(self):
20848 
    return
20849 
 
20850 
 
20851 
  def __repr__(self):
20852 
    L = ['%s=%r' % (key, value)
20853 
      for key, value in self.__dict__.iteritems()]
20854 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20855 
 
20856 
  def __eq__(self, other):
20857 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20858 
 
20859 
  def __ne__(self, other):
20860 
    return not (self == other)
20861 
 
20862 
class getVatPercentageForItem_result:
20863 
  """
20864 
  Attributes:
20865 
   - success
7340 amit.gupta 20866 
   - cex
6039 amit.gupta 20867 
  """
20868 
 
20869 
  thrift_spec = (
20870 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
7340 amit.gupta 20871 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6039 amit.gupta 20872 
  )
20873 
 
7340 amit.gupta 20874 
  def __init__(self, success=None, cex=None,):
6039 amit.gupta 20875 
    self.success = success
7340 amit.gupta 20876 
    self.cex = cex
6039 amit.gupta 20877 
 
20878 
  def read(self, iprot):
20879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20881 
      return
20882 
    iprot.readStructBegin()
20883 
    while True:
20884 
      (fname, ftype, fid) = iprot.readFieldBegin()
20885 
      if ftype == TType.STOP:
20886 
        break
20887 
      if fid == 0:
20888 
        if ftype == TType.DOUBLE:
20889 
          self.success = iprot.readDouble();
20890 
        else:
20891 
          iprot.skip(ftype)
7340 amit.gupta 20892 
      elif fid == 1:
20893 
        if ftype == TType.STRUCT:
20894 
          self.cex = CatalogServiceException()
20895 
          self.cex.read(iprot)
20896 
        else:
20897 
          iprot.skip(ftype)
6039 amit.gupta 20898 
      else:
20899 
        iprot.skip(ftype)
20900 
      iprot.readFieldEnd()
20901 
    iprot.readStructEnd()
20902 
 
20903 
  def write(self, oprot):
20904 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20905 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20906 
      return
20907 
    oprot.writeStructBegin('getVatPercentageForItem_result')
20908 
    if self.success is not None:
20909 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
20910 
      oprot.writeDouble(self.success)
20911 
      oprot.writeFieldEnd()
7340 amit.gupta 20912 
    if self.cex is not None:
20913 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
20914 
      self.cex.write(oprot)
20915 
      oprot.writeFieldEnd()
6039 amit.gupta 20916 
    oprot.writeFieldStop()
20917 
    oprot.writeStructEnd()
20918 
 
20919 
  def validate(self):
20920 
    return
20921 
 
20922 
 
20923 
  def __repr__(self):
20924 
    L = ['%s=%r' % (key, value)
20925 
      for key, value in self.__dict__.iteritems()]
20926 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20927 
 
20928 
  def __eq__(self, other):
20929 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20930 
 
20931 
  def __ne__(self, other):
20932 
    return not (self == other)
20933 
 
20934 
class getVatAmountForItem_args:
20935 
  """
20936 
  Attributes:
20937 
   - itemId
20938 
   - price
20939 
  """
20940 
 
20941 
  thrift_spec = (
20942 
    None, # 0
20943 
    (1, TType.I64, 'itemId', None, None, ), # 1
20944 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
20945 
  )
20946 
 
20947 
  def __init__(self, itemId=None, price=None,):
20948 
    self.itemId = itemId
20949 
    self.price = price
20950 
 
20951 
  def read(self, iprot):
20952 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20953 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20954 
      return
20955 
    iprot.readStructBegin()
20956 
    while True:
20957 
      (fname, ftype, fid) = iprot.readFieldBegin()
20958 
      if ftype == TType.STOP:
20959 
        break
20960 
      if fid == 1:
20961 
        if ftype == TType.I64:
20962 
          self.itemId = iprot.readI64();
20963 
        else:
20964 
          iprot.skip(ftype)
20965 
      elif fid == 2:
20966 
        if ftype == TType.DOUBLE:
20967 
          self.price = iprot.readDouble();
20968 
        else:
20969 
          iprot.skip(ftype)
20970 
      else:
20971 
        iprot.skip(ftype)
20972 
      iprot.readFieldEnd()
20973 
    iprot.readStructEnd()
20974 
 
20975 
  def write(self, oprot):
20976 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20977 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20978 
      return
20979 
    oprot.writeStructBegin('getVatAmountForItem_args')
20980 
    if self.itemId is not None:
20981 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20982 
      oprot.writeI64(self.itemId)
20983 
      oprot.writeFieldEnd()
20984 
    if self.price is not None:
20985 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
20986 
      oprot.writeDouble(self.price)
20987 
      oprot.writeFieldEnd()
20988 
    oprot.writeFieldStop()
20989 
    oprot.writeStructEnd()
20990 
 
20991 
  def validate(self):
20992 
    return
20993 
 
20994 
 
20995 
  def __repr__(self):
20996 
    L = ['%s=%r' % (key, value)
20997 
      for key, value in self.__dict__.iteritems()]
20998 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20999 
 
21000 
  def __eq__(self, other):
21001 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21002 
 
21003 
  def __ne__(self, other):
21004 
    return not (self == other)
21005 
 
21006 
class getVatAmountForItem_result:
21007 
  """
21008 
  Attributes:
21009 
   - success
21010 
  """
21011 
 
21012 
  thrift_spec = (
21013 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
21014 
  )
21015 
 
21016 
  def __init__(self, success=None,):
21017 
    self.success = success
21018 
 
21019 
  def read(self, iprot):
21020 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21021 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21022 
      return
21023 
    iprot.readStructBegin()
21024 
    while True:
21025 
      (fname, ftype, fid) = iprot.readFieldBegin()
21026 
      if ftype == TType.STOP:
21027 
        break
21028 
      if fid == 0:
21029 
        if ftype == TType.DOUBLE:
21030 
          self.success = iprot.readDouble();
21031 
        else:
21032 
          iprot.skip(ftype)
21033 
      else:
21034 
        iprot.skip(ftype)
21035 
      iprot.readFieldEnd()
21036 
    iprot.readStructEnd()
21037 
 
21038 
  def write(self, oprot):
21039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21041 
      return
21042 
    oprot.writeStructBegin('getVatAmountForItem_result')
21043 
    if self.success is not None:
21044 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
21045 
      oprot.writeDouble(self.success)
21046 
      oprot.writeFieldEnd()
21047 
    oprot.writeFieldStop()
21048 
    oprot.writeStructEnd()
21049 
 
21050 
  def validate(self):
21051 
    return
21052 
 
21053 
 
21054 
  def __repr__(self):
21055 
    L = ['%s=%r' % (key, value)
21056 
      for key, value in self.__dict__.iteritems()]
21057 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21058 
 
21059 
  def __eq__(self, other):
21060 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21061 
 
21062 
  def __ne__(self, other):
21063 
    return not (self == other)
6531 vikram.rag 21064 
 
21065 
class getAllIgnoredInventoryUpdateItemsList_args:
21066 
  """
21067 
  Attributes:
21068 
   - offset
21069 
   - limit
21070 
  """
21071 
 
21072 
  thrift_spec = (
21073 
    None, # 0
21074 
    (1, TType.I32, 'offset', None, None, ), # 1
21075 
    (2, TType.I32, 'limit', None, None, ), # 2
21076 
  )
21077 
 
21078 
  def __init__(self, offset=None, limit=None,):
21079 
    self.offset = offset
21080 
    self.limit = limit
21081 
 
21082 
  def read(self, iprot):
21083 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21084 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21085 
      return
21086 
    iprot.readStructBegin()
21087 
    while True:
21088 
      (fname, ftype, fid) = iprot.readFieldBegin()
21089 
      if ftype == TType.STOP:
21090 
        break
21091 
      if fid == 1:
21092 
        if ftype == TType.I32:
21093 
          self.offset = iprot.readI32();
21094 
        else:
21095 
          iprot.skip(ftype)
21096 
      elif fid == 2:
21097 
        if ftype == TType.I32:
21098 
          self.limit = iprot.readI32();
21099 
        else:
21100 
          iprot.skip(ftype)
21101 
      else:
21102 
        iprot.skip(ftype)
21103 
      iprot.readFieldEnd()
21104 
    iprot.readStructEnd()
21105 
 
21106 
  def write(self, oprot):
21107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21109 
      return
21110 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_args')
21111 
    if self.offset is not None:
21112 
      oprot.writeFieldBegin('offset', TType.I32, 1)
21113 
      oprot.writeI32(self.offset)
21114 
      oprot.writeFieldEnd()
21115 
    if self.limit is not None:
21116 
      oprot.writeFieldBegin('limit', TType.I32, 2)
21117 
      oprot.writeI32(self.limit)
21118 
      oprot.writeFieldEnd()
21119 
    oprot.writeFieldStop()
21120 
    oprot.writeStructEnd()
21121 
 
21122 
  def validate(self):
21123 
    return
21124 
 
21125 
 
21126 
  def __repr__(self):
21127 
    L = ['%s=%r' % (key, value)
21128 
      for key, value in self.__dict__.iteritems()]
21129 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21130 
 
21131 
  def __eq__(self, other):
21132 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21133 
 
21134 
  def __ne__(self, other):
21135 
    return not (self == other)
21136 
 
21137 
class getAllIgnoredInventoryUpdateItemsList_result:
21138 
  """
21139 
  Attributes:
21140 
   - success
21141 
  """
21142 
 
21143 
  thrift_spec = (
21144 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
21145 
  )
21146 
 
21147 
  def __init__(self, success=None,):
21148 
    self.success = success
21149 
 
21150 
  def read(self, iprot):
21151 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21152 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21153 
      return
21154 
    iprot.readStructBegin()
21155 
    while True:
21156 
      (fname, ftype, fid) = iprot.readFieldBegin()
21157 
      if ftype == TType.STOP:
21158 
        break
21159 
      if fid == 0:
21160 
        if ftype == TType.LIST:
21161 
          self.success = []
13493 amit.gupta 21162 
          (_etype395, _size392) = iprot.readListBegin()
21163 
          for _i396 in xrange(_size392):
21164 
            _elem397 = Item()
21165 
            _elem397.read(iprot)
21166 
            self.success.append(_elem397)
6531 vikram.rag 21167 
          iprot.readListEnd()
21168 
        else:
21169 
          iprot.skip(ftype)
21170 
      else:
21171 
        iprot.skip(ftype)
21172 
      iprot.readFieldEnd()
21173 
    iprot.readStructEnd()
21174 
 
21175 
  def write(self, oprot):
21176 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21177 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21178 
      return
21179 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_result')
21180 
    if self.success is not None:
21181 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21182 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 21183 
      for iter398 in self.success:
21184 
        iter398.write(oprot)
6531 vikram.rag 21185 
      oprot.writeListEnd()
21186 
      oprot.writeFieldEnd()
21187 
    oprot.writeFieldStop()
21188 
    oprot.writeStructEnd()
21189 
 
21190 
  def validate(self):
21191 
    return
21192 
 
21193 
 
21194 
  def __repr__(self):
21195 
    L = ['%s=%r' % (key, value)
21196 
      for key, value in self.__dict__.iteritems()]
21197 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21198 
 
21199 
  def __eq__(self, other):
21200 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21201 
 
21202 
  def __ne__(self, other):
21203 
    return not (self == other)
6805 anupam.sin 21204 
 
6821 amar.kumar 21205 
class getAllAliveItems_args:
21206 
 
21207 
  thrift_spec = (
21208 
  )
21209 
 
21210 
  def read(self, iprot):
21211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21213 
      return
21214 
    iprot.readStructBegin()
21215 
    while True:
21216 
      (fname, ftype, fid) = iprot.readFieldBegin()
21217 
      if ftype == TType.STOP:
21218 
        break
21219 
      else:
21220 
        iprot.skip(ftype)
21221 
      iprot.readFieldEnd()
21222 
    iprot.readStructEnd()
21223 
 
21224 
  def write(self, oprot):
21225 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21226 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21227 
      return
21228 
    oprot.writeStructBegin('getAllAliveItems_args')
21229 
    oprot.writeFieldStop()
21230 
    oprot.writeStructEnd()
21231 
 
21232 
  def validate(self):
21233 
    return
21234 
 
21235 
 
21236 
  def __repr__(self):
21237 
    L = ['%s=%r' % (key, value)
21238 
      for key, value in self.__dict__.iteritems()]
21239 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21240 
 
21241 
  def __eq__(self, other):
21242 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21243 
 
21244 
  def __ne__(self, other):
21245 
    return not (self == other)
21246 
 
21247 
class getAllAliveItems_result:
21248 
  """
21249 
  Attributes:
21250 
   - success
21251 
  """
21252 
 
21253 
  thrift_spec = (
21254 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
21255 
  )
21256 
 
21257 
  def __init__(self, success=None,):
21258 
    self.success = success
21259 
 
21260 
  def read(self, iprot):
21261 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21262 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21263 
      return
21264 
    iprot.readStructBegin()
21265 
    while True:
21266 
      (fname, ftype, fid) = iprot.readFieldBegin()
21267 
      if ftype == TType.STOP:
21268 
        break
21269 
      if fid == 0:
21270 
        if ftype == TType.LIST:
21271 
          self.success = []
13493 amit.gupta 21272 
          (_etype402, _size399) = iprot.readListBegin()
21273 
          for _i403 in xrange(_size399):
21274 
            _elem404 = Item()
21275 
            _elem404.read(iprot)
21276 
            self.success.append(_elem404)
6821 amar.kumar 21277 
          iprot.readListEnd()
21278 
        else:
21279 
          iprot.skip(ftype)
21280 
      else:
21281 
        iprot.skip(ftype)
21282 
      iprot.readFieldEnd()
21283 
    iprot.readStructEnd()
21284 
 
21285 
  def write(self, oprot):
21286 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21287 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21288 
      return
21289 
    oprot.writeStructBegin('getAllAliveItems_result')
21290 
    if self.success is not None:
21291 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21292 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 21293 
      for iter405 in self.success:
21294 
        iter405.write(oprot)
6821 amar.kumar 21295 
      oprot.writeListEnd()
21296 
      oprot.writeFieldEnd()
21297 
    oprot.writeFieldStop()
21298 
    oprot.writeStructEnd()
21299 
 
21300 
  def validate(self):
21301 
    return
21302 
 
21303 
 
21304 
  def __repr__(self):
21305 
    L = ['%s=%r' % (key, value)
21306 
      for key, value in self.__dict__.iteritems()]
21307 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21308 
 
21309 
  def __eq__(self, other):
21310 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21311 
 
21312 
  def __ne__(self, other):
21313 
    return not (self == other)
21314 
 
6805 anupam.sin 21315 
class getInsuranceAmount_args:
21316 
  """
21317 
  Attributes:
21318 
   - itemId
6921 anupam.sin 21319 
   - price
6805 anupam.sin 21320 
   - insurerId
21321 
   - quantity
21322 
  """
21323 
 
21324 
  thrift_spec = (
21325 
    None, # 0
21326 
    (1, TType.I64, 'itemId', None, None, ), # 1
6921 anupam.sin 21327 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
21328 
    (3, TType.I64, 'insurerId', None, None, ), # 3
21329 
    (4, TType.I64, 'quantity', None, None, ), # 4
6805 anupam.sin 21330 
  )
21331 
 
6921 anupam.sin 21332 
  def __init__(self, itemId=None, price=None, insurerId=None, quantity=None,):
6805 anupam.sin 21333 
    self.itemId = itemId
6921 anupam.sin 21334 
    self.price = price
6805 anupam.sin 21335 
    self.insurerId = insurerId
21336 
    self.quantity = quantity
21337 
 
21338 
  def read(self, iprot):
21339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21341 
      return
21342 
    iprot.readStructBegin()
21343 
    while True:
21344 
      (fname, ftype, fid) = iprot.readFieldBegin()
21345 
      if ftype == TType.STOP:
21346 
        break
21347 
      if fid == 1:
21348 
        if ftype == TType.I64:
21349 
          self.itemId = iprot.readI64();
21350 
        else:
21351 
          iprot.skip(ftype)
21352 
      elif fid == 2:
6921 anupam.sin 21353 
        if ftype == TType.DOUBLE:
21354 
          self.price = iprot.readDouble();
21355 
        else:
21356 
          iprot.skip(ftype)
21357 
      elif fid == 3:
6805 anupam.sin 21358 
        if ftype == TType.I64:
21359 
          self.insurerId = iprot.readI64();
21360 
        else:
21361 
          iprot.skip(ftype)
6921 anupam.sin 21362 
      elif fid == 4:
6805 anupam.sin 21363 
        if ftype == TType.I64:
21364 
          self.quantity = iprot.readI64();
21365 
        else:
21366 
          iprot.skip(ftype)
21367 
      else:
21368 
        iprot.skip(ftype)
21369 
      iprot.readFieldEnd()
21370 
    iprot.readStructEnd()
21371 
 
21372 
  def write(self, oprot):
21373 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21374 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21375 
      return
21376 
    oprot.writeStructBegin('getInsuranceAmount_args')
21377 
    if self.itemId is not None:
21378 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
21379 
      oprot.writeI64(self.itemId)
21380 
      oprot.writeFieldEnd()
6921 anupam.sin 21381 
    if self.price is not None:
21382 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
21383 
      oprot.writeDouble(self.price)
21384 
      oprot.writeFieldEnd()
6805 anupam.sin 21385 
    if self.insurerId is not None:
6921 anupam.sin 21386 
      oprot.writeFieldBegin('insurerId', TType.I64, 3)
6805 anupam.sin 21387 
      oprot.writeI64(self.insurerId)
21388 
      oprot.writeFieldEnd()
21389 
    if self.quantity is not None:
6921 anupam.sin 21390 
      oprot.writeFieldBegin('quantity', TType.I64, 4)
6805 anupam.sin 21391 
      oprot.writeI64(self.quantity)
21392 
      oprot.writeFieldEnd()
21393 
    oprot.writeFieldStop()
21394 
    oprot.writeStructEnd()
21395 
 
21396 
  def validate(self):
21397 
    return
21398 
 
21399 
 
21400 
  def __repr__(self):
21401 
    L = ['%s=%r' % (key, value)
21402 
      for key, value in self.__dict__.iteritems()]
21403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21404 
 
21405 
  def __eq__(self, other):
21406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21407 
 
21408 
  def __ne__(self, other):
21409 
    return not (self == other)
21410 
 
21411 
class getInsuranceAmount_result:
21412 
  """
21413 
  Attributes:
21414 
   - success
21415 
  """
21416 
 
21417 
  thrift_spec = (
21418 
    (0, TType.I64, 'success', None, None, ), # 0
21419 
  )
21420 
 
21421 
  def __init__(self, success=None,):
21422 
    self.success = success
21423 
 
21424 
  def read(self, iprot):
21425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21427 
      return
21428 
    iprot.readStructBegin()
21429 
    while True:
21430 
      (fname, ftype, fid) = iprot.readFieldBegin()
21431 
      if ftype == TType.STOP:
21432 
        break
21433 
      if fid == 0:
21434 
        if ftype == TType.I64:
21435 
          self.success = iprot.readI64();
21436 
        else:
21437 
          iprot.skip(ftype)
21438 
      else:
21439 
        iprot.skip(ftype)
21440 
      iprot.readFieldEnd()
21441 
    iprot.readStructEnd()
21442 
 
21443 
  def write(self, oprot):
21444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21446 
      return
21447 
    oprot.writeStructBegin('getInsuranceAmount_result')
21448 
    if self.success is not None:
21449 
      oprot.writeFieldBegin('success', TType.I64, 0)
21450 
      oprot.writeI64(self.success)
21451 
      oprot.writeFieldEnd()
21452 
    oprot.writeFieldStop()
21453 
    oprot.writeStructEnd()
21454 
 
21455 
  def validate(self):
21456 
    return
21457 
 
21458 
 
21459 
  def __repr__(self):
21460 
    L = ['%s=%r' % (key, value)
21461 
      for key, value in self.__dict__.iteritems()]
21462 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21463 
 
21464 
  def __eq__(self, other):
21465 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21466 
 
21467 
  def __ne__(self, other):
21468 
    return not (self == other)
21469 
 
21470 
class getInsurer_args:
21471 
  """
21472 
  Attributes:
21473 
   - insurerId
21474 
  """
21475 
 
21476 
  thrift_spec = (
21477 
    None, # 0
21478 
    (1, TType.I64, 'insurerId', None, None, ), # 1
21479 
  )
21480 
 
21481 
  def __init__(self, insurerId=None,):
21482 
    self.insurerId = insurerId
21483 
 
21484 
  def read(self, iprot):
21485 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21486 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21487 
      return
21488 
    iprot.readStructBegin()
21489 
    while True:
21490 
      (fname, ftype, fid) = iprot.readFieldBegin()
21491 
      if ftype == TType.STOP:
21492 
        break
21493 
      if fid == 1:
21494 
        if ftype == TType.I64:
21495 
          self.insurerId = iprot.readI64();
21496 
        else:
21497 
          iprot.skip(ftype)
21498 
      else:
21499 
        iprot.skip(ftype)
21500 
      iprot.readFieldEnd()
21501 
    iprot.readStructEnd()
21502 
 
21503 
  def write(self, oprot):
21504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21506 
      return
21507 
    oprot.writeStructBegin('getInsurer_args')
21508 
    if self.insurerId is not None:
21509 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
21510 
      oprot.writeI64(self.insurerId)
21511 
      oprot.writeFieldEnd()
21512 
    oprot.writeFieldStop()
21513 
    oprot.writeStructEnd()
21514 
 
21515 
  def validate(self):
21516 
    return
21517 
 
21518 
 
21519 
  def __repr__(self):
21520 
    L = ['%s=%r' % (key, value)
21521 
      for key, value in self.__dict__.iteritems()]
21522 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21523 
 
21524 
  def __eq__(self, other):
21525 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21526 
 
21527 
  def __ne__(self, other):
21528 
    return not (self == other)
21529 
 
21530 
class getInsurer_result:
21531 
  """
21532 
  Attributes:
21533 
   - success
21534 
  """
21535 
 
21536 
  thrift_spec = (
21537 
    (0, TType.STRUCT, 'success', (Insurer, Insurer.thrift_spec), None, ), # 0
21538 
  )
21539 
 
21540 
  def __init__(self, success=None,):
21541 
    self.success = success
21542 
 
21543 
  def read(self, iprot):
21544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21546 
      return
21547 
    iprot.readStructBegin()
21548 
    while True:
21549 
      (fname, ftype, fid) = iprot.readFieldBegin()
21550 
      if ftype == TType.STOP:
21551 
        break
21552 
      if fid == 0:
21553 
        if ftype == TType.STRUCT:
21554 
          self.success = Insurer()
21555 
          self.success.read(iprot)
21556 
        else:
21557 
          iprot.skip(ftype)
21558 
      else:
21559 
        iprot.skip(ftype)
21560 
      iprot.readFieldEnd()
21561 
    iprot.readStructEnd()
21562 
 
21563 
  def write(self, oprot):
21564 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21565 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21566 
      return
21567 
    oprot.writeStructBegin('getInsurer_result')
21568 
    if self.success is not None:
21569 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21570 
      self.success.write(oprot)
21571 
      oprot.writeFieldEnd()
21572 
    oprot.writeFieldStop()
21573 
    oprot.writeStructEnd()
21574 
 
21575 
  def validate(self):
21576 
    return
21577 
 
21578 
 
21579 
  def __repr__(self):
21580 
    L = ['%s=%r' % (key, value)
21581 
      for key, value in self.__dict__.iteritems()]
21582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21583 
 
21584 
  def __eq__(self, other):
21585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21586 
 
21587 
  def __ne__(self, other):
21588 
    return not (self == other)
6838 vikram.rag 21589 
 
21590 
class getAllInsurers_args:
21591 
 
21592 
  thrift_spec = (
21593 
  )
21594 
 
21595 
  def read(self, iprot):
21596 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21597 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21598 
      return
21599 
    iprot.readStructBegin()
21600 
    while True:
21601 
      (fname, ftype, fid) = iprot.readFieldBegin()
21602 
      if ftype == TType.STOP:
21603 
        break
21604 
      else:
21605 
        iprot.skip(ftype)
21606 
      iprot.readFieldEnd()
21607 
    iprot.readStructEnd()
21608 
 
21609 
  def write(self, oprot):
21610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21612 
      return
21613 
    oprot.writeStructBegin('getAllInsurers_args')
21614 
    oprot.writeFieldStop()
21615 
    oprot.writeStructEnd()
21616 
 
21617 
  def validate(self):
21618 
    return
21619 
 
21620 
 
21621 
  def __repr__(self):
21622 
    L = ['%s=%r' % (key, value)
21623 
      for key, value in self.__dict__.iteritems()]
21624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21625 
 
21626 
  def __eq__(self, other):
21627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21628 
 
21629 
  def __ne__(self, other):
21630 
    return not (self == other)
21631 
 
21632 
class getAllInsurers_result:
21633 
  """
21634 
  Attributes:
21635 
   - success
21636 
  """
21637 
 
21638 
  thrift_spec = (
21639 
    (0, TType.LIST, 'success', (TType.STRUCT,(Insurer, Insurer.thrift_spec)), None, ), # 0
21640 
  )
21641 
 
21642 
  def __init__(self, success=None,):
21643 
    self.success = success
21644 
 
21645 
  def read(self, iprot):
21646 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21647 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21648 
      return
21649 
    iprot.readStructBegin()
21650 
    while True:
21651 
      (fname, ftype, fid) = iprot.readFieldBegin()
21652 
      if ftype == TType.STOP:
21653 
        break
21654 
      if fid == 0:
21655 
        if ftype == TType.LIST:
21656 
          self.success = []
13493 amit.gupta 21657 
          (_etype409, _size406) = iprot.readListBegin()
21658 
          for _i410 in xrange(_size406):
21659 
            _elem411 = Insurer()
21660 
            _elem411.read(iprot)
21661 
            self.success.append(_elem411)
6838 vikram.rag 21662 
          iprot.readListEnd()
21663 
        else:
21664 
          iprot.skip(ftype)
21665 
      else:
21666 
        iprot.skip(ftype)
21667 
      iprot.readFieldEnd()
21668 
    iprot.readStructEnd()
21669 
 
21670 
  def write(self, oprot):
21671 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21672 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21673 
      return
21674 
    oprot.writeStructBegin('getAllInsurers_result')
21675 
    if self.success is not None:
21676 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21677 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 21678 
      for iter412 in self.success:
21679 
        iter412.write(oprot)
6838 vikram.rag 21680 
      oprot.writeListEnd()
21681 
      oprot.writeFieldEnd()
21682 
    oprot.writeFieldStop()
21683 
    oprot.writeStructEnd()
21684 
 
21685 
  def validate(self):
21686 
    return
21687 
 
21688 
 
21689 
  def __repr__(self):
21690 
    L = ['%s=%r' % (key, value)
21691 
      for key, value in self.__dict__.iteritems()]
21692 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21693 
 
21694 
  def __eq__(self, other):
21695 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21696 
 
21697 
  def __ne__(self, other):
21698 
    return not (self == other)
6962 rajveer 21699 
 
21700 
class updateInsuranceDeclaredAmount_args:
21701 
  """
21702 
  Attributes:
21703 
   - insurerId
21704 
   - amount
21705 
  """
21706 
 
21707 
  thrift_spec = (
21708 
    None, # 0
21709 
    (1, TType.I64, 'insurerId', None, None, ), # 1
21710 
    (2, TType.DOUBLE, 'amount', None, None, ), # 2
21711 
  )
21712 
 
21713 
  def __init__(self, insurerId=None, amount=None,):
21714 
    self.insurerId = insurerId
21715 
    self.amount = amount
21716 
 
21717 
  def read(self, iprot):
21718 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21719 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21720 
      return
21721 
    iprot.readStructBegin()
21722 
    while True:
21723 
      (fname, ftype, fid) = iprot.readFieldBegin()
21724 
      if ftype == TType.STOP:
21725 
        break
21726 
      if fid == 1:
21727 
        if ftype == TType.I64:
21728 
          self.insurerId = iprot.readI64();
21729 
        else:
21730 
          iprot.skip(ftype)
21731 
      elif fid == 2:
21732 
        if ftype == TType.DOUBLE:
21733 
          self.amount = iprot.readDouble();
21734 
        else:
21735 
          iprot.skip(ftype)
21736 
      else:
21737 
        iprot.skip(ftype)
21738 
      iprot.readFieldEnd()
21739 
    iprot.readStructEnd()
21740 
 
21741 
  def write(self, oprot):
21742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21744 
      return
21745 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_args')
21746 
    if self.insurerId is not None:
21747 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
21748 
      oprot.writeI64(self.insurerId)
21749 
      oprot.writeFieldEnd()
21750 
    if self.amount is not None:
21751 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 2)
21752 
      oprot.writeDouble(self.amount)
21753 
      oprot.writeFieldEnd()
21754 
    oprot.writeFieldStop()
21755 
    oprot.writeStructEnd()
21756 
 
21757 
  def validate(self):
21758 
    return
21759 
 
21760 
 
21761 
  def __repr__(self):
21762 
    L = ['%s=%r' % (key, value)
21763 
      for key, value in self.__dict__.iteritems()]
21764 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21765 
 
21766 
  def __eq__(self, other):
21767 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21768 
 
21769 
  def __ne__(self, other):
21770 
    return not (self == other)
21771 
 
21772 
class updateInsuranceDeclaredAmount_result:
21773 
 
21774 
  thrift_spec = (
21775 
  )
21776 
 
21777 
  def read(self, iprot):
21778 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21779 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21780 
      return
21781 
    iprot.readStructBegin()
21782 
    while True:
21783 
      (fname, ftype, fid) = iprot.readFieldBegin()
21784 
      if ftype == TType.STOP:
21785 
        break
21786 
      else:
21787 
        iprot.skip(ftype)
21788 
      iprot.readFieldEnd()
21789 
    iprot.readStructEnd()
21790 
 
21791 
  def write(self, oprot):
21792 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21793 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21794 
      return
21795 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_result')
21796 
    oprot.writeFieldStop()
21797 
    oprot.writeStructEnd()
21798 
 
21799 
  def validate(self):
21800 
    return
21801 
 
21802 
 
21803 
  def __repr__(self):
21804 
    L = ['%s=%r' % (key, value)
21805 
      for key, value in self.__dict__.iteritems()]
21806 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21807 
 
21808 
  def __eq__(self, other):
21809 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21810 
 
21811 
  def __ne__(self, other):
21812 
    return not (self == other)
7190 amar.kumar 21813 
 
21814 
class getFreebieForItem_args:
21815 
  """
21816 
  Attributes:
21817 
   - itemId
21818 
  """
21819 
 
21820 
  thrift_spec = (
21821 
    None, # 0
21822 
    (1, TType.I64, 'itemId', None, None, ), # 1
21823 
  )
21824 
 
21825 
  def __init__(self, itemId=None,):
21826 
    self.itemId = itemId
21827 
 
21828 
  def read(self, iprot):
21829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21831 
      return
21832 
    iprot.readStructBegin()
21833 
    while True:
21834 
      (fname, ftype, fid) = iprot.readFieldBegin()
21835 
      if ftype == TType.STOP:
21836 
        break
21837 
      if fid == 1:
21838 
        if ftype == TType.I64:
21839 
          self.itemId = iprot.readI64();
21840 
        else:
21841 
          iprot.skip(ftype)
21842 
      else:
21843 
        iprot.skip(ftype)
21844 
      iprot.readFieldEnd()
21845 
    iprot.readStructEnd()
21846 
 
21847 
  def write(self, oprot):
21848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21850 
      return
21851 
    oprot.writeStructBegin('getFreebieForItem_args')
21852 
    if self.itemId is not None:
21853 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
21854 
      oprot.writeI64(self.itemId)
21855 
      oprot.writeFieldEnd()
21856 
    oprot.writeFieldStop()
21857 
    oprot.writeStructEnd()
21858 
 
21859 
  def validate(self):
21860 
    return
21861 
 
21862 
 
21863 
  def __repr__(self):
21864 
    L = ['%s=%r' % (key, value)
21865 
      for key, value in self.__dict__.iteritems()]
21866 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21867 
 
21868 
  def __eq__(self, other):
21869 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21870 
 
21871 
  def __ne__(self, other):
21872 
    return not (self == other)
21873 
 
21874 
class getFreebieForItem_result:
21875 
  """
21876 
  Attributes:
21877 
   - success
21878 
  """
21879 
 
21880 
  thrift_spec = (
21881 
    (0, TType.I64, 'success', None, None, ), # 0
21882 
  )
21883 
 
21884 
  def __init__(self, success=None,):
21885 
    self.success = success
21886 
 
21887 
  def read(self, iprot):
21888 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21889 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21890 
      return
21891 
    iprot.readStructBegin()
21892 
    while True:
21893 
      (fname, ftype, fid) = iprot.readFieldBegin()
21894 
      if ftype == TType.STOP:
21895 
        break
21896 
      if fid == 0:
21897 
        if ftype == TType.I64:
21898 
          self.success = iprot.readI64();
21899 
        else:
21900 
          iprot.skip(ftype)
21901 
      else:
21902 
        iprot.skip(ftype)
21903 
      iprot.readFieldEnd()
21904 
    iprot.readStructEnd()
21905 
 
21906 
  def write(self, oprot):
21907 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21908 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21909 
      return
21910 
    oprot.writeStructBegin('getFreebieForItem_result')
21911 
    if self.success is not None:
21912 
      oprot.writeFieldBegin('success', TType.I64, 0)
21913 
      oprot.writeI64(self.success)
21914 
      oprot.writeFieldEnd()
21915 
    oprot.writeFieldStop()
21916 
    oprot.writeStructEnd()
21917 
 
21918 
  def validate(self):
21919 
    return
21920 
 
21921 
 
21922 
  def __repr__(self):
21923 
    L = ['%s=%r' % (key, value)
21924 
      for key, value in self.__dict__.iteritems()]
21925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21926 
 
21927 
  def __eq__(self, other):
21928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21929 
 
21930 
  def __ne__(self, other):
21931 
    return not (self == other)
21932 
 
21933 
class addOrUpdateFreebieForItem_args:
21934 
  """
21935 
  Attributes:
21936 
   - freebieItem
21937 
  """
21938 
 
21939 
  thrift_spec = (
21940 
    None, # 0
21941 
    (1, TType.STRUCT, 'freebieItem', (FreebieItem, FreebieItem.thrift_spec), None, ), # 1
21942 
  )
21943 
 
21944 
  def __init__(self, freebieItem=None,):
21945 
    self.freebieItem = freebieItem
21946 
 
21947 
  def read(self, iprot):
21948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21950 
      return
21951 
    iprot.readStructBegin()
21952 
    while True:
21953 
      (fname, ftype, fid) = iprot.readFieldBegin()
21954 
      if ftype == TType.STOP:
21955 
        break
21956 
      if fid == 1:
21957 
        if ftype == TType.STRUCT:
21958 
          self.freebieItem = FreebieItem()
21959 
          self.freebieItem.read(iprot)
21960 
        else:
21961 
          iprot.skip(ftype)
21962 
      else:
21963 
        iprot.skip(ftype)
21964 
      iprot.readFieldEnd()
21965 
    iprot.readStructEnd()
21966 
 
21967 
  def write(self, oprot):
21968 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21969 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21970 
      return
21971 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_args')
21972 
    if self.freebieItem is not None:
21973 
      oprot.writeFieldBegin('freebieItem', TType.STRUCT, 1)
21974 
      self.freebieItem.write(oprot)
21975 
      oprot.writeFieldEnd()
21976 
    oprot.writeFieldStop()
21977 
    oprot.writeStructEnd()
21978 
 
21979 
  def validate(self):
21980 
    return
21981 
 
21982 
 
21983 
  def __repr__(self):
21984 
    L = ['%s=%r' % (key, value)
21985 
      for key, value in self.__dict__.iteritems()]
21986 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21987 
 
21988 
  def __eq__(self, other):
21989 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21990 
 
21991 
  def __ne__(self, other):
21992 
    return not (self == other)
21993 
 
21994 
class addOrUpdateFreebieForItem_result:
21995 
 
21996 
  thrift_spec = (
21997 
  )
21998 
 
21999 
  def read(self, iprot):
22000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22002 
      return
22003 
    iprot.readStructBegin()
22004 
    while True:
22005 
      (fname, ftype, fid) = iprot.readFieldBegin()
22006 
      if ftype == TType.STOP:
22007 
        break
22008 
      else:
22009 
        iprot.skip(ftype)
22010 
      iprot.readFieldEnd()
22011 
    iprot.readStructEnd()
22012 
 
22013 
  def write(self, oprot):
22014 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22015 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22016 
      return
22017 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_result')
22018 
    oprot.writeFieldStop()
22019 
    oprot.writeStructEnd()
22020 
 
22021 
  def validate(self):
22022 
    return
22023 
 
22024 
 
22025 
  def __repr__(self):
22026 
    L = ['%s=%r' % (key, value)
22027 
      for key, value in self.__dict__.iteritems()]
22028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22029 
 
22030 
  def __eq__(self, other):
22031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22032 
 
22033 
  def __ne__(self, other):
22034 
    return not (self == other)
7256 rajveer 22035 
 
7272 amit.gupta 22036 
class addOrUpdateBrandInfo_args:
22037 
  """
22038 
  Attributes:
22039 
   - brandInfo
22040 
  """
22041 
 
22042 
  thrift_spec = (
22043 
    None, # 0
22044 
    (1, TType.STRUCT, 'brandInfo', (BrandInfo, BrandInfo.thrift_spec), None, ), # 1
22045 
  )
22046 
 
22047 
  def __init__(self, brandInfo=None,):
22048 
    self.brandInfo = brandInfo
22049 
 
22050 
  def read(self, iprot):
22051 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22052 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22053 
      return
22054 
    iprot.readStructBegin()
22055 
    while True:
22056 
      (fname, ftype, fid) = iprot.readFieldBegin()
22057 
      if ftype == TType.STOP:
22058 
        break
22059 
      if fid == 1:
22060 
        if ftype == TType.STRUCT:
22061 
          self.brandInfo = BrandInfo()
22062 
          self.brandInfo.read(iprot)
22063 
        else:
22064 
          iprot.skip(ftype)
22065 
      else:
22066 
        iprot.skip(ftype)
22067 
      iprot.readFieldEnd()
22068 
    iprot.readStructEnd()
22069 
 
22070 
  def write(self, oprot):
22071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22073 
      return
22074 
    oprot.writeStructBegin('addOrUpdateBrandInfo_args')
22075 
    if self.brandInfo is not None:
22076 
      oprot.writeFieldBegin('brandInfo', TType.STRUCT, 1)
22077 
      self.brandInfo.write(oprot)
22078 
      oprot.writeFieldEnd()
22079 
    oprot.writeFieldStop()
22080 
    oprot.writeStructEnd()
22081 
 
22082 
  def validate(self):
22083 
    return
22084 
 
22085 
 
22086 
  def __repr__(self):
22087 
    L = ['%s=%r' % (key, value)
22088 
      for key, value in self.__dict__.iteritems()]
22089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22090 
 
22091 
  def __eq__(self, other):
22092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22093 
 
22094 
  def __ne__(self, other):
22095 
    return not (self == other)
22096 
 
22097 
class addOrUpdateBrandInfo_result:
22098 
 
22099 
  thrift_spec = (
22100 
  )
22101 
 
22102 
  def read(self, iprot):
22103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22105 
      return
22106 
    iprot.readStructBegin()
22107 
    while True:
22108 
      (fname, ftype, fid) = iprot.readFieldBegin()
22109 
      if ftype == TType.STOP:
22110 
        break
22111 
      else:
22112 
        iprot.skip(ftype)
22113 
      iprot.readFieldEnd()
22114 
    iprot.readStructEnd()
22115 
 
22116 
  def write(self, oprot):
22117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22119 
      return
22120 
    oprot.writeStructBegin('addOrUpdateBrandInfo_result')
22121 
    oprot.writeFieldStop()
22122 
    oprot.writeStructEnd()
22123 
 
22124 
  def validate(self):
22125 
    return
22126 
 
22127 
 
22128 
  def __repr__(self):
22129 
    L = ['%s=%r' % (key, value)
22130 
      for key, value in self.__dict__.iteritems()]
22131 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22132 
 
22133 
  def __eq__(self, other):
22134 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22135 
 
22136 
  def __ne__(self, other):
22137 
    return not (self == other)
22138 
 
22139 
class getBrandInfo_args:
22140 
 
22141 
  thrift_spec = (
22142 
  )
22143 
 
22144 
  def read(self, iprot):
22145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22147 
      return
22148 
    iprot.readStructBegin()
22149 
    while True:
22150 
      (fname, ftype, fid) = iprot.readFieldBegin()
22151 
      if ftype == TType.STOP:
22152 
        break
22153 
      else:
22154 
        iprot.skip(ftype)
22155 
      iprot.readFieldEnd()
22156 
    iprot.readStructEnd()
22157 
 
22158 
  def write(self, oprot):
22159 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22160 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22161 
      return
22162 
    oprot.writeStructBegin('getBrandInfo_args')
22163 
    oprot.writeFieldStop()
22164 
    oprot.writeStructEnd()
22165 
 
22166 
  def validate(self):
22167 
    return
22168 
 
22169 
 
22170 
  def __repr__(self):
22171 
    L = ['%s=%r' % (key, value)
22172 
      for key, value in self.__dict__.iteritems()]
22173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22174 
 
22175 
  def __eq__(self, other):
22176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22177 
 
22178 
  def __ne__(self, other):
22179 
    return not (self == other)
22180 
 
22181 
class getBrandInfo_result:
22182 
  """
22183 
  Attributes:
22184 
   - success
22185 
  """
22186 
 
22187 
  thrift_spec = (
22188 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(BrandInfo, BrandInfo.thrift_spec)), None, ), # 0
22189 
  )
22190 
 
22191 
  def __init__(self, success=None,):
22192 
    self.success = success
22193 
 
22194 
  def read(self, iprot):
22195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22197 
      return
22198 
    iprot.readStructBegin()
22199 
    while True:
22200 
      (fname, ftype, fid) = iprot.readFieldBegin()
22201 
      if ftype == TType.STOP:
22202 
        break
22203 
      if fid == 0:
22204 
        if ftype == TType.MAP:
22205 
          self.success = {}
13493 amit.gupta 22206 
          (_ktype414, _vtype415, _size413 ) = iprot.readMapBegin()
22207 
          for _i417 in xrange(_size413):
22208 
            _key418 = iprot.readString();
22209 
            _val419 = BrandInfo()
22210 
            _val419.read(iprot)
22211 
            self.success[_key418] = _val419
7272 amit.gupta 22212 
          iprot.readMapEnd()
22213 
        else:
22214 
          iprot.skip(ftype)
22215 
      else:
22216 
        iprot.skip(ftype)
22217 
      iprot.readFieldEnd()
22218 
    iprot.readStructEnd()
22219 
 
22220 
  def write(self, oprot):
22221 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22222 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22223 
      return
22224 
    oprot.writeStructBegin('getBrandInfo_result')
22225 
    if self.success is not None:
22226 
      oprot.writeFieldBegin('success', TType.MAP, 0)
22227 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
13493 amit.gupta 22228 
      for kiter420,viter421 in self.success.items():
22229 
        oprot.writeString(kiter420)
22230 
        viter421.write(oprot)
7272 amit.gupta 22231 
      oprot.writeMapEnd()
22232 
      oprot.writeFieldEnd()
22233 
    oprot.writeFieldStop()
22234 
    oprot.writeStructEnd()
22235 
 
22236 
  def validate(self):
22237 
    return
22238 
 
22239 
 
22240 
  def __repr__(self):
22241 
    L = ['%s=%r' % (key, value)
22242 
      for key, value in self.__dict__.iteritems()]
22243 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22244 
 
22245 
  def __eq__(self, other):
22246 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22247 
 
22248 
  def __ne__(self, other):
22249 
    return not (self == other)
22250 
 
7256 rajveer 22251 
class getStorePricing_args:
22252 
  """
22253 
  Attributes:
22254 
   - itemId
22255 
  """
22256 
 
22257 
  thrift_spec = (
22258 
    None, # 0
22259 
    (1, TType.I64, 'itemId', None, None, ), # 1
22260 
  )
22261 
 
22262 
  def __init__(self, itemId=None,):
22263 
    self.itemId = itemId
22264 
 
22265 
  def read(self, iprot):
22266 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22267 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22268 
      return
22269 
    iprot.readStructBegin()
22270 
    while True:
22271 
      (fname, ftype, fid) = iprot.readFieldBegin()
22272 
      if ftype == TType.STOP:
22273 
        break
22274 
      if fid == 1:
22275 
        if ftype == TType.I64:
22276 
          self.itemId = iprot.readI64();
22277 
        else:
22278 
          iprot.skip(ftype)
22279 
      else:
22280 
        iprot.skip(ftype)
22281 
      iprot.readFieldEnd()
22282 
    iprot.readStructEnd()
22283 
 
22284 
  def write(self, oprot):
22285 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22286 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22287 
      return
22288 
    oprot.writeStructBegin('getStorePricing_args')
22289 
    if self.itemId is not None:
22290 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
22291 
      oprot.writeI64(self.itemId)
22292 
      oprot.writeFieldEnd()
22293 
    oprot.writeFieldStop()
22294 
    oprot.writeStructEnd()
22295 
 
22296 
  def validate(self):
22297 
    return
22298 
 
22299 
 
22300 
  def __repr__(self):
22301 
    L = ['%s=%r' % (key, value)
22302 
      for key, value in self.__dict__.iteritems()]
22303 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22304 
 
22305 
  def __eq__(self, other):
22306 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22307 
 
22308 
  def __ne__(self, other):
22309 
    return not (self == other)
22310 
 
22311 
class getStorePricing_result:
22312 
  """
22313 
  Attributes:
22314 
   - success
22315 
  """
22316 
 
22317 
  thrift_spec = (
22318 
    (0, TType.STRUCT, 'success', (StorePricing, StorePricing.thrift_spec), None, ), # 0
22319 
  )
22320 
 
22321 
  def __init__(self, success=None,):
22322 
    self.success = success
22323 
 
22324 
  def read(self, iprot):
22325 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22326 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22327 
      return
22328 
    iprot.readStructBegin()
22329 
    while True:
22330 
      (fname, ftype, fid) = iprot.readFieldBegin()
22331 
      if ftype == TType.STOP:
22332 
        break
22333 
      if fid == 0:
22334 
        if ftype == TType.STRUCT:
22335 
          self.success = StorePricing()
22336 
          self.success.read(iprot)
22337 
        else:
22338 
          iprot.skip(ftype)
22339 
      else:
22340 
        iprot.skip(ftype)
22341 
      iprot.readFieldEnd()
22342 
    iprot.readStructEnd()
22343 
 
22344 
  def write(self, oprot):
22345 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22346 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22347 
      return
22348 
    oprot.writeStructBegin('getStorePricing_result')
22349 
    if self.success is not None:
22350 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22351 
      self.success.write(oprot)
22352 
      oprot.writeFieldEnd()
22353 
    oprot.writeFieldStop()
22354 
    oprot.writeStructEnd()
22355 
 
22356 
  def validate(self):
22357 
    return
22358 
 
22359 
 
22360 
  def __repr__(self):
22361 
    L = ['%s=%r' % (key, value)
22362 
      for key, value in self.__dict__.iteritems()]
22363 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22364 
 
22365 
  def __eq__(self, other):
22366 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22367 
 
22368 
  def __ne__(self, other):
22369 
    return not (self == other)
7265 rajveer 22370 
 
7306 rajveer 22371 
class getStorePricings_args:
22372 
  """
22373 
  Attributes:
22374 
   - itemIds
22375 
  """
22376 
 
22377 
  thrift_spec = (
22378 
    None, # 0
22379 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
22380 
  )
22381 
 
22382 
  def __init__(self, itemIds=None,):
22383 
    self.itemIds = itemIds
22384 
 
22385 
  def read(self, iprot):
22386 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22387 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22388 
      return
22389 
    iprot.readStructBegin()
22390 
    while True:
22391 
      (fname, ftype, fid) = iprot.readFieldBegin()
22392 
      if ftype == TType.STOP:
22393 
        break
22394 
      if fid == 1:
22395 
        if ftype == TType.LIST:
22396 
          self.itemIds = []
13493 amit.gupta 22397 
          (_etype425, _size422) = iprot.readListBegin()
22398 
          for _i426 in xrange(_size422):
22399 
            _elem427 = iprot.readI64();
22400 
            self.itemIds.append(_elem427)
7306 rajveer 22401 
          iprot.readListEnd()
22402 
        else:
22403 
          iprot.skip(ftype)
22404 
      else:
22405 
        iprot.skip(ftype)
22406 
      iprot.readFieldEnd()
22407 
    iprot.readStructEnd()
22408 
 
22409 
  def write(self, oprot):
22410 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22411 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22412 
      return
22413 
    oprot.writeStructBegin('getStorePricings_args')
22414 
    if self.itemIds is not None:
22415 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
22416 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
13493 amit.gupta 22417 
      for iter428 in self.itemIds:
22418 
        oprot.writeI64(iter428)
7306 rajveer 22419 
      oprot.writeListEnd()
22420 
      oprot.writeFieldEnd()
22421 
    oprot.writeFieldStop()
22422 
    oprot.writeStructEnd()
22423 
 
22424 
  def validate(self):
22425 
    return
22426 
 
22427 
 
22428 
  def __repr__(self):
22429 
    L = ['%s=%r' % (key, value)
22430 
      for key, value in self.__dict__.iteritems()]
22431 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22432 
 
22433 
  def __eq__(self, other):
22434 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22435 
 
22436 
  def __ne__(self, other):
22437 
    return not (self == other)
22438 
 
22439 
class getStorePricings_result:
22440 
  """
22441 
  Attributes:
22442 
   - success
22443 
  """
22444 
 
22445 
  thrift_spec = (
22446 
    (0, TType.LIST, 'success', (TType.STRUCT,(StorePricing, StorePricing.thrift_spec)), None, ), # 0
22447 
  )
22448 
 
22449 
  def __init__(self, success=None,):
22450 
    self.success = success
22451 
 
22452 
  def read(self, iprot):
22453 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22454 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22455 
      return
22456 
    iprot.readStructBegin()
22457 
    while True:
22458 
      (fname, ftype, fid) = iprot.readFieldBegin()
22459 
      if ftype == TType.STOP:
22460 
        break
22461 
      if fid == 0:
22462 
        if ftype == TType.LIST:
22463 
          self.success = []
13493 amit.gupta 22464 
          (_etype432, _size429) = iprot.readListBegin()
22465 
          for _i433 in xrange(_size429):
22466 
            _elem434 = StorePricing()
22467 
            _elem434.read(iprot)
22468 
            self.success.append(_elem434)
7306 rajveer 22469 
          iprot.readListEnd()
22470 
        else:
22471 
          iprot.skip(ftype)
22472 
      else:
22473 
        iprot.skip(ftype)
22474 
      iprot.readFieldEnd()
22475 
    iprot.readStructEnd()
22476 
 
22477 
  def write(self, oprot):
22478 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22479 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22480 
      return
22481 
    oprot.writeStructBegin('getStorePricings_result')
22482 
    if self.success is not None:
22483 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22484 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 22485 
      for iter435 in self.success:
22486 
        iter435.write(oprot)
7306 rajveer 22487 
      oprot.writeListEnd()
22488 
      oprot.writeFieldEnd()
22489 
    oprot.writeFieldStop()
22490 
    oprot.writeStructEnd()
22491 
 
22492 
  def validate(self):
22493 
    return
22494 
 
22495 
 
22496 
  def __repr__(self):
22497 
    L = ['%s=%r' % (key, value)
22498 
      for key, value in self.__dict__.iteritems()]
22499 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22500 
 
22501 
  def __eq__(self, other):
22502 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22503 
 
22504 
  def __ne__(self, other):
22505 
    return not (self == other)
22506 
 
7265 rajveer 22507 
class updateStorePricing_args:
22508 
  """
22509 
  Attributes:
22510 
   - sp
7382 rajveer 22511 
   - allColors
7265 rajveer 22512 
  """
22513 
 
22514 
  thrift_spec = (
22515 
    None, # 0
22516 
    (1, TType.STRUCT, 'sp', (StorePricing, StorePricing.thrift_spec), None, ), # 1
7382 rajveer 22517 
    (2, TType.BOOL, 'allColors', None, None, ), # 2
7265 rajveer 22518 
  )
22519 
 
7382 rajveer 22520 
  def __init__(self, sp=None, allColors=None,):
7265 rajveer 22521 
    self.sp = sp
7382 rajveer 22522 
    self.allColors = allColors
7265 rajveer 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 
      if fid == 1:
22534 
        if ftype == TType.STRUCT:
22535 
          self.sp = StorePricing()
22536 
          self.sp.read(iprot)
22537 
        else:
22538 
          iprot.skip(ftype)
7382 rajveer 22539 
      elif fid == 2:
22540 
        if ftype == TType.BOOL:
22541 
          self.allColors = iprot.readBool();
22542 
        else:
22543 
          iprot.skip(ftype)
7265 rajveer 22544 
      else:
22545 
        iprot.skip(ftype)
22546 
      iprot.readFieldEnd()
22547 
    iprot.readStructEnd()
22548 
 
22549 
  def write(self, oprot):
22550 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22551 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22552 
      return
22553 
    oprot.writeStructBegin('updateStorePricing_args')
22554 
    if self.sp is not None:
22555 
      oprot.writeFieldBegin('sp', TType.STRUCT, 1)
22556 
      self.sp.write(oprot)
22557 
      oprot.writeFieldEnd()
7382 rajveer 22558 
    if self.allColors is not None:
22559 
      oprot.writeFieldBegin('allColors', TType.BOOL, 2)
22560 
      oprot.writeBool(self.allColors)
22561 
      oprot.writeFieldEnd()
7265 rajveer 22562 
    oprot.writeFieldStop()
22563 
    oprot.writeStructEnd()
22564 
 
22565 
  def validate(self):
22566 
    return
22567 
 
22568 
 
22569 
  def __repr__(self):
22570 
    L = ['%s=%r' % (key, value)
22571 
      for key, value in self.__dict__.iteritems()]
22572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22573 
 
22574 
  def __eq__(self, other):
22575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22576 
 
22577 
  def __ne__(self, other):
22578 
    return not (self == other)
22579 
 
22580 
class updateStorePricing_result:
22581 
 
22582 
  thrift_spec = (
22583 
  )
22584 
 
22585 
  def read(self, iprot):
22586 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22587 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22588 
      return
22589 
    iprot.readStructBegin()
22590 
    while True:
22591 
      (fname, ftype, fid) = iprot.readFieldBegin()
22592 
      if ftype == TType.STOP:
22593 
        break
22594 
      else:
22595 
        iprot.skip(ftype)
22596 
      iprot.readFieldEnd()
22597 
    iprot.readStructEnd()
22598 
 
22599 
  def write(self, oprot):
22600 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22601 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22602 
      return
22603 
    oprot.writeStructBegin('updateStorePricing_result')
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)
7281 kshitij.so 22621 
 
22622 
class getAllAmazonListedItems_args:
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('getAllAmazonListedItems_args')
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 getAllAmazonListedItems_result:
22665 
  """
22666 
  Attributes:
22667 
   - success
22668 
  """
22669 
 
22670 
  thrift_spec = (
22671 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
22672 
  )
22673 
 
22674 
  def __init__(self, success=None,):
22675 
    self.success = success
22676 
 
22677 
  def read(self, iprot):
22678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22680 
      return
22681 
    iprot.readStructBegin()
22682 
    while True:
22683 
      (fname, ftype, fid) = iprot.readFieldBegin()
22684 
      if ftype == TType.STOP:
22685 
        break
22686 
      if fid == 0:
22687 
        if ftype == TType.LIST:
22688 
          self.success = []
13493 amit.gupta 22689 
          (_etype439, _size436) = iprot.readListBegin()
22690 
          for _i440 in xrange(_size436):
22691 
            _elem441 = Amazonlisted()
22692 
            _elem441.read(iprot)
22693 
            self.success.append(_elem441)
7281 kshitij.so 22694 
          iprot.readListEnd()
22695 
        else:
22696 
          iprot.skip(ftype)
22697 
      else:
22698 
        iprot.skip(ftype)
22699 
      iprot.readFieldEnd()
22700 
    iprot.readStructEnd()
22701 
 
22702 
  def write(self, oprot):
22703 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22704 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22705 
      return
22706 
    oprot.writeStructBegin('getAllAmazonListedItems_result')
22707 
    if self.success is not None:
22708 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22709 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 22710 
      for iter442 in self.success:
22711 
        iter442.write(oprot)
7281 kshitij.so 22712 
      oprot.writeListEnd()
22713 
      oprot.writeFieldEnd()
22714 
    oprot.writeFieldStop()
22715 
    oprot.writeStructEnd()
22716 
 
22717 
  def validate(self):
22718 
    return
22719 
 
22720 
 
22721 
  def __repr__(self):
22722 
    L = ['%s=%r' % (key, value)
22723 
      for key, value in self.__dict__.iteritems()]
22724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22725 
 
22726 
  def __eq__(self, other):
22727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22728 
 
22729 
  def __ne__(self, other):
22730 
    return not (self == other)
22731 
 
8619 kshitij.so 22732 
class searchAmazonItems_args:
22733 
  """
22734 
  Attributes:
22735 
   - searchTerm
22736 
   - offset
22737 
   - limit
22738 
  """
22739 
 
22740 
  thrift_spec = (
22741 
    None, # 0
22742 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
22743 
    (2, TType.I64, 'offset', None, None, ), # 2
22744 
    (3, TType.I64, 'limit', None, None, ), # 3
22745 
  )
22746 
 
22747 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
22748 
    self.searchTerm = searchTerm
22749 
    self.offset = offset
22750 
    self.limit = limit
22751 
 
22752 
  def read(self, iprot):
22753 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22754 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22755 
      return
22756 
    iprot.readStructBegin()
22757 
    while True:
22758 
      (fname, ftype, fid) = iprot.readFieldBegin()
22759 
      if ftype == TType.STOP:
22760 
        break
22761 
      if fid == 1:
22762 
        if ftype == TType.LIST:
22763 
          self.searchTerm = []
13493 amit.gupta 22764 
          (_etype446, _size443) = iprot.readListBegin()
22765 
          for _i447 in xrange(_size443):
22766 
            _elem448 = iprot.readString();
22767 
            self.searchTerm.append(_elem448)
8619 kshitij.so 22768 
          iprot.readListEnd()
22769 
        else:
22770 
          iprot.skip(ftype)
22771 
      elif fid == 2:
22772 
        if ftype == TType.I64:
22773 
          self.offset = iprot.readI64();
22774 
        else:
22775 
          iprot.skip(ftype)
22776 
      elif fid == 3:
22777 
        if ftype == TType.I64:
22778 
          self.limit = iprot.readI64();
22779 
        else:
22780 
          iprot.skip(ftype)
22781 
      else:
22782 
        iprot.skip(ftype)
22783 
      iprot.readFieldEnd()
22784 
    iprot.readStructEnd()
22785 
 
22786 
  def write(self, oprot):
22787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22789 
      return
22790 
    oprot.writeStructBegin('searchAmazonItems_args')
22791 
    if self.searchTerm is not None:
22792 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
22793 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
13493 amit.gupta 22794 
      for iter449 in self.searchTerm:
22795 
        oprot.writeString(iter449)
8619 kshitij.so 22796 
      oprot.writeListEnd()
22797 
      oprot.writeFieldEnd()
22798 
    if self.offset is not None:
22799 
      oprot.writeFieldBegin('offset', TType.I64, 2)
22800 
      oprot.writeI64(self.offset)
22801 
      oprot.writeFieldEnd()
22802 
    if self.limit is not None:
22803 
      oprot.writeFieldBegin('limit', TType.I64, 3)
22804 
      oprot.writeI64(self.limit)
22805 
      oprot.writeFieldEnd()
22806 
    oprot.writeFieldStop()
22807 
    oprot.writeStructEnd()
22808 
 
22809 
  def validate(self):
22810 
    return
22811 
 
22812 
 
22813 
  def __repr__(self):
22814 
    L = ['%s=%r' % (key, value)
22815 
      for key, value in self.__dict__.iteritems()]
22816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22817 
 
22818 
  def __eq__(self, other):
22819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22820 
 
22821 
  def __ne__(self, other):
22822 
    return not (self == other)
22823 
 
22824 
class searchAmazonItems_result:
22825 
  """
22826 
  Attributes:
22827 
   - success
22828 
  """
22829 
 
22830 
  thrift_spec = (
22831 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
22832 
  )
22833 
 
22834 
  def __init__(self, success=None,):
22835 
    self.success = success
22836 
 
22837 
  def read(self, iprot):
22838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22840 
      return
22841 
    iprot.readStructBegin()
22842 
    while True:
22843 
      (fname, ftype, fid) = iprot.readFieldBegin()
22844 
      if ftype == TType.STOP:
22845 
        break
22846 
      if fid == 0:
22847 
        if ftype == TType.LIST:
22848 
          self.success = []
13493 amit.gupta 22849 
          (_etype453, _size450) = iprot.readListBegin()
22850 
          for _i454 in xrange(_size450):
22851 
            _elem455 = Amazonlisted()
22852 
            _elem455.read(iprot)
22853 
            self.success.append(_elem455)
8619 kshitij.so 22854 
          iprot.readListEnd()
22855 
        else:
22856 
          iprot.skip(ftype)
22857 
      else:
22858 
        iprot.skip(ftype)
22859 
      iprot.readFieldEnd()
22860 
    iprot.readStructEnd()
22861 
 
22862 
  def write(self, oprot):
22863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22865 
      return
22866 
    oprot.writeStructBegin('searchAmazonItems_result')
22867 
    if self.success is not None:
22868 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22869 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 22870 
      for iter456 in self.success:
22871 
        iter456.write(oprot)
8619 kshitij.so 22872 
      oprot.writeListEnd()
22873 
      oprot.writeFieldEnd()
22874 
    oprot.writeFieldStop()
22875 
    oprot.writeStructEnd()
22876 
 
22877 
  def validate(self):
22878 
    return
22879 
 
22880 
 
22881 
  def __repr__(self):
22882 
    L = ['%s=%r' % (key, value)
22883 
      for key, value in self.__dict__.iteritems()]
22884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22885 
 
22886 
  def __eq__(self, other):
22887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22888 
 
22889 
  def __ne__(self, other):
22890 
    return not (self == other)
22891 
 
22892 
class getAmazonSearchResultCount_args:
22893 
  """
22894 
  Attributes:
22895 
   - searchTerm
22896 
  """
22897 
 
22898 
  thrift_spec = (
22899 
    None, # 0
22900 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
22901 
  )
22902 
 
22903 
  def __init__(self, searchTerm=None,):
22904 
    self.searchTerm = searchTerm
22905 
 
22906 
  def read(self, iprot):
22907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22909 
      return
22910 
    iprot.readStructBegin()
22911 
    while True:
22912 
      (fname, ftype, fid) = iprot.readFieldBegin()
22913 
      if ftype == TType.STOP:
22914 
        break
22915 
      if fid == 1:
22916 
        if ftype == TType.LIST:
22917 
          self.searchTerm = []
13493 amit.gupta 22918 
          (_etype460, _size457) = iprot.readListBegin()
22919 
          for _i461 in xrange(_size457):
22920 
            _elem462 = iprot.readString();
22921 
            self.searchTerm.append(_elem462)
8619 kshitij.so 22922 
          iprot.readListEnd()
22923 
        else:
22924 
          iprot.skip(ftype)
22925 
      else:
22926 
        iprot.skip(ftype)
22927 
      iprot.readFieldEnd()
22928 
    iprot.readStructEnd()
22929 
 
22930 
  def write(self, oprot):
22931 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22932 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22933 
      return
22934 
    oprot.writeStructBegin('getAmazonSearchResultCount_args')
22935 
    if self.searchTerm is not None:
22936 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
22937 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
13493 amit.gupta 22938 
      for iter463 in self.searchTerm:
22939 
        oprot.writeString(iter463)
8619 kshitij.so 22940 
      oprot.writeListEnd()
22941 
      oprot.writeFieldEnd()
22942 
    oprot.writeFieldStop()
22943 
    oprot.writeStructEnd()
22944 
 
22945 
  def validate(self):
22946 
    return
22947 
 
22948 
 
22949 
  def __repr__(self):
22950 
    L = ['%s=%r' % (key, value)
22951 
      for key, value in self.__dict__.iteritems()]
22952 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22953 
 
22954 
  def __eq__(self, other):
22955 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22956 
 
22957 
  def __ne__(self, other):
22958 
    return not (self == other)
22959 
 
22960 
class getAmazonSearchResultCount_result:
22961 
  """
22962 
  Attributes:
22963 
   - success
22964 
  """
22965 
 
22966 
  thrift_spec = (
22967 
    (0, TType.I64, 'success', None, None, ), # 0
22968 
  )
22969 
 
22970 
  def __init__(self, success=None,):
22971 
    self.success = success
22972 
 
22973 
  def read(self, iprot):
22974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22976 
      return
22977 
    iprot.readStructBegin()
22978 
    while True:
22979 
      (fname, ftype, fid) = iprot.readFieldBegin()
22980 
      if ftype == TType.STOP:
22981 
        break
22982 
      if fid == 0:
22983 
        if ftype == TType.I64:
22984 
          self.success = iprot.readI64();
22985 
        else:
22986 
          iprot.skip(ftype)
22987 
      else:
22988 
        iprot.skip(ftype)
22989 
      iprot.readFieldEnd()
22990 
    iprot.readStructEnd()
22991 
 
22992 
  def write(self, oprot):
22993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22995 
      return
22996 
    oprot.writeStructBegin('getAmazonSearchResultCount_result')
22997 
    if self.success is not None:
22998 
      oprot.writeFieldBegin('success', TType.I64, 0)
22999 
      oprot.writeI64(self.success)
23000 
      oprot.writeFieldEnd()
23001 
    oprot.writeFieldStop()
23002 
    oprot.writeStructEnd()
23003 
 
23004 
  def validate(self):
23005 
    return
23006 
 
23007 
 
23008 
  def __repr__(self):
23009 
    L = ['%s=%r' % (key, value)
23010 
      for key, value in self.__dict__.iteritems()]
23011 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23012 
 
23013 
  def __eq__(self, other):
23014 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23015 
 
23016 
  def __ne__(self, other):
23017 
    return not (self == other)
23018 
 
23019 
class getCountForAmazonlistedItems_args:
23020 
 
23021 
  thrift_spec = (
23022 
  )
23023 
 
23024 
  def read(self, iprot):
23025 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23026 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23027 
      return
23028 
    iprot.readStructBegin()
23029 
    while True:
23030 
      (fname, ftype, fid) = iprot.readFieldBegin()
23031 
      if ftype == TType.STOP:
23032 
        break
23033 
      else:
23034 
        iprot.skip(ftype)
23035 
      iprot.readFieldEnd()
23036 
    iprot.readStructEnd()
23037 
 
23038 
  def write(self, oprot):
23039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23041 
      return
23042 
    oprot.writeStructBegin('getCountForAmazonlistedItems_args')
23043 
    oprot.writeFieldStop()
23044 
    oprot.writeStructEnd()
23045 
 
23046 
  def validate(self):
23047 
    return
23048 
 
23049 
 
23050 
  def __repr__(self):
23051 
    L = ['%s=%r' % (key, value)
23052 
      for key, value in self.__dict__.iteritems()]
23053 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23054 
 
23055 
  def __eq__(self, other):
23056 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23057 
 
23058 
  def __ne__(self, other):
23059 
    return not (self == other)
23060 
 
23061 
class getCountForAmazonlistedItems_result:
23062 
  """
23063 
  Attributes:
23064 
   - success
23065 
  """
23066 
 
23067 
  thrift_spec = (
23068 
    (0, TType.I64, 'success', None, None, ), # 0
23069 
  )
23070 
 
23071 
  def __init__(self, success=None,):
23072 
    self.success = success
23073 
 
23074 
  def read(self, iprot):
23075 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23076 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23077 
      return
23078 
    iprot.readStructBegin()
23079 
    while True:
23080 
      (fname, ftype, fid) = iprot.readFieldBegin()
23081 
      if ftype == TType.STOP:
23082 
        break
23083 
      if fid == 0:
23084 
        if ftype == TType.I64:
23085 
          self.success = iprot.readI64();
23086 
        else:
23087 
          iprot.skip(ftype)
23088 
      else:
23089 
        iprot.skip(ftype)
23090 
      iprot.readFieldEnd()
23091 
    iprot.readStructEnd()
23092 
 
23093 
  def write(self, oprot):
23094 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23095 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23096 
      return
23097 
    oprot.writeStructBegin('getCountForAmazonlistedItems_result')
23098 
    if self.success is not None:
23099 
      oprot.writeFieldBegin('success', TType.I64, 0)
23100 
      oprot.writeI64(self.success)
23101 
      oprot.writeFieldEnd()
23102 
    oprot.writeFieldStop()
23103 
    oprot.writeStructEnd()
23104 
 
23105 
  def validate(self):
23106 
    return
23107 
 
23108 
 
23109 
  def __repr__(self):
23110 
    L = ['%s=%r' % (key, value)
23111 
      for key, value in self.__dict__.iteritems()]
23112 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23113 
 
23114 
  def __eq__(self, other):
23115 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23116 
 
23117 
  def __ne__(self, other):
23118 
    return not (self == other)
23119 
 
7281 kshitij.so 23120 
class getAmazonItemDetails_args:
23121 
  """
23122 
  Attributes:
23123 
   - itemId
23124 
  """
23125 
 
23126 
  thrift_spec = (
23127 
    None, # 0
23128 
    (1, TType.I64, 'itemId', None, None, ), # 1
23129 
  )
23130 
 
23131 
  def __init__(self, itemId=None,):
23132 
    self.itemId = itemId
23133 
 
23134 
  def read(self, iprot):
23135 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23136 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23137 
      return
23138 
    iprot.readStructBegin()
23139 
    while True:
23140 
      (fname, ftype, fid) = iprot.readFieldBegin()
23141 
      if ftype == TType.STOP:
23142 
        break
23143 
      if fid == 1:
23144 
        if ftype == TType.I64:
23145 
          self.itemId = iprot.readI64();
23146 
        else:
23147 
          iprot.skip(ftype)
23148 
      else:
23149 
        iprot.skip(ftype)
23150 
      iprot.readFieldEnd()
23151 
    iprot.readStructEnd()
23152 
 
23153 
  def write(self, oprot):
23154 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23155 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23156 
      return
23157 
    oprot.writeStructBegin('getAmazonItemDetails_args')
23158 
    if self.itemId is not None:
23159 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
23160 
      oprot.writeI64(self.itemId)
23161 
      oprot.writeFieldEnd()
23162 
    oprot.writeFieldStop()
23163 
    oprot.writeStructEnd()
23164 
 
23165 
  def validate(self):
23166 
    return
23167 
 
23168 
 
23169 
  def __repr__(self):
23170 
    L = ['%s=%r' % (key, value)
23171 
      for key, value in self.__dict__.iteritems()]
23172 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23173 
 
23174 
  def __eq__(self, other):
23175 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23176 
 
23177 
  def __ne__(self, other):
23178 
    return not (self == other)
23179 
 
23180 
class getAmazonItemDetails_result:
23181 
  """
23182 
  Attributes:
23183 
   - success
23184 
  """
23185 
 
23186 
  thrift_spec = (
23187 
    (0, TType.STRUCT, 'success', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 0
23188 
  )
23189 
 
23190 
  def __init__(self, success=None,):
23191 
    self.success = success
23192 
 
23193 
  def read(self, iprot):
23194 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23195 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23196 
      return
23197 
    iprot.readStructBegin()
23198 
    while True:
23199 
      (fname, ftype, fid) = iprot.readFieldBegin()
23200 
      if ftype == TType.STOP:
23201 
        break
23202 
      if fid == 0:
23203 
        if ftype == TType.STRUCT:
23204 
          self.success = Amazonlisted()
23205 
          self.success.read(iprot)
23206 
        else:
23207 
          iprot.skip(ftype)
23208 
      else:
23209 
        iprot.skip(ftype)
23210 
      iprot.readFieldEnd()
23211 
    iprot.readStructEnd()
23212 
 
23213 
  def write(self, oprot):
23214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23216 
      return
23217 
    oprot.writeStructBegin('getAmazonItemDetails_result')
23218 
    if self.success is not None:
23219 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23220 
      self.success.write(oprot)
23221 
      oprot.writeFieldEnd()
23222 
    oprot.writeFieldStop()
23223 
    oprot.writeStructEnd()
23224 
 
23225 
  def validate(self):
23226 
    return
23227 
 
23228 
 
23229 
  def __repr__(self):
23230 
    L = ['%s=%r' % (key, value)
23231 
      for key, value in self.__dict__.iteritems()]
23232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23233 
 
23234 
  def __eq__(self, other):
23235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23236 
 
23237 
  def __ne__(self, other):
23238 
    return not (self == other)
23239 
 
23240 
class updateAmazonItemDetails_args:
23241 
  """
23242 
  Attributes:
8168 kshitij.so 23243 
   - amazonlisted
7281 kshitij.so 23244 
  """
23245 
 
23246 
  thrift_spec = (
23247 
    None, # 0
8168 kshitij.so 23248 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
7281 kshitij.so 23249 
  )
23250 
 
8168 kshitij.so 23251 
  def __init__(self, amazonlisted=None,):
23252 
    self.amazonlisted = amazonlisted
7281 kshitij.so 23253 
 
23254 
  def read(self, iprot):
23255 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23256 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23257 
      return
23258 
    iprot.readStructBegin()
23259 
    while True:
23260 
      (fname, ftype, fid) = iprot.readFieldBegin()
23261 
      if ftype == TType.STOP:
23262 
        break
23263 
      if fid == 1:
8168 kshitij.so 23264 
        if ftype == TType.STRUCT:
23265 
          self.amazonlisted = Amazonlisted()
23266 
          self.amazonlisted.read(iprot)
7281 kshitij.so 23267 
        else:
23268 
          iprot.skip(ftype)
23269 
      else:
23270 
        iprot.skip(ftype)
23271 
      iprot.readFieldEnd()
23272 
    iprot.readStructEnd()
23273 
 
23274 
  def write(self, oprot):
23275 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23276 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23277 
      return
23278 
    oprot.writeStructBegin('updateAmazonItemDetails_args')
8168 kshitij.so 23279 
    if self.amazonlisted is not None:
23280 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
23281 
      self.amazonlisted.write(oprot)
7281 kshitij.so 23282 
      oprot.writeFieldEnd()
23283 
    oprot.writeFieldStop()
23284 
    oprot.writeStructEnd()
23285 
 
23286 
  def validate(self):
23287 
    return
23288 
 
23289 
 
23290 
  def __repr__(self):
23291 
    L = ['%s=%r' % (key, value)
23292 
      for key, value in self.__dict__.iteritems()]
23293 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23294 
 
23295 
  def __eq__(self, other):
23296 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23297 
 
23298 
  def __ne__(self, other):
23299 
    return not (self == other)
23300 
 
23301 
class updateAmazonItemDetails_result:
23302 
 
23303 
  thrift_spec = (
23304 
  )
23305 
 
23306 
  def read(self, iprot):
23307 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23308 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23309 
      return
23310 
    iprot.readStructBegin()
23311 
    while True:
23312 
      (fname, ftype, fid) = iprot.readFieldBegin()
23313 
      if ftype == TType.STOP:
23314 
        break
23315 
      else:
23316 
        iprot.skip(ftype)
23317 
      iprot.readFieldEnd()
23318 
    iprot.readStructEnd()
23319 
 
23320 
  def write(self, oprot):
23321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23323 
      return
23324 
    oprot.writeStructBegin('updateAmazonItemDetails_result')
23325 
    oprot.writeFieldStop()
23326 
    oprot.writeStructEnd()
23327 
 
23328 
  def validate(self):
23329 
    return
23330 
 
23331 
 
23332 
  def __repr__(self):
23333 
    L = ['%s=%r' % (key, value)
23334 
      for key, value in self.__dict__.iteritems()]
23335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23336 
 
23337 
  def __eq__(self, other):
23338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23339 
 
23340 
  def __ne__(self, other):
23341 
    return not (self == other)
23342 
 
23343 
class addAmazonItem_args:
23344 
  """
23345 
  Attributes:
23346 
   - amazonlisted
23347 
  """
23348 
 
23349 
  thrift_spec = (
23350 
    None, # 0
23351 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
23352 
  )
23353 
 
23354 
  def __init__(self, amazonlisted=None,):
23355 
    self.amazonlisted = amazonlisted
23356 
 
23357 
  def read(self, iprot):
23358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23360 
      return
23361 
    iprot.readStructBegin()
23362 
    while True:
23363 
      (fname, ftype, fid) = iprot.readFieldBegin()
23364 
      if ftype == TType.STOP:
23365 
        break
23366 
      if fid == 1:
23367 
        if ftype == TType.STRUCT:
23368 
          self.amazonlisted = Amazonlisted()
23369 
          self.amazonlisted.read(iprot)
23370 
        else:
23371 
          iprot.skip(ftype)
23372 
      else:
23373 
        iprot.skip(ftype)
23374 
      iprot.readFieldEnd()
23375 
    iprot.readStructEnd()
23376 
 
23377 
  def write(self, oprot):
23378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23380 
      return
23381 
    oprot.writeStructBegin('addAmazonItem_args')
23382 
    if self.amazonlisted is not None:
23383 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
23384 
      self.amazonlisted.write(oprot)
23385 
      oprot.writeFieldEnd()
23386 
    oprot.writeFieldStop()
23387 
    oprot.writeStructEnd()
23388 
 
23389 
  def validate(self):
23390 
    return
23391 
 
23392 
 
23393 
  def __repr__(self):
23394 
    L = ['%s=%r' % (key, value)
23395 
      for key, value in self.__dict__.iteritems()]
23396 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23397 
 
23398 
  def __eq__(self, other):
23399 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23400 
 
23401 
  def __ne__(self, other):
23402 
    return not (self == other)
23403 
 
23404 
class addAmazonItem_result:
23405 
 
23406 
  thrift_spec = (
23407 
  )
23408 
 
23409 
  def read(self, iprot):
23410 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23411 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23412 
      return
23413 
    iprot.readStructBegin()
23414 
    while True:
23415 
      (fname, ftype, fid) = iprot.readFieldBegin()
23416 
      if ftype == TType.STOP:
23417 
        break
23418 
      else:
23419 
        iprot.skip(ftype)
23420 
      iprot.readFieldEnd()
23421 
    iprot.readStructEnd()
23422 
 
23423 
  def write(self, oprot):
23424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23426 
      return
23427 
    oprot.writeStructBegin('addAmazonItem_result')
23428 
    oprot.writeFieldStop()
23429 
    oprot.writeStructEnd()
23430 
 
23431 
  def validate(self):
23432 
    return
23433 
 
23434 
 
23435 
  def __repr__(self):
23436 
    L = ['%s=%r' % (key, value)
23437 
      for key, value in self.__dict__.iteritems()]
23438 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23439 
 
23440 
  def __eq__(self, other):
23441 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23442 
 
23443 
  def __ne__(self, other):
23444 
    return not (self == other)
7291 vikram.rag 23445 
 
23446 
class getAsinItems_args:
23447 
 
23448 
  thrift_spec = (
23449 
  )
23450 
 
23451 
  def read(self, iprot):
23452 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23453 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23454 
      return
23455 
    iprot.readStructBegin()
23456 
    while True:
23457 
      (fname, ftype, fid) = iprot.readFieldBegin()
23458 
      if ftype == TType.STOP:
23459 
        break
23460 
      else:
23461 
        iprot.skip(ftype)
23462 
      iprot.readFieldEnd()
23463 
    iprot.readStructEnd()
23464 
 
23465 
  def write(self, oprot):
23466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23468 
      return
23469 
    oprot.writeStructBegin('getAsinItems_args')
23470 
    oprot.writeFieldStop()
23471 
    oprot.writeStructEnd()
23472 
 
23473 
  def validate(self):
23474 
    return
23475 
 
23476 
 
23477 
  def __repr__(self):
23478 
    L = ['%s=%r' % (key, value)
23479 
      for key, value in self.__dict__.iteritems()]
23480 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23481 
 
23482 
  def __eq__(self, other):
23483 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23484 
 
23485 
  def __ne__(self, other):
23486 
    return not (self == other)
23487 
 
23488 
class getAsinItems_result:
23489 
  """
23490 
  Attributes:
23491 
   - success
23492 
  """
23493 
 
23494 
  thrift_spec = (
23495 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
23496 
  )
23497 
 
23498 
  def __init__(self, success=None,):
23499 
    self.success = success
23500 
 
23501 
  def read(self, iprot):
23502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23504 
      return
23505 
    iprot.readStructBegin()
23506 
    while True:
23507 
      (fname, ftype, fid) = iprot.readFieldBegin()
23508 
      if ftype == TType.STOP:
23509 
        break
23510 
      if fid == 0:
23511 
        if ftype == TType.LIST:
23512 
          self.success = []
13493 amit.gupta 23513 
          (_etype467, _size464) = iprot.readListBegin()
23514 
          for _i468 in xrange(_size464):
23515 
            _elem469 = Item()
23516 
            _elem469.read(iprot)
23517 
            self.success.append(_elem469)
7291 vikram.rag 23518 
          iprot.readListEnd()
23519 
        else:
23520 
          iprot.skip(ftype)
23521 
      else:
23522 
        iprot.skip(ftype)
23523 
      iprot.readFieldEnd()
23524 
    iprot.readStructEnd()
23525 
 
23526 
  def write(self, oprot):
23527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23529 
      return
23530 
    oprot.writeStructBegin('getAsinItems_result')
23531 
    if self.success is not None:
23532 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23533 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 23534 
      for iter470 in self.success:
23535 
        iter470.write(oprot)
7291 vikram.rag 23536 
      oprot.writeListEnd()
23537 
      oprot.writeFieldEnd()
23538 
    oprot.writeFieldStop()
23539 
    oprot.writeStructEnd()
23540 
 
23541 
  def validate(self):
23542 
    return
23543 
 
23544 
 
23545 
  def __repr__(self):
23546 
    L = ['%s=%r' % (key, value)
23547 
      for key, value in self.__dict__.iteritems()]
23548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23549 
 
23550 
  def __eq__(self, other):
23551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23552 
 
23553 
  def __ne__(self, other):
23554 
    return not (self == other)
23555 
 
23556 
class getAllFbaListedItems_args:
23557 
 
23558 
  thrift_spec = (
23559 
  )
23560 
 
23561 
  def read(self, iprot):
23562 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23563 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23564 
      return
23565 
    iprot.readStructBegin()
23566 
    while True:
23567 
      (fname, ftype, fid) = iprot.readFieldBegin()
23568 
      if ftype == TType.STOP:
23569 
        break
23570 
      else:
23571 
        iprot.skip(ftype)
23572 
      iprot.readFieldEnd()
23573 
    iprot.readStructEnd()
23574 
 
23575 
  def write(self, oprot):
23576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23578 
      return
23579 
    oprot.writeStructBegin('getAllFbaListedItems_args')
23580 
    oprot.writeFieldStop()
23581 
    oprot.writeStructEnd()
23582 
 
23583 
  def validate(self):
23584 
    return
23585 
 
23586 
 
23587 
  def __repr__(self):
23588 
    L = ['%s=%r' % (key, value)
23589 
      for key, value in self.__dict__.iteritems()]
23590 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23591 
 
23592 
  def __eq__(self, other):
23593 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23594 
 
23595 
  def __ne__(self, other):
23596 
    return not (self == other)
23597 
 
23598 
class getAllFbaListedItems_result:
23599 
  """
23600 
  Attributes:
23601 
   - success
23602 
  """
23603 
 
23604 
  thrift_spec = (
23605 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
23606 
  )
23607 
 
23608 
  def __init__(self, success=None,):
23609 
    self.success = success
23610 
 
23611 
  def read(self, iprot):
23612 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23613 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23614 
      return
23615 
    iprot.readStructBegin()
23616 
    while True:
23617 
      (fname, ftype, fid) = iprot.readFieldBegin()
23618 
      if ftype == TType.STOP:
23619 
        break
23620 
      if fid == 0:
23621 
        if ftype == TType.LIST:
23622 
          self.success = []
13493 amit.gupta 23623 
          (_etype474, _size471) = iprot.readListBegin()
23624 
          for _i475 in xrange(_size471):
23625 
            _elem476 = Amazonlisted()
23626 
            _elem476.read(iprot)
23627 
            self.success.append(_elem476)
7291 vikram.rag 23628 
          iprot.readListEnd()
23629 
        else:
23630 
          iprot.skip(ftype)
23631 
      else:
23632 
        iprot.skip(ftype)
23633 
      iprot.readFieldEnd()
23634 
    iprot.readStructEnd()
23635 
 
23636 
  def write(self, oprot):
23637 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23638 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23639 
      return
23640 
    oprot.writeStructBegin('getAllFbaListedItems_result')
23641 
    if self.success is not None:
23642 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23643 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 23644 
      for iter477 in self.success:
23645 
        iter477.write(oprot)
7291 vikram.rag 23646 
      oprot.writeListEnd()
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 
 
23666 
class getAllNonFbaListedItems_args:
23667 
 
23668 
  thrift_spec = (
23669 
  )
23670 
 
23671 
  def read(self, iprot):
23672 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23673 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23674 
      return
23675 
    iprot.readStructBegin()
23676 
    while True:
23677 
      (fname, ftype, fid) = iprot.readFieldBegin()
23678 
      if ftype == TType.STOP:
23679 
        break
23680 
      else:
23681 
        iprot.skip(ftype)
23682 
      iprot.readFieldEnd()
23683 
    iprot.readStructEnd()
23684 
 
23685 
  def write(self, oprot):
23686 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23687 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23688 
      return
23689 
    oprot.writeStructBegin('getAllNonFbaListedItems_args')
23690 
    oprot.writeFieldStop()
23691 
    oprot.writeStructEnd()
23692 
 
23693 
  def validate(self):
23694 
    return
23695 
 
23696 
 
23697 
  def __repr__(self):
23698 
    L = ['%s=%r' % (key, value)
23699 
      for key, value in self.__dict__.iteritems()]
23700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23701 
 
23702 
  def __eq__(self, other):
23703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23704 
 
23705 
  def __ne__(self, other):
23706 
    return not (self == other)
23707 
 
23708 
class getAllNonFbaListedItems_result:
23709 
  """
23710 
  Attributes:
23711 
   - success
23712 
  """
23713 
 
23714 
  thrift_spec = (
23715 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
23716 
  )
23717 
 
23718 
  def __init__(self, success=None,):
23719 
    self.success = success
23720 
 
23721 
  def read(self, iprot):
23722 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23723 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23724 
      return
23725 
    iprot.readStructBegin()
23726 
    while True:
23727 
      (fname, ftype, fid) = iprot.readFieldBegin()
23728 
      if ftype == TType.STOP:
23729 
        break
23730 
      if fid == 0:
23731 
        if ftype == TType.LIST:
23732 
          self.success = []
13493 amit.gupta 23733 
          (_etype481, _size478) = iprot.readListBegin()
23734 
          for _i482 in xrange(_size478):
23735 
            _elem483 = Amazonlisted()
23736 
            _elem483.read(iprot)
23737 
            self.success.append(_elem483)
7291 vikram.rag 23738 
          iprot.readListEnd()
23739 
        else:
23740 
          iprot.skip(ftype)
23741 
      else:
23742 
        iprot.skip(ftype)
23743 
      iprot.readFieldEnd()
23744 
    iprot.readStructEnd()
23745 
 
23746 
  def write(self, oprot):
23747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23749 
      return
23750 
    oprot.writeStructBegin('getAllNonFbaListedItems_result')
23751 
    if self.success is not None:
23752 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23753 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 23754 
      for iter484 in self.success:
23755 
        iter484.write(oprot)
7291 vikram.rag 23756 
      oprot.writeListEnd()
23757 
      oprot.writeFieldEnd()
23758 
    oprot.writeFieldStop()
23759 
    oprot.writeStructEnd()
23760 
 
23761 
  def validate(self):
23762 
    return
23763 
 
23764 
 
23765 
  def __repr__(self):
23766 
    L = ['%s=%r' % (key, value)
23767 
      for key, value in self.__dict__.iteritems()]
23768 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23769 
 
23770 
  def __eq__(self, other):
23771 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23772 
 
23773 
  def __ne__(self, other):
23774 
    return not (self == other)
7460 kshitij.so 23775 
 
23776 
class updateItemInventory_args:
23777 
  """
23778 
  Attributes:
23779 
   - itemId
23780 
   - holdInventory
23781 
   - defaultInventory
23782 
  """
23783 
 
23784 
  thrift_spec = (
23785 
    None, # 0
23786 
    (1, TType.I64, 'itemId', None, None, ), # 1
23787 
    (2, TType.I64, 'holdInventory', None, None, ), # 2
23788 
    (3, TType.I64, 'defaultInventory', None, None, ), # 3
23789 
  )
23790 
 
23791 
  def __init__(self, itemId=None, holdInventory=None, defaultInventory=None,):
23792 
    self.itemId = itemId
23793 
    self.holdInventory = holdInventory
23794 
    self.defaultInventory = defaultInventory
23795 
 
23796 
  def read(self, iprot):
23797 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23798 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23799 
      return
23800 
    iprot.readStructBegin()
23801 
    while True:
23802 
      (fname, ftype, fid) = iprot.readFieldBegin()
23803 
      if ftype == TType.STOP:
23804 
        break
23805 
      if fid == 1:
23806 
        if ftype == TType.I64:
23807 
          self.itemId = iprot.readI64();
23808 
        else:
23809 
          iprot.skip(ftype)
23810 
      elif fid == 2:
23811 
        if ftype == TType.I64:
23812 
          self.holdInventory = iprot.readI64();
23813 
        else:
23814 
          iprot.skip(ftype)
23815 
      elif fid == 3:
23816 
        if ftype == TType.I64:
23817 
          self.defaultInventory = iprot.readI64();
23818 
        else:
23819 
          iprot.skip(ftype)
23820 
      else:
23821 
        iprot.skip(ftype)
23822 
      iprot.readFieldEnd()
23823 
    iprot.readStructEnd()
23824 
 
23825 
  def write(self, oprot):
23826 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23827 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23828 
      return
23829 
    oprot.writeStructBegin('updateItemInventory_args')
23830 
    if self.itemId is not None:
23831 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
23832 
      oprot.writeI64(self.itemId)
23833 
      oprot.writeFieldEnd()
23834 
    if self.holdInventory is not None:
23835 
      oprot.writeFieldBegin('holdInventory', TType.I64, 2)
23836 
      oprot.writeI64(self.holdInventory)
23837 
      oprot.writeFieldEnd()
23838 
    if self.defaultInventory is not None:
23839 
      oprot.writeFieldBegin('defaultInventory', TType.I64, 3)
23840 
      oprot.writeI64(self.defaultInventory)
23841 
      oprot.writeFieldEnd()
23842 
    oprot.writeFieldStop()
23843 
    oprot.writeStructEnd()
23844 
 
23845 
  def validate(self):
23846 
    return
23847 
 
23848 
 
23849 
  def __repr__(self):
23850 
    L = ['%s=%r' % (key, value)
23851 
      for key, value in self.__dict__.iteritems()]
23852 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23853 
 
23854 
  def __eq__(self, other):
23855 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23856 
 
23857 
  def __ne__(self, other):
23858 
    return not (self == other)
23859 
 
23860 
class updateItemInventory_result:
23861 
  """
23862 
  Attributes:
23863 
   - success
23864 
  """
23865 
 
23866 
  thrift_spec = (
23867 
    (0, TType.BOOL, 'success', None, None, ), # 0
23868 
  )
23869 
 
23870 
  def __init__(self, success=None,):
23871 
    self.success = success
23872 
 
23873 
  def read(self, iprot):
23874 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23875 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23876 
      return
23877 
    iprot.readStructBegin()
23878 
    while True:
23879 
      (fname, ftype, fid) = iprot.readFieldBegin()
23880 
      if ftype == TType.STOP:
23881 
        break
23882 
      if fid == 0:
23883 
        if ftype == TType.BOOL:
23884 
          self.success = iprot.readBool();
23885 
        else:
23886 
          iprot.skip(ftype)
23887 
      else:
23888 
        iprot.skip(ftype)
23889 
      iprot.readFieldEnd()
23890 
    iprot.readStructEnd()
23891 
 
23892 
  def write(self, oprot):
23893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23895 
      return
23896 
    oprot.writeStructBegin('updateItemInventory_result')
23897 
    if self.success is not None:
23898 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
23899 
      oprot.writeBool(self.success)
23900 
      oprot.writeFieldEnd()
23901 
    oprot.writeFieldStop()
23902 
    oprot.writeStructEnd()
23903 
 
23904 
  def validate(self):
23905 
    return
23906 
 
23907 
 
23908 
  def __repr__(self):
23909 
    L = ['%s=%r' % (key, value)
23910 
      for key, value in self.__dict__.iteritems()]
23911 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23912 
 
23913 
  def __eq__(self, other):
23914 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23915 
 
23916 
  def __ne__(self, other):
23917 
    return not (self == other)
7770 kshitij.so 23918 
 
23919 
class updateTimestampForAmazonFeeds_args:
23920 
  """
23921 
  Attributes:
23922 
   - type
23923 
   - sku
23924 
   - timestamp
23925 
  """
23926 
 
23927 
  thrift_spec = (
23928 
    None, # 0
23929 
    (1, TType.STRING, 'type', None, None, ), # 1
23930 
    (2, TType.LIST, 'sku', (TType.I64,None), None, ), # 2
23931 
    (3, TType.I64, 'timestamp', None, None, ), # 3
23932 
  )
23933 
 
23934 
  def __init__(self, type=None, sku=None, timestamp=None,):
23935 
    self.type = type
23936 
    self.sku = sku
23937 
    self.timestamp = timestamp
23938 
 
23939 
  def read(self, iprot):
23940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23942 
      return
23943 
    iprot.readStructBegin()
23944 
    while True:
23945 
      (fname, ftype, fid) = iprot.readFieldBegin()
23946 
      if ftype == TType.STOP:
23947 
        break
23948 
      if fid == 1:
23949 
        if ftype == TType.STRING:
23950 
          self.type = iprot.readString();
23951 
        else:
23952 
          iprot.skip(ftype)
23953 
      elif fid == 2:
23954 
        if ftype == TType.LIST:
23955 
          self.sku = []
13493 amit.gupta 23956 
          (_etype488, _size485) = iprot.readListBegin()
23957 
          for _i489 in xrange(_size485):
23958 
            _elem490 = iprot.readI64();
23959 
            self.sku.append(_elem490)
7770 kshitij.so 23960 
          iprot.readListEnd()
23961 
        else:
23962 
          iprot.skip(ftype)
23963 
      elif fid == 3:
23964 
        if ftype == TType.I64:
23965 
          self.timestamp = iprot.readI64();
23966 
        else:
23967 
          iprot.skip(ftype)
23968 
      else:
23969 
        iprot.skip(ftype)
23970 
      iprot.readFieldEnd()
23971 
    iprot.readStructEnd()
23972 
 
23973 
  def write(self, oprot):
23974 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23975 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23976 
      return
23977 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_args')
23978 
    if self.type is not None:
23979 
      oprot.writeFieldBegin('type', TType.STRING, 1)
23980 
      oprot.writeString(self.type)
23981 
      oprot.writeFieldEnd()
23982 
    if self.sku is not None:
23983 
      oprot.writeFieldBegin('sku', TType.LIST, 2)
23984 
      oprot.writeListBegin(TType.I64, len(self.sku))
13493 amit.gupta 23985 
      for iter491 in self.sku:
23986 
        oprot.writeI64(iter491)
7770 kshitij.so 23987 
      oprot.writeListEnd()
23988 
      oprot.writeFieldEnd()
23989 
    if self.timestamp is not None:
23990 
      oprot.writeFieldBegin('timestamp', TType.I64, 3)
23991 
      oprot.writeI64(self.timestamp)
23992 
      oprot.writeFieldEnd()
23993 
    oprot.writeFieldStop()
23994 
    oprot.writeStructEnd()
23995 
 
23996 
  def validate(self):
23997 
    return
23998 
 
23999 
 
24000 
  def __repr__(self):
24001 
    L = ['%s=%r' % (key, value)
24002 
      for key, value in self.__dict__.iteritems()]
24003 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24004 
 
24005 
  def __eq__(self, other):
24006 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24007 
 
24008 
  def __ne__(self, other):
24009 
    return not (self == other)
24010 
 
24011 
class updateTimestampForAmazonFeeds_result:
24012 
  """
24013 
  Attributes:
24014 
   - success
24015 
  """
24016 
 
24017 
  thrift_spec = (
24018 
    (0, TType.BOOL, 'success', None, None, ), # 0
24019 
  )
24020 
 
24021 
  def __init__(self, success=None,):
24022 
    self.success = success
24023 
 
24024 
  def read(self, iprot):
24025 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24026 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24027 
      return
24028 
    iprot.readStructBegin()
24029 
    while True:
24030 
      (fname, ftype, fid) = iprot.readFieldBegin()
24031 
      if ftype == TType.STOP:
24032 
        break
24033 
      if fid == 0:
24034 
        if ftype == TType.BOOL:
24035 
          self.success = iprot.readBool();
24036 
        else:
24037 
          iprot.skip(ftype)
24038 
      else:
24039 
        iprot.skip(ftype)
24040 
      iprot.readFieldEnd()
24041 
    iprot.readStructEnd()
24042 
 
24043 
  def write(self, oprot):
24044 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24045 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24046 
      return
24047 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_result')
24048 
    if self.success is not None:
24049 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
24050 
      oprot.writeBool(self.success)
24051 
      oprot.writeFieldEnd()
24052 
    oprot.writeFieldStop()
24053 
    oprot.writeStructEnd()
24054 
 
24055 
  def validate(self):
24056 
    return
24057 
 
24058 
 
24059 
  def __repr__(self):
24060 
    L = ['%s=%r' % (key, value)
24061 
      for key, value in self.__dict__.iteritems()]
24062 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24063 
 
24064 
  def __eq__(self, other):
24065 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24066 
 
24067 
  def __ne__(self, other):
24068 
    return not (self == other)
7897 amar.kumar 24069 
 
24070 
class getAllParentCategories_args:
24071 
 
24072 
  thrift_spec = (
24073 
  )
24074 
 
24075 
  def read(self, iprot):
24076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24078 
      return
24079 
    iprot.readStructBegin()
24080 
    while True:
24081 
      (fname, ftype, fid) = iprot.readFieldBegin()
24082 
      if ftype == TType.STOP:
24083 
        break
24084 
      else:
24085 
        iprot.skip(ftype)
24086 
      iprot.readFieldEnd()
24087 
    iprot.readStructEnd()
24088 
 
24089 
  def write(self, oprot):
24090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24092 
      return
24093 
    oprot.writeStructBegin('getAllParentCategories_args')
24094 
    oprot.writeFieldStop()
24095 
    oprot.writeStructEnd()
24096 
 
24097 
  def validate(self):
24098 
    return
24099 
 
24100 
 
24101 
  def __repr__(self):
24102 
    L = ['%s=%r' % (key, value)
24103 
      for key, value in self.__dict__.iteritems()]
24104 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24105 
 
24106 
  def __eq__(self, other):
24107 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24108 
 
24109 
  def __ne__(self, other):
24110 
    return not (self == other)
24111 
 
24112 
class getAllParentCategories_result:
24113 
  """
24114 
  Attributes:
24115 
   - success
24116 
  """
24117 
 
24118 
  thrift_spec = (
24119 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
24120 
  )
24121 
 
24122 
  def __init__(self, success=None,):
24123 
    self.success = success
24124 
 
24125 
  def read(self, iprot):
24126 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24127 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24128 
      return
24129 
    iprot.readStructBegin()
24130 
    while True:
24131 
      (fname, ftype, fid) = iprot.readFieldBegin()
24132 
      if ftype == TType.STOP:
24133 
        break
24134 
      if fid == 0:
24135 
        if ftype == TType.LIST:
24136 
          self.success = []
13493 amit.gupta 24137 
          (_etype495, _size492) = iprot.readListBegin()
24138 
          for _i496 in xrange(_size492):
24139 
            _elem497 = Category()
24140 
            _elem497.read(iprot)
24141 
            self.success.append(_elem497)
7897 amar.kumar 24142 
          iprot.readListEnd()
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('getAllParentCategories_result')
24155 
    if self.success is not None:
24156 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24157 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 24158 
      for iter498 in self.success:
24159 
        iter498.write(oprot)
7897 amar.kumar 24160 
      oprot.writeListEnd()
24161 
      oprot.writeFieldEnd()
24162 
    oprot.writeFieldStop()
24163 
    oprot.writeStructEnd()
24164 
 
24165 
  def validate(self):
24166 
    return
24167 
 
24168 
 
24169 
  def __repr__(self):
24170 
    L = ['%s=%r' % (key, value)
24171 
      for key, value in self.__dict__.iteritems()]
24172 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24173 
 
24174 
  def __eq__(self, other):
24175 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24176 
 
24177 
  def __ne__(self, other):
24178 
    return not (self == other)
7977 kshitij.so 24179 
 
24180 
class addPageViewEvent_args:
24181 
  """
24182 
  Attributes:
24183 
   - pageViewEvents
24184 
  """
24185 
 
24186 
  thrift_spec = (
24187 
    None, # 0
24188 
    (1, TType.STRUCT, 'pageViewEvents', (PageViewEvents, PageViewEvents.thrift_spec), None, ), # 1
24189 
  )
24190 
 
24191 
  def __init__(self, pageViewEvents=None,):
24192 
    self.pageViewEvents = pageViewEvents
24193 
 
24194 
  def read(self, iprot):
24195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24197 
      return
24198 
    iprot.readStructBegin()
24199 
    while True:
24200 
      (fname, ftype, fid) = iprot.readFieldBegin()
24201 
      if ftype == TType.STOP:
24202 
        break
24203 
      if fid == 1:
24204 
        if ftype == TType.STRUCT:
24205 
          self.pageViewEvents = PageViewEvents()
24206 
          self.pageViewEvents.read(iprot)
24207 
        else:
24208 
          iprot.skip(ftype)
24209 
      else:
24210 
        iprot.skip(ftype)
24211 
      iprot.readFieldEnd()
24212 
    iprot.readStructEnd()
24213 
 
24214 
  def write(self, oprot):
24215 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24216 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24217 
      return
24218 
    oprot.writeStructBegin('addPageViewEvent_args')
24219 
    if self.pageViewEvents is not None:
24220 
      oprot.writeFieldBegin('pageViewEvents', TType.STRUCT, 1)
24221 
      self.pageViewEvents.write(oprot)
24222 
      oprot.writeFieldEnd()
24223 
    oprot.writeFieldStop()
24224 
    oprot.writeStructEnd()
24225 
 
24226 
  def validate(self):
24227 
    return
24228 
 
24229 
 
24230 
  def __repr__(self):
24231 
    L = ['%s=%r' % (key, value)
24232 
      for key, value in self.__dict__.iteritems()]
24233 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24234 
 
24235 
  def __eq__(self, other):
24236 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24237 
 
24238 
  def __ne__(self, other):
24239 
    return not (self == other)
24240 
 
24241 
class addPageViewEvent_result:
24242 
 
24243 
  thrift_spec = (
24244 
  )
24245 
 
24246 
  def read(self, iprot):
24247 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24248 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24249 
      return
24250 
    iprot.readStructBegin()
24251 
    while True:
24252 
      (fname, ftype, fid) = iprot.readFieldBegin()
24253 
      if ftype == TType.STOP:
24254 
        break
24255 
      else:
24256 
        iprot.skip(ftype)
24257 
      iprot.readFieldEnd()
24258 
    iprot.readStructEnd()
24259 
 
24260 
  def write(self, oprot):
24261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24263 
      return
24264 
    oprot.writeStructBegin('addPageViewEvent_result')
24265 
    oprot.writeFieldStop()
24266 
    oprot.writeStructEnd()
24267 
 
24268 
  def validate(self):
24269 
    return
24270 
 
24271 
 
24272 
  def __repr__(self):
24273 
    L = ['%s=%r' % (key, value)
24274 
      for key, value in self.__dict__.iteritems()]
24275 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24276 
 
24277 
  def __eq__(self, other):
24278 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24279 
 
24280 
  def __ne__(self, other):
24281 
    return not (self == other)
24282 
 
24283 
class addCartEvent_args:
24284 
  """
24285 
  Attributes:
24286 
   - cartEvents
24287 
  """
24288 
 
24289 
  thrift_spec = (
24290 
    None, # 0
24291 
    (1, TType.STRUCT, 'cartEvents', (CartEvents, CartEvents.thrift_spec), None, ), # 1
24292 
  )
24293 
 
24294 
  def __init__(self, cartEvents=None,):
24295 
    self.cartEvents = cartEvents
24296 
 
24297 
  def read(self, iprot):
24298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24300 
      return
24301 
    iprot.readStructBegin()
24302 
    while True:
24303 
      (fname, ftype, fid) = iprot.readFieldBegin()
24304 
      if ftype == TType.STOP:
24305 
        break
24306 
      if fid == 1:
24307 
        if ftype == TType.STRUCT:
24308 
          self.cartEvents = CartEvents()
24309 
          self.cartEvents.read(iprot)
24310 
        else:
24311 
          iprot.skip(ftype)
24312 
      else:
24313 
        iprot.skip(ftype)
24314 
      iprot.readFieldEnd()
24315 
    iprot.readStructEnd()
24316 
 
24317 
  def write(self, oprot):
24318 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24319 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24320 
      return
24321 
    oprot.writeStructBegin('addCartEvent_args')
24322 
    if self.cartEvents is not None:
24323 
      oprot.writeFieldBegin('cartEvents', TType.STRUCT, 1)
24324 
      self.cartEvents.write(oprot)
24325 
      oprot.writeFieldEnd()
24326 
    oprot.writeFieldStop()
24327 
    oprot.writeStructEnd()
24328 
 
24329 
  def validate(self):
24330 
    return
24331 
 
24332 
 
24333 
  def __repr__(self):
24334 
    L = ['%s=%r' % (key, value)
24335 
      for key, value in self.__dict__.iteritems()]
24336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24337 
 
24338 
  def __eq__(self, other):
24339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24340 
 
24341 
  def __ne__(self, other):
24342 
    return not (self == other)
24343 
 
24344 
class addCartEvent_result:
24345 
 
24346 
  thrift_spec = (
24347 
  )
24348 
 
24349 
  def read(self, iprot):
24350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24352 
      return
24353 
    iprot.readStructBegin()
24354 
    while True:
24355 
      (fname, ftype, fid) = iprot.readFieldBegin()
24356 
      if ftype == TType.STOP:
24357 
        break
24358 
      else:
24359 
        iprot.skip(ftype)
24360 
      iprot.readFieldEnd()
24361 
    iprot.readStructEnd()
24362 
 
24363 
  def write(self, oprot):
24364 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24365 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24366 
      return
24367 
    oprot.writeStructBegin('addCartEvent_result')
24368 
    oprot.writeFieldStop()
24369 
    oprot.writeStructEnd()
24370 
 
24371 
  def validate(self):
24372 
    return
24373 
 
24374 
 
24375 
  def __repr__(self):
24376 
    L = ['%s=%r' % (key, value)
24377 
      for key, value in self.__dict__.iteritems()]
24378 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24379 
 
24380 
  def __eq__(self, other):
24381 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24382 
 
24383 
  def __ne__(self, other):
24384 
    return not (self == other)
8139 kshitij.so 24385 
 
8182 amar.kumar 24386 
class addEbayItem_args:
24387 
  """
24388 
  Attributes:
24389 
   - ebayItem
24390 
  """
24391 
 
24392 
  thrift_spec = (
24393 
    None, # 0
24394 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
24395 
  )
24396 
 
24397 
  def __init__(self, ebayItem=None,):
24398 
    self.ebayItem = ebayItem
24399 
 
24400 
  def read(self, iprot):
24401 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24402 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24403 
      return
24404 
    iprot.readStructBegin()
24405 
    while True:
24406 
      (fname, ftype, fid) = iprot.readFieldBegin()
24407 
      if ftype == TType.STOP:
24408 
        break
24409 
      if fid == 1:
24410 
        if ftype == TType.STRUCT:
24411 
          self.ebayItem = EbayItem()
24412 
          self.ebayItem.read(iprot)
24413 
        else:
24414 
          iprot.skip(ftype)
24415 
      else:
24416 
        iprot.skip(ftype)
24417 
      iprot.readFieldEnd()
24418 
    iprot.readStructEnd()
24419 
 
24420 
  def write(self, oprot):
24421 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24422 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24423 
      return
24424 
    oprot.writeStructBegin('addEbayItem_args')
24425 
    if self.ebayItem is not None:
24426 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
24427 
      self.ebayItem.write(oprot)
24428 
      oprot.writeFieldEnd()
24429 
    oprot.writeFieldStop()
24430 
    oprot.writeStructEnd()
24431 
 
24432 
  def validate(self):
24433 
    return
24434 
 
24435 
 
24436 
  def __repr__(self):
24437 
    L = ['%s=%r' % (key, value)
24438 
      for key, value in self.__dict__.iteritems()]
24439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24440 
 
24441 
  def __eq__(self, other):
24442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24443 
 
24444 
  def __ne__(self, other):
24445 
    return not (self == other)
24446 
 
24447 
class addEbayItem_result:
24448 
 
24449 
  thrift_spec = (
24450 
  )
24451 
 
24452 
  def read(self, iprot):
24453 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24454 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24455 
      return
24456 
    iprot.readStructBegin()
24457 
    while True:
24458 
      (fname, ftype, fid) = iprot.readFieldBegin()
24459 
      if ftype == TType.STOP:
24460 
        break
24461 
      else:
24462 
        iprot.skip(ftype)
24463 
      iprot.readFieldEnd()
24464 
    iprot.readStructEnd()
24465 
 
24466 
  def write(self, oprot):
24467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24469 
      return
24470 
    oprot.writeStructBegin('addEbayItem_result')
24471 
    oprot.writeFieldStop()
24472 
    oprot.writeStructEnd()
24473 
 
24474 
  def validate(self):
24475 
    return
24476 
 
24477 
 
24478 
  def __repr__(self):
24479 
    L = ['%s=%r' % (key, value)
24480 
      for key, value in self.__dict__.iteritems()]
24481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24482 
 
24483 
  def __eq__(self, other):
24484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24485 
 
24486 
  def __ne__(self, other):
24487 
    return not (self == other)
24488 
 
24489 
class getEbayItem_args:
24490 
  """
24491 
  Attributes:
24492 
   - listingId
24493 
  """
24494 
 
24495 
  thrift_spec = (
24496 
    None, # 0
24497 
    (1, TType.STRING, 'listingId', None, None, ), # 1
24498 
  )
24499 
 
24500 
  def __init__(self, listingId=None,):
24501 
    self.listingId = listingId
24502 
 
24503 
  def read(self, iprot):
24504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24506 
      return
24507 
    iprot.readStructBegin()
24508 
    while True:
24509 
      (fname, ftype, fid) = iprot.readFieldBegin()
24510 
      if ftype == TType.STOP:
24511 
        break
24512 
      if fid == 1:
24513 
        if ftype == TType.STRING:
24514 
          self.listingId = iprot.readString();
24515 
        else:
24516 
          iprot.skip(ftype)
24517 
      else:
24518 
        iprot.skip(ftype)
24519 
      iprot.readFieldEnd()
24520 
    iprot.readStructEnd()
24521 
 
24522 
  def write(self, oprot):
24523 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24524 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24525 
      return
24526 
    oprot.writeStructBegin('getEbayItem_args')
24527 
    if self.listingId is not None:
24528 
      oprot.writeFieldBegin('listingId', TType.STRING, 1)
24529 
      oprot.writeString(self.listingId)
24530 
      oprot.writeFieldEnd()
24531 
    oprot.writeFieldStop()
24532 
    oprot.writeStructEnd()
24533 
 
24534 
  def validate(self):
24535 
    return
24536 
 
24537 
 
24538 
  def __repr__(self):
24539 
    L = ['%s=%r' % (key, value)
24540 
      for key, value in self.__dict__.iteritems()]
24541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24542 
 
24543 
  def __eq__(self, other):
24544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24545 
 
24546 
  def __ne__(self, other):
24547 
    return not (self == other)
24548 
 
24549 
class getEbayItem_result:
24550 
  """
24551 
  Attributes:
24552 
   - success
24553 
  """
24554 
 
24555 
  thrift_spec = (
24556 
    (0, TType.STRUCT, 'success', (EbayItem, EbayItem.thrift_spec), None, ), # 0
24557 
  )
24558 
 
24559 
  def __init__(self, success=None,):
24560 
    self.success = success
24561 
 
24562 
  def read(self, iprot):
24563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24565 
      return
24566 
    iprot.readStructBegin()
24567 
    while True:
24568 
      (fname, ftype, fid) = iprot.readFieldBegin()
24569 
      if ftype == TType.STOP:
24570 
        break
24571 
      if fid == 0:
24572 
        if ftype == TType.STRUCT:
24573 
          self.success = EbayItem()
24574 
          self.success.read(iprot)
24575 
        else:
24576 
          iprot.skip(ftype)
24577 
      else:
24578 
        iprot.skip(ftype)
24579 
      iprot.readFieldEnd()
24580 
    iprot.readStructEnd()
24581 
 
24582 
  def write(self, oprot):
24583 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24584 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24585 
      return
24586 
    oprot.writeStructBegin('getEbayItem_result')
24587 
    if self.success is not None:
24588 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24589 
      self.success.write(oprot)
24590 
      oprot.writeFieldEnd()
24591 
    oprot.writeFieldStop()
24592 
    oprot.writeStructEnd()
24593 
 
24594 
  def validate(self):
24595 
    return
24596 
 
24597 
 
24598 
  def __repr__(self):
24599 
    L = ['%s=%r' % (key, value)
24600 
      for key, value in self.__dict__.iteritems()]
24601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24602 
 
24603 
  def __eq__(self, other):
24604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24605 
 
24606 
  def __ne__(self, other):
24607 
    return not (self == other)
24608 
 
24609 
class updateEbayItem_args:
24610 
  """
24611 
  Attributes:
24612 
   - ebayItem
24613 
  """
24614 
 
24615 
  thrift_spec = (
24616 
    None, # 0
24617 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
24618 
  )
24619 
 
24620 
  def __init__(self, ebayItem=None,):
24621 
    self.ebayItem = ebayItem
24622 
 
24623 
  def read(self, iprot):
24624 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24625 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24626 
      return
24627 
    iprot.readStructBegin()
24628 
    while True:
24629 
      (fname, ftype, fid) = iprot.readFieldBegin()
24630 
      if ftype == TType.STOP:
24631 
        break
24632 
      if fid == 1:
24633 
        if ftype == TType.STRUCT:
24634 
          self.ebayItem = EbayItem()
24635 
          self.ebayItem.read(iprot)
24636 
        else:
24637 
          iprot.skip(ftype)
24638 
      else:
24639 
        iprot.skip(ftype)
24640 
      iprot.readFieldEnd()
24641 
    iprot.readStructEnd()
24642 
 
24643 
  def write(self, oprot):
24644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24646 
      return
24647 
    oprot.writeStructBegin('updateEbayItem_args')
24648 
    if self.ebayItem is not None:
24649 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
24650 
      self.ebayItem.write(oprot)
24651 
      oprot.writeFieldEnd()
24652 
    oprot.writeFieldStop()
24653 
    oprot.writeStructEnd()
24654 
 
24655 
  def validate(self):
24656 
    return
24657 
 
24658 
 
24659 
  def __repr__(self):
24660 
    L = ['%s=%r' % (key, value)
24661 
      for key, value in self.__dict__.iteritems()]
24662 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24663 
 
24664 
  def __eq__(self, other):
24665 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24666 
 
24667 
  def __ne__(self, other):
24668 
    return not (self == other)
24669 
 
24670 
class updateEbayItem_result:
24671 
 
24672 
  thrift_spec = (
24673 
  )
24674 
 
24675 
  def read(self, iprot):
24676 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24677 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24678 
      return
24679 
    iprot.readStructBegin()
24680 
    while True:
24681 
      (fname, ftype, fid) = iprot.readFieldBegin()
24682 
      if ftype == TType.STOP:
24683 
        break
24684 
      else:
24685 
        iprot.skip(ftype)
24686 
      iprot.readFieldEnd()
24687 
    iprot.readStructEnd()
24688 
 
24689 
  def write(self, oprot):
24690 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24691 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24692 
      return
24693 
    oprot.writeStructBegin('updateEbayItem_result')
24694 
    oprot.writeFieldStop()
24695 
    oprot.writeStructEnd()
24696 
 
24697 
  def validate(self):
24698 
    return
24699 
 
24700 
 
24701 
  def __repr__(self):
24702 
    L = ['%s=%r' % (key, value)
24703 
      for key, value in self.__dict__.iteritems()]
24704 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24705 
 
24706 
  def __eq__(self, other):
24707 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24708 
 
24709 
  def __ne__(self, other):
24710 
    return not (self == other)
24711 
 
8139 kshitij.so 24712 
class getAmazonListedItems_args:
24713 
  """
24714 
  Attributes:
24715 
   - offset
24716 
   - limit
24717 
  """
24718 
 
24719 
  thrift_spec = (
24720 
    None, # 0
24721 
    (1, TType.I64, 'offset', None, None, ), # 1
24722 
    (2, TType.I64, 'limit', None, None, ), # 2
24723 
  )
24724 
 
24725 
  def __init__(self, offset=None, limit=None,):
24726 
    self.offset = offset
24727 
    self.limit = limit
24728 
 
24729 
  def read(self, iprot):
24730 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24731 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24732 
      return
24733 
    iprot.readStructBegin()
24734 
    while True:
24735 
      (fname, ftype, fid) = iprot.readFieldBegin()
24736 
      if ftype == TType.STOP:
24737 
        break
24738 
      if fid == 1:
24739 
        if ftype == TType.I64:
24740 
          self.offset = iprot.readI64();
24741 
        else:
24742 
          iprot.skip(ftype)
24743 
      elif fid == 2:
24744 
        if ftype == TType.I64:
24745 
          self.limit = iprot.readI64();
24746 
        else:
24747 
          iprot.skip(ftype)
24748 
      else:
24749 
        iprot.skip(ftype)
24750 
      iprot.readFieldEnd()
24751 
    iprot.readStructEnd()
24752 
 
24753 
  def write(self, oprot):
24754 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24755 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24756 
      return
24757 
    oprot.writeStructBegin('getAmazonListedItems_args')
24758 
    if self.offset is not None:
24759 
      oprot.writeFieldBegin('offset', TType.I64, 1)
24760 
      oprot.writeI64(self.offset)
24761 
      oprot.writeFieldEnd()
24762 
    if self.limit is not None:
24763 
      oprot.writeFieldBegin('limit', TType.I64, 2)
24764 
      oprot.writeI64(self.limit)
24765 
      oprot.writeFieldEnd()
24766 
    oprot.writeFieldStop()
24767 
    oprot.writeStructEnd()
24768 
 
24769 
  def validate(self):
24770 
    return
24771 
 
24772 
 
24773 
  def __repr__(self):
24774 
    L = ['%s=%r' % (key, value)
24775 
      for key, value in self.__dict__.iteritems()]
24776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24777 
 
24778 
  def __eq__(self, other):
24779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24780 
 
24781 
  def __ne__(self, other):
24782 
    return not (self == other)
24783 
 
24784 
class getAmazonListedItems_result:
24785 
  """
24786 
  Attributes:
24787 
   - success
24788 
  """
24789 
 
24790 
  thrift_spec = (
24791 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
24792 
  )
24793 
 
24794 
  def __init__(self, success=None,):
24795 
    self.success = success
24796 
 
24797 
  def read(self, iprot):
24798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24800 
      return
24801 
    iprot.readStructBegin()
24802 
    while True:
24803 
      (fname, ftype, fid) = iprot.readFieldBegin()
24804 
      if ftype == TType.STOP:
24805 
        break
24806 
      if fid == 0:
24807 
        if ftype == TType.LIST:
24808 
          self.success = []
13493 amit.gupta 24809 
          (_etype502, _size499) = iprot.readListBegin()
24810 
          for _i503 in xrange(_size499):
24811 
            _elem504 = Amazonlisted()
24812 
            _elem504.read(iprot)
24813 
            self.success.append(_elem504)
8139 kshitij.so 24814 
          iprot.readListEnd()
24815 
        else:
24816 
          iprot.skip(ftype)
24817 
      else:
24818 
        iprot.skip(ftype)
24819 
      iprot.readFieldEnd()
24820 
    iprot.readStructEnd()
24821 
 
24822 
  def write(self, oprot):
24823 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24824 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24825 
      return
24826 
    oprot.writeStructBegin('getAmazonListedItems_result')
24827 
    if self.success is not None:
24828 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24829 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 24830 
      for iter505 in self.success:
24831 
        iter505.write(oprot)
8139 kshitij.so 24832 
      oprot.writeListEnd()
24833 
      oprot.writeFieldEnd()
24834 
    oprot.writeFieldStop()
24835 
    oprot.writeStructEnd()
24836 
 
24837 
  def validate(self):
24838 
    return
24839 
 
24840 
 
24841 
  def __repr__(self):
24842 
    L = ['%s=%r' % (key, value)
24843 
      for key, value in self.__dict__.iteritems()]
24844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24845 
 
24846 
  def __eq__(self, other):
24847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24848 
 
24849 
  def __ne__(self, other):
24850 
    return not (self == other)
8168 kshitij.so 24851 
 
24852 
class updateAmazonAttributesInBulk_args:
24853 
  """
24854 
  Attributes:
24855 
   - amazonlisted
24856 
  """
24857 
 
24858 
  thrift_spec = (
24859 
    None, # 0
24860 
    (1, TType.MAP, 'amazonlisted', (TType.I64,None,TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 1
24861 
  )
24862 
 
24863 
  def __init__(self, amazonlisted=None,):
24864 
    self.amazonlisted = amazonlisted
24865 
 
24866 
  def read(self, iprot):
24867 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24868 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24869 
      return
24870 
    iprot.readStructBegin()
24871 
    while True:
24872 
      (fname, ftype, fid) = iprot.readFieldBegin()
24873 
      if ftype == TType.STOP:
24874 
        break
24875 
      if fid == 1:
24876 
        if ftype == TType.MAP:
24877 
          self.amazonlisted = {}
13493 amit.gupta 24878 
          (_ktype507, _vtype508, _size506 ) = iprot.readMapBegin()
24879 
          for _i510 in xrange(_size506):
24880 
            _key511 = iprot.readI64();
24881 
            _val512 = Amazonlisted()
24882 
            _val512.read(iprot)
24883 
            self.amazonlisted[_key511] = _val512
8168 kshitij.so 24884 
          iprot.readMapEnd()
24885 
        else:
24886 
          iprot.skip(ftype)
24887 
      else:
24888 
        iprot.skip(ftype)
24889 
      iprot.readFieldEnd()
24890 
    iprot.readStructEnd()
24891 
 
24892 
  def write(self, oprot):
24893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24895 
      return
24896 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_args')
24897 
    if self.amazonlisted is not None:
24898 
      oprot.writeFieldBegin('amazonlisted', TType.MAP, 1)
24899 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.amazonlisted))
13493 amit.gupta 24900 
      for kiter513,viter514 in self.amazonlisted.items():
24901 
        oprot.writeI64(kiter513)
24902 
        viter514.write(oprot)
8168 kshitij.so 24903 
      oprot.writeMapEnd()
24904 
      oprot.writeFieldEnd()
24905 
    oprot.writeFieldStop()
24906 
    oprot.writeStructEnd()
24907 
 
24908 
  def validate(self):
24909 
    return
24910 
 
24911 
 
24912 
  def __repr__(self):
24913 
    L = ['%s=%r' % (key, value)
24914 
      for key, value in self.__dict__.iteritems()]
24915 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24916 
 
24917 
  def __eq__(self, other):
24918 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24919 
 
24920 
  def __ne__(self, other):
24921 
    return not (self == other)
24922 
 
24923 
class updateAmazonAttributesInBulk_result:
24924 
  """
24925 
  Attributes:
24926 
   - success
24927 
  """
24928 
 
24929 
  thrift_spec = (
24930 
    (0, TType.BOOL, 'success', None, None, ), # 0
24931 
  )
24932 
 
24933 
  def __init__(self, success=None,):
24934 
    self.success = success
24935 
 
24936 
  def read(self, iprot):
24937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24939 
      return
24940 
    iprot.readStructBegin()
24941 
    while True:
24942 
      (fname, ftype, fid) = iprot.readFieldBegin()
24943 
      if ftype == TType.STOP:
24944 
        break
24945 
      if fid == 0:
24946 
        if ftype == TType.BOOL:
24947 
          self.success = iprot.readBool();
24948 
        else:
24949 
          iprot.skip(ftype)
24950 
      else:
24951 
        iprot.skip(ftype)
24952 
      iprot.readFieldEnd()
24953 
    iprot.readStructEnd()
24954 
 
24955 
  def write(self, oprot):
24956 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24957 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24958 
      return
24959 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_result')
24960 
    if self.success is not None:
24961 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
24962 
      oprot.writeBool(self.success)
24963 
      oprot.writeFieldEnd()
24964 
    oprot.writeFieldStop()
24965 
    oprot.writeStructEnd()
24966 
 
24967 
  def validate(self):
24968 
    return
24969 
 
24970 
 
24971 
  def __repr__(self):
24972 
    L = ['%s=%r' % (key, value)
24973 
      for key, value in self.__dict__.iteritems()]
24974 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24975 
 
24976 
  def __eq__(self, other):
24977 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24978 
 
24979 
  def __ne__(self, other):
24980 
    return not (self == other)
8379 vikram.rag 24981 
 
24982 
class getAllItemstoListOnFba_args:
24983 
 
24984 
  thrift_spec = (
24985 
  )
24986 
 
24987 
  def read(self, iprot):
24988 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24989 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24990 
      return
24991 
    iprot.readStructBegin()
24992 
    while True:
24993 
      (fname, ftype, fid) = iprot.readFieldBegin()
24994 
      if ftype == TType.STOP:
24995 
        break
24996 
      else:
24997 
        iprot.skip(ftype)
24998 
      iprot.readFieldEnd()
24999 
    iprot.readStructEnd()
25000 
 
25001 
  def write(self, oprot):
25002 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25003 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25004 
      return
25005 
    oprot.writeStructBegin('getAllItemstoListOnFba_args')
25006 
    oprot.writeFieldStop()
25007 
    oprot.writeStructEnd()
25008 
 
25009 
  def validate(self):
25010 
    return
25011 
 
25012 
 
25013 
  def __repr__(self):
25014 
    L = ['%s=%r' % (key, value)
25015 
      for key, value in self.__dict__.iteritems()]
25016 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25017 
 
25018 
  def __eq__(self, other):
25019 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25020 
 
25021 
  def __ne__(self, other):
25022 
    return not (self == other)
25023 
 
25024 
class getAllItemstoListOnFba_result:
25025 
  """
25026 
  Attributes:
25027 
   - success
25028 
  """
25029 
 
25030 
  thrift_spec = (
25031 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
25032 
  )
25033 
 
25034 
  def __init__(self, success=None,):
25035 
    self.success = success
25036 
 
25037 
  def read(self, iprot):
25038 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25039 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25040 
      return
25041 
    iprot.readStructBegin()
25042 
    while True:
25043 
      (fname, ftype, fid) = iprot.readFieldBegin()
25044 
      if ftype == TType.STOP:
25045 
        break
25046 
      if fid == 0:
25047 
        if ftype == TType.LIST:
25048 
          self.success = []
13493 amit.gupta 25049 
          (_etype518, _size515) = iprot.readListBegin()
25050 
          for _i519 in xrange(_size515):
25051 
            _elem520 = Amazonlisted()
25052 
            _elem520.read(iprot)
25053 
            self.success.append(_elem520)
8379 vikram.rag 25054 
          iprot.readListEnd()
25055 
        else:
25056 
          iprot.skip(ftype)
25057 
      else:
25058 
        iprot.skip(ftype)
25059 
      iprot.readFieldEnd()
25060 
    iprot.readStructEnd()
25061 
 
25062 
  def write(self, oprot):
25063 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25064 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25065 
      return
25066 
    oprot.writeStructBegin('getAllItemstoListOnFba_result')
25067 
    if self.success is not None:
25068 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25069 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 25070 
      for iter521 in self.success:
25071 
        iter521.write(oprot)
8379 vikram.rag 25072 
      oprot.writeListEnd()
25073 
      oprot.writeFieldEnd()
25074 
    oprot.writeFieldStop()
25075 
    oprot.writeStructEnd()
25076 
 
25077 
  def validate(self):
25078 
    return
25079 
 
25080 
 
25081 
  def __repr__(self):
25082 
    L = ['%s=%r' % (key, value)
25083 
      for key, value in self.__dict__.iteritems()]
25084 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25085 
 
25086 
  def __eq__(self, other):
25087 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25088 
 
25089 
  def __ne__(self, other):
25090 
    return not (self == other)
25091 
 
25092 
class getAllItemstoListOnNonFba_args:
25093 
 
25094 
  thrift_spec = (
25095 
  )
25096 
 
25097 
  def read(self, iprot):
25098 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25099 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25100 
      return
25101 
    iprot.readStructBegin()
25102 
    while True:
25103 
      (fname, ftype, fid) = iprot.readFieldBegin()
25104 
      if ftype == TType.STOP:
25105 
        break
25106 
      else:
25107 
        iprot.skip(ftype)
25108 
      iprot.readFieldEnd()
25109 
    iprot.readStructEnd()
25110 
 
25111 
  def write(self, oprot):
25112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25114 
      return
25115 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_args')
25116 
    oprot.writeFieldStop()
25117 
    oprot.writeStructEnd()
25118 
 
25119 
  def validate(self):
25120 
    return
25121 
 
25122 
 
25123 
  def __repr__(self):
25124 
    L = ['%s=%r' % (key, value)
25125 
      for key, value in self.__dict__.iteritems()]
25126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25127 
 
25128 
  def __eq__(self, other):
25129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25130 
 
25131 
  def __ne__(self, other):
25132 
    return not (self == other)
25133 
 
25134 
class getAllItemstoListOnNonFba_result:
25135 
  """
25136 
  Attributes:
25137 
   - success
25138 
  """
25139 
 
25140 
  thrift_spec = (
25141 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
25142 
  )
25143 
 
25144 
  def __init__(self, success=None,):
25145 
    self.success = success
25146 
 
25147 
  def read(self, iprot):
25148 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25149 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25150 
      return
25151 
    iprot.readStructBegin()
25152 
    while True:
25153 
      (fname, ftype, fid) = iprot.readFieldBegin()
25154 
      if ftype == TType.STOP:
25155 
        break
25156 
      if fid == 0:
25157 
        if ftype == TType.LIST:
25158 
          self.success = []
13493 amit.gupta 25159 
          (_etype525, _size522) = iprot.readListBegin()
25160 
          for _i526 in xrange(_size522):
25161 
            _elem527 = Amazonlisted()
25162 
            _elem527.read(iprot)
25163 
            self.success.append(_elem527)
8379 vikram.rag 25164 
          iprot.readListEnd()
25165 
        else:
25166 
          iprot.skip(ftype)
25167 
      else:
25168 
        iprot.skip(ftype)
25169 
      iprot.readFieldEnd()
25170 
    iprot.readStructEnd()
25171 
 
25172 
  def write(self, oprot):
25173 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25174 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25175 
      return
25176 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_result')
25177 
    if self.success is not None:
25178 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25179 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 25180 
      for iter528 in self.success:
25181 
        iter528.write(oprot)
8379 vikram.rag 25182 
      oprot.writeListEnd()
25183 
      oprot.writeFieldEnd()
25184 
    oprot.writeFieldStop()
25185 
    oprot.writeStructEnd()
25186 
 
25187 
  def validate(self):
25188 
    return
25189 
 
25190 
 
25191 
  def __repr__(self):
25192 
    L = ['%s=%r' % (key, value)
25193 
      for key, value in self.__dict__.iteritems()]
25194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25195 
 
25196 
  def __eq__(self, other):
25197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25198 
 
25199 
  def __ne__(self, other):
25200 
    return not (self == other)
8616 vikram.rag 25201 
 
9242 kshitij.so 25202 
class updateAsin_args:
25203 
  """
25204 
  Attributes:
25205 
   - item
25206 
  """
8616 vikram.rag 25207 
 
25208 
  thrift_spec = (
9242 kshitij.so 25209 
    None, # 0
25210 
    (1, TType.MAP, 'item', (TType.I64,None,TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 1
8616 vikram.rag 25211 
  )
25212 
 
9242 kshitij.so 25213 
  def __init__(self, item=None,):
25214 
    self.item = item
25215 
 
8616 vikram.rag 25216 
  def read(self, iprot):
25217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25219 
      return
25220 
    iprot.readStructBegin()
25221 
    while True:
25222 
      (fname, ftype, fid) = iprot.readFieldBegin()
25223 
      if ftype == TType.STOP:
25224 
        break
9242 kshitij.so 25225 
      if fid == 1:
25226 
        if ftype == TType.MAP:
25227 
          self.item = {}
13493 amit.gupta 25228 
          (_ktype530, _vtype531, _size529 ) = iprot.readMapBegin()
25229 
          for _i533 in xrange(_size529):
25230 
            _key534 = iprot.readI64();
25231 
            _val535 = Item()
25232 
            _val535.read(iprot)
25233 
            self.item[_key534] = _val535
9242 kshitij.so 25234 
          iprot.readMapEnd()
25235 
        else:
25236 
          iprot.skip(ftype)
8616 vikram.rag 25237 
      else:
25238 
        iprot.skip(ftype)
25239 
      iprot.readFieldEnd()
25240 
    iprot.readStructEnd()
25241 
 
25242 
  def write(self, oprot):
25243 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25244 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25245 
      return
9242 kshitij.so 25246 
    oprot.writeStructBegin('updateAsin_args')
25247 
    if self.item is not None:
25248 
      oprot.writeFieldBegin('item', TType.MAP, 1)
25249 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.item))
13493 amit.gupta 25250 
      for kiter536,viter537 in self.item.items():
25251 
        oprot.writeI64(kiter536)
25252 
        viter537.write(oprot)
9242 kshitij.so 25253 
      oprot.writeMapEnd()
25254 
      oprot.writeFieldEnd()
8616 vikram.rag 25255 
    oprot.writeFieldStop()
25256 
    oprot.writeStructEnd()
25257 
 
25258 
  def validate(self):
25259 
    return
25260 
 
25261 
 
25262 
  def __repr__(self):
25263 
    L = ['%s=%r' % (key, value)
25264 
      for key, value in self.__dict__.iteritems()]
25265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25266 
 
25267 
  def __eq__(self, other):
25268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25269 
 
25270 
  def __ne__(self, other):
25271 
    return not (self == other)
25272 
 
9242 kshitij.so 25273 
class updateAsin_result:
8616 vikram.rag 25274 
 
25275 
  thrift_spec = (
25276 
  )
25277 
 
25278 
  def read(self, iprot):
25279 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25280 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25281 
      return
25282 
    iprot.readStructBegin()
25283 
    while True:
25284 
      (fname, ftype, fid) = iprot.readFieldBegin()
25285 
      if ftype == TType.STOP:
25286 
        break
25287 
      else:
25288 
        iprot.skip(ftype)
25289 
      iprot.readFieldEnd()
25290 
    iprot.readStructEnd()
25291 
 
25292 
  def write(self, oprot):
25293 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25294 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25295 
      return
9242 kshitij.so 25296 
    oprot.writeStructBegin('updateAsin_result')
8616 vikram.rag 25297 
    oprot.writeFieldStop()
25298 
    oprot.writeStructEnd()
25299 
 
25300 
  def validate(self):
25301 
    return
25302 
 
25303 
 
25304 
  def __repr__(self):
25305 
    L = ['%s=%r' % (key, value)
25306 
      for key, value in self.__dict__.iteritems()]
25307 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25308 
 
25309 
  def __eq__(self, other):
25310 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25311 
 
25312 
  def __ne__(self, other):
25313 
    return not (self == other)
8619 kshitij.so 25314 
 
9242 kshitij.so 25315 
class addOrUpdateSnapdealItem_args:
8619 kshitij.so 25316 
  """
25317 
  Attributes:
9242 kshitij.so 25318 
   - snapdealitem
8619 kshitij.so 25319 
  """
25320 
 
9242 kshitij.so 25321 
  thrift_spec = None
25322 
  def __init__(self, snapdealitem=None,):
25323 
    self.snapdealitem = snapdealitem
8619 kshitij.so 25324 
 
25325 
  def read(self, iprot):
25326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25328 
      return
25329 
    iprot.readStructBegin()
25330 
    while True:
25331 
      (fname, ftype, fid) = iprot.readFieldBegin()
25332 
      if ftype == TType.STOP:
25333 
        break
9242 kshitij.so 25334 
      if fid == -1:
25335 
        if ftype == TType.STRUCT:
25336 
          self.snapdealitem = SnapdealItem()
25337 
          self.snapdealitem.read(iprot)
8619 kshitij.so 25338 
        else:
25339 
          iprot.skip(ftype)
25340 
      else:
25341 
        iprot.skip(ftype)
25342 
      iprot.readFieldEnd()
25343 
    iprot.readStructEnd()
25344 
 
25345 
  def write(self, oprot):
25346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25348 
      return
9242 kshitij.so 25349 
    oprot.writeStructBegin('addOrUpdateSnapdealItem_args')
25350 
    if self.snapdealitem is not None:
25351 
      oprot.writeFieldBegin('snapdealitem', TType.STRUCT, -1)
25352 
      self.snapdealitem.write(oprot)
8619 kshitij.so 25353 
      oprot.writeFieldEnd()
25354 
    oprot.writeFieldStop()
25355 
    oprot.writeStructEnd()
25356 
 
25357 
  def validate(self):
25358 
    return
25359 
 
25360 
 
25361 
  def __repr__(self):
25362 
    L = ['%s=%r' % (key, value)
25363 
      for key, value in self.__dict__.iteritems()]
25364 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25365 
 
25366 
  def __eq__(self, other):
25367 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25368 
 
25369 
  def __ne__(self, other):
25370 
    return not (self == other)
25371 
 
9242 kshitij.so 25372 
class addOrUpdateSnapdealItem_result:
25373 
  """
25374 
  Attributes:
25375 
   - success
25376 
  """
8619 kshitij.so 25377 
 
25378 
  thrift_spec = (
9242 kshitij.so 25379 
    (0, TType.BOOL, 'success', None, None, ), # 0
8619 kshitij.so 25380 
  )
25381 
 
9242 kshitij.so 25382 
  def __init__(self, success=None,):
25383 
    self.success = success
25384 
 
8619 kshitij.so 25385 
  def read(self, iprot):
25386 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25387 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25388 
      return
25389 
    iprot.readStructBegin()
25390 
    while True:
25391 
      (fname, ftype, fid) = iprot.readFieldBegin()
25392 
      if ftype == TType.STOP:
25393 
        break
9242 kshitij.so 25394 
      if fid == 0:
25395 
        if ftype == TType.BOOL:
25396 
          self.success = iprot.readBool();
25397 
        else:
25398 
          iprot.skip(ftype)
8619 kshitij.so 25399 
      else:
25400 
        iprot.skip(ftype)
25401 
      iprot.readFieldEnd()
25402 
    iprot.readStructEnd()
25403 
 
25404 
  def write(self, oprot):
25405 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25406 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25407 
      return
9242 kshitij.so 25408 
    oprot.writeStructBegin('addOrUpdateSnapdealItem_result')
25409 
    if self.success is not None:
25410 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
25411 
      oprot.writeBool(self.success)
25412 
      oprot.writeFieldEnd()
8619 kshitij.so 25413 
    oprot.writeFieldStop()
25414 
    oprot.writeStructEnd()
25415 
 
25416 
  def validate(self):
25417 
    return
25418 
 
25419 
 
25420 
  def __repr__(self):
25421 
    L = ['%s=%r' % (key, value)
25422 
      for key, value in self.__dict__.iteritems()]
25423 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25424 
 
25425 
  def __eq__(self, other):
25426 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25427 
 
25428 
  def __ne__(self, other):
25429 
    return not (self == other)
8739 vikram.rag 25430 
 
9242 kshitij.so 25431 
class getSnapdealItem_args:
8739 vikram.rag 25432 
  """
25433 
  Attributes:
9242 kshitij.so 25434 
   - item_id
8739 vikram.rag 25435 
  """
25436 
 
9242 kshitij.so 25437 
  thrift_spec = (
25438 
    None, # 0
25439 
    (1, TType.I64, 'item_id', None, None, ), # 1
25440 
  )
8739 vikram.rag 25441 
 
9242 kshitij.so 25442 
  def __init__(self, item_id=None,):
25443 
    self.item_id = item_id
25444 
 
8739 vikram.rag 25445 
  def read(self, iprot):
25446 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25447 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25448 
      return
25449 
    iprot.readStructBegin()
25450 
    while True:
25451 
      (fname, ftype, fid) = iprot.readFieldBegin()
25452 
      if ftype == TType.STOP:
25453 
        break
9242 kshitij.so 25454 
      if fid == 1:
25455 
        if ftype == TType.I64:
25456 
          self.item_id = iprot.readI64();
8739 vikram.rag 25457 
        else:
25458 
          iprot.skip(ftype)
25459 
      else:
25460 
        iprot.skip(ftype)
25461 
      iprot.readFieldEnd()
25462 
    iprot.readStructEnd()
25463 
 
25464 
  def write(self, oprot):
25465 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25466 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25467 
      return
9242 kshitij.so 25468 
    oprot.writeStructBegin('getSnapdealItem_args')
25469 
    if self.item_id is not None:
25470 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
25471 
      oprot.writeI64(self.item_id)
8739 vikram.rag 25472 
      oprot.writeFieldEnd()
25473 
    oprot.writeFieldStop()
25474 
    oprot.writeStructEnd()
25475 
 
25476 
  def validate(self):
25477 
    return
25478 
 
25479 
 
25480 
  def __repr__(self):
25481 
    L = ['%s=%r' % (key, value)
25482 
      for key, value in self.__dict__.iteritems()]
25483 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25484 
 
25485 
  def __eq__(self, other):
25486 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25487 
 
25488 
  def __ne__(self, other):
25489 
    return not (self == other)
25490 
 
9242 kshitij.so 25491 
class getSnapdealItem_result:
8739 vikram.rag 25492 
  """
25493 
  Attributes:
25494 
   - success
25495 
  """
25496 
 
25497 
  thrift_spec = (
9242 kshitij.so 25498 
    (0, TType.STRUCT, 'success', (SnapdealItem, SnapdealItem.thrift_spec), None, ), # 0
8739 vikram.rag 25499 
  )
25500 
 
25501 
  def __init__(self, success=None,):
25502 
    self.success = success
25503 
 
25504 
  def read(self, iprot):
25505 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25506 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25507 
      return
25508 
    iprot.readStructBegin()
25509 
    while True:
25510 
      (fname, ftype, fid) = iprot.readFieldBegin()
25511 
      if ftype == TType.STOP:
25512 
        break
25513 
      if fid == 0:
9242 kshitij.so 25514 
        if ftype == TType.STRUCT:
25515 
          self.success = SnapdealItem()
25516 
          self.success.read(iprot)
8739 vikram.rag 25517 
        else:
25518 
          iprot.skip(ftype)
25519 
      else:
25520 
        iprot.skip(ftype)
25521 
      iprot.readFieldEnd()
25522 
    iprot.readStructEnd()
25523 
 
25524 
  def write(self, oprot):
25525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25527 
      return
9242 kshitij.so 25528 
    oprot.writeStructBegin('getSnapdealItem_result')
8739 vikram.rag 25529 
    if self.success is not None:
9242 kshitij.so 25530 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
25531 
      self.success.write(oprot)
8739 vikram.rag 25532 
      oprot.writeFieldEnd()
25533 
    oprot.writeFieldStop()
25534 
    oprot.writeStructEnd()
25535 
 
25536 
  def validate(self):
25537 
    return
25538 
 
25539 
 
25540 
  def __repr__(self):
25541 
    L = ['%s=%r' % (key, value)
25542 
      for key, value in self.__dict__.iteritems()]
25543 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25544 
 
25545 
  def __eq__(self, other):
25546 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25547 
 
25548 
  def __ne__(self, other):
25549 
    return not (self == other)
25550 
 
9242 kshitij.so 25551 
class getSnapdealItemDetails_args:
8739 vikram.rag 25552 
  """
25553 
  Attributes:
25554 
   - item_id
25555 
  """
25556 
 
25557 
  thrift_spec = (
25558 
    None, # 0
25559 
    (1, TType.I64, 'item_id', None, None, ), # 1
25560 
  )
25561 
 
25562 
  def __init__(self, item_id=None,):
25563 
    self.item_id = item_id
25564 
 
25565 
  def read(self, iprot):
25566 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25567 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25568 
      return
25569 
    iprot.readStructBegin()
25570 
    while True:
25571 
      (fname, ftype, fid) = iprot.readFieldBegin()
25572 
      if ftype == TType.STOP:
25573 
        break
25574 
      if fid == 1:
25575 
        if ftype == TType.I64:
25576 
          self.item_id = iprot.readI64();
25577 
        else:
25578 
          iprot.skip(ftype)
25579 
      else:
25580 
        iprot.skip(ftype)
25581 
      iprot.readFieldEnd()
25582 
    iprot.readStructEnd()
25583 
 
25584 
  def write(self, oprot):
25585 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25586 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25587 
      return
9242 kshitij.so 25588 
    oprot.writeStructBegin('getSnapdealItemDetails_args')
8739 vikram.rag 25589 
    if self.item_id is not None:
25590 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
25591 
      oprot.writeI64(self.item_id)
25592 
      oprot.writeFieldEnd()
25593 
    oprot.writeFieldStop()
25594 
    oprot.writeStructEnd()
25595 
 
25596 
  def validate(self):
25597 
    return
25598 
 
25599 
 
25600 
  def __repr__(self):
25601 
    L = ['%s=%r' % (key, value)
25602 
      for key, value in self.__dict__.iteritems()]
25603 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25604 
 
25605 
  def __eq__(self, other):
25606 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25607 
 
25608 
  def __ne__(self, other):
25609 
    return not (self == other)
25610 
 
9242 kshitij.so 25611 
class getSnapdealItemDetails_result:
8739 vikram.rag 25612 
  """
25613 
  Attributes:
25614 
   - success
25615 
  """
25616 
 
25617 
  thrift_spec = (
9242 kshitij.so 25618 
    (0, TType.STRUCT, 'success', (SnapdealItemDetails, SnapdealItemDetails.thrift_spec), None, ), # 0
8739 vikram.rag 25619 
  )
25620 
 
25621 
  def __init__(self, success=None,):
25622 
    self.success = success
25623 
 
25624 
  def read(self, iprot):
25625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25627 
      return
25628 
    iprot.readStructBegin()
25629 
    while True:
25630 
      (fname, ftype, fid) = iprot.readFieldBegin()
25631 
      if ftype == TType.STOP:
25632 
        break
25633 
      if fid == 0:
25634 
        if ftype == TType.STRUCT:
9242 kshitij.so 25635 
          self.success = SnapdealItemDetails()
8739 vikram.rag 25636 
          self.success.read(iprot)
25637 
        else:
25638 
          iprot.skip(ftype)
25639 
      else:
25640 
        iprot.skip(ftype)
25641 
      iprot.readFieldEnd()
25642 
    iprot.readStructEnd()
25643 
 
25644 
  def write(self, oprot):
25645 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25646 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25647 
      return
9242 kshitij.so 25648 
    oprot.writeStructBegin('getSnapdealItemDetails_result')
8739 vikram.rag 25649 
    if self.success is not None:
25650 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
25651 
      self.success.write(oprot)
25652 
      oprot.writeFieldEnd()
25653 
    oprot.writeFieldStop()
25654 
    oprot.writeStructEnd()
25655 
 
25656 
  def validate(self):
25657 
    return
25658 
 
25659 
 
25660 
  def __repr__(self):
25661 
    L = ['%s=%r' % (key, value)
25662 
      for key, value in self.__dict__.iteritems()]
25663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25664 
 
25665 
  def __eq__(self, other):
25666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25667 
 
25668 
  def __ne__(self, other):
25669 
    return not (self == other)
25670 
 
25671 
class getAllSnapdealItems_args:
25672 
 
25673 
  thrift_spec = (
25674 
  )
25675 
 
25676 
  def read(self, iprot):
25677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25679 
      return
25680 
    iprot.readStructBegin()
25681 
    while True:
25682 
      (fname, ftype, fid) = iprot.readFieldBegin()
25683 
      if ftype == TType.STOP:
25684 
        break
25685 
      else:
25686 
        iprot.skip(ftype)
25687 
      iprot.readFieldEnd()
25688 
    iprot.readStructEnd()
25689 
 
25690 
  def write(self, oprot):
25691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25693 
      return
25694 
    oprot.writeStructBegin('getAllSnapdealItems_args')
25695 
    oprot.writeFieldStop()
25696 
    oprot.writeStructEnd()
25697 
 
25698 
  def validate(self):
25699 
    return
25700 
 
25701 
 
25702 
  def __repr__(self):
25703 
    L = ['%s=%r' % (key, value)
25704 
      for key, value in self.__dict__.iteritems()]
25705 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25706 
 
25707 
  def __eq__(self, other):
25708 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25709 
 
25710 
  def __ne__(self, other):
25711 
    return not (self == other)
25712 
 
25713 
class getAllSnapdealItems_result:
25714 
  """
25715 
  Attributes:
25716 
   - success
25717 
  """
25718 
 
25719 
  thrift_spec = (
9242 kshitij.so 25720 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
8739 vikram.rag 25721 
  )
25722 
 
25723 
  def __init__(self, success=None,):
25724 
    self.success = success
25725 
 
25726 
  def read(self, iprot):
25727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25729 
      return
25730 
    iprot.readStructBegin()
25731 
    while True:
25732 
      (fname, ftype, fid) = iprot.readFieldBegin()
25733 
      if ftype == TType.STOP:
25734 
        break
25735 
      if fid == 0:
25736 
        if ftype == TType.LIST:
25737 
          self.success = []
13493 amit.gupta 25738 
          (_etype541, _size538) = iprot.readListBegin()
25739 
          for _i542 in xrange(_size538):
25740 
            _elem543 = SnapdealItemDetails()
25741 
            _elem543.read(iprot)
25742 
            self.success.append(_elem543)
9242 kshitij.so 25743 
          iprot.readListEnd()
25744 
        else:
25745 
          iprot.skip(ftype)
25746 
      else:
25747 
        iprot.skip(ftype)
25748 
      iprot.readFieldEnd()
25749 
    iprot.readStructEnd()
25750 
 
25751 
  def write(self, oprot):
25752 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25753 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25754 
      return
25755 
    oprot.writeStructBegin('getAllSnapdealItems_result')
25756 
    if self.success is not None:
25757 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25758 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 25759 
      for iter544 in self.success:
25760 
        iter544.write(oprot)
9242 kshitij.so 25761 
      oprot.writeListEnd()
25762 
      oprot.writeFieldEnd()
25763 
    oprot.writeFieldStop()
25764 
    oprot.writeStructEnd()
25765 
 
25766 
  def validate(self):
25767 
    return
25768 
 
25769 
 
25770 
  def __repr__(self):
25771 
    L = ['%s=%r' % (key, value)
25772 
      for key, value in self.__dict__.iteritems()]
25773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25774 
 
25775 
  def __eq__(self, other):
25776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25777 
 
25778 
  def __ne__(self, other):
25779 
    return not (self == other)
25780 
 
25781 
class getSnapdealItems_args:
25782 
  """
25783 
  Attributes:
25784 
   - offset
25785 
   - limit
25786 
  """
25787 
 
25788 
  thrift_spec = (
25789 
    None, # 0
25790 
    (1, TType.I64, 'offset', None, None, ), # 1
25791 
    (2, TType.I64, 'limit', None, None, ), # 2
25792 
  )
25793 
 
25794 
  def __init__(self, offset=None, limit=None,):
25795 
    self.offset = offset
25796 
    self.limit = limit
25797 
 
25798 
  def read(self, iprot):
25799 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25800 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25801 
      return
25802 
    iprot.readStructBegin()
25803 
    while True:
25804 
      (fname, ftype, fid) = iprot.readFieldBegin()
25805 
      if ftype == TType.STOP:
25806 
        break
25807 
      if fid == 1:
25808 
        if ftype == TType.I64:
25809 
          self.offset = iprot.readI64();
25810 
        else:
25811 
          iprot.skip(ftype)
25812 
      elif fid == 2:
25813 
        if ftype == TType.I64:
25814 
          self.limit = iprot.readI64();
25815 
        else:
25816 
          iprot.skip(ftype)
25817 
      else:
25818 
        iprot.skip(ftype)
25819 
      iprot.readFieldEnd()
25820 
    iprot.readStructEnd()
25821 
 
25822 
  def write(self, oprot):
25823 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25824 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25825 
      return
25826 
    oprot.writeStructBegin('getSnapdealItems_args')
25827 
    if self.offset is not None:
25828 
      oprot.writeFieldBegin('offset', TType.I64, 1)
25829 
      oprot.writeI64(self.offset)
25830 
      oprot.writeFieldEnd()
25831 
    if self.limit is not None:
25832 
      oprot.writeFieldBegin('limit', TType.I64, 2)
25833 
      oprot.writeI64(self.limit)
25834 
      oprot.writeFieldEnd()
25835 
    oprot.writeFieldStop()
25836 
    oprot.writeStructEnd()
25837 
 
25838 
  def validate(self):
25839 
    return
25840 
 
25841 
 
25842 
  def __repr__(self):
25843 
    L = ['%s=%r' % (key, value)
25844 
      for key, value in self.__dict__.iteritems()]
25845 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25846 
 
25847 
  def __eq__(self, other):
25848 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25849 
 
25850 
  def __ne__(self, other):
25851 
    return not (self == other)
25852 
 
25853 
class getSnapdealItems_result:
25854 
  """
25855 
  Attributes:
25856 
   - success
25857 
  """
25858 
 
25859 
  thrift_spec = (
25860 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
25861 
  )
25862 
 
25863 
  def __init__(self, success=None,):
25864 
    self.success = success
25865 
 
25866 
  def read(self, iprot):
25867 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25868 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25869 
      return
25870 
    iprot.readStructBegin()
25871 
    while True:
25872 
      (fname, ftype, fid) = iprot.readFieldBegin()
25873 
      if ftype == TType.STOP:
25874 
        break
25875 
      if fid == 0:
25876 
        if ftype == TType.LIST:
25877 
          self.success = []
13493 amit.gupta 25878 
          (_etype548, _size545) = iprot.readListBegin()
25879 
          for _i549 in xrange(_size545):
25880 
            _elem550 = SnapdealItemDetails()
25881 
            _elem550.read(iprot)
25882 
            self.success.append(_elem550)
8739 vikram.rag 25883 
          iprot.readListEnd()
25884 
        else:
25885 
          iprot.skip(ftype)
25886 
      else:
25887 
        iprot.skip(ftype)
25888 
      iprot.readFieldEnd()
25889 
    iprot.readStructEnd()
25890 
 
25891 
  def write(self, oprot):
25892 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25893 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25894 
      return
9242 kshitij.so 25895 
    oprot.writeStructBegin('getSnapdealItems_result')
8739 vikram.rag 25896 
    if self.success is not None:
25897 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25898 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 25899 
      for iter551 in self.success:
25900 
        iter551.write(oprot)
8739 vikram.rag 25901 
      oprot.writeListEnd()
25902 
      oprot.writeFieldEnd()
25903 
    oprot.writeFieldStop()
25904 
    oprot.writeStructEnd()
25905 
 
25906 
  def validate(self):
25907 
    return
25908 
 
25909 
 
25910 
  def __repr__(self):
25911 
    L = ['%s=%r' % (key, value)
25912 
      for key, value in self.__dict__.iteritems()]
25913 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25914 
 
25915 
  def __eq__(self, other):
25916 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25917 
 
25918 
  def __ne__(self, other):
25919 
    return not (self == other)
9242 kshitij.so 25920 
 
25921 
class searchSnapdealItems_args:
25922 
  """
25923 
  Attributes:
25924 
   - searchTerm
25925 
   - offset
25926 
   - limit
25927 
  """
25928 
 
25929 
  thrift_spec = (
25930 
    None, # 0
25931 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
25932 
    (2, TType.I64, 'offset', None, None, ), # 2
25933 
    (3, TType.I64, 'limit', None, None, ), # 3
25934 
  )
25935 
 
25936 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
25937 
    self.searchTerm = searchTerm
25938 
    self.offset = offset
25939 
    self.limit = limit
25940 
 
25941 
  def read(self, iprot):
25942 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25943 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25944 
      return
25945 
    iprot.readStructBegin()
25946 
    while True:
25947 
      (fname, ftype, fid) = iprot.readFieldBegin()
25948 
      if ftype == TType.STOP:
25949 
        break
25950 
      if fid == 1:
25951 
        if ftype == TType.LIST:
25952 
          self.searchTerm = []
13493 amit.gupta 25953 
          (_etype555, _size552) = iprot.readListBegin()
25954 
          for _i556 in xrange(_size552):
25955 
            _elem557 = iprot.readString();
25956 
            self.searchTerm.append(_elem557)
9242 kshitij.so 25957 
          iprot.readListEnd()
25958 
        else:
25959 
          iprot.skip(ftype)
25960 
      elif fid == 2:
25961 
        if ftype == TType.I64:
25962 
          self.offset = iprot.readI64();
25963 
        else:
25964 
          iprot.skip(ftype)
25965 
      elif fid == 3:
25966 
        if ftype == TType.I64:
25967 
          self.limit = iprot.readI64();
25968 
        else:
25969 
          iprot.skip(ftype)
25970 
      else:
25971 
        iprot.skip(ftype)
25972 
      iprot.readFieldEnd()
25973 
    iprot.readStructEnd()
25974 
 
25975 
  def write(self, oprot):
25976 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25977 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25978 
      return
25979 
    oprot.writeStructBegin('searchSnapdealItems_args')
25980 
    if self.searchTerm is not None:
25981 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
25982 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
13493 amit.gupta 25983 
      for iter558 in self.searchTerm:
25984 
        oprot.writeString(iter558)
9242 kshitij.so 25985 
      oprot.writeListEnd()
25986 
      oprot.writeFieldEnd()
25987 
    if self.offset is not None:
25988 
      oprot.writeFieldBegin('offset', TType.I64, 2)
25989 
      oprot.writeI64(self.offset)
25990 
      oprot.writeFieldEnd()
25991 
    if self.limit is not None:
25992 
      oprot.writeFieldBegin('limit', TType.I64, 3)
25993 
      oprot.writeI64(self.limit)
25994 
      oprot.writeFieldEnd()
25995 
    oprot.writeFieldStop()
25996 
    oprot.writeStructEnd()
25997 
 
25998 
  def validate(self):
25999 
    return
26000 
 
26001 
 
26002 
  def __repr__(self):
26003 
    L = ['%s=%r' % (key, value)
26004 
      for key, value in self.__dict__.iteritems()]
26005 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26006 
 
26007 
  def __eq__(self, other):
26008 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26009 
 
26010 
  def __ne__(self, other):
26011 
    return not (self == other)
26012 
 
26013 
class searchSnapdealItems_result:
26014 
  """
26015 
  Attributes:
26016 
   - success
26017 
  """
26018 
 
26019 
  thrift_spec = (
26020 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
26021 
  )
26022 
 
26023 
  def __init__(self, success=None,):
26024 
    self.success = success
26025 
 
26026 
  def read(self, iprot):
26027 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26028 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26029 
      return
26030 
    iprot.readStructBegin()
26031 
    while True:
26032 
      (fname, ftype, fid) = iprot.readFieldBegin()
26033 
      if ftype == TType.STOP:
26034 
        break
26035 
      if fid == 0:
26036 
        if ftype == TType.LIST:
26037 
          self.success = []
13493 amit.gupta 26038 
          (_etype562, _size559) = iprot.readListBegin()
26039 
          for _i563 in xrange(_size559):
26040 
            _elem564 = SnapdealItemDetails()
26041 
            _elem564.read(iprot)
26042 
            self.success.append(_elem564)
9242 kshitij.so 26043 
          iprot.readListEnd()
26044 
        else:
26045 
          iprot.skip(ftype)
26046 
      else:
26047 
        iprot.skip(ftype)
26048 
      iprot.readFieldEnd()
26049 
    iprot.readStructEnd()
26050 
 
26051 
  def write(self, oprot):
26052 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26053 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26054 
      return
26055 
    oprot.writeStructBegin('searchSnapdealItems_result')
26056 
    if self.success is not None:
26057 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26058 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 26059 
      for iter565 in self.success:
26060 
        iter565.write(oprot)
9242 kshitij.so 26061 
      oprot.writeListEnd()
26062 
      oprot.writeFieldEnd()
26063 
    oprot.writeFieldStop()
26064 
    oprot.writeStructEnd()
26065 
 
26066 
  def validate(self):
26067 
    return
26068 
 
26069 
 
26070 
  def __repr__(self):
26071 
    L = ['%s=%r' % (key, value)
26072 
      for key, value in self.__dict__.iteritems()]
26073 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26074 
 
26075 
  def __eq__(self, other):
26076 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26077 
 
26078 
  def __ne__(self, other):
26079 
    return not (self == other)
26080 
 
26081 
class getCountForSnapdealItems_args:
26082 
 
26083 
  thrift_spec = (
26084 
  )
26085 
 
26086 
  def read(self, iprot):
26087 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26088 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26089 
      return
26090 
    iprot.readStructBegin()
26091 
    while True:
26092 
      (fname, ftype, fid) = iprot.readFieldBegin()
26093 
      if ftype == TType.STOP:
26094 
        break
26095 
      else:
26096 
        iprot.skip(ftype)
26097 
      iprot.readFieldEnd()
26098 
    iprot.readStructEnd()
26099 
 
26100 
  def write(self, oprot):
26101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26103 
      return
26104 
    oprot.writeStructBegin('getCountForSnapdealItems_args')
26105 
    oprot.writeFieldStop()
26106 
    oprot.writeStructEnd()
26107 
 
26108 
  def validate(self):
26109 
    return
26110 
 
26111 
 
26112 
  def __repr__(self):
26113 
    L = ['%s=%r' % (key, value)
26114 
      for key, value in self.__dict__.iteritems()]
26115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26116 
 
26117 
  def __eq__(self, other):
26118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26119 
 
26120 
  def __ne__(self, other):
26121 
    return not (self == other)
26122 
 
26123 
class getCountForSnapdealItems_result:
26124 
  """
26125 
  Attributes:
26126 
   - success
26127 
  """
26128 
 
26129 
  thrift_spec = (
26130 
    (0, TType.I64, 'success', None, None, ), # 0
26131 
  )
26132 
 
26133 
  def __init__(self, success=None,):
26134 
    self.success = success
26135 
 
26136 
  def read(self, iprot):
26137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26139 
      return
26140 
    iprot.readStructBegin()
26141 
    while True:
26142 
      (fname, ftype, fid) = iprot.readFieldBegin()
26143 
      if ftype == TType.STOP:
26144 
        break
26145 
      if fid == 0:
26146 
        if ftype == TType.I64:
26147 
          self.success = iprot.readI64();
26148 
        else:
26149 
          iprot.skip(ftype)
26150 
      else:
26151 
        iprot.skip(ftype)
26152 
      iprot.readFieldEnd()
26153 
    iprot.readStructEnd()
26154 
 
26155 
  def write(self, oprot):
26156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26158 
      return
26159 
    oprot.writeStructBegin('getCountForSnapdealItems_result')
26160 
    if self.success is not None:
26161 
      oprot.writeFieldBegin('success', TType.I64, 0)
26162 
      oprot.writeI64(self.success)
26163 
      oprot.writeFieldEnd()
26164 
    oprot.writeFieldStop()
26165 
    oprot.writeStructEnd()
26166 
 
26167 
  def validate(self):
26168 
    return
26169 
 
26170 
 
26171 
  def __repr__(self):
26172 
    L = ['%s=%r' % (key, value)
26173 
      for key, value in self.__dict__.iteritems()]
26174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26175 
 
26176 
  def __eq__(self, other):
26177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26178 
 
26179 
  def __ne__(self, other):
26180 
    return not (self == other)
26181 
 
26182 
class getSnapdealSearchResultCount_args:
26183 
  """
26184 
  Attributes:
26185 
   - searchTerm
26186 
  """
26187 
 
26188 
  thrift_spec = (
26189 
    None, # 0
26190 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
26191 
  )
26192 
 
26193 
  def __init__(self, searchTerm=None,):
26194 
    self.searchTerm = searchTerm
26195 
 
26196 
  def read(self, iprot):
26197 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26198 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26199 
      return
26200 
    iprot.readStructBegin()
26201 
    while True:
26202 
      (fname, ftype, fid) = iprot.readFieldBegin()
26203 
      if ftype == TType.STOP:
26204 
        break
26205 
      if fid == 1:
26206 
        if ftype == TType.LIST:
26207 
          self.searchTerm = []
13493 amit.gupta 26208 
          (_etype569, _size566) = iprot.readListBegin()
26209 
          for _i570 in xrange(_size566):
26210 
            _elem571 = iprot.readString();
26211 
            self.searchTerm.append(_elem571)
9242 kshitij.so 26212 
          iprot.readListEnd()
26213 
        else:
26214 
          iprot.skip(ftype)
26215 
      else:
26216 
        iprot.skip(ftype)
26217 
      iprot.readFieldEnd()
26218 
    iprot.readStructEnd()
26219 
 
26220 
  def write(self, oprot):
26221 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26222 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26223 
      return
26224 
    oprot.writeStructBegin('getSnapdealSearchResultCount_args')
26225 
    if self.searchTerm is not None:
26226 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
26227 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
13493 amit.gupta 26228 
      for iter572 in self.searchTerm:
26229 
        oprot.writeString(iter572)
9242 kshitij.so 26230 
      oprot.writeListEnd()
26231 
      oprot.writeFieldEnd()
26232 
    oprot.writeFieldStop()
26233 
    oprot.writeStructEnd()
26234 
 
26235 
  def validate(self):
26236 
    return
26237 
 
26238 
 
26239 
  def __repr__(self):
26240 
    L = ['%s=%r' % (key, value)
26241 
      for key, value in self.__dict__.iteritems()]
26242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26243 
 
26244 
  def __eq__(self, other):
26245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26246 
 
26247 
  def __ne__(self, other):
26248 
    return not (self == other)
26249 
 
26250 
class getSnapdealSearchResultCount_result:
26251 
  """
26252 
  Attributes:
26253 
   - success
26254 
  """
26255 
 
26256 
  thrift_spec = (
26257 
    (0, TType.I64, 'success', None, None, ), # 0
26258 
  )
26259 
 
26260 
  def __init__(self, success=None,):
26261 
    self.success = success
26262 
 
26263 
  def read(self, iprot):
26264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26266 
      return
26267 
    iprot.readStructBegin()
26268 
    while True:
26269 
      (fname, ftype, fid) = iprot.readFieldBegin()
26270 
      if ftype == TType.STOP:
26271 
        break
26272 
      if fid == 0:
26273 
        if ftype == TType.I64:
26274 
          self.success = iprot.readI64();
26275 
        else:
26276 
          iprot.skip(ftype)
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('getSnapdealSearchResultCount_result')
26287 
    if self.success is not None:
26288 
      oprot.writeFieldBegin('success', TType.I64, 0)
26289 
      oprot.writeI64(self.success)
26290 
      oprot.writeFieldEnd()
26291 
    oprot.writeFieldStop()
26292 
    oprot.writeStructEnd()
26293 
 
26294 
  def validate(self):
26295 
    return
26296 
 
26297 
 
26298 
  def __repr__(self):
26299 
    L = ['%s=%r' % (key, value)
26300 
      for key, value in self.__dict__.iteritems()]
26301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26302 
 
26303 
  def __eq__(self, other):
26304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26305 
 
26306 
  def __ne__(self, other):
26307 
    return not (self == other)
9299 kshitij.so 26308 
 
26309 
class getPrefferedInsurerForItem_args:
26310 
  """
26311 
  Attributes:
26312 
   - itemId
26313 
   - insurerType
26314 
  """
26315 
 
26316 
  thrift_spec = (
26317 
    None, # 0
26318 
    (1, TType.I64, 'itemId', None, None, ), # 1
26319 
    (2, TType.I32, 'insurerType', None, None, ), # 2
26320 
  )
26321 
 
26322 
  def __init__(self, itemId=None, insurerType=None,):
26323 
    self.itemId = itemId
26324 
    self.insurerType = insurerType
26325 
 
26326 
  def read(self, iprot):
26327 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26328 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26329 
      return
26330 
    iprot.readStructBegin()
26331 
    while True:
26332 
      (fname, ftype, fid) = iprot.readFieldBegin()
26333 
      if ftype == TType.STOP:
26334 
        break
26335 
      if fid == 1:
26336 
        if ftype == TType.I64:
26337 
          self.itemId = iprot.readI64();
26338 
        else:
26339 
          iprot.skip(ftype)
26340 
      elif fid == 2:
26341 
        if ftype == TType.I32:
26342 
          self.insurerType = iprot.readI32();
26343 
        else:
26344 
          iprot.skip(ftype)
26345 
      else:
26346 
        iprot.skip(ftype)
26347 
      iprot.readFieldEnd()
26348 
    iprot.readStructEnd()
26349 
 
26350 
  def write(self, oprot):
26351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26353 
      return
26354 
    oprot.writeStructBegin('getPrefferedInsurerForItem_args')
26355 
    if self.itemId is not None:
26356 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
26357 
      oprot.writeI64(self.itemId)
26358 
      oprot.writeFieldEnd()
26359 
    if self.insurerType is not None:
26360 
      oprot.writeFieldBegin('insurerType', TType.I32, 2)
26361 
      oprot.writeI32(self.insurerType)
26362 
      oprot.writeFieldEnd()
26363 
    oprot.writeFieldStop()
26364 
    oprot.writeStructEnd()
26365 
 
26366 
  def validate(self):
26367 
    return
26368 
 
26369 
 
26370 
  def __repr__(self):
26371 
    L = ['%s=%r' % (key, value)
26372 
      for key, value in self.__dict__.iteritems()]
26373 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26374 
 
26375 
  def __eq__(self, other):
26376 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26377 
 
26378 
  def __ne__(self, other):
26379 
    return not (self == other)
26380 
 
26381 
class getPrefferedInsurerForItem_result:
26382 
  """
26383 
  Attributes:
26384 
   - success
26385 
  """
26386 
 
26387 
  thrift_spec = (
26388 
    (0, TType.I64, 'success', None, None, ), # 0
26389 
  )
26390 
 
26391 
  def __init__(self, success=None,):
26392 
    self.success = success
26393 
 
26394 
  def read(self, iprot):
26395 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26396 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26397 
      return
26398 
    iprot.readStructBegin()
26399 
    while True:
26400 
      (fname, ftype, fid) = iprot.readFieldBegin()
26401 
      if ftype == TType.STOP:
26402 
        break
26403 
      if fid == 0:
26404 
        if ftype == TType.I64:
26405 
          self.success = iprot.readI64();
26406 
        else:
26407 
          iprot.skip(ftype)
26408 
      else:
26409 
        iprot.skip(ftype)
26410 
      iprot.readFieldEnd()
26411 
    iprot.readStructEnd()
26412 
 
26413 
  def write(self, oprot):
26414 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26415 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26416 
      return
26417 
    oprot.writeStructBegin('getPrefferedInsurerForItem_result')
26418 
    if self.success is not None:
26419 
      oprot.writeFieldBegin('success', TType.I64, 0)
26420 
      oprot.writeI64(self.success)
26421 
      oprot.writeFieldEnd()
26422 
    oprot.writeFieldStop()
26423 
    oprot.writeStructEnd()
26424 
 
26425 
  def validate(self):
26426 
    return
26427 
 
26428 
 
26429 
  def __repr__(self):
26430 
    L = ['%s=%r' % (key, value)
26431 
      for key, value in self.__dict__.iteritems()]
26432 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26433 
 
26434 
  def __eq__(self, other):
26435 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26436 
 
26437 
  def __ne__(self, other):
26438 
    return not (self == other)
9456 vikram.rag 26439 
 
26440 
class getSnapdealItembySkuAtSnapdeal_args:
26441 
  """
26442 
  Attributes:
26443 
   - skuAtSnapdeal
26444 
  """
26445 
 
26446 
  thrift_spec = None
26447 
  def __init__(self, skuAtSnapdeal=None,):
26448 
    self.skuAtSnapdeal = skuAtSnapdeal
26449 
 
26450 
  def read(self, iprot):
26451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26453 
      return
26454 
    iprot.readStructBegin()
26455 
    while True:
26456 
      (fname, ftype, fid) = iprot.readFieldBegin()
26457 
      if ftype == TType.STOP:
26458 
        break
26459 
      if fid == -1:
26460 
        if ftype == TType.STRING:
26461 
          self.skuAtSnapdeal = iprot.readString();
26462 
        else:
26463 
          iprot.skip(ftype)
26464 
      else:
26465 
        iprot.skip(ftype)
26466 
      iprot.readFieldEnd()
26467 
    iprot.readStructEnd()
26468 
 
26469 
  def write(self, oprot):
26470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26472 
      return
26473 
    oprot.writeStructBegin('getSnapdealItembySkuAtSnapdeal_args')
26474 
    if self.skuAtSnapdeal is not None:
26475 
      oprot.writeFieldBegin('skuAtSnapdeal', TType.STRING, -1)
26476 
      oprot.writeString(self.skuAtSnapdeal)
26477 
      oprot.writeFieldEnd()
26478 
    oprot.writeFieldStop()
26479 
    oprot.writeStructEnd()
26480 
 
26481 
  def validate(self):
26482 
    return
26483 
 
26484 
 
26485 
  def __repr__(self):
26486 
    L = ['%s=%r' % (key, value)
26487 
      for key, value in self.__dict__.iteritems()]
26488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26489 
 
26490 
  def __eq__(self, other):
26491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26492 
 
26493 
  def __ne__(self, other):
26494 
    return not (self == other)
26495 
 
26496 
class getSnapdealItembySkuAtSnapdeal_result:
26497 
  """
26498 
  Attributes:
26499 
   - success
26500 
  """
26501 
 
26502 
  thrift_spec = (
26503 
    (0, TType.STRUCT, 'success', (SnapdealItem, SnapdealItem.thrift_spec), None, ), # 0
26504 
  )
26505 
 
26506 
  def __init__(self, success=None,):
26507 
    self.success = success
26508 
 
26509 
  def read(self, iprot):
26510 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26511 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26512 
      return
26513 
    iprot.readStructBegin()
26514 
    while True:
26515 
      (fname, ftype, fid) = iprot.readFieldBegin()
26516 
      if ftype == TType.STOP:
26517 
        break
26518 
      if fid == 0:
26519 
        if ftype == TType.STRUCT:
26520 
          self.success = SnapdealItem()
26521 
          self.success.read(iprot)
26522 
        else:
26523 
          iprot.skip(ftype)
26524 
      else:
26525 
        iprot.skip(ftype)
26526 
      iprot.readFieldEnd()
26527 
    iprot.readStructEnd()
26528 
 
26529 
  def write(self, oprot):
26530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26532 
      return
26533 
    oprot.writeStructBegin('getSnapdealItembySkuAtSnapdeal_result')
26534 
    if self.success is not None:
26535 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26536 
      self.success.write(oprot)
26537 
      oprot.writeFieldEnd()
26538 
    oprot.writeFieldStop()
26539 
    oprot.writeStructEnd()
26540 
 
26541 
  def validate(self):
26542 
    return
26543 
 
26544 
 
26545 
  def __repr__(self):
26546 
    L = ['%s=%r' % (key, value)
26547 
      for key, value in self.__dict__.iteritems()]
26548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26549 
 
26550 
  def __eq__(self, other):
26551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26552 
 
26553 
  def __ne__(self, other):
26554 
    return not (self == other)
9621 manish.sha 26555 
 
26556 
class getProductFeedSubmit_args:
26557 
  """
26558 
  Attributes:
26559 
   - catalogItemId
26560 
  """
26561 
 
26562 
  thrift_spec = (
26563 
    None, # 0
26564 
    (1, TType.I64, 'catalogItemId', None, None, ), # 1
26565 
  )
26566 
 
26567 
  def __init__(self, catalogItemId=None,):
26568 
    self.catalogItemId = catalogItemId
26569 
 
26570 
  def read(self, iprot):
26571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26573 
      return
26574 
    iprot.readStructBegin()
26575 
    while True:
26576 
      (fname, ftype, fid) = iprot.readFieldBegin()
26577 
      if ftype == TType.STOP:
26578 
        break
26579 
      if fid == 1:
26580 
        if ftype == TType.I64:
26581 
          self.catalogItemId = iprot.readI64();
26582 
        else:
26583 
          iprot.skip(ftype)
26584 
      else:
26585 
        iprot.skip(ftype)
26586 
      iprot.readFieldEnd()
26587 
    iprot.readStructEnd()
26588 
 
26589 
  def write(self, oprot):
26590 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26591 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26592 
      return
26593 
    oprot.writeStructBegin('getProductFeedSubmit_args')
26594 
    if self.catalogItemId is not None:
26595 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 1)
26596 
      oprot.writeI64(self.catalogItemId)
26597 
      oprot.writeFieldEnd()
26598 
    oprot.writeFieldStop()
26599 
    oprot.writeStructEnd()
26600 
 
26601 
  def validate(self):
26602 
    return
26603 
 
26604 
 
26605 
  def __repr__(self):
26606 
    L = ['%s=%r' % (key, value)
26607 
      for key, value in self.__dict__.iteritems()]
26608 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26609 
 
26610 
  def __eq__(self, other):
26611 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26612 
 
26613 
  def __ne__(self, other):
26614 
    return not (self == other)
26615 
 
26616 
class getProductFeedSubmit_result:
26617 
  """
26618 
  Attributes:
26619 
   - success
26620 
   - cex
26621 
  """
26622 
 
26623 
  thrift_spec = (
26624 
    (0, TType.STRUCT, 'success', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 0
26625 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
26626 
  )
26627 
 
26628 
  def __init__(self, success=None, cex=None,):
26629 
    self.success = success
26630 
    self.cex = cex
26631 
 
26632 
  def read(self, iprot):
26633 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26634 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26635 
      return
26636 
    iprot.readStructBegin()
26637 
    while True:
26638 
      (fname, ftype, fid) = iprot.readFieldBegin()
26639 
      if ftype == TType.STOP:
26640 
        break
26641 
      if fid == 0:
26642 
        if ftype == TType.STRUCT:
26643 
          self.success = ProductFeedSubmit()
26644 
          self.success.read(iprot)
26645 
        else:
26646 
          iprot.skip(ftype)
26647 
      elif fid == 1:
26648 
        if ftype == TType.STRUCT:
26649 
          self.cex = CatalogServiceException()
26650 
          self.cex.read(iprot)
26651 
        else:
26652 
          iprot.skip(ftype)
26653 
      else:
26654 
        iprot.skip(ftype)
26655 
      iprot.readFieldEnd()
26656 
    iprot.readStructEnd()
26657 
 
26658 
  def write(self, oprot):
26659 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26660 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26661 
      return
26662 
    oprot.writeStructBegin('getProductFeedSubmit_result')
26663 
    if self.success is not None:
26664 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26665 
      self.success.write(oprot)
26666 
      oprot.writeFieldEnd()
26667 
    if self.cex is not None:
26668 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
26669 
      self.cex.write(oprot)
26670 
      oprot.writeFieldEnd()
26671 
    oprot.writeFieldStop()
26672 
    oprot.writeStructEnd()
26673 
 
26674 
  def validate(self):
26675 
    return
26676 
 
26677 
 
26678 
  def __repr__(self):
26679 
    L = ['%s=%r' % (key, value)
26680 
      for key, value in self.__dict__.iteritems()]
26681 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26682 
 
26683 
  def __eq__(self, other):
26684 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26685 
 
26686 
  def __ne__(self, other):
26687 
    return not (self == other)
26688 
 
26689 
class addProductFeedSubmit_args:
26690 
  """
26691 
  Attributes:
26692 
   - productFeedSubmit
26693 
  """
26694 
 
26695 
  thrift_spec = (
26696 
    None, # 0
26697 
    (1, TType.STRUCT, 'productFeedSubmit', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 1
26698 
  )
26699 
 
26700 
  def __init__(self, productFeedSubmit=None,):
26701 
    self.productFeedSubmit = productFeedSubmit
26702 
 
26703 
  def read(self, iprot):
26704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26706 
      return
26707 
    iprot.readStructBegin()
26708 
    while True:
26709 
      (fname, ftype, fid) = iprot.readFieldBegin()
26710 
      if ftype == TType.STOP:
26711 
        break
26712 
      if fid == 1:
26713 
        if ftype == TType.STRUCT:
26714 
          self.productFeedSubmit = ProductFeedSubmit()
26715 
          self.productFeedSubmit.read(iprot)
26716 
        else:
26717 
          iprot.skip(ftype)
26718 
      else:
26719 
        iprot.skip(ftype)
26720 
      iprot.readFieldEnd()
26721 
    iprot.readStructEnd()
26722 
 
26723 
  def write(self, oprot):
26724 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26725 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26726 
      return
26727 
    oprot.writeStructBegin('addProductFeedSubmit_args')
26728 
    if self.productFeedSubmit is not None:
26729 
      oprot.writeFieldBegin('productFeedSubmit', TType.STRUCT, 1)
26730 
      self.productFeedSubmit.write(oprot)
26731 
      oprot.writeFieldEnd()
26732 
    oprot.writeFieldStop()
26733 
    oprot.writeStructEnd()
26734 
 
26735 
  def validate(self):
26736 
    return
26737 
 
26738 
 
26739 
  def __repr__(self):
26740 
    L = ['%s=%r' % (key, value)
26741 
      for key, value in self.__dict__.iteritems()]
26742 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26743 
 
26744 
  def __eq__(self, other):
26745 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26746 
 
26747 
  def __ne__(self, other):
26748 
    return not (self == other)
26749 
 
26750 
class addProductFeedSubmit_result:
26751 
  """
26752 
  Attributes:
26753 
   - success
26754 
   - cex
26755 
  """
26756 
 
26757 
  thrift_spec = (
26758 
    (0, TType.BOOL, 'success', None, None, ), # 0
26759 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
26760 
  )
26761 
 
26762 
  def __init__(self, success=None, cex=None,):
26763 
    self.success = success
26764 
    self.cex = cex
26765 
 
26766 
  def read(self, iprot):
26767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26769 
      return
26770 
    iprot.readStructBegin()
26771 
    while True:
26772 
      (fname, ftype, fid) = iprot.readFieldBegin()
26773 
      if ftype == TType.STOP:
26774 
        break
26775 
      if fid == 0:
26776 
        if ftype == TType.BOOL:
26777 
          self.success = iprot.readBool();
26778 
        else:
26779 
          iprot.skip(ftype)
26780 
      elif fid == 1:
26781 
        if ftype == TType.STRUCT:
26782 
          self.cex = CatalogServiceException()
26783 
          self.cex.read(iprot)
26784 
        else:
26785 
          iprot.skip(ftype)
26786 
      else:
26787 
        iprot.skip(ftype)
26788 
      iprot.readFieldEnd()
26789 
    iprot.readStructEnd()
26790 
 
26791 
  def write(self, oprot):
26792 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26793 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26794 
      return
26795 
    oprot.writeStructBegin('addProductFeedSubmit_result')
26796 
    if self.success is not None:
26797 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26798 
      oprot.writeBool(self.success)
26799 
      oprot.writeFieldEnd()
26800 
    if self.cex is not None:
26801 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
26802 
      self.cex.write(oprot)
26803 
      oprot.writeFieldEnd()
26804 
    oprot.writeFieldStop()
26805 
    oprot.writeStructEnd()
26806 
 
26807 
  def validate(self):
26808 
    return
26809 
 
26810 
 
26811 
  def __repr__(self):
26812 
    L = ['%s=%r' % (key, value)
26813 
      for key, value in self.__dict__.iteritems()]
26814 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26815 
 
26816 
  def __eq__(self, other):
26817 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26818 
 
26819 
  def __ne__(self, other):
26820 
    return not (self == other)
26821 
 
26822 
class updateProductFeedSubmit_args:
26823 
  """
26824 
  Attributes:
26825 
   - productFeedSubmit
26826 
  """
26827 
 
26828 
  thrift_spec = (
26829 
    None, # 0
26830 
    (1, TType.STRUCT, 'productFeedSubmit', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 1
26831 
  )
26832 
 
26833 
  def __init__(self, productFeedSubmit=None,):
26834 
    self.productFeedSubmit = productFeedSubmit
26835 
 
26836 
  def read(self, iprot):
26837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26839 
      return
26840 
    iprot.readStructBegin()
26841 
    while True:
26842 
      (fname, ftype, fid) = iprot.readFieldBegin()
26843 
      if ftype == TType.STOP:
26844 
        break
26845 
      if fid == 1:
26846 
        if ftype == TType.STRUCT:
26847 
          self.productFeedSubmit = ProductFeedSubmit()
26848 
          self.productFeedSubmit.read(iprot)
26849 
        else:
26850 
          iprot.skip(ftype)
26851 
      else:
26852 
        iprot.skip(ftype)
26853 
      iprot.readFieldEnd()
26854 
    iprot.readStructEnd()
26855 
 
26856 
  def write(self, oprot):
26857 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26858 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26859 
      return
26860 
    oprot.writeStructBegin('updateProductFeedSubmit_args')
26861 
    if self.productFeedSubmit is not None:
26862 
      oprot.writeFieldBegin('productFeedSubmit', TType.STRUCT, 1)
26863 
      self.productFeedSubmit.write(oprot)
26864 
      oprot.writeFieldEnd()
26865 
    oprot.writeFieldStop()
26866 
    oprot.writeStructEnd()
26867 
 
26868 
  def validate(self):
26869 
    return
26870 
 
26871 
 
26872 
  def __repr__(self):
26873 
    L = ['%s=%r' % (key, value)
26874 
      for key, value in self.__dict__.iteritems()]
26875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26876 
 
26877 
  def __eq__(self, other):
26878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26879 
 
26880 
  def __ne__(self, other):
26881 
    return not (self == other)
26882 
 
26883 
class updateProductFeedSubmit_result:
26884 
  """
26885 
  Attributes:
26886 
   - success
26887 
   - cex
26888 
  """
26889 
 
26890 
  thrift_spec = (
26891 
    (0, TType.BOOL, 'success', None, None, ), # 0
26892 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
26893 
  )
26894 
 
26895 
  def __init__(self, success=None, cex=None,):
26896 
    self.success = success
26897 
    self.cex = cex
26898 
 
26899 
  def read(self, iprot):
26900 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26901 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26902 
      return
26903 
    iprot.readStructBegin()
26904 
    while True:
26905 
      (fname, ftype, fid) = iprot.readFieldBegin()
26906 
      if ftype == TType.STOP:
26907 
        break
26908 
      if fid == 0:
26909 
        if ftype == TType.BOOL:
26910 
          self.success = iprot.readBool();
26911 
        else:
26912 
          iprot.skip(ftype)
26913 
      elif fid == 1:
26914 
        if ftype == TType.STRUCT:
26915 
          self.cex = CatalogServiceException()
26916 
          self.cex.read(iprot)
26917 
        else:
26918 
          iprot.skip(ftype)
26919 
      else:
26920 
        iprot.skip(ftype)
26921 
      iprot.readFieldEnd()
26922 
    iprot.readStructEnd()
26923 
 
26924 
  def write(self, oprot):
26925 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26926 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26927 
      return
26928 
    oprot.writeStructBegin('updateProductFeedSubmit_result')
26929 
    if self.success is not None:
26930 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26931 
      oprot.writeBool(self.success)
26932 
      oprot.writeFieldEnd()
26933 
    if self.cex is not None:
26934 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
26935 
      self.cex.write(oprot)
26936 
      oprot.writeFieldEnd()
26937 
    oprot.writeFieldStop()
26938 
    oprot.writeStructEnd()
26939 
 
26940 
  def validate(self):
26941 
    return
26942 
 
26943 
 
26944 
  def __repr__(self):
26945 
    L = ['%s=%r' % (key, value)
26946 
      for key, value in self.__dict__.iteritems()]
26947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26948 
 
26949 
  def __eq__(self, other):
26950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26951 
 
26952 
  def __ne__(self, other):
26953 
    return not (self == other)
26954 
 
26955 
class deleteProductFeedSubmit_args:
26956 
  """
26957 
  Attributes:
26958 
   - catalogItemId
26959 
  """
26960 
 
26961 
  thrift_spec = (
26962 
    None, # 0
26963 
    (1, TType.I64, 'catalogItemId', None, None, ), # 1
26964 
  )
26965 
 
26966 
  def __init__(self, catalogItemId=None,):
26967 
    self.catalogItemId = catalogItemId
26968 
 
26969 
  def read(self, iprot):
26970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26972 
      return
26973 
    iprot.readStructBegin()
26974 
    while True:
26975 
      (fname, ftype, fid) = iprot.readFieldBegin()
26976 
      if ftype == TType.STOP:
26977 
        break
26978 
      if fid == 1:
26979 
        if ftype == TType.I64:
26980 
          self.catalogItemId = iprot.readI64();
26981 
        else:
26982 
          iprot.skip(ftype)
26983 
      else:
26984 
        iprot.skip(ftype)
26985 
      iprot.readFieldEnd()
26986 
    iprot.readStructEnd()
26987 
 
26988 
  def write(self, oprot):
26989 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26990 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26991 
      return
26992 
    oprot.writeStructBegin('deleteProductFeedSubmit_args')
26993 
    if self.catalogItemId is not None:
26994 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 1)
26995 
      oprot.writeI64(self.catalogItemId)
26996 
      oprot.writeFieldEnd()
26997 
    oprot.writeFieldStop()
26998 
    oprot.writeStructEnd()
26999 
 
27000 
  def validate(self):
27001 
    return
27002 
 
27003 
 
27004 
  def __repr__(self):
27005 
    L = ['%s=%r' % (key, value)
27006 
      for key, value in self.__dict__.iteritems()]
27007 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27008 
 
27009 
  def __eq__(self, other):
27010 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27011 
 
27012 
  def __ne__(self, other):
27013 
    return not (self == other)
27014 
 
27015 
class deleteProductFeedSubmit_result:
27016 
  """
27017 
  Attributes:
27018 
   - success
27019 
   - cex
27020 
  """
27021 
 
27022 
  thrift_spec = (
27023 
    (0, TType.BOOL, 'success', None, None, ), # 0
27024 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
27025 
  )
27026 
 
27027 
  def __init__(self, success=None, cex=None,):
27028 
    self.success = success
27029 
    self.cex = cex
27030 
 
27031 
  def read(self, iprot):
27032 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27033 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27034 
      return
27035 
    iprot.readStructBegin()
27036 
    while True:
27037 
      (fname, ftype, fid) = iprot.readFieldBegin()
27038 
      if ftype == TType.STOP:
27039 
        break
27040 
      if fid == 0:
27041 
        if ftype == TType.BOOL:
27042 
          self.success = iprot.readBool();
27043 
        else:
27044 
          iprot.skip(ftype)
27045 
      elif fid == 1:
27046 
        if ftype == TType.STRUCT:
27047 
          self.cex = CatalogServiceException()
27048 
          self.cex.read(iprot)
27049 
        else:
27050 
          iprot.skip(ftype)
27051 
      else:
27052 
        iprot.skip(ftype)
27053 
      iprot.readFieldEnd()
27054 
    iprot.readStructEnd()
27055 
 
27056 
  def write(self, oprot):
27057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27059 
      return
27060 
    oprot.writeStructBegin('deleteProductFeedSubmit_result')
27061 
    if self.success is not None:
27062 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27063 
      oprot.writeBool(self.success)
27064 
      oprot.writeFieldEnd()
27065 
    if self.cex is not None:
27066 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
27067 
      self.cex.write(oprot)
27068 
      oprot.writeFieldEnd()
27069 
    oprot.writeFieldStop()
27070 
    oprot.writeStructEnd()
27071 
 
27072 
  def validate(self):
27073 
    return
27074 
 
27075 
 
27076 
  def __repr__(self):
27077 
    L = ['%s=%r' % (key, value)
27078 
      for key, value in self.__dict__.iteritems()]
27079 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27080 
 
27081 
  def __eq__(self, other):
27082 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27083 
 
27084 
  def __ne__(self, other):
27085 
    return not (self == other)
27086 
 
27087 
class getAllProductFeedSubmit_args:
27088 
 
27089 
  thrift_spec = (
27090 
  )
27091 
 
27092 
  def read(self, iprot):
27093 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27094 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27095 
      return
27096 
    iprot.readStructBegin()
27097 
    while True:
27098 
      (fname, ftype, fid) = iprot.readFieldBegin()
27099 
      if ftype == TType.STOP:
27100 
        break
27101 
      else:
27102 
        iprot.skip(ftype)
27103 
      iprot.readFieldEnd()
27104 
    iprot.readStructEnd()
27105 
 
27106 
  def write(self, oprot):
27107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27109 
      return
27110 
    oprot.writeStructBegin('getAllProductFeedSubmit_args')
27111 
    oprot.writeFieldStop()
27112 
    oprot.writeStructEnd()
27113 
 
27114 
  def validate(self):
27115 
    return
27116 
 
27117 
 
27118 
  def __repr__(self):
27119 
    L = ['%s=%r' % (key, value)
27120 
      for key, value in self.__dict__.iteritems()]
27121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27122 
 
27123 
  def __eq__(self, other):
27124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27125 
 
27126 
  def __ne__(self, other):
27127 
    return not (self == other)
27128 
 
27129 
class getAllProductFeedSubmit_result:
27130 
  """
27131 
  Attributes:
27132 
   - success
27133 
   - cex
27134 
  """
27135 
 
27136 
  thrift_spec = (
27137 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductFeedSubmit, ProductFeedSubmit.thrift_spec)), None, ), # 0
27138 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
27139 
  )
27140 
 
27141 
  def __init__(self, success=None, cex=None,):
27142 
    self.success = success
27143 
    self.cex = cex
27144 
 
27145 
  def read(self, iprot):
27146 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27147 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27148 
      return
27149 
    iprot.readStructBegin()
27150 
    while True:
27151 
      (fname, ftype, fid) = iprot.readFieldBegin()
27152 
      if ftype == TType.STOP:
27153 
        break
27154 
      if fid == 0:
27155 
        if ftype == TType.LIST:
27156 
          self.success = []
13493 amit.gupta 27157 
          (_etype576, _size573) = iprot.readListBegin()
27158 
          for _i577 in xrange(_size573):
27159 
            _elem578 = ProductFeedSubmit()
27160 
            _elem578.read(iprot)
27161 
            self.success.append(_elem578)
9621 manish.sha 27162 
          iprot.readListEnd()
27163 
        else:
27164 
          iprot.skip(ftype)
27165 
      elif fid == 1:
27166 
        if ftype == TType.STRUCT:
27167 
          self.cex = CatalogServiceException()
27168 
          self.cex.read(iprot)
27169 
        else:
27170 
          iprot.skip(ftype)
27171 
      else:
27172 
        iprot.skip(ftype)
27173 
      iprot.readFieldEnd()
27174 
    iprot.readStructEnd()
27175 
 
27176 
  def write(self, oprot):
27177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27179 
      return
27180 
    oprot.writeStructBegin('getAllProductFeedSubmit_result')
27181 
    if self.success is not None:
27182 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27183 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 27184 
      for iter579 in self.success:
27185 
        iter579.write(oprot)
9621 manish.sha 27186 
      oprot.writeListEnd()
27187 
      oprot.writeFieldEnd()
27188 
    if self.cex is not None:
27189 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
27190 
      self.cex.write(oprot)
27191 
      oprot.writeFieldEnd()
27192 
    oprot.writeFieldStop()
27193 
    oprot.writeStructEnd()
27194 
 
27195 
  def validate(self):
27196 
    return
27197 
 
27198 
 
27199 
  def __repr__(self):
27200 
    L = ['%s=%r' % (key, value)
27201 
      for key, value in self.__dict__.iteritems()]
27202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27203 
 
27204 
  def __eq__(self, other):
27205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27206 
 
27207 
  def __ne__(self, other):
27208 
    return not (self == other)
9724 kshitij.so 27209 
 
27210 
class getMarketplacedetailsForItem_args:
27211 
  """
27212 
  Attributes:
27213 
   - itemId
27214 
   - sourceId
27215 
  """
27216 
 
27217 
  thrift_spec = (
27218 
    None, # 0
27219 
    (1, TType.I64, 'itemId', None, None, ), # 1
27220 
    (2, TType.I64, 'sourceId', None, None, ), # 2
27221 
  )
27222 
 
27223 
  def __init__(self, itemId=None, sourceId=None,):
27224 
    self.itemId = itemId
27225 
    self.sourceId = sourceId
27226 
 
27227 
  def read(self, iprot):
27228 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27229 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27230 
      return
27231 
    iprot.readStructBegin()
27232 
    while True:
27233 
      (fname, ftype, fid) = iprot.readFieldBegin()
27234 
      if ftype == TType.STOP:
27235 
        break
27236 
      if fid == 1:
27237 
        if ftype == TType.I64:
27238 
          self.itemId = iprot.readI64();
27239 
        else:
27240 
          iprot.skip(ftype)
27241 
      elif fid == 2:
27242 
        if ftype == TType.I64:
27243 
          self.sourceId = iprot.readI64();
27244 
        else:
27245 
          iprot.skip(ftype)
27246 
      else:
27247 
        iprot.skip(ftype)
27248 
      iprot.readFieldEnd()
27249 
    iprot.readStructEnd()
27250 
 
27251 
  def write(self, oprot):
27252 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27253 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27254 
      return
27255 
    oprot.writeStructBegin('getMarketplacedetailsForItem_args')
27256 
    if self.itemId is not None:
27257 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
27258 
      oprot.writeI64(self.itemId)
27259 
      oprot.writeFieldEnd()
27260 
    if self.sourceId is not None:
27261 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
27262 
      oprot.writeI64(self.sourceId)
27263 
      oprot.writeFieldEnd()
27264 
    oprot.writeFieldStop()
27265 
    oprot.writeStructEnd()
27266 
 
27267 
  def validate(self):
27268 
    return
27269 
 
27270 
 
27271 
  def __repr__(self):
27272 
    L = ['%s=%r' % (key, value)
27273 
      for key, value in self.__dict__.iteritems()]
27274 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27275 
 
27276 
  def __eq__(self, other):
27277 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27278 
 
27279 
  def __ne__(self, other):
27280 
    return not (self == other)
27281 
 
27282 
class getMarketplacedetailsForItem_result:
27283 
  """
27284 
  Attributes:
27285 
   - success
27286 
  """
27287 
 
27288 
  thrift_spec = (
27289 
    (0, TType.STRUCT, 'success', (MarketplaceItems, MarketplaceItems.thrift_spec), None, ), # 0
27290 
  )
27291 
 
27292 
  def __init__(self, success=None,):
27293 
    self.success = success
27294 
 
27295 
  def read(self, iprot):
27296 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27297 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27298 
      return
27299 
    iprot.readStructBegin()
27300 
    while True:
27301 
      (fname, ftype, fid) = iprot.readFieldBegin()
27302 
      if ftype == TType.STOP:
27303 
        break
27304 
      if fid == 0:
27305 
        if ftype == TType.STRUCT:
27306 
          self.success = MarketplaceItems()
27307 
          self.success.read(iprot)
27308 
        else:
27309 
          iprot.skip(ftype)
27310 
      else:
27311 
        iprot.skip(ftype)
27312 
      iprot.readFieldEnd()
27313 
    iprot.readStructEnd()
27314 
 
27315 
  def write(self, oprot):
27316 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27317 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27318 
      return
27319 
    oprot.writeStructBegin('getMarketplacedetailsForItem_result')
27320 
    if self.success is not None:
27321 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27322 
      self.success.write(oprot)
27323 
      oprot.writeFieldEnd()
27324 
    oprot.writeFieldStop()
27325 
    oprot.writeStructEnd()
27326 
 
27327 
  def validate(self):
27328 
    return
27329 
 
27330 
 
27331 
  def __repr__(self):
27332 
    L = ['%s=%r' % (key, value)
27333 
      for key, value in self.__dict__.iteritems()]
27334 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27335 
 
27336 
  def __eq__(self, other):
27337 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27338 
 
27339 
  def __ne__(self, other):
27340 
    return not (self == other)
27341 
 
27342 
class updateMarketplaceAttributesForItem_args:
27343 
  """
27344 
  Attributes:
27345 
   - marketPlaceItem
27346 
  """
27347 
 
27348 
  thrift_spec = (
27349 
    None, # 0
27350 
    (1, TType.STRUCT, 'marketPlaceItem', (MarketplaceItems, MarketplaceItems.thrift_spec), None, ), # 1
27351 
  )
27352 
 
27353 
  def __init__(self, marketPlaceItem=None,):
27354 
    self.marketPlaceItem = marketPlaceItem
27355 
 
27356 
  def read(self, iprot):
27357 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27358 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27359 
      return
27360 
    iprot.readStructBegin()
27361 
    while True:
27362 
      (fname, ftype, fid) = iprot.readFieldBegin()
27363 
      if ftype == TType.STOP:
27364 
        break
27365 
      if fid == 1:
27366 
        if ftype == TType.STRUCT:
27367 
          self.marketPlaceItem = MarketplaceItems()
27368 
          self.marketPlaceItem.read(iprot)
27369 
        else:
27370 
          iprot.skip(ftype)
27371 
      else:
27372 
        iprot.skip(ftype)
27373 
      iprot.readFieldEnd()
27374 
    iprot.readStructEnd()
27375 
 
27376 
  def write(self, oprot):
27377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27379 
      return
27380 
    oprot.writeStructBegin('updateMarketplaceAttributesForItem_args')
27381 
    if self.marketPlaceItem is not None:
27382 
      oprot.writeFieldBegin('marketPlaceItem', TType.STRUCT, 1)
27383 
      self.marketPlaceItem.write(oprot)
27384 
      oprot.writeFieldEnd()
27385 
    oprot.writeFieldStop()
27386 
    oprot.writeStructEnd()
27387 
 
27388 
  def validate(self):
27389 
    return
27390 
 
27391 
 
27392 
  def __repr__(self):
27393 
    L = ['%s=%r' % (key, value)
27394 
      for key, value in self.__dict__.iteritems()]
27395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27396 
 
27397 
  def __eq__(self, other):
27398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27399 
 
27400 
  def __ne__(self, other):
27401 
    return not (self == other)
27402 
 
27403 
class updateMarketplaceAttributesForItem_result:
27404 
  """
27405 
  Attributes:
27406 
   - success
27407 
  """
27408 
 
27409 
  thrift_spec = (
27410 
    (0, TType.BOOL, 'success', None, None, ), # 0
27411 
  )
27412 
 
27413 
  def __init__(self, success=None,):
27414 
    self.success = success
27415 
 
27416 
  def read(self, iprot):
27417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27419 
      return
27420 
    iprot.readStructBegin()
27421 
    while True:
27422 
      (fname, ftype, fid) = iprot.readFieldBegin()
27423 
      if ftype == TType.STOP:
27424 
        break
27425 
      if fid == 0:
27426 
        if ftype == TType.BOOL:
27427 
          self.success = iprot.readBool();
27428 
        else:
27429 
          iprot.skip(ftype)
27430 
      else:
27431 
        iprot.skip(ftype)
27432 
      iprot.readFieldEnd()
27433 
    iprot.readStructEnd()
27434 
 
27435 
  def write(self, oprot):
27436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27438 
      return
27439 
    oprot.writeStructBegin('updateMarketplaceAttributesForItem_result')
27440 
    if self.success is not None:
27441 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27442 
      oprot.writeBool(self.success)
27443 
      oprot.writeFieldEnd()
27444 
    oprot.writeFieldStop()
27445 
    oprot.writeStructEnd()
27446 
 
27447 
  def validate(self):
27448 
    return
27449 
 
27450 
 
27451 
  def __repr__(self):
27452 
    L = ['%s=%r' % (key, value)
27453 
      for key, value in self.__dict__.iteritems()]
27454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27455 
 
27456 
  def __eq__(self, other):
27457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27458 
 
27459 
  def __ne__(self, other):
27460 
    return not (self == other)
9776 vikram.rag 27461 
 
9779 kshitij.so 27462 
class getCostingForMarketplace_args:
27463 
  """
27464 
  Attributes:
27465 
   - source
27466 
   - item_id
27467 
  """
27468 
 
27469 
  thrift_spec = (
27470 
    None, # 0
27471 
    (1, TType.I64, 'source', None, None, ), # 1
27472 
    (2, TType.I64, 'item_id', None, None, ), # 2
27473 
  )
27474 
 
27475 
  def __init__(self, source=None, item_id=None,):
27476 
    self.source = source
27477 
    self.item_id = item_id
27478 
 
27479 
  def read(self, iprot):
27480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27482 
      return
27483 
    iprot.readStructBegin()
27484 
    while True:
27485 
      (fname, ftype, fid) = iprot.readFieldBegin()
27486 
      if ftype == TType.STOP:
27487 
        break
27488 
      if fid == 1:
27489 
        if ftype == TType.I64:
27490 
          self.source = iprot.readI64();
27491 
        else:
27492 
          iprot.skip(ftype)
27493 
      elif fid == 2:
27494 
        if ftype == TType.I64:
27495 
          self.item_id = iprot.readI64();
27496 
        else:
27497 
          iprot.skip(ftype)
27498 
      else:
27499 
        iprot.skip(ftype)
27500 
      iprot.readFieldEnd()
27501 
    iprot.readStructEnd()
27502 
 
27503 
  def write(self, oprot):
27504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27506 
      return
27507 
    oprot.writeStructBegin('getCostingForMarketplace_args')
27508 
    if self.source is not None:
27509 
      oprot.writeFieldBegin('source', TType.I64, 1)
27510 
      oprot.writeI64(self.source)
27511 
      oprot.writeFieldEnd()
27512 
    if self.item_id is not None:
27513 
      oprot.writeFieldBegin('item_id', TType.I64, 2)
27514 
      oprot.writeI64(self.item_id)
27515 
      oprot.writeFieldEnd()
27516 
    oprot.writeFieldStop()
27517 
    oprot.writeStructEnd()
27518 
 
27519 
  def validate(self):
27520 
    return
27521 
 
27522 
 
27523 
  def __repr__(self):
27524 
    L = ['%s=%r' % (key, value)
27525 
      for key, value in self.__dict__.iteritems()]
27526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27527 
 
27528 
  def __eq__(self, other):
27529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27530 
 
27531 
  def __ne__(self, other):
27532 
    return not (self == other)
27533 
 
27534 
class getCostingForMarketplace_result:
27535 
  """
27536 
  Attributes:
27537 
   - success
27538 
  """
27539 
 
27540 
  thrift_spec = (
27541 
    (0, TType.STRUCT, 'success', (MarketplacePercentage, MarketplacePercentage.thrift_spec), None, ), # 0
27542 
  )
27543 
 
27544 
  def __init__(self, success=None,):
27545 
    self.success = success
27546 
 
27547 
  def read(self, iprot):
27548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27550 
      return
27551 
    iprot.readStructBegin()
27552 
    while True:
27553 
      (fname, ftype, fid) = iprot.readFieldBegin()
27554 
      if ftype == TType.STOP:
27555 
        break
27556 
      if fid == 0:
27557 
        if ftype == TType.STRUCT:
27558 
          self.success = MarketplacePercentage()
27559 
          self.success.read(iprot)
27560 
        else:
27561 
          iprot.skip(ftype)
27562 
      else:
27563 
        iprot.skip(ftype)
27564 
      iprot.readFieldEnd()
27565 
    iprot.readStructEnd()
27566 
 
27567 
  def write(self, oprot):
27568 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27569 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27570 
      return
27571 
    oprot.writeStructBegin('getCostingForMarketplace_result')
27572 
    if self.success is not None:
27573 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27574 
      self.success.write(oprot)
27575 
      oprot.writeFieldEnd()
27576 
    oprot.writeFieldStop()
27577 
    oprot.writeStructEnd()
27578 
 
27579 
  def validate(self):
27580 
    return
27581 
 
27582 
 
27583 
  def __repr__(self):
27584 
    L = ['%s=%r' % (key, value)
27585 
      for key, value in self.__dict__.iteritems()]
27586 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27587 
 
27588 
  def __eq__(self, other):
27589 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27590 
 
27591 
  def __ne__(self, other):
27592 
    return not (self == other)
27593 
 
9776 vikram.rag 27594 
class getMarketPlaceItemsForPriceUpdate_args:
27595 
  """
27596 
  Attributes:
27597 
   - source
27598 
  """
27599 
 
27600 
  thrift_spec = (
27601 
    None, # 0
27602 
    (1, TType.I64, 'source', None, None, ), # 1
27603 
  )
27604 
 
27605 
  def __init__(self, source=None,):
27606 
    self.source = source
27607 
 
27608 
  def read(self, iprot):
27609 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27610 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27611 
      return
27612 
    iprot.readStructBegin()
27613 
    while True:
27614 
      (fname, ftype, fid) = iprot.readFieldBegin()
27615 
      if ftype == TType.STOP:
27616 
        break
27617 
      if fid == 1:
27618 
        if ftype == TType.I64:
27619 
          self.source = iprot.readI64();
27620 
        else:
27621 
          iprot.skip(ftype)
27622 
      else:
27623 
        iprot.skip(ftype)
27624 
      iprot.readFieldEnd()
27625 
    iprot.readStructEnd()
27626 
 
27627 
  def write(self, oprot):
27628 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27629 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27630 
      return
27631 
    oprot.writeStructBegin('getMarketPlaceItemsForPriceUpdate_args')
27632 
    if self.source is not None:
27633 
      oprot.writeFieldBegin('source', TType.I64, 1)
27634 
      oprot.writeI64(self.source)
27635 
      oprot.writeFieldEnd()
27636 
    oprot.writeFieldStop()
27637 
    oprot.writeStructEnd()
27638 
 
27639 
  def validate(self):
27640 
    return
27641 
 
27642 
 
27643 
  def __repr__(self):
27644 
    L = ['%s=%r' % (key, value)
27645 
      for key, value in self.__dict__.iteritems()]
27646 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27647 
 
27648 
  def __eq__(self, other):
27649 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27650 
 
27651 
  def __ne__(self, other):
27652 
    return not (self == other)
27653 
 
27654 
class getMarketPlaceItemsForPriceUpdate_result:
27655 
  """
27656 
  Attributes:
27657 
   - success
27658 
  """
27659 
 
27660 
  thrift_spec = (
27661 
    (0, TType.LIST, 'success', (TType.STRUCT,(MarketPlaceItemPrice, MarketPlaceItemPrice.thrift_spec)), None, ), # 0
27662 
  )
27663 
 
27664 
  def __init__(self, success=None,):
27665 
    self.success = success
27666 
 
27667 
  def read(self, iprot):
27668 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27669 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27670 
      return
27671 
    iprot.readStructBegin()
27672 
    while True:
27673 
      (fname, ftype, fid) = iprot.readFieldBegin()
27674 
      if ftype == TType.STOP:
27675 
        break
27676 
      if fid == 0:
27677 
        if ftype == TType.LIST:
27678 
          self.success = []
13493 amit.gupta 27679 
          (_etype583, _size580) = iprot.readListBegin()
27680 
          for _i584 in xrange(_size580):
27681 
            _elem585 = MarketPlaceItemPrice()
27682 
            _elem585.read(iprot)
27683 
            self.success.append(_elem585)
9776 vikram.rag 27684 
          iprot.readListEnd()
27685 
        else:
27686 
          iprot.skip(ftype)
27687 
      else:
27688 
        iprot.skip(ftype)
27689 
      iprot.readFieldEnd()
27690 
    iprot.readStructEnd()
27691 
 
27692 
  def write(self, oprot):
27693 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27694 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27695 
      return
27696 
    oprot.writeStructBegin('getMarketPlaceItemsForPriceUpdate_result')
27697 
    if self.success is not None:
27698 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27699 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 27700 
      for iter586 in self.success:
27701 
        iter586.write(oprot)
9776 vikram.rag 27702 
      oprot.writeListEnd()
27703 
      oprot.writeFieldEnd()
27704 
    oprot.writeFieldStop()
27705 
    oprot.writeStructEnd()
27706 
 
27707 
  def validate(self):
27708 
    return
27709 
 
27710 
 
27711 
  def __repr__(self):
27712 
    L = ['%s=%r' % (key, value)
27713 
      for key, value in self.__dict__.iteritems()]
27714 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27715 
 
27716 
  def __eq__(self, other):
27717 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27718 
 
27719 
  def __ne__(self, other):
27720 
    return not (self == other)
27721 
 
27722 
class updateMarketPlacePriceUpdateStatus_args:
27723 
  """
27724 
  Attributes:
27725 
   - skulist
27726 
   - timestamp
9816 kshitij.so 27727 
   - source
9776 vikram.rag 27728 
  """
27729 
 
27730 
  thrift_spec = (
27731 
    None, # 0
27732 
    (1, TType.LIST, 'skulist', (TType.I64,None), None, ), # 1
27733 
    (2, TType.I64, 'timestamp', None, None, ), # 2
9816 kshitij.so 27734 
    (3, TType.I64, 'source', None, None, ), # 3
9776 vikram.rag 27735 
  )
27736 
 
9816 kshitij.so 27737 
  def __init__(self, skulist=None, timestamp=None, source=None,):
9776 vikram.rag 27738 
    self.skulist = skulist
27739 
    self.timestamp = timestamp
9816 kshitij.so 27740 
    self.source = source
9776 vikram.rag 27741 
 
27742 
  def read(self, iprot):
27743 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27744 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27745 
      return
27746 
    iprot.readStructBegin()
27747 
    while True:
27748 
      (fname, ftype, fid) = iprot.readFieldBegin()
27749 
      if ftype == TType.STOP:
27750 
        break
27751 
      if fid == 1:
27752 
        if ftype == TType.LIST:
27753 
          self.skulist = []
13493 amit.gupta 27754 
          (_etype590, _size587) = iprot.readListBegin()
27755 
          for _i591 in xrange(_size587):
27756 
            _elem592 = iprot.readI64();
27757 
            self.skulist.append(_elem592)
9776 vikram.rag 27758 
          iprot.readListEnd()
27759 
        else:
27760 
          iprot.skip(ftype)
27761 
      elif fid == 2:
27762 
        if ftype == TType.I64:
27763 
          self.timestamp = iprot.readI64();
27764 
        else:
27765 
          iprot.skip(ftype)
9816 kshitij.so 27766 
      elif fid == 3:
27767 
        if ftype == TType.I64:
27768 
          self.source = iprot.readI64();
27769 
        else:
27770 
          iprot.skip(ftype)
9776 vikram.rag 27771 
      else:
27772 
        iprot.skip(ftype)
27773 
      iprot.readFieldEnd()
27774 
    iprot.readStructEnd()
27775 
 
27776 
  def write(self, oprot):
27777 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27778 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27779 
      return
27780 
    oprot.writeStructBegin('updateMarketPlacePriceUpdateStatus_args')
27781 
    if self.skulist is not None:
27782 
      oprot.writeFieldBegin('skulist', TType.LIST, 1)
27783 
      oprot.writeListBegin(TType.I64, len(self.skulist))
13493 amit.gupta 27784 
      for iter593 in self.skulist:
27785 
        oprot.writeI64(iter593)
9776 vikram.rag 27786 
      oprot.writeListEnd()
27787 
      oprot.writeFieldEnd()
27788 
    if self.timestamp is not None:
27789 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
27790 
      oprot.writeI64(self.timestamp)
27791 
      oprot.writeFieldEnd()
9816 kshitij.so 27792 
    if self.source is not None:
27793 
      oprot.writeFieldBegin('source', TType.I64, 3)
27794 
      oprot.writeI64(self.source)
27795 
      oprot.writeFieldEnd()
9776 vikram.rag 27796 
    oprot.writeFieldStop()
27797 
    oprot.writeStructEnd()
27798 
 
27799 
  def validate(self):
27800 
    return
27801 
 
27802 
 
27803 
  def __repr__(self):
27804 
    L = ['%s=%r' % (key, value)
27805 
      for key, value in self.__dict__.iteritems()]
27806 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27807 
 
27808 
  def __eq__(self, other):
27809 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27810 
 
27811 
  def __ne__(self, other):
27812 
    return not (self == other)
27813 
 
27814 
class updateMarketPlacePriceUpdateStatus_result:
27815 
 
27816 
  thrift_spec = (
27817 
  )
27818 
 
27819 
  def read(self, iprot):
27820 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27821 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27822 
      return
27823 
    iprot.readStructBegin()
27824 
    while True:
27825 
      (fname, ftype, fid) = iprot.readFieldBegin()
27826 
      if ftype == TType.STOP:
27827 
        break
27828 
      else:
27829 
        iprot.skip(ftype)
27830 
      iprot.readFieldEnd()
27831 
    iprot.readStructEnd()
27832 
 
27833 
  def write(self, oprot):
27834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27836 
      return
27837 
    oprot.writeStructBegin('updateMarketPlacePriceUpdateStatus_result')
27838 
    oprot.writeFieldStop()
27839 
    oprot.writeStructEnd()
27840 
 
27841 
  def validate(self):
27842 
    return
27843 
 
27844 
 
27845 
  def __repr__(self):
27846 
    L = ['%s=%r' % (key, value)
27847 
      for key, value in self.__dict__.iteritems()]
27848 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27849 
 
27850 
  def __eq__(self, other):
27851 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27852 
 
27853 
  def __ne__(self, other):
27854 
    return not (self == other)
9861 rajveer 27855 
 
27856 
class updateItemHoldInventory_args:
27857 
  """
27858 
  Attributes:
27859 
   - itemHoldMap
27860 
  """
27861 
 
27862 
  thrift_spec = (
27863 
    None, # 0
27864 
    (1, TType.MAP, 'itemHoldMap', (TType.I64,None,TType.I64,None), None, ), # 1
27865 
  )
27866 
 
27867 
  def __init__(self, itemHoldMap=None,):
27868 
    self.itemHoldMap = itemHoldMap
27869 
 
27870 
  def read(self, iprot):
27871 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27872 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27873 
      return
27874 
    iprot.readStructBegin()
27875 
    while True:
27876 
      (fname, ftype, fid) = iprot.readFieldBegin()
27877 
      if ftype == TType.STOP:
27878 
        break
27879 
      if fid == 1:
27880 
        if ftype == TType.MAP:
27881 
          self.itemHoldMap = {}
13493 amit.gupta 27882 
          (_ktype595, _vtype596, _size594 ) = iprot.readMapBegin()
27883 
          for _i598 in xrange(_size594):
27884 
            _key599 = iprot.readI64();
27885 
            _val600 = iprot.readI64();
27886 
            self.itemHoldMap[_key599] = _val600
9861 rajveer 27887 
          iprot.readMapEnd()
27888 
        else:
27889 
          iprot.skip(ftype)
27890 
      else:
27891 
        iprot.skip(ftype)
27892 
      iprot.readFieldEnd()
27893 
    iprot.readStructEnd()
27894 
 
27895 
  def write(self, oprot):
27896 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27897 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27898 
      return
27899 
    oprot.writeStructBegin('updateItemHoldInventory_args')
27900 
    if self.itemHoldMap is not None:
27901 
      oprot.writeFieldBegin('itemHoldMap', TType.MAP, 1)
27902 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.itemHoldMap))
13493 amit.gupta 27903 
      for kiter601,viter602 in self.itemHoldMap.items():
27904 
        oprot.writeI64(kiter601)
27905 
        oprot.writeI64(viter602)
9861 rajveer 27906 
      oprot.writeMapEnd()
27907 
      oprot.writeFieldEnd()
27908 
    oprot.writeFieldStop()
27909 
    oprot.writeStructEnd()
27910 
 
27911 
  def validate(self):
27912 
    return
27913 
 
27914 
 
27915 
  def __repr__(self):
27916 
    L = ['%s=%r' % (key, value)
27917 
      for key, value in self.__dict__.iteritems()]
27918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27919 
 
27920 
  def __eq__(self, other):
27921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27922 
 
27923 
  def __ne__(self, other):
27924 
    return not (self == other)
27925 
 
27926 
class updateItemHoldInventory_result:
27927 
 
27928 
  thrift_spec = (
27929 
  )
27930 
 
27931 
  def read(self, iprot):
27932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27934 
      return
27935 
    iprot.readStructBegin()
27936 
    while True:
27937 
      (fname, ftype, fid) = iprot.readFieldBegin()
27938 
      if ftype == TType.STOP:
27939 
        break
27940 
      else:
27941 
        iprot.skip(ftype)
27942 
      iprot.readFieldEnd()
27943 
    iprot.readStructEnd()
27944 
 
27945 
  def write(self, oprot):
27946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27948 
      return
27949 
    oprot.writeStructBegin('updateItemHoldInventory_result')
27950 
    oprot.writeFieldStop()
27951 
    oprot.writeStructEnd()
27952 
 
27953 
  def validate(self):
27954 
    return
27955 
 
27956 
 
27957 
  def __repr__(self):
27958 
    L = ['%s=%r' % (key, value)
27959 
      for key, value in self.__dict__.iteritems()]
27960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27961 
 
27962 
  def __eq__(self, other):
27963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27964 
 
27965 
  def __ne__(self, other):
27966 
    return not (self == other)
9895 vikram.rag 27967 
 
27968 
class updateNlcAtMarketplaces_args:
27969 
  """
27970 
  Attributes:
27971 
   - item_id
27972 
   - vendor_id
27973 
   - nlc
27974 
  """
27975 
 
27976 
  thrift_spec = None
27977 
  def __init__(self, item_id=None, vendor_id=None, nlc=None,):
27978 
    self.item_id = item_id
27979 
    self.vendor_id = vendor_id
27980 
    self.nlc = nlc
27981 
 
27982 
  def read(self, iprot):
27983 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27984 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27985 
      return
27986 
    iprot.readStructBegin()
27987 
    while True:
27988 
      (fname, ftype, fid) = iprot.readFieldBegin()
27989 
      if ftype == TType.STOP:
27990 
        break
27991 
      if fid == 1:
27992 
        if ftype == TType.I64:
27993 
          self.item_id = iprot.readI64();
27994 
        else:
27995 
          iprot.skip(ftype)
27996 
      elif fid == 2:
27997 
        if ftype == TType.I64:
27998 
          self.vendor_id = iprot.readI64();
27999 
        else:
28000 
          iprot.skip(ftype)
28001 
      elif fid == -1:
28002 
        if ftype == TType.DOUBLE:
28003 
          self.nlc = iprot.readDouble();
28004 
        else:
28005 
          iprot.skip(ftype)
28006 
      else:
28007 
        iprot.skip(ftype)
28008 
      iprot.readFieldEnd()
28009 
    iprot.readStructEnd()
28010 
 
28011 
  def write(self, oprot):
28012 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28013 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28014 
      return
28015 
    oprot.writeStructBegin('updateNlcAtMarketplaces_args')
28016 
    if self.nlc is not None:
28017 
      oprot.writeFieldBegin('nlc', TType.DOUBLE, -1)
28018 
      oprot.writeDouble(self.nlc)
28019 
      oprot.writeFieldEnd()
28020 
    if self.item_id is not None:
28021 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
28022 
      oprot.writeI64(self.item_id)
28023 
      oprot.writeFieldEnd()
28024 
    if self.vendor_id is not None:
28025 
      oprot.writeFieldBegin('vendor_id', TType.I64, 2)
28026 
      oprot.writeI64(self.vendor_id)
28027 
      oprot.writeFieldEnd()
28028 
    oprot.writeFieldStop()
28029 
    oprot.writeStructEnd()
28030 
 
28031 
  def validate(self):
28032 
    return
28033 
 
28034 
 
28035 
  def __repr__(self):
28036 
    L = ['%s=%r' % (key, value)
28037 
      for key, value in self.__dict__.iteritems()]
28038 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28039 
 
28040 
  def __eq__(self, other):
28041 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28042 
 
28043 
  def __ne__(self, other):
28044 
    return not (self == other)
28045 
 
28046 
class updateNlcAtMarketplaces_result:
28047 
 
28048 
  thrift_spec = (
28049 
  )
28050 
 
28051 
  def read(self, iprot):
28052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28054 
      return
28055 
    iprot.readStructBegin()
28056 
    while True:
28057 
      (fname, ftype, fid) = iprot.readFieldBegin()
28058 
      if ftype == TType.STOP:
28059 
        break
28060 
      else:
28061 
        iprot.skip(ftype)
28062 
      iprot.readFieldEnd()
28063 
    iprot.readStructEnd()
28064 
 
28065 
  def write(self, oprot):
28066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28068 
      return
28069 
    oprot.writeStructBegin('updateNlcAtMarketplaces_result')
28070 
    oprot.writeFieldStop()
28071 
    oprot.writeStructEnd()
28072 
 
28073 
  def validate(self):
28074 
    return
28075 
 
28076 
 
28077 
  def __repr__(self):
28078 
    L = ['%s=%r' % (key, value)
28079 
      for key, value in self.__dict__.iteritems()]
28080 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28081 
 
28082 
  def __eq__(self, other):
28083 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28084 
 
28085 
  def __ne__(self, other):
28086 
    return not (self == other)
9945 vikram.rag 28087 
 
28088 
class getAllFlipkartItems_args:
28089 
 
28090 
  thrift_spec = (
28091 
  )
28092 
 
28093 
  def read(self, iprot):
28094 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28095 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28096 
      return
28097 
    iprot.readStructBegin()
28098 
    while True:
28099 
      (fname, ftype, fid) = iprot.readFieldBegin()
28100 
      if ftype == TType.STOP:
28101 
        break
28102 
      else:
28103 
        iprot.skip(ftype)
28104 
      iprot.readFieldEnd()
28105 
    iprot.readStructEnd()
28106 
 
28107 
  def write(self, oprot):
28108 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28109 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28110 
      return
28111 
    oprot.writeStructBegin('getAllFlipkartItems_args')
28112 
    oprot.writeFieldStop()
28113 
    oprot.writeStructEnd()
28114 
 
28115 
  def validate(self):
28116 
    return
28117 
 
28118 
 
28119 
  def __repr__(self):
28120 
    L = ['%s=%r' % (key, value)
28121 
      for key, value in self.__dict__.iteritems()]
28122 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28123 
 
28124 
  def __eq__(self, other):
28125 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28126 
 
28127 
  def __ne__(self, other):
28128 
    return not (self == other)
28129 
 
28130 
class getAllFlipkartItems_result:
28131 
  """
28132 
  Attributes:
28133 
   - success
28134 
  """
28135 
 
28136 
  thrift_spec = (
28137 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartItem, FlipkartItem.thrift_spec)), None, ), # 0
28138 
  )
28139 
 
28140 
  def __init__(self, success=None,):
28141 
    self.success = success
28142 
 
28143 
  def read(self, iprot):
28144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28146 
      return
28147 
    iprot.readStructBegin()
28148 
    while True:
28149 
      (fname, ftype, fid) = iprot.readFieldBegin()
28150 
      if ftype == TType.STOP:
28151 
        break
28152 
      if fid == 0:
28153 
        if ftype == TType.LIST:
28154 
          self.success = []
13493 amit.gupta 28155 
          (_etype606, _size603) = iprot.readListBegin()
28156 
          for _i607 in xrange(_size603):
28157 
            _elem608 = FlipkartItem()
28158 
            _elem608.read(iprot)
28159 
            self.success.append(_elem608)
9945 vikram.rag 28160 
          iprot.readListEnd()
28161 
        else:
28162 
          iprot.skip(ftype)
28163 
      else:
28164 
        iprot.skip(ftype)
28165 
      iprot.readFieldEnd()
28166 
    iprot.readStructEnd()
28167 
 
28168 
  def write(self, oprot):
28169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28171 
      return
28172 
    oprot.writeStructBegin('getAllFlipkartItems_result')
28173 
    if self.success is not None:
28174 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28175 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 28176 
      for iter609 in self.success:
28177 
        iter609.write(oprot)
9945 vikram.rag 28178 
      oprot.writeListEnd()
28179 
      oprot.writeFieldEnd()
28180 
    oprot.writeFieldStop()
28181 
    oprot.writeStructEnd()
28182 
 
28183 
  def validate(self):
28184 
    return
28185 
 
28186 
 
28187 
  def __repr__(self):
28188 
    L = ['%s=%r' % (key, value)
28189 
      for key, value in self.__dict__.iteritems()]
28190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28191 
 
28192 
  def __eq__(self, other):
28193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28194 
 
28195 
  def __ne__(self, other):
28196 
    return not (self == other)
10097 kshitij.so 28197 
 
28198 
class addOrUpdateFlipkartItem_args:
28199 
  """
28200 
  Attributes:
28201 
   - flipkartitem
28202 
  """
28203 
 
28204 
  thrift_spec = None
28205 
  def __init__(self, flipkartitem=None,):
28206 
    self.flipkartitem = flipkartitem
28207 
 
28208 
  def read(self, iprot):
28209 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28210 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28211 
      return
28212 
    iprot.readStructBegin()
28213 
    while True:
28214 
      (fname, ftype, fid) = iprot.readFieldBegin()
28215 
      if ftype == TType.STOP:
28216 
        break
28217 
      if fid == -1:
28218 
        if ftype == TType.STRUCT:
28219 
          self.flipkartitem = FlipkartItem()
28220 
          self.flipkartitem.read(iprot)
28221 
        else:
28222 
          iprot.skip(ftype)
28223 
      else:
28224 
        iprot.skip(ftype)
28225 
      iprot.readFieldEnd()
28226 
    iprot.readStructEnd()
28227 
 
28228 
  def write(self, oprot):
28229 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28230 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28231 
      return
28232 
    oprot.writeStructBegin('addOrUpdateFlipkartItem_args')
28233 
    if self.flipkartitem is not None:
28234 
      oprot.writeFieldBegin('flipkartitem', TType.STRUCT, -1)
28235 
      self.flipkartitem.write(oprot)
28236 
      oprot.writeFieldEnd()
28237 
    oprot.writeFieldStop()
28238 
    oprot.writeStructEnd()
28239 
 
28240 
  def validate(self):
28241 
    return
28242 
 
28243 
 
28244 
  def __repr__(self):
28245 
    L = ['%s=%r' % (key, value)
28246 
      for key, value in self.__dict__.iteritems()]
28247 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28248 
 
28249 
  def __eq__(self, other):
28250 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28251 
 
28252 
  def __ne__(self, other):
28253 
    return not (self == other)
28254 
 
28255 
class addOrUpdateFlipkartItem_result:
28256 
  """
28257 
  Attributes:
28258 
   - success
28259 
  """
28260 
 
28261 
  thrift_spec = (
28262 
    (0, TType.BOOL, 'success', None, None, ), # 0
28263 
  )
28264 
 
28265 
  def __init__(self, success=None,):
28266 
    self.success = success
28267 
 
28268 
  def read(self, iprot):
28269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28271 
      return
28272 
    iprot.readStructBegin()
28273 
    while True:
28274 
      (fname, ftype, fid) = iprot.readFieldBegin()
28275 
      if ftype == TType.STOP:
28276 
        break
28277 
      if fid == 0:
28278 
        if ftype == TType.BOOL:
28279 
          self.success = iprot.readBool();
28280 
        else:
28281 
          iprot.skip(ftype)
28282 
      else:
28283 
        iprot.skip(ftype)
28284 
      iprot.readFieldEnd()
28285 
    iprot.readStructEnd()
28286 
 
28287 
  def write(self, oprot):
28288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28290 
      return
28291 
    oprot.writeStructBegin('addOrUpdateFlipkartItem_result')
28292 
    if self.success is not None:
28293 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
28294 
      oprot.writeBool(self.success)
28295 
      oprot.writeFieldEnd()
28296 
    oprot.writeFieldStop()
28297 
    oprot.writeStructEnd()
28298 
 
28299 
  def validate(self):
28300 
    return
28301 
 
28302 
 
28303 
  def __repr__(self):
28304 
    L = ['%s=%r' % (key, value)
28305 
      for key, value in self.__dict__.iteritems()]
28306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28307 
 
28308 
  def __eq__(self, other):
28309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28310 
 
28311 
  def __ne__(self, other):
28312 
    return not (self == other)
28313 
 
28314 
class getFlipkartItem_args:
28315 
  """
28316 
  Attributes:
28317 
   - item_id
28318 
  """
28319 
 
28320 
  thrift_spec = (
28321 
    None, # 0
28322 
    (1, TType.I64, 'item_id', None, None, ), # 1
28323 
  )
28324 
 
28325 
  def __init__(self, item_id=None,):
28326 
    self.item_id = item_id
28327 
 
28328 
  def read(self, iprot):
28329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28331 
      return
28332 
    iprot.readStructBegin()
28333 
    while True:
28334 
      (fname, ftype, fid) = iprot.readFieldBegin()
28335 
      if ftype == TType.STOP:
28336 
        break
28337 
      if fid == 1:
28338 
        if ftype == TType.I64:
28339 
          self.item_id = iprot.readI64();
28340 
        else:
28341 
          iprot.skip(ftype)
28342 
      else:
28343 
        iprot.skip(ftype)
28344 
      iprot.readFieldEnd()
28345 
    iprot.readStructEnd()
28346 
 
28347 
  def write(self, oprot):
28348 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28349 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28350 
      return
28351 
    oprot.writeStructBegin('getFlipkartItem_args')
28352 
    if self.item_id is not None:
28353 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
28354 
      oprot.writeI64(self.item_id)
28355 
      oprot.writeFieldEnd()
28356 
    oprot.writeFieldStop()
28357 
    oprot.writeStructEnd()
28358 
 
28359 
  def validate(self):
28360 
    return
28361 
 
28362 
 
28363 
  def __repr__(self):
28364 
    L = ['%s=%r' % (key, value)
28365 
      for key, value in self.__dict__.iteritems()]
28366 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28367 
 
28368 
  def __eq__(self, other):
28369 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28370 
 
28371 
  def __ne__(self, other):
28372 
    return not (self == other)
28373 
 
28374 
class getFlipkartItem_result:
28375 
  """
28376 
  Attributes:
28377 
   - success
28378 
  """
28379 
 
28380 
  thrift_spec = (
28381 
    (0, TType.STRUCT, 'success', (FlipkartItem, FlipkartItem.thrift_spec), None, ), # 0
28382 
  )
28383 
 
28384 
  def __init__(self, success=None,):
28385 
    self.success = success
28386 
 
28387 
  def read(self, iprot):
28388 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28389 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28390 
      return
28391 
    iprot.readStructBegin()
28392 
    while True:
28393 
      (fname, ftype, fid) = iprot.readFieldBegin()
28394 
      if ftype == TType.STOP:
28395 
        break
28396 
      if fid == 0:
28397 
        if ftype == TType.STRUCT:
28398 
          self.success = FlipkartItem()
28399 
          self.success.read(iprot)
28400 
        else:
28401 
          iprot.skip(ftype)
28402 
      else:
28403 
        iprot.skip(ftype)
28404 
      iprot.readFieldEnd()
28405 
    iprot.readStructEnd()
28406 
 
28407 
  def write(self, oprot):
28408 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28409 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28410 
      return
28411 
    oprot.writeStructBegin('getFlipkartItem_result')
28412 
    if self.success is not None:
28413 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28414 
      self.success.write(oprot)
28415 
      oprot.writeFieldEnd()
28416 
    oprot.writeFieldStop()
28417 
    oprot.writeStructEnd()
28418 
 
28419 
  def validate(self):
28420 
    return
28421 
 
28422 
 
28423 
  def __repr__(self):
28424 
    L = ['%s=%r' % (key, value)
28425 
      for key, value in self.__dict__.iteritems()]
28426 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28427 
 
28428 
  def __eq__(self, other):
28429 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28430 
 
28431 
  def __ne__(self, other):
28432 
    return not (self == other)
28433 
 
28434 
class getFlipkartItemDetails_args:
28435 
  """
28436 
  Attributes:
28437 
   - item_id
28438 
  """
28439 
 
28440 
  thrift_spec = (
28441 
    None, # 0
28442 
    (1, TType.I64, 'item_id', None, None, ), # 1
28443 
  )
28444 
 
28445 
  def __init__(self, item_id=None,):
28446 
    self.item_id = item_id
28447 
 
28448 
  def read(self, iprot):
28449 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28450 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28451 
      return
28452 
    iprot.readStructBegin()
28453 
    while True:
28454 
      (fname, ftype, fid) = iprot.readFieldBegin()
28455 
      if ftype == TType.STOP:
28456 
        break
28457 
      if fid == 1:
28458 
        if ftype == TType.I64:
28459 
          self.item_id = iprot.readI64();
28460 
        else:
28461 
          iprot.skip(ftype)
28462 
      else:
28463 
        iprot.skip(ftype)
28464 
      iprot.readFieldEnd()
28465 
    iprot.readStructEnd()
28466 
 
28467 
  def write(self, oprot):
28468 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28469 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28470 
      return
28471 
    oprot.writeStructBegin('getFlipkartItemDetails_args')
28472 
    if self.item_id is not None:
28473 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
28474 
      oprot.writeI64(self.item_id)
28475 
      oprot.writeFieldEnd()
28476 
    oprot.writeFieldStop()
28477 
    oprot.writeStructEnd()
28478 
 
28479 
  def validate(self):
28480 
    return
28481 
 
28482 
 
28483 
  def __repr__(self):
28484 
    L = ['%s=%r' % (key, value)
28485 
      for key, value in self.__dict__.iteritems()]
28486 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28487 
 
28488 
  def __eq__(self, other):
28489 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28490 
 
28491 
  def __ne__(self, other):
28492 
    return not (self == other)
28493 
 
28494 
class getFlipkartItemDetails_result:
28495 
  """
28496 
  Attributes:
28497 
   - success
28498 
  """
28499 
 
28500 
  thrift_spec = (
28501 
    (0, TType.STRUCT, 'success', (FlipkartItemDetails, FlipkartItemDetails.thrift_spec), None, ), # 0
28502 
  )
28503 
 
28504 
  def __init__(self, success=None,):
28505 
    self.success = success
28506 
 
28507 
  def read(self, iprot):
28508 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28509 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28510 
      return
28511 
    iprot.readStructBegin()
28512 
    while True:
28513 
      (fname, ftype, fid) = iprot.readFieldBegin()
28514 
      if ftype == TType.STOP:
28515 
        break
28516 
      if fid == 0:
28517 
        if ftype == TType.STRUCT:
28518 
          self.success = FlipkartItemDetails()
28519 
          self.success.read(iprot)
28520 
        else:
28521 
          iprot.skip(ftype)
28522 
      else:
28523 
        iprot.skip(ftype)
28524 
      iprot.readFieldEnd()
28525 
    iprot.readStructEnd()
28526 
 
28527 
  def write(self, oprot):
28528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28530 
      return
28531 
    oprot.writeStructBegin('getFlipkartItemDetails_result')
28532 
    if self.success is not None:
28533 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28534 
      self.success.write(oprot)
28535 
      oprot.writeFieldEnd()
28536 
    oprot.writeFieldStop()
28537 
    oprot.writeStructEnd()
28538 
 
28539 
  def validate(self):
28540 
    return
28541 
 
28542 
 
28543 
  def __repr__(self):
28544 
    L = ['%s=%r' % (key, value)
28545 
      for key, value in self.__dict__.iteritems()]
28546 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28547 
 
28548 
  def __eq__(self, other):
28549 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28550 
 
28551 
  def __ne__(self, other):
28552 
    return not (self == other)
28553 
 
28554 
class getFlipkartItems_args:
28555 
  """
28556 
  Attributes:
28557 
   - offset
28558 
   - limit
28559 
  """
28560 
 
28561 
  thrift_spec = (
28562 
    None, # 0
28563 
    (1, TType.I64, 'offset', None, None, ), # 1
28564 
    (2, TType.I64, 'limit', None, None, ), # 2
28565 
  )
28566 
 
28567 
  def __init__(self, offset=None, limit=None,):
28568 
    self.offset = offset
28569 
    self.limit = limit
28570 
 
28571 
  def read(self, iprot):
28572 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28573 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28574 
      return
28575 
    iprot.readStructBegin()
28576 
    while True:
28577 
      (fname, ftype, fid) = iprot.readFieldBegin()
28578 
      if ftype == TType.STOP:
28579 
        break
28580 
      if fid == 1:
28581 
        if ftype == TType.I64:
28582 
          self.offset = iprot.readI64();
28583 
        else:
28584 
          iprot.skip(ftype)
28585 
      elif fid == 2:
28586 
        if ftype == TType.I64:
28587 
          self.limit = iprot.readI64();
28588 
        else:
28589 
          iprot.skip(ftype)
28590 
      else:
28591 
        iprot.skip(ftype)
28592 
      iprot.readFieldEnd()
28593 
    iprot.readStructEnd()
28594 
 
28595 
  def write(self, oprot):
28596 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28597 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28598 
      return
28599 
    oprot.writeStructBegin('getFlipkartItems_args')
28600 
    if self.offset is not None:
28601 
      oprot.writeFieldBegin('offset', TType.I64, 1)
28602 
      oprot.writeI64(self.offset)
28603 
      oprot.writeFieldEnd()
28604 
    if self.limit is not None:
28605 
      oprot.writeFieldBegin('limit', TType.I64, 2)
28606 
      oprot.writeI64(self.limit)
28607 
      oprot.writeFieldEnd()
28608 
    oprot.writeFieldStop()
28609 
    oprot.writeStructEnd()
28610 
 
28611 
  def validate(self):
28612 
    return
28613 
 
28614 
 
28615 
  def __repr__(self):
28616 
    L = ['%s=%r' % (key, value)
28617 
      for key, value in self.__dict__.iteritems()]
28618 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28619 
 
28620 
  def __eq__(self, other):
28621 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28622 
 
28623 
  def __ne__(self, other):
28624 
    return not (self == other)
28625 
 
28626 
class getFlipkartItems_result:
28627 
  """
28628 
  Attributes:
28629 
   - success
28630 
  """
28631 
 
28632 
  thrift_spec = (
28633 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartItemDetails, FlipkartItemDetails.thrift_spec)), None, ), # 0
28634 
  )
28635 
 
28636 
  def __init__(self, success=None,):
28637 
    self.success = success
28638 
 
28639 
  def read(self, iprot):
28640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28642 
      return
28643 
    iprot.readStructBegin()
28644 
    while True:
28645 
      (fname, ftype, fid) = iprot.readFieldBegin()
28646 
      if ftype == TType.STOP:
28647 
        break
28648 
      if fid == 0:
28649 
        if ftype == TType.LIST:
28650 
          self.success = []
13493 amit.gupta 28651 
          (_etype613, _size610) = iprot.readListBegin()
28652 
          for _i614 in xrange(_size610):
28653 
            _elem615 = FlipkartItemDetails()
28654 
            _elem615.read(iprot)
28655 
            self.success.append(_elem615)
10097 kshitij.so 28656 
          iprot.readListEnd()
28657 
        else:
28658 
          iprot.skip(ftype)
28659 
      else:
28660 
        iprot.skip(ftype)
28661 
      iprot.readFieldEnd()
28662 
    iprot.readStructEnd()
28663 
 
28664 
  def write(self, oprot):
28665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28667 
      return
28668 
    oprot.writeStructBegin('getFlipkartItems_result')
28669 
    if self.success is not None:
28670 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28671 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 28672 
      for iter616 in self.success:
28673 
        iter616.write(oprot)
10097 kshitij.so 28674 
      oprot.writeListEnd()
28675 
      oprot.writeFieldEnd()
28676 
    oprot.writeFieldStop()
28677 
    oprot.writeStructEnd()
28678 
 
28679 
  def validate(self):
28680 
    return
28681 
 
28682 
 
28683 
  def __repr__(self):
28684 
    L = ['%s=%r' % (key, value)
28685 
      for key, value in self.__dict__.iteritems()]
28686 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28687 
 
28688 
  def __eq__(self, other):
28689 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28690 
 
28691 
  def __ne__(self, other):
28692 
    return not (self == other)
28693 
 
28694 
class searchFlipkartItems_args:
28695 
  """
28696 
  Attributes:
28697 
   - searchTerm
28698 
   - offset
28699 
   - limit
28700 
  """
28701 
 
28702 
  thrift_spec = (
28703 
    None, # 0
28704 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
28705 
    (2, TType.I64, 'offset', None, None, ), # 2
28706 
    (3, TType.I64, 'limit', None, None, ), # 3
28707 
  )
28708 
 
28709 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
28710 
    self.searchTerm = searchTerm
28711 
    self.offset = offset
28712 
    self.limit = limit
28713 
 
28714 
  def read(self, iprot):
28715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28717 
      return
28718 
    iprot.readStructBegin()
28719 
    while True:
28720 
      (fname, ftype, fid) = iprot.readFieldBegin()
28721 
      if ftype == TType.STOP:
28722 
        break
28723 
      if fid == 1:
28724 
        if ftype == TType.LIST:
28725 
          self.searchTerm = []
13493 amit.gupta 28726 
          (_etype620, _size617) = iprot.readListBegin()
28727 
          for _i621 in xrange(_size617):
28728 
            _elem622 = iprot.readString();
28729 
            self.searchTerm.append(_elem622)
10097 kshitij.so 28730 
          iprot.readListEnd()
28731 
        else:
28732 
          iprot.skip(ftype)
28733 
      elif fid == 2:
28734 
        if ftype == TType.I64:
28735 
          self.offset = iprot.readI64();
28736 
        else:
28737 
          iprot.skip(ftype)
28738 
      elif fid == 3:
28739 
        if ftype == TType.I64:
28740 
          self.limit = iprot.readI64();
28741 
        else:
28742 
          iprot.skip(ftype)
28743 
      else:
28744 
        iprot.skip(ftype)
28745 
      iprot.readFieldEnd()
28746 
    iprot.readStructEnd()
28747 
 
28748 
  def write(self, oprot):
28749 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28750 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28751 
      return
28752 
    oprot.writeStructBegin('searchFlipkartItems_args')
28753 
    if self.searchTerm is not None:
28754 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
28755 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
13493 amit.gupta 28756 
      for iter623 in self.searchTerm:
28757 
        oprot.writeString(iter623)
10097 kshitij.so 28758 
      oprot.writeListEnd()
28759 
      oprot.writeFieldEnd()
28760 
    if self.offset is not None:
28761 
      oprot.writeFieldBegin('offset', TType.I64, 2)
28762 
      oprot.writeI64(self.offset)
28763 
      oprot.writeFieldEnd()
28764 
    if self.limit is not None:
28765 
      oprot.writeFieldBegin('limit', TType.I64, 3)
28766 
      oprot.writeI64(self.limit)
28767 
      oprot.writeFieldEnd()
28768 
    oprot.writeFieldStop()
28769 
    oprot.writeStructEnd()
28770 
 
28771 
  def validate(self):
28772 
    return
28773 
 
28774 
 
28775 
  def __repr__(self):
28776 
    L = ['%s=%r' % (key, value)
28777 
      for key, value in self.__dict__.iteritems()]
28778 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28779 
 
28780 
  def __eq__(self, other):
28781 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28782 
 
28783 
  def __ne__(self, other):
28784 
    return not (self == other)
28785 
 
28786 
class searchFlipkartItems_result:
28787 
  """
28788 
  Attributes:
28789 
   - success
28790 
  """
28791 
 
28792 
  thrift_spec = (
28793 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartItemDetails, FlipkartItemDetails.thrift_spec)), None, ), # 0
28794 
  )
28795 
 
28796 
  def __init__(self, success=None,):
28797 
    self.success = success
28798 
 
28799 
  def read(self, iprot):
28800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28802 
      return
28803 
    iprot.readStructBegin()
28804 
    while True:
28805 
      (fname, ftype, fid) = iprot.readFieldBegin()
28806 
      if ftype == TType.STOP:
28807 
        break
28808 
      if fid == 0:
28809 
        if ftype == TType.LIST:
28810 
          self.success = []
13493 amit.gupta 28811 
          (_etype627, _size624) = iprot.readListBegin()
28812 
          for _i628 in xrange(_size624):
28813 
            _elem629 = FlipkartItemDetails()
28814 
            _elem629.read(iprot)
28815 
            self.success.append(_elem629)
10097 kshitij.so 28816 
          iprot.readListEnd()
28817 
        else:
28818 
          iprot.skip(ftype)
28819 
      else:
28820 
        iprot.skip(ftype)
28821 
      iprot.readFieldEnd()
28822 
    iprot.readStructEnd()
28823 
 
28824 
  def write(self, oprot):
28825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28827 
      return
28828 
    oprot.writeStructBegin('searchFlipkartItems_result')
28829 
    if self.success is not None:
28830 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28831 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 28832 
      for iter630 in self.success:
28833 
        iter630.write(oprot)
10097 kshitij.so 28834 
      oprot.writeListEnd()
28835 
      oprot.writeFieldEnd()
28836 
    oprot.writeFieldStop()
28837 
    oprot.writeStructEnd()
28838 
 
28839 
  def validate(self):
28840 
    return
28841 
 
28842 
 
28843 
  def __repr__(self):
28844 
    L = ['%s=%r' % (key, value)
28845 
      for key, value in self.__dict__.iteritems()]
28846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28847 
 
28848 
  def __eq__(self, other):
28849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28850 
 
28851 
  def __ne__(self, other):
28852 
    return not (self == other)
28853 
 
28854 
class getCountForFlipkartItems_args:
28855 
 
28856 
  thrift_spec = (
28857 
  )
28858 
 
28859 
  def read(self, iprot):
28860 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28861 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28862 
      return
28863 
    iprot.readStructBegin()
28864 
    while True:
28865 
      (fname, ftype, fid) = iprot.readFieldBegin()
28866 
      if ftype == TType.STOP:
28867 
        break
28868 
      else:
28869 
        iprot.skip(ftype)
28870 
      iprot.readFieldEnd()
28871 
    iprot.readStructEnd()
28872 
 
28873 
  def write(self, oprot):
28874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28876 
      return
28877 
    oprot.writeStructBegin('getCountForFlipkartItems_args')
28878 
    oprot.writeFieldStop()
28879 
    oprot.writeStructEnd()
28880 
 
28881 
  def validate(self):
28882 
    return
28883 
 
28884 
 
28885 
  def __repr__(self):
28886 
    L = ['%s=%r' % (key, value)
28887 
      for key, value in self.__dict__.iteritems()]
28888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28889 
 
28890 
  def __eq__(self, other):
28891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28892 
 
28893 
  def __ne__(self, other):
28894 
    return not (self == other)
28895 
 
28896 
class getCountForFlipkartItems_result:
28897 
  """
28898 
  Attributes:
28899 
   - success
28900 
  """
28901 
 
28902 
  thrift_spec = (
28903 
    (0, TType.I64, 'success', None, None, ), # 0
28904 
  )
28905 
 
28906 
  def __init__(self, success=None,):
28907 
    self.success = success
28908 
 
28909 
  def read(self, iprot):
28910 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28911 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28912 
      return
28913 
    iprot.readStructBegin()
28914 
    while True:
28915 
      (fname, ftype, fid) = iprot.readFieldBegin()
28916 
      if ftype == TType.STOP:
28917 
        break
28918 
      if fid == 0:
28919 
        if ftype == TType.I64:
28920 
          self.success = iprot.readI64();
28921 
        else:
28922 
          iprot.skip(ftype)
28923 
      else:
28924 
        iprot.skip(ftype)
28925 
      iprot.readFieldEnd()
28926 
    iprot.readStructEnd()
28927 
 
28928 
  def write(self, oprot):
28929 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28930 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28931 
      return
28932 
    oprot.writeStructBegin('getCountForFlipkartItems_result')
28933 
    if self.success is not None:
28934 
      oprot.writeFieldBegin('success', TType.I64, 0)
28935 
      oprot.writeI64(self.success)
28936 
      oprot.writeFieldEnd()
28937 
    oprot.writeFieldStop()
28938 
    oprot.writeStructEnd()
28939 
 
28940 
  def validate(self):
28941 
    return
28942 
 
28943 
 
28944 
  def __repr__(self):
28945 
    L = ['%s=%r' % (key, value)
28946 
      for key, value in self.__dict__.iteritems()]
28947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28948 
 
28949 
  def __eq__(self, other):
28950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28951 
 
28952 
  def __ne__(self, other):
28953 
    return not (self == other)
28954 
 
28955 
class getFlipkartSearchResultCount_args:
28956 
  """
28957 
  Attributes:
28958 
   - searchTerm
28959 
  """
28960 
 
28961 
  thrift_spec = (
28962 
    None, # 0
28963 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
28964 
  )
28965 
 
28966 
  def __init__(self, searchTerm=None,):
28967 
    self.searchTerm = searchTerm
28968 
 
28969 
  def read(self, iprot):
28970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28972 
      return
28973 
    iprot.readStructBegin()
28974 
    while True:
28975 
      (fname, ftype, fid) = iprot.readFieldBegin()
28976 
      if ftype == TType.STOP:
28977 
        break
28978 
      if fid == 1:
28979 
        if ftype == TType.LIST:
28980 
          self.searchTerm = []
13493 amit.gupta 28981 
          (_etype634, _size631) = iprot.readListBegin()
28982 
          for _i635 in xrange(_size631):
28983 
            _elem636 = iprot.readString();
28984 
            self.searchTerm.append(_elem636)
10097 kshitij.so 28985 
          iprot.readListEnd()
28986 
        else:
28987 
          iprot.skip(ftype)
28988 
      else:
28989 
        iprot.skip(ftype)
28990 
      iprot.readFieldEnd()
28991 
    iprot.readStructEnd()
28992 
 
28993 
  def write(self, oprot):
28994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28996 
      return
28997 
    oprot.writeStructBegin('getFlipkartSearchResultCount_args')
28998 
    if self.searchTerm is not None:
28999 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
29000 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
13493 amit.gupta 29001 
      for iter637 in self.searchTerm:
29002 
        oprot.writeString(iter637)
10097 kshitij.so 29003 
      oprot.writeListEnd()
29004 
      oprot.writeFieldEnd()
29005 
    oprot.writeFieldStop()
29006 
    oprot.writeStructEnd()
29007 
 
29008 
  def validate(self):
29009 
    return
29010 
 
29011 
 
29012 
  def __repr__(self):
29013 
    L = ['%s=%r' % (key, value)
29014 
      for key, value in self.__dict__.iteritems()]
29015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29016 
 
29017 
  def __eq__(self, other):
29018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29019 
 
29020 
  def __ne__(self, other):
29021 
    return not (self == other)
29022 
 
29023 
class getFlipkartSearchResultCount_result:
29024 
  """
29025 
  Attributes:
29026 
   - success
29027 
  """
29028 
 
29029 
  thrift_spec = (
29030 
    (0, TType.I64, 'success', None, None, ), # 0
29031 
  )
29032 
 
29033 
  def __init__(self, success=None,):
29034 
    self.success = success
29035 
 
29036 
  def read(self, iprot):
29037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29039 
      return
29040 
    iprot.readStructBegin()
29041 
    while True:
29042 
      (fname, ftype, fid) = iprot.readFieldBegin()
29043 
      if ftype == TType.STOP:
29044 
        break
29045 
      if fid == 0:
29046 
        if ftype == TType.I64:
29047 
          self.success = iprot.readI64();
29048 
        else:
29049 
          iprot.skip(ftype)
29050 
      else:
29051 
        iprot.skip(ftype)
29052 
      iprot.readFieldEnd()
29053 
    iprot.readStructEnd()
29054 
 
29055 
  def write(self, oprot):
29056 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29057 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29058 
      return
29059 
    oprot.writeStructBegin('getFlipkartSearchResultCount_result')
29060 
    if self.success is not None:
29061 
      oprot.writeFieldBegin('success', TType.I64, 0)
29062 
      oprot.writeI64(self.success)
29063 
      oprot.writeFieldEnd()
29064 
    oprot.writeFieldStop()
29065 
    oprot.writeStructEnd()
29066 
 
29067 
  def validate(self):
29068 
    return
29069 
 
29070 
 
29071 
  def __repr__(self):
29072 
    L = ['%s=%r' % (key, value)
29073 
      for key, value in self.__dict__.iteritems()]
29074 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29075 
 
29076 
  def __eq__(self, other):
29077 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29078 
 
29079 
  def __ne__(self, other):
29080 
    return not (self == other)
29081 
 
29082 
class getAllFkItems_args:
29083 
 
29084 
  thrift_spec = (
29085 
  )
29086 
 
29087 
  def read(self, iprot):
29088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29090 
      return
29091 
    iprot.readStructBegin()
29092 
    while True:
29093 
      (fname, ftype, fid) = iprot.readFieldBegin()
29094 
      if ftype == TType.STOP:
29095 
        break
29096 
      else:
29097 
        iprot.skip(ftype)
29098 
      iprot.readFieldEnd()
29099 
    iprot.readStructEnd()
29100 
 
29101 
  def write(self, oprot):
29102 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29103 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29104 
      return
29105 
    oprot.writeStructBegin('getAllFkItems_args')
29106 
    oprot.writeFieldStop()
29107 
    oprot.writeStructEnd()
29108 
 
29109 
  def validate(self):
29110 
    return
29111 
 
29112 
 
29113 
  def __repr__(self):
29114 
    L = ['%s=%r' % (key, value)
29115 
      for key, value in self.__dict__.iteritems()]
29116 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29117 
 
29118 
  def __eq__(self, other):
29119 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29120 
 
29121 
  def __ne__(self, other):
29122 
    return not (self == other)
29123 
 
29124 
class getAllFkItems_result:
29125 
  """
29126 
  Attributes:
29127 
   - success
29128 
  """
29129 
 
29130 
  thrift_spec = (
29131 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartItemDetails, FlipkartItemDetails.thrift_spec)), None, ), # 0
29132 
  )
29133 
 
29134 
  def __init__(self, success=None,):
29135 
    self.success = success
29136 
 
29137 
  def read(self, iprot):
29138 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29139 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29140 
      return
29141 
    iprot.readStructBegin()
29142 
    while True:
29143 
      (fname, ftype, fid) = iprot.readFieldBegin()
29144 
      if ftype == TType.STOP:
29145 
        break
29146 
      if fid == 0:
29147 
        if ftype == TType.LIST:
29148 
          self.success = []
13493 amit.gupta 29149 
          (_etype641, _size638) = iprot.readListBegin()
29150 
          for _i642 in xrange(_size638):
29151 
            _elem643 = FlipkartItemDetails()
29152 
            _elem643.read(iprot)
29153 
            self.success.append(_elem643)
10097 kshitij.so 29154 
          iprot.readListEnd()
29155 
        else:
29156 
          iprot.skip(ftype)
29157 
      else:
29158 
        iprot.skip(ftype)
29159 
      iprot.readFieldEnd()
29160 
    iprot.readStructEnd()
29161 
 
29162 
  def write(self, oprot):
29163 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29164 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29165 
      return
29166 
    oprot.writeStructBegin('getAllFkItems_result')
29167 
    if self.success is not None:
29168 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29169 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 29170 
      for iter644 in self.success:
29171 
        iter644.write(oprot)
10097 kshitij.so 29172 
      oprot.writeListEnd()
29173 
      oprot.writeFieldEnd()
29174 
    oprot.writeFieldStop()
29175 
    oprot.writeStructEnd()
29176 
 
29177 
  def validate(self):
29178 
    return
29179 
 
29180 
 
29181 
  def __repr__(self):
29182 
    L = ['%s=%r' % (key, value)
29183 
      for key, value in self.__dict__.iteritems()]
29184 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29185 
 
29186 
  def __eq__(self, other):
29187 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29188 
 
29189 
  def __ne__(self, other):
29190 
    return not (self == other)
10140 vikram.rag 29191 
 
29192 
class getFlipkartItemBySkyAtFlipkart_args:
29193 
  """
29194 
  Attributes:
29195 
   - sku
29196 
  """
29197 
 
11531 vikram.rag 29198 
  thrift_spec = None
10140 vikram.rag 29199 
  def __init__(self, sku=None,):
29200 
    self.sku = sku
29201 
 
29202 
  def read(self, iprot):
29203 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29204 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29205 
      return
29206 
    iprot.readStructBegin()
29207 
    while True:
29208 
      (fname, ftype, fid) = iprot.readFieldBegin()
29209 
      if ftype == TType.STOP:
29210 
        break
11531 vikram.rag 29211 
      if fid == -1:
10140 vikram.rag 29212 
        if ftype == TType.STRING:
29213 
          self.sku = iprot.readString();
29214 
        else:
29215 
          iprot.skip(ftype)
29216 
      else:
29217 
        iprot.skip(ftype)
29218 
      iprot.readFieldEnd()
29219 
    iprot.readStructEnd()
29220 
 
29221 
  def write(self, oprot):
29222 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29223 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29224 
      return
29225 
    oprot.writeStructBegin('getFlipkartItemBySkyAtFlipkart_args')
29226 
    if self.sku is not None:
11531 vikram.rag 29227 
      oprot.writeFieldBegin('sku', TType.STRING, -1)
10140 vikram.rag 29228 
      oprot.writeString(self.sku)
29229 
      oprot.writeFieldEnd()
29230 
    oprot.writeFieldStop()
29231 
    oprot.writeStructEnd()
29232 
 
29233 
  def validate(self):
29234 
    return
29235 
 
29236 
 
29237 
  def __repr__(self):
29238 
    L = ['%s=%r' % (key, value)
29239 
      for key, value in self.__dict__.iteritems()]
29240 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29241 
 
29242 
  def __eq__(self, other):
29243 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29244 
 
29245 
  def __ne__(self, other):
29246 
    return not (self == other)
29247 
 
29248 
class getFlipkartItemBySkyAtFlipkart_result:
29249 
  """
29250 
  Attributes:
29251 
   - success
29252 
  """
29253 
 
29254 
  thrift_spec = (
29255 
    (0, TType.STRUCT, 'success', (FlipkartItem, FlipkartItem.thrift_spec), None, ), # 0
29256 
  )
29257 
 
29258 
  def __init__(self, success=None,):
29259 
    self.success = success
29260 
 
29261 
  def read(self, iprot):
29262 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29263 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29264 
      return
29265 
    iprot.readStructBegin()
29266 
    while True:
29267 
      (fname, ftype, fid) = iprot.readFieldBegin()
29268 
      if ftype == TType.STOP:
29269 
        break
29270 
      if fid == 0:
29271 
        if ftype == TType.STRUCT:
29272 
          self.success = FlipkartItem()
29273 
          self.success.read(iprot)
29274 
        else:
29275 
          iprot.skip(ftype)
29276 
      else:
29277 
        iprot.skip(ftype)
29278 
      iprot.readFieldEnd()
29279 
    iprot.readStructEnd()
29280 
 
29281 
  def write(self, oprot):
29282 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29283 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29284 
      return
29285 
    oprot.writeStructBegin('getFlipkartItemBySkyAtFlipkart_result')
29286 
    if self.success is not None:
29287 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
29288 
      self.success.write(oprot)
29289 
      oprot.writeFieldEnd()
29290 
    oprot.writeFieldStop()
29291 
    oprot.writeStructEnd()
29292 
 
29293 
  def validate(self):
29294 
    return
29295 
 
29296 
 
29297 
  def __repr__(self):
29298 
    L = ['%s=%r' % (key, value)
29299 
      for key, value in self.__dict__.iteritems()]
29300 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29301 
 
29302 
  def __eq__(self, other):
29303 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29304 
 
29305 
  def __ne__(self, other):
29306 
    return not (self == other)
10909 vikram.rag 29307 
 
11015 kshitij.so 29308 
class getMarketplaceHistory_args:
29309 
  """
29310 
  Attributes:
29311 
   - source
29312 
   - offset
29313 
   - itemId
29314 
  """
10909 vikram.rag 29315 
 
29316 
  thrift_spec = (
11015 kshitij.so 29317 
    None, # 0
29318 
    (1, TType.I64, 'source', None, None, ), # 1
29319 
    (2, TType.I64, 'offset', None, None, ), # 2
29320 
    (3, TType.I64, 'itemId', None, None, ), # 3
10909 vikram.rag 29321 
  )
29322 
 
11015 kshitij.so 29323 
  def __init__(self, source=None, offset=None, itemId=None,):
29324 
    self.source = source
29325 
    self.offset = offset
29326 
    self.itemId = itemId
29327 
 
10909 vikram.rag 29328 
  def read(self, iprot):
29329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29331 
      return
29332 
    iprot.readStructBegin()
29333 
    while True:
29334 
      (fname, ftype, fid) = iprot.readFieldBegin()
29335 
      if ftype == TType.STOP:
29336 
        break
11015 kshitij.so 29337 
      if fid == 1:
29338 
        if ftype == TType.I64:
29339 
          self.source = iprot.readI64();
29340 
        else:
29341 
          iprot.skip(ftype)
29342 
      elif fid == 2:
29343 
        if ftype == TType.I64:
29344 
          self.offset = iprot.readI64();
29345 
        else:
29346 
          iprot.skip(ftype)
29347 
      elif fid == 3:
29348 
        if ftype == TType.I64:
29349 
          self.itemId = iprot.readI64();
29350 
        else:
29351 
          iprot.skip(ftype)
10909 vikram.rag 29352 
      else:
29353 
        iprot.skip(ftype)
29354 
      iprot.readFieldEnd()
29355 
    iprot.readStructEnd()
29356 
 
29357 
  def write(self, oprot):
29358 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29359 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29360 
      return
11015 kshitij.so 29361 
    oprot.writeStructBegin('getMarketplaceHistory_args')
29362 
    if self.source is not None:
29363 
      oprot.writeFieldBegin('source', TType.I64, 1)
29364 
      oprot.writeI64(self.source)
29365 
      oprot.writeFieldEnd()
29366 
    if self.offset is not None:
29367 
      oprot.writeFieldBegin('offset', TType.I64, 2)
29368 
      oprot.writeI64(self.offset)
29369 
      oprot.writeFieldEnd()
29370 
    if self.itemId is not None:
29371 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
29372 
      oprot.writeI64(self.itemId)
29373 
      oprot.writeFieldEnd()
10909 vikram.rag 29374 
    oprot.writeFieldStop()
29375 
    oprot.writeStructEnd()
29376 
 
29377 
  def validate(self):
29378 
    return
29379 
 
29380 
 
29381 
  def __repr__(self):
29382 
    L = ['%s=%r' % (key, value)
29383 
      for key, value in self.__dict__.iteritems()]
29384 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29385 
 
29386 
  def __eq__(self, other):
29387 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29388 
 
29389 
  def __ne__(self, other):
29390 
    return not (self == other)
29391 
 
11015 kshitij.so 29392 
class getMarketplaceHistory_result:
10909 vikram.rag 29393 
  """
29394 
  Attributes:
29395 
   - success
29396 
  """
29397 
 
29398 
  thrift_spec = (
11015 kshitij.so 29399 
    (0, TType.LIST, 'success', (TType.STRUCT,(MarketplaceHistory, MarketplaceHistory.thrift_spec)), None, ), # 0
10909 vikram.rag 29400 
  )
29401 
 
29402 
  def __init__(self, success=None,):
29403 
    self.success = success
29404 
 
29405 
  def read(self, iprot):
29406 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29407 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29408 
      return
29409 
    iprot.readStructBegin()
29410 
    while True:
29411 
      (fname, ftype, fid) = iprot.readFieldBegin()
29412 
      if ftype == TType.STOP:
29413 
        break
29414 
      if fid == 0:
29415 
        if ftype == TType.LIST:
29416 
          self.success = []
13493 amit.gupta 29417 
          (_etype648, _size645) = iprot.readListBegin()
29418 
          for _i649 in xrange(_size645):
29419 
            _elem650 = MarketplaceHistory()
29420 
            _elem650.read(iprot)
29421 
            self.success.append(_elem650)
10909 vikram.rag 29422 
          iprot.readListEnd()
29423 
        else:
29424 
          iprot.skip(ftype)
29425 
      else:
29426 
        iprot.skip(ftype)
29427 
      iprot.readFieldEnd()
29428 
    iprot.readStructEnd()
29429 
 
29430 
  def write(self, oprot):
29431 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29432 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29433 
      return
11015 kshitij.so 29434 
    oprot.writeStructBegin('getMarketplaceHistory_result')
10909 vikram.rag 29435 
    if self.success is not None:
29436 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29437 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 29438 
      for iter651 in self.success:
29439 
        iter651.write(oprot)
10909 vikram.rag 29440 
      oprot.writeListEnd()
29441 
      oprot.writeFieldEnd()
29442 
    oprot.writeFieldStop()
29443 
    oprot.writeStructEnd()
29444 
 
29445 
  def validate(self):
29446 
    return
29447 
 
29448 
 
29449 
  def __repr__(self):
29450 
    L = ['%s=%r' % (key, value)
29451 
      for key, value in self.__dict__.iteritems()]
29452 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29453 
 
29454 
  def __eq__(self, other):
29455 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29456 
 
29457 
  def __ne__(self, other):
29458 
    return not (self == other)
10924 vikram.rag 29459 
 
11015 kshitij.so 29460 
class getAllFbbListedItems_args:
10924 vikram.rag 29461 
 
29462 
  thrift_spec = (
29463 
  )
29464 
 
29465 
  def read(self, iprot):
29466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29468 
      return
29469 
    iprot.readStructBegin()
29470 
    while True:
29471 
      (fname, ftype, fid) = iprot.readFieldBegin()
29472 
      if ftype == TType.STOP:
29473 
        break
29474 
      else:
29475 
        iprot.skip(ftype)
29476 
      iprot.readFieldEnd()
29477 
    iprot.readStructEnd()
29478 
 
29479 
  def write(self, oprot):
29480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29482 
      return
11015 kshitij.so 29483 
    oprot.writeStructBegin('getAllFbbListedItems_args')
10924 vikram.rag 29484 
    oprot.writeFieldStop()
29485 
    oprot.writeStructEnd()
29486 
 
29487 
  def validate(self):
29488 
    return
29489 
 
29490 
 
29491 
  def __repr__(self):
29492 
    L = ['%s=%r' % (key, value)
29493 
      for key, value in self.__dict__.iteritems()]
29494 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29495 
 
29496 
  def __eq__(self, other):
29497 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29498 
 
29499 
  def __ne__(self, other):
29500 
    return not (self == other)
29501 
 
11015 kshitij.so 29502 
class getAllFbbListedItems_result:
10924 vikram.rag 29503 
  """
29504 
  Attributes:
29505 
   - success
29506 
  """
29507 
 
29508 
  thrift_spec = (
29509 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
29510 
  )
29511 
 
29512 
  def __init__(self, success=None,):
29513 
    self.success = success
29514 
 
29515 
  def read(self, iprot):
29516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29518 
      return
29519 
    iprot.readStructBegin()
29520 
    while True:
29521 
      (fname, ftype, fid) = iprot.readFieldBegin()
29522 
      if ftype == TType.STOP:
29523 
        break
29524 
      if fid == 0:
29525 
        if ftype == TType.LIST:
29526 
          self.success = []
13493 amit.gupta 29527 
          (_etype655, _size652) = iprot.readListBegin()
29528 
          for _i656 in xrange(_size652):
29529 
            _elem657 = Amazonlisted()
29530 
            _elem657.read(iprot)
29531 
            self.success.append(_elem657)
10924 vikram.rag 29532 
          iprot.readListEnd()
29533 
        else:
29534 
          iprot.skip(ftype)
29535 
      else:
29536 
        iprot.skip(ftype)
29537 
      iprot.readFieldEnd()
29538 
    iprot.readStructEnd()
29539 
 
29540 
  def write(self, oprot):
29541 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29542 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29543 
      return
11015 kshitij.so 29544 
    oprot.writeStructBegin('getAllFbbListedItems_result')
10924 vikram.rag 29545 
    if self.success is not None:
29546 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29547 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 29548 
      for iter658 in self.success:
29549 
        iter658.write(oprot)
10924 vikram.rag 29550 
      oprot.writeListEnd()
29551 
      oprot.writeFieldEnd()
29552 
    oprot.writeFieldStop()
29553 
    oprot.writeStructEnd()
29554 
 
29555 
  def validate(self):
29556 
    return
29557 
 
29558 
 
29559 
  def __repr__(self):
29560 
    L = ['%s=%r' % (key, value)
29561 
      for key, value in self.__dict__.iteritems()]
29562 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29563 
 
29564 
  def __eq__(self, other):
29565 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29566 
 
29567 
  def __ne__(self, other):
29568 
    return not (self == other)
11015 kshitij.so 29569 
 
29570 
class getAllFbbPricingItems_args:
29571 
 
29572 
  thrift_spec = (
29573 
  )
29574 
 
29575 
  def read(self, iprot):
29576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29578 
      return
29579 
    iprot.readStructBegin()
29580 
    while True:
29581 
      (fname, ftype, fid) = iprot.readFieldBegin()
29582 
      if ftype == TType.STOP:
29583 
        break
29584 
      else:
29585 
        iprot.skip(ftype)
29586 
      iprot.readFieldEnd()
29587 
    iprot.readStructEnd()
29588 
 
29589 
  def write(self, oprot):
29590 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29591 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29592 
      return
29593 
    oprot.writeStructBegin('getAllFbbPricingItems_args')
29594 
    oprot.writeFieldStop()
29595 
    oprot.writeStructEnd()
29596 
 
29597 
  def validate(self):
29598 
    return
29599 
 
29600 
 
29601 
  def __repr__(self):
29602 
    L = ['%s=%r' % (key, value)
29603 
      for key, value in self.__dict__.iteritems()]
29604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29605 
 
29606 
  def __eq__(self, other):
29607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29608 
 
29609 
  def __ne__(self, other):
29610 
    return not (self == other)
29611 
 
29612 
class getAllFbbPricingItems_result:
29613 
  """
29614 
  Attributes:
29615 
   - success
29616 
  """
29617 
 
29618 
  thrift_spec = (
29619 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
29620 
  )
29621 
 
29622 
  def __init__(self, success=None,):
29623 
    self.success = success
29624 
 
29625 
  def read(self, iprot):
29626 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29627 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29628 
      return
29629 
    iprot.readStructBegin()
29630 
    while True:
29631 
      (fname, ftype, fid) = iprot.readFieldBegin()
29632 
      if ftype == TType.STOP:
29633 
        break
29634 
      if fid == 0:
29635 
        if ftype == TType.LIST:
29636 
          self.success = []
13493 amit.gupta 29637 
          (_etype662, _size659) = iprot.readListBegin()
29638 
          for _i663 in xrange(_size659):
29639 
            _elem664 = Amazonlisted()
29640 
            _elem664.read(iprot)
29641 
            self.success.append(_elem664)
11015 kshitij.so 29642 
          iprot.readListEnd()
29643 
        else:
29644 
          iprot.skip(ftype)
29645 
      else:
29646 
        iprot.skip(ftype)
29647 
      iprot.readFieldEnd()
29648 
    iprot.readStructEnd()
29649 
 
29650 
  def write(self, oprot):
29651 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29652 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29653 
      return
29654 
    oprot.writeStructBegin('getAllFbbPricingItems_result')
29655 
    if self.success is not None:
29656 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29657 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 29658 
      for iter665 in self.success:
29659 
        iter665.write(oprot)
11015 kshitij.so 29660 
      oprot.writeListEnd()
29661 
      oprot.writeFieldEnd()
29662 
    oprot.writeFieldStop()
29663 
    oprot.writeStructEnd()
29664 
 
29665 
  def validate(self):
29666 
    return
29667 
 
29668 
 
29669 
  def __repr__(self):
29670 
    L = ['%s=%r' % (key, value)
29671 
      for key, value in self.__dict__.iteritems()]
29672 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29673 
 
29674 
  def __eq__(self, other):
29675 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29676 
 
29677 
  def __ne__(self, other):
29678 
    return not (self == other)
29679 
 
29680 
class getCountForMarketplaceHistory_args:
29681 
  """
29682 
  Attributes:
29683 
   - source
29684 
   - itemId
29685 
  """
29686 
 
29687 
  thrift_spec = (
29688 
    None, # 0
29689 
    (1, TType.I64, 'source', None, None, ), # 1
29690 
    (2, TType.I64, 'itemId', None, None, ), # 2
29691 
  )
29692 
 
29693 
  def __init__(self, source=None, itemId=None,):
29694 
    self.source = source
29695 
    self.itemId = itemId
29696 
 
29697 
  def read(self, iprot):
29698 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29699 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29700 
      return
29701 
    iprot.readStructBegin()
29702 
    while True:
29703 
      (fname, ftype, fid) = iprot.readFieldBegin()
29704 
      if ftype == TType.STOP:
29705 
        break
29706 
      if fid == 1:
29707 
        if ftype == TType.I64:
29708 
          self.source = iprot.readI64();
29709 
        else:
29710 
          iprot.skip(ftype)
29711 
      elif fid == 2:
29712 
        if ftype == TType.I64:
29713 
          self.itemId = iprot.readI64();
29714 
        else:
29715 
          iprot.skip(ftype)
29716 
      else:
29717 
        iprot.skip(ftype)
29718 
      iprot.readFieldEnd()
29719 
    iprot.readStructEnd()
29720 
 
29721 
  def write(self, oprot):
29722 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29723 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29724 
      return
29725 
    oprot.writeStructBegin('getCountForMarketplaceHistory_args')
29726 
    if self.source is not None:
29727 
      oprot.writeFieldBegin('source', TType.I64, 1)
29728 
      oprot.writeI64(self.source)
29729 
      oprot.writeFieldEnd()
29730 
    if self.itemId is not None:
29731 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
29732 
      oprot.writeI64(self.itemId)
29733 
      oprot.writeFieldEnd()
29734 
    oprot.writeFieldStop()
29735 
    oprot.writeStructEnd()
29736 
 
29737 
  def validate(self):
29738 
    return
29739 
 
29740 
 
29741 
  def __repr__(self):
29742 
    L = ['%s=%r' % (key, value)
29743 
      for key, value in self.__dict__.iteritems()]
29744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29745 
 
29746 
  def __eq__(self, other):
29747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29748 
 
29749 
  def __ne__(self, other):
29750 
    return not (self == other)
29751 
 
29752 
class getCountForMarketplaceHistory_result:
29753 
  """
29754 
  Attributes:
29755 
   - success
29756 
  """
29757 
 
29758 
  thrift_spec = (
29759 
    (0, TType.I64, 'success', None, None, ), # 0
29760 
  )
29761 
 
29762 
  def __init__(self, success=None,):
29763 
    self.success = success
29764 
 
29765 
  def read(self, iprot):
29766 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29767 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29768 
      return
29769 
    iprot.readStructBegin()
29770 
    while True:
29771 
      (fname, ftype, fid) = iprot.readFieldBegin()
29772 
      if ftype == TType.STOP:
29773 
        break
29774 
      if fid == 0:
29775 
        if ftype == TType.I64:
29776 
          self.success = iprot.readI64();
29777 
        else:
29778 
          iprot.skip(ftype)
29779 
      else:
29780 
        iprot.skip(ftype)
29781 
      iprot.readFieldEnd()
29782 
    iprot.readStructEnd()
29783 
 
29784 
  def write(self, oprot):
29785 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29786 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29787 
      return
29788 
    oprot.writeStructBegin('getCountForMarketplaceHistory_result')
29789 
    if self.success is not None:
29790 
      oprot.writeFieldBegin('success', TType.I64, 0)
29791 
      oprot.writeI64(self.success)
29792 
      oprot.writeFieldEnd()
29793 
    oprot.writeFieldStop()
29794 
    oprot.writeStructEnd()
29795 
 
29796 
  def validate(self):
29797 
    return
29798 
 
29799 
 
29800 
  def __repr__(self):
29801 
    L = ['%s=%r' % (key, value)
29802 
      for key, value in self.__dict__.iteritems()]
29803 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29804 
 
29805 
  def __eq__(self, other):
29806 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29807 
 
29808 
  def __ne__(self, other):
29809 
    return not (self == other)
29810 
 
29811 
class getMarketplaceHistoryByDate_args:
29812 
  """
29813 
  Attributes:
29814 
   - source
29815 
   - startDate
29816 
   - endDate
29817 
   - offset
29818 
   - limit
29819 
   - itemId
29820 
  """
29821 
 
29822 
  thrift_spec = (
29823 
    None, # 0
29824 
    (1, TType.I64, 'source', None, None, ), # 1
29825 
    (2, TType.I64, 'startDate', None, None, ), # 2
29826 
    (3, TType.I64, 'endDate', None, None, ), # 3
29827 
    (4, TType.I64, 'offset', None, None, ), # 4
29828 
    (5, TType.I64, 'limit', None, None, ), # 5
29829 
    (6, TType.I64, 'itemId', None, None, ), # 6
29830 
  )
29831 
 
29832 
  def __init__(self, source=None, startDate=None, endDate=None, offset=None, limit=None, itemId=None,):
29833 
    self.source = source
29834 
    self.startDate = startDate
29835 
    self.endDate = endDate
29836 
    self.offset = offset
29837 
    self.limit = limit
29838 
    self.itemId = itemId
29839 
 
29840 
  def read(self, iprot):
29841 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29842 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29843 
      return
29844 
    iprot.readStructBegin()
29845 
    while True:
29846 
      (fname, ftype, fid) = iprot.readFieldBegin()
29847 
      if ftype == TType.STOP:
29848 
        break
29849 
      if fid == 1:
29850 
        if ftype == TType.I64:
29851 
          self.source = iprot.readI64();
29852 
        else:
29853 
          iprot.skip(ftype)
29854 
      elif fid == 2:
29855 
        if ftype == TType.I64:
29856 
          self.startDate = iprot.readI64();
29857 
        else:
29858 
          iprot.skip(ftype)
29859 
      elif fid == 3:
29860 
        if ftype == TType.I64:
29861 
          self.endDate = iprot.readI64();
29862 
        else:
29863 
          iprot.skip(ftype)
29864 
      elif fid == 4:
29865 
        if ftype == TType.I64:
29866 
          self.offset = iprot.readI64();
29867 
        else:
29868 
          iprot.skip(ftype)
29869 
      elif fid == 5:
29870 
        if ftype == TType.I64:
29871 
          self.limit = iprot.readI64();
29872 
        else:
29873 
          iprot.skip(ftype)
29874 
      elif fid == 6:
29875 
        if ftype == TType.I64:
29876 
          self.itemId = iprot.readI64();
29877 
        else:
29878 
          iprot.skip(ftype)
29879 
      else:
29880 
        iprot.skip(ftype)
29881 
      iprot.readFieldEnd()
29882 
    iprot.readStructEnd()
29883 
 
29884 
  def write(self, oprot):
29885 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29886 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29887 
      return
29888 
    oprot.writeStructBegin('getMarketplaceHistoryByDate_args')
29889 
    if self.source is not None:
29890 
      oprot.writeFieldBegin('source', TType.I64, 1)
29891 
      oprot.writeI64(self.source)
29892 
      oprot.writeFieldEnd()
29893 
    if self.startDate is not None:
29894 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
29895 
      oprot.writeI64(self.startDate)
29896 
      oprot.writeFieldEnd()
29897 
    if self.endDate is not None:
29898 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
29899 
      oprot.writeI64(self.endDate)
29900 
      oprot.writeFieldEnd()
29901 
    if self.offset is not None:
29902 
      oprot.writeFieldBegin('offset', TType.I64, 4)
29903 
      oprot.writeI64(self.offset)
29904 
      oprot.writeFieldEnd()
29905 
    if self.limit is not None:
29906 
      oprot.writeFieldBegin('limit', TType.I64, 5)
29907 
      oprot.writeI64(self.limit)
29908 
      oprot.writeFieldEnd()
29909 
    if self.itemId is not None:
29910 
      oprot.writeFieldBegin('itemId', TType.I64, 6)
29911 
      oprot.writeI64(self.itemId)
29912 
      oprot.writeFieldEnd()
29913 
    oprot.writeFieldStop()
29914 
    oprot.writeStructEnd()
29915 
 
29916 
  def validate(self):
29917 
    return
29918 
 
29919 
 
29920 
  def __repr__(self):
29921 
    L = ['%s=%r' % (key, value)
29922 
      for key, value in self.__dict__.iteritems()]
29923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29924 
 
29925 
  def __eq__(self, other):
29926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29927 
 
29928 
  def __ne__(self, other):
29929 
    return not (self == other)
29930 
 
29931 
class getMarketplaceHistoryByDate_result:
29932 
  """
29933 
  Attributes:
29934 
   - success
29935 
  """
29936 
 
29937 
  thrift_spec = (
29938 
    (0, TType.LIST, 'success', (TType.STRUCT,(MarketplaceHistory, MarketplaceHistory.thrift_spec)), None, ), # 0
29939 
  )
29940 
 
29941 
  def __init__(self, success=None,):
29942 
    self.success = success
29943 
 
29944 
  def read(self, iprot):
29945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29947 
      return
29948 
    iprot.readStructBegin()
29949 
    while True:
29950 
      (fname, ftype, fid) = iprot.readFieldBegin()
29951 
      if ftype == TType.STOP:
29952 
        break
29953 
      if fid == 0:
29954 
        if ftype == TType.LIST:
29955 
          self.success = []
13493 amit.gupta 29956 
          (_etype669, _size666) = iprot.readListBegin()
29957 
          for _i670 in xrange(_size666):
29958 
            _elem671 = MarketplaceHistory()
29959 
            _elem671.read(iprot)
29960 
            self.success.append(_elem671)
11015 kshitij.so 29961 
          iprot.readListEnd()
29962 
        else:
29963 
          iprot.skip(ftype)
29964 
      else:
29965 
        iprot.skip(ftype)
29966 
      iprot.readFieldEnd()
29967 
    iprot.readStructEnd()
29968 
 
29969 
  def write(self, oprot):
29970 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29971 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29972 
      return
29973 
    oprot.writeStructBegin('getMarketplaceHistoryByDate_result')
29974 
    if self.success is not None:
29975 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29976 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 29977 
      for iter672 in self.success:
29978 
        iter672.write(oprot)
11015 kshitij.so 29979 
      oprot.writeListEnd()
29980 
      oprot.writeFieldEnd()
29981 
    oprot.writeFieldStop()
29982 
    oprot.writeStructEnd()
29983 
 
29984 
  def validate(self):
29985 
    return
29986 
 
29987 
 
29988 
  def __repr__(self):
29989 
    L = ['%s=%r' % (key, value)
29990 
      for key, value in self.__dict__.iteritems()]
29991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29992 
 
29993 
  def __eq__(self, other):
29994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29995 
 
29996 
  def __ne__(self, other):
29997 
    return not (self == other)
11531 vikram.rag 29998 
 
29999 
class getPrivateDealDetails_args:
30000 
  """
30001 
  Attributes:
30002 
   - item_id
30003 
  """
30004 
 
30005 
  thrift_spec = (
30006 
    None, # 0
30007 
    (1, TType.I64, 'item_id', None, None, ), # 1
30008 
  )
30009 
 
30010 
  def __init__(self, item_id=None,):
30011 
    self.item_id = item_id
30012 
 
30013 
  def read(self, iprot):
30014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30016 
      return
30017 
    iprot.readStructBegin()
30018 
    while True:
30019 
      (fname, ftype, fid) = iprot.readFieldBegin()
30020 
      if ftype == TType.STOP:
30021 
        break
30022 
      if fid == 1:
30023 
        if ftype == TType.I64:
30024 
          self.item_id = iprot.readI64();
30025 
        else:
30026 
          iprot.skip(ftype)
30027 
      else:
30028 
        iprot.skip(ftype)
30029 
      iprot.readFieldEnd()
30030 
    iprot.readStructEnd()
30031 
 
30032 
  def write(self, oprot):
30033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30035 
      return
30036 
    oprot.writeStructBegin('getPrivateDealDetails_args')
30037 
    if self.item_id is not None:
30038 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
30039 
      oprot.writeI64(self.item_id)
30040 
      oprot.writeFieldEnd()
30041 
    oprot.writeFieldStop()
30042 
    oprot.writeStructEnd()
30043 
 
30044 
  def validate(self):
30045 
    return
30046 
 
30047 
 
30048 
  def __repr__(self):
30049 
    L = ['%s=%r' % (key, value)
30050 
      for key, value in self.__dict__.iteritems()]
30051 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30052 
 
30053 
  def __eq__(self, other):
30054 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30055 
 
30056 
  def __ne__(self, other):
30057 
    return not (self == other)
30058 
 
30059 
class getPrivateDealDetails_result:
30060 
  """
30061 
  Attributes:
30062 
   - success
30063 
  """
30064 
 
30065 
  thrift_spec = (
30066 
    (0, TType.STRUCT, 'success', (PrivateDeal, PrivateDeal.thrift_spec), None, ), # 0
30067 
  )
30068 
 
30069 
  def __init__(self, success=None,):
30070 
    self.success = success
30071 
 
30072 
  def read(self, iprot):
30073 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30074 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30075 
      return
30076 
    iprot.readStructBegin()
30077 
    while True:
30078 
      (fname, ftype, fid) = iprot.readFieldBegin()
30079 
      if ftype == TType.STOP:
30080 
        break
30081 
      if fid == 0:
30082 
        if ftype == TType.STRUCT:
30083 
          self.success = PrivateDeal()
30084 
          self.success.read(iprot)
30085 
        else:
30086 
          iprot.skip(ftype)
30087 
      else:
30088 
        iprot.skip(ftype)
30089 
      iprot.readFieldEnd()
30090 
    iprot.readStructEnd()
30091 
 
30092 
  def write(self, oprot):
30093 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30094 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30095 
      return
30096 
    oprot.writeStructBegin('getPrivateDealDetails_result')
30097 
    if self.success is not None:
30098 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
30099 
      self.success.write(oprot)
30100 
      oprot.writeFieldEnd()
30101 
    oprot.writeFieldStop()
30102 
    oprot.writeStructEnd()
30103 
 
30104 
  def validate(self):
30105 
    return
30106 
 
30107 
 
30108 
  def __repr__(self):
30109 
    L = ['%s=%r' % (key, value)
30110 
      for key, value in self.__dict__.iteritems()]
30111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30112 
 
30113 
  def __eq__(self, other):
30114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30115 
 
30116 
  def __ne__(self, other):
30117 
    return not (self == other)
30118 
 
30119 
class getPrivateDealItems_args:
30120 
  """
30121 
  Attributes:
30122 
   - offset
30123 
   - limit
30124 
  """
30125 
 
30126 
  thrift_spec = (
30127 
    None, # 0
30128 
    (1, TType.I64, 'offset', None, None, ), # 1
30129 
    (2, TType.I64, 'limit', None, None, ), # 2
30130 
  )
30131 
 
30132 
  def __init__(self, offset=None, limit=None,):
30133 
    self.offset = offset
30134 
    self.limit = limit
30135 
 
30136 
  def read(self, iprot):
30137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30139 
      return
30140 
    iprot.readStructBegin()
30141 
    while True:
30142 
      (fname, ftype, fid) = iprot.readFieldBegin()
30143 
      if ftype == TType.STOP:
30144 
        break
30145 
      if fid == 1:
30146 
        if ftype == TType.I64:
30147 
          self.offset = iprot.readI64();
30148 
        else:
30149 
          iprot.skip(ftype)
30150 
      elif fid == 2:
30151 
        if ftype == TType.I64:
30152 
          self.limit = iprot.readI64();
30153 
        else:
30154 
          iprot.skip(ftype)
30155 
      else:
30156 
        iprot.skip(ftype)
30157 
      iprot.readFieldEnd()
30158 
    iprot.readStructEnd()
30159 
 
30160 
  def write(self, oprot):
30161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30163 
      return
30164 
    oprot.writeStructBegin('getPrivateDealItems_args')
30165 
    if self.offset is not None:
30166 
      oprot.writeFieldBegin('offset', TType.I64, 1)
30167 
      oprot.writeI64(self.offset)
30168 
      oprot.writeFieldEnd()
30169 
    if self.limit is not None:
30170 
      oprot.writeFieldBegin('limit', TType.I64, 2)
30171 
      oprot.writeI64(self.limit)
30172 
      oprot.writeFieldEnd()
30173 
    oprot.writeFieldStop()
30174 
    oprot.writeStructEnd()
30175 
 
30176 
  def validate(self):
30177 
    return
30178 
 
30179 
 
30180 
  def __repr__(self):
30181 
    L = ['%s=%r' % (key, value)
30182 
      for key, value in self.__dict__.iteritems()]
30183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30184 
 
30185 
  def __eq__(self, other):
30186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30187 
 
30188 
  def __ne__(self, other):
30189 
    return not (self == other)
30190 
 
30191 
class getPrivateDealItems_result:
30192 
  """
30193 
  Attributes:
30194 
   - success
30195 
  """
30196 
 
30197 
  thrift_spec = (
30198 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
30199 
  )
30200 
 
30201 
  def __init__(self, success=None,):
30202 
    self.success = success
30203 
 
30204 
  def read(self, iprot):
30205 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30206 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30207 
      return
30208 
    iprot.readStructBegin()
30209 
    while True:
30210 
      (fname, ftype, fid) = iprot.readFieldBegin()
30211 
      if ftype == TType.STOP:
30212 
        break
30213 
      if fid == 0:
30214 
        if ftype == TType.LIST:
30215 
          self.success = []
13493 amit.gupta 30216 
          (_etype676, _size673) = iprot.readListBegin()
30217 
          for _i677 in xrange(_size673):
30218 
            _elem678 = Item()
30219 
            _elem678.read(iprot)
30220 
            self.success.append(_elem678)
11531 vikram.rag 30221 
          iprot.readListEnd()
30222 
        else:
30223 
          iprot.skip(ftype)
30224 
      else:
30225 
        iprot.skip(ftype)
30226 
      iprot.readFieldEnd()
30227 
    iprot.readStructEnd()
30228 
 
30229 
  def write(self, oprot):
30230 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30231 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30232 
      return
30233 
    oprot.writeStructBegin('getPrivateDealItems_result')
30234 
    if self.success is not None:
30235 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30236 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 30237 
      for iter679 in self.success:
30238 
        iter679.write(oprot)
11531 vikram.rag 30239 
      oprot.writeListEnd()
30240 
      oprot.writeFieldEnd()
30241 
    oprot.writeFieldStop()
30242 
    oprot.writeStructEnd()
30243 
 
30244 
  def validate(self):
30245 
    return
30246 
 
30247 
 
30248 
  def __repr__(self):
30249 
    L = ['%s=%r' % (key, value)
30250 
      for key, value in self.__dict__.iteritems()]
30251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30252 
 
30253 
  def __eq__(self, other):
30254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30255 
 
30256 
  def __ne__(self, other):
30257 
    return not (self == other)
30258 
 
11592 amit.gupta 30259 
class getAllActivePrivateDeals_args:
11653 amit.gupta 30260 
  """
30261 
  Attributes:
30262 
   - itemIds
30263 
   - daysDelta
30264 
  """
11592 amit.gupta 30265 
 
30266 
  thrift_spec = (
11653 amit.gupta 30267 
    None, # 0
30268 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
30269 
    (2, TType.I64, 'daysDelta', None, None, ), # 2
11592 amit.gupta 30270 
  )
30271 
 
11653 amit.gupta 30272 
  def __init__(self, itemIds=None, daysDelta=None,):
30273 
    self.itemIds = itemIds
30274 
    self.daysDelta = daysDelta
30275 
 
11592 amit.gupta 30276 
  def read(self, iprot):
30277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30279 
      return
30280 
    iprot.readStructBegin()
30281 
    while True:
30282 
      (fname, ftype, fid) = iprot.readFieldBegin()
30283 
      if ftype == TType.STOP:
30284 
        break
11653 amit.gupta 30285 
      if fid == 1:
30286 
        if ftype == TType.LIST:
30287 
          self.itemIds = []
13493 amit.gupta 30288 
          (_etype683, _size680) = iprot.readListBegin()
30289 
          for _i684 in xrange(_size680):
30290 
            _elem685 = iprot.readI64();
30291 
            self.itemIds.append(_elem685)
11653 amit.gupta 30292 
          iprot.readListEnd()
30293 
        else:
30294 
          iprot.skip(ftype)
30295 
      elif fid == 2:
30296 
        if ftype == TType.I64:
30297 
          self.daysDelta = iprot.readI64();
30298 
        else:
30299 
          iprot.skip(ftype)
11592 amit.gupta 30300 
      else:
30301 
        iprot.skip(ftype)
30302 
      iprot.readFieldEnd()
30303 
    iprot.readStructEnd()
30304 
 
30305 
  def write(self, oprot):
30306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30308 
      return
30309 
    oprot.writeStructBegin('getAllActivePrivateDeals_args')
11653 amit.gupta 30310 
    if self.itemIds is not None:
30311 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
30312 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
13493 amit.gupta 30313 
      for iter686 in self.itemIds:
30314 
        oprot.writeI64(iter686)
11653 amit.gupta 30315 
      oprot.writeListEnd()
30316 
      oprot.writeFieldEnd()
30317 
    if self.daysDelta is not None:
30318 
      oprot.writeFieldBegin('daysDelta', TType.I64, 2)
30319 
      oprot.writeI64(self.daysDelta)
30320 
      oprot.writeFieldEnd()
11592 amit.gupta 30321 
    oprot.writeFieldStop()
30322 
    oprot.writeStructEnd()
30323 
 
30324 
  def validate(self):
30325 
    return
30326 
 
30327 
 
30328 
  def __repr__(self):
30329 
    L = ['%s=%r' % (key, value)
30330 
      for key, value in self.__dict__.iteritems()]
30331 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30332 
 
30333 
  def __eq__(self, other):
30334 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30335 
 
30336 
  def __ne__(self, other):
30337 
    return not (self == other)
30338 
 
30339 
class getAllActivePrivateDeals_result:
30340 
  """
30341 
  Attributes:
30342 
   - success
30343 
  """
30344 
 
30345 
  thrift_spec = (
30346 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRUCT,(PrivateDeal, PrivateDeal.thrift_spec)), None, ), # 0
30347 
  )
30348 
 
30349 
  def __init__(self, success=None,):
30350 
    self.success = success
30351 
 
30352 
  def read(self, iprot):
30353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30355 
      return
30356 
    iprot.readStructBegin()
30357 
    while True:
30358 
      (fname, ftype, fid) = iprot.readFieldBegin()
30359 
      if ftype == TType.STOP:
30360 
        break
30361 
      if fid == 0:
30362 
        if ftype == TType.MAP:
30363 
          self.success = {}
13493 amit.gupta 30364 
          (_ktype688, _vtype689, _size687 ) = iprot.readMapBegin()
30365 
          for _i691 in xrange(_size687):
30366 
            _key692 = iprot.readI64();
30367 
            _val693 = PrivateDeal()
30368 
            _val693.read(iprot)
30369 
            self.success[_key692] = _val693
11592 amit.gupta 30370 
          iprot.readMapEnd()
30371 
        else:
30372 
          iprot.skip(ftype)
30373 
      else:
30374 
        iprot.skip(ftype)
30375 
      iprot.readFieldEnd()
30376 
    iprot.readStructEnd()
30377 
 
30378 
  def write(self, oprot):
30379 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30380 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30381 
      return
30382 
    oprot.writeStructBegin('getAllActivePrivateDeals_result')
30383 
    if self.success is not None:
30384 
      oprot.writeFieldBegin('success', TType.MAP, 0)
30385 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.success))
13493 amit.gupta 30386 
      for kiter694,viter695 in self.success.items():
30387 
        oprot.writeI64(kiter694)
30388 
        viter695.write(oprot)
11592 amit.gupta 30389 
      oprot.writeMapEnd()
30390 
      oprot.writeFieldEnd()
30391 
    oprot.writeFieldStop()
30392 
    oprot.writeStructEnd()
30393 
 
30394 
  def validate(self):
30395 
    return
30396 
 
30397 
 
30398 
  def __repr__(self):
30399 
    L = ['%s=%r' % (key, value)
30400 
      for key, value in self.__dict__.iteritems()]
30401 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30402 
 
30403 
  def __eq__(self, other):
30404 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30405 
 
30406 
  def __ne__(self, other):
30407 
    return not (self == other)
30408 
 
11531 vikram.rag 30409 
class addOrUpdatePrivateDeal_args:
30410 
  """
30411 
  Attributes:
30412 
   - privateDeal
30413 
  """
30414 
 
30415 
  thrift_spec = (
30416 
    None, # 0
30417 
    (1, TType.STRUCT, 'privateDeal', (PrivateDeal, PrivateDeal.thrift_spec), None, ), # 1
30418 
  )
30419 
 
30420 
  def __init__(self, privateDeal=None,):
30421 
    self.privateDeal = privateDeal
30422 
 
30423 
  def read(self, iprot):
30424 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30425 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30426 
      return
30427 
    iprot.readStructBegin()
30428 
    while True:
30429 
      (fname, ftype, fid) = iprot.readFieldBegin()
30430 
      if ftype == TType.STOP:
30431 
        break
30432 
      if fid == 1:
30433 
        if ftype == TType.STRUCT:
30434 
          self.privateDeal = PrivateDeal()
30435 
          self.privateDeal.read(iprot)
30436 
        else:
30437 
          iprot.skip(ftype)
30438 
      else:
30439 
        iprot.skip(ftype)
30440 
      iprot.readFieldEnd()
30441 
    iprot.readStructEnd()
30442 
 
30443 
  def write(self, oprot):
30444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30446 
      return
30447 
    oprot.writeStructBegin('addOrUpdatePrivateDeal_args')
30448 
    if self.privateDeal is not None:
30449 
      oprot.writeFieldBegin('privateDeal', TType.STRUCT, 1)
30450 
      self.privateDeal.write(oprot)
30451 
      oprot.writeFieldEnd()
30452 
    oprot.writeFieldStop()
30453 
    oprot.writeStructEnd()
30454 
 
30455 
  def validate(self):
30456 
    return
30457 
 
30458 
 
30459 
  def __repr__(self):
30460 
    L = ['%s=%r' % (key, value)
30461 
      for key, value in self.__dict__.iteritems()]
30462 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30463 
 
30464 
  def __eq__(self, other):
30465 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30466 
 
30467 
  def __ne__(self, other):
30468 
    return not (self == other)
30469 
 
30470 
class addOrUpdatePrivateDeal_result:
30471 
  """
30472 
  Attributes:
30473 
   - success
30474 
  """
30475 
 
30476 
  thrift_spec = (
30477 
    (0, TType.BOOL, 'success', None, None, ), # 0
30478 
  )
30479 
 
30480 
  def __init__(self, success=None,):
30481 
    self.success = success
30482 
 
30483 
  def read(self, iprot):
30484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30486 
      return
30487 
    iprot.readStructBegin()
30488 
    while True:
30489 
      (fname, ftype, fid) = iprot.readFieldBegin()
30490 
      if ftype == TType.STOP:
30491 
        break
30492 
      if fid == 0:
30493 
        if ftype == TType.BOOL:
30494 
          self.success = iprot.readBool();
30495 
        else:
30496 
          iprot.skip(ftype)
30497 
      else:
30498 
        iprot.skip(ftype)
30499 
      iprot.readFieldEnd()
30500 
    iprot.readStructEnd()
30501 
 
30502 
  def write(self, oprot):
30503 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30504 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30505 
      return
30506 
    oprot.writeStructBegin('addOrUpdatePrivateDeal_result')
30507 
    if self.success is not None:
30508 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
30509 
      oprot.writeBool(self.success)
30510 
      oprot.writeFieldEnd()
30511 
    oprot.writeFieldStop()
30512 
    oprot.writeStructEnd()
30513 
 
30514 
  def validate(self):
30515 
    return
30516 
 
30517 
 
30518 
  def __repr__(self):
30519 
    L = ['%s=%r' % (key, value)
30520 
      for key, value in self.__dict__.iteritems()]
30521 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30522 
 
30523 
  def __eq__(self, other):
30524 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30525 
 
30526 
  def __ne__(self, other):
30527 
    return not (self == other)
11635 vikram.rag 30528 
 
30529 
class getPrivateDealsCatalogIds_args:
30530 
  """
30531 
  Attributes:
30532 
   - beginIndex
30533 
   - totalItems
30534 
  """
30535 
 
30536 
  thrift_spec = (
30537 
    None, # 0
30538 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
30539 
    (2, TType.I64, 'totalItems', None, None, ), # 2
30540 
  )
30541 
 
30542 
  def __init__(self, beginIndex=None, totalItems=None,):
30543 
    self.beginIndex = beginIndex
30544 
    self.totalItems = totalItems
30545 
 
30546 
  def read(self, iprot):
30547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30549 
      return
30550 
    iprot.readStructBegin()
30551 
    while True:
30552 
      (fname, ftype, fid) = iprot.readFieldBegin()
30553 
      if ftype == TType.STOP:
30554 
        break
30555 
      if fid == 1:
30556 
        if ftype == TType.I64:
30557 
          self.beginIndex = iprot.readI64();
30558 
        else:
30559 
          iprot.skip(ftype)
30560 
      elif fid == 2:
30561 
        if ftype == TType.I64:
30562 
          self.totalItems = iprot.readI64();
30563 
        else:
30564 
          iprot.skip(ftype)
30565 
      else:
30566 
        iprot.skip(ftype)
30567 
      iprot.readFieldEnd()
30568 
    iprot.readStructEnd()
30569 
 
30570 
  def write(self, oprot):
30571 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30572 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30573 
      return
30574 
    oprot.writeStructBegin('getPrivateDealsCatalogIds_args')
30575 
    if self.beginIndex is not None:
30576 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
30577 
      oprot.writeI64(self.beginIndex)
30578 
      oprot.writeFieldEnd()
30579 
    if self.totalItems is not None:
30580 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
30581 
      oprot.writeI64(self.totalItems)
30582 
      oprot.writeFieldEnd()
30583 
    oprot.writeFieldStop()
30584 
    oprot.writeStructEnd()
30585 
 
30586 
  def validate(self):
30587 
    return
30588 
 
30589 
 
30590 
  def __repr__(self):
30591 
    L = ['%s=%r' % (key, value)
30592 
      for key, value in self.__dict__.iteritems()]
30593 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30594 
 
30595 
  def __eq__(self, other):
30596 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30597 
 
30598 
  def __ne__(self, other):
30599 
    return not (self == other)
30600 
 
30601 
class getPrivateDealsCatalogIds_result:
30602 
  """
30603 
  Attributes:
30604 
   - success
30605 
   - cex
30606 
  """
30607 
 
30608 
  thrift_spec = (
30609 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
30610 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
30611 
  )
30612 
 
30613 
  def __init__(self, success=None, cex=None,):
30614 
    self.success = success
30615 
    self.cex = cex
30616 
 
30617 
  def read(self, iprot):
30618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30620 
      return
30621 
    iprot.readStructBegin()
30622 
    while True:
30623 
      (fname, ftype, fid) = iprot.readFieldBegin()
30624 
      if ftype == TType.STOP:
30625 
        break
30626 
      if fid == 0:
30627 
        if ftype == TType.LIST:
30628 
          self.success = []
13493 amit.gupta 30629 
          (_etype699, _size696) = iprot.readListBegin()
30630 
          for _i700 in xrange(_size696):
30631 
            _elem701 = iprot.readI64();
30632 
            self.success.append(_elem701)
11635 vikram.rag 30633 
          iprot.readListEnd()
30634 
        else:
30635 
          iprot.skip(ftype)
30636 
      elif fid == 1:
30637 
        if ftype == TType.STRUCT:
30638 
          self.cex = CatalogServiceException()
30639 
          self.cex.read(iprot)
30640 
        else:
30641 
          iprot.skip(ftype)
30642 
      else:
30643 
        iprot.skip(ftype)
30644 
      iprot.readFieldEnd()
30645 
    iprot.readStructEnd()
30646 
 
30647 
  def write(self, oprot):
30648 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30649 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30650 
      return
30651 
    oprot.writeStructBegin('getPrivateDealsCatalogIds_result')
30652 
    if self.success is not None:
30653 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30654 
      oprot.writeListBegin(TType.I64, len(self.success))
13493 amit.gupta 30655 
      for iter702 in self.success:
30656 
        oprot.writeI64(iter702)
11635 vikram.rag 30657 
      oprot.writeListEnd()
30658 
      oprot.writeFieldEnd()
30659 
    if self.cex is not None:
30660 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
30661 
      self.cex.write(oprot)
30662 
      oprot.writeFieldEnd()
30663 
    oprot.writeFieldStop()
30664 
    oprot.writeStructEnd()
30665 
 
30666 
  def validate(self):
30667 
    return
30668 
 
30669 
 
30670 
  def __repr__(self):
30671 
    L = ['%s=%r' % (key, value)
30672 
      for key, value in self.__dict__.iteritems()]
30673 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30674 
 
30675 
  def __eq__(self, other):
30676 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30677 
 
30678 
  def __ne__(self, other):
30679 
    return not (self == other)
11645 amit.gupta 30680 
 
30681 
class getPrivateDealsCount_args:
30682 
 
30683 
  thrift_spec = (
30684 
  )
30685 
 
30686 
  def read(self, iprot):
30687 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30688 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30689 
      return
30690 
    iprot.readStructBegin()
30691 
    while True:
30692 
      (fname, ftype, fid) = iprot.readFieldBegin()
30693 
      if ftype == TType.STOP:
30694 
        break
30695 
      else:
30696 
        iprot.skip(ftype)
30697 
      iprot.readFieldEnd()
30698 
    iprot.readStructEnd()
30699 
 
30700 
  def write(self, oprot):
30701 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30702 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30703 
      return
30704 
    oprot.writeStructBegin('getPrivateDealsCount_args')
30705 
    oprot.writeFieldStop()
30706 
    oprot.writeStructEnd()
30707 
 
30708 
  def validate(self):
30709 
    return
30710 
 
30711 
 
30712 
  def __repr__(self):
30713 
    L = ['%s=%r' % (key, value)
30714 
      for key, value in self.__dict__.iteritems()]
30715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30716 
 
30717 
  def __eq__(self, other):
30718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30719 
 
30720 
  def __ne__(self, other):
30721 
    return not (self == other)
30722 
 
30723 
class getPrivateDealsCount_result:
30724 
  """
30725 
  Attributes:
30726 
   - success
30727 
  """
30728 
 
30729 
  thrift_spec = (
30730 
    (0, TType.I32, 'success', None, None, ), # 0
30731 
  )
30732 
 
30733 
  def __init__(self, success=None,):
30734 
    self.success = success
30735 
 
30736 
  def read(self, iprot):
30737 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30738 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30739 
      return
30740 
    iprot.readStructBegin()
30741 
    while True:
30742 
      (fname, ftype, fid) = iprot.readFieldBegin()
30743 
      if ftype == TType.STOP:
30744 
        break
30745 
      if fid == 0:
30746 
        if ftype == TType.I32:
30747 
          self.success = iprot.readI32();
30748 
        else:
30749 
          iprot.skip(ftype)
30750 
      else:
30751 
        iprot.skip(ftype)
30752 
      iprot.readFieldEnd()
30753 
    iprot.readStructEnd()
30754 
 
30755 
  def write(self, oprot):
30756 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30757 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30758 
      return
30759 
    oprot.writeStructBegin('getPrivateDealsCount_result')
30760 
    if self.success is not None:
30761 
      oprot.writeFieldBegin('success', TType.I32, 0)
30762 
      oprot.writeI32(self.success)
30763 
      oprot.writeFieldEnd()
30764 
    oprot.writeFieldStop()
30765 
    oprot.writeStructEnd()
30766 
 
30767 
  def validate(self):
30768 
    return
30769 
 
30770 
 
30771 
  def __repr__(self):
30772 
    L = ['%s=%r' % (key, value)
30773 
      for key, value in self.__dict__.iteritems()]
30774 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30775 
 
30776 
  def __eq__(self, other):
30777 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30778 
 
30779 
  def __ne__(self, other):
30780 
    return not (self == other)
11905 kshitij.so 30781 
 
30782 
class getAmazonOutSyncItems_args:
30783 
  """
30784 
  Attributes:
30785 
   - item_id
30786 
  """
30787 
 
30788 
  thrift_spec = (
30789 
    None, # 0
30790 
    (1, TType.I64, 'item_id', None, None, ), # 1
30791 
  )
30792 
 
30793 
  def __init__(self, item_id=None,):
30794 
    self.item_id = item_id
30795 
 
30796 
  def read(self, iprot):
30797 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30798 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30799 
      return
30800 
    iprot.readStructBegin()
30801 
    while True:
30802 
      (fname, ftype, fid) = iprot.readFieldBegin()
30803 
      if ftype == TType.STOP:
30804 
        break
30805 
      if fid == 1:
30806 
        if ftype == TType.I64:
30807 
          self.item_id = iprot.readI64();
30808 
        else:
30809 
          iprot.skip(ftype)
30810 
      else:
30811 
        iprot.skip(ftype)
30812 
      iprot.readFieldEnd()
30813 
    iprot.readStructEnd()
30814 
 
30815 
  def write(self, oprot):
30816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30818 
      return
30819 
    oprot.writeStructBegin('getAmazonOutSyncItems_args')
30820 
    if self.item_id is not None:
30821 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
30822 
      oprot.writeI64(self.item_id)
30823 
      oprot.writeFieldEnd()
30824 
    oprot.writeFieldStop()
30825 
    oprot.writeStructEnd()
30826 
 
30827 
  def validate(self):
30828 
    return
30829 
 
30830 
 
30831 
  def __repr__(self):
30832 
    L = ['%s=%r' % (key, value)
30833 
      for key, value in self.__dict__.iteritems()]
30834 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30835 
 
30836 
  def __eq__(self, other):
30837 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30838 
 
30839 
  def __ne__(self, other):
30840 
    return not (self == other)
30841 
 
30842 
class getAmazonOutSyncItems_result:
30843 
  """
30844 
  Attributes:
30845 
   - success
30846 
  """
30847 
 
30848 
  thrift_spec = (
30849 
    (0, TType.STRUCT, 'success', (AmazonOutOfSync, AmazonOutOfSync.thrift_spec), None, ), # 0
30850 
  )
30851 
 
30852 
  def __init__(self, success=None,):
30853 
    self.success = success
30854 
 
30855 
  def read(self, iprot):
30856 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30857 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30858 
      return
30859 
    iprot.readStructBegin()
30860 
    while True:
30861 
      (fname, ftype, fid) = iprot.readFieldBegin()
30862 
      if ftype == TType.STOP:
30863 
        break
30864 
      if fid == 0:
30865 
        if ftype == TType.STRUCT:
30866 
          self.success = AmazonOutOfSync()
30867 
          self.success.read(iprot)
30868 
        else:
30869 
          iprot.skip(ftype)
30870 
      else:
30871 
        iprot.skip(ftype)
30872 
      iprot.readFieldEnd()
30873 
    iprot.readStructEnd()
30874 
 
30875 
  def write(self, oprot):
30876 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30877 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30878 
      return
30879 
    oprot.writeStructBegin('getAmazonOutSyncItems_result')
30880 
    if self.success is not None:
30881 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
30882 
      self.success.write(oprot)
30883 
      oprot.writeFieldEnd()
30884 
    oprot.writeFieldStop()
30885 
    oprot.writeStructEnd()
30886 
 
30887 
  def validate(self):
30888 
    return
30889 
 
30890 
 
30891 
  def __repr__(self):
30892 
    L = ['%s=%r' % (key, value)
30893 
      for key, value in self.__dict__.iteritems()]
30894 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30895 
 
30896 
  def __eq__(self, other):
30897 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30898 
 
30899 
  def __ne__(self, other):
30900 
    return not (self == other)
30901 
 
30902 
class getAllPrivateDealsComparison_args:
30903 
 
30904 
  thrift_spec = (
30905 
  )
30906 
 
30907 
  def read(self, iprot):
30908 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30909 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30910 
      return
30911 
    iprot.readStructBegin()
30912 
    while True:
30913 
      (fname, ftype, fid) = iprot.readFieldBegin()
30914 
      if ftype == TType.STOP:
30915 
        break
30916 
      else:
30917 
        iprot.skip(ftype)
30918 
      iprot.readFieldEnd()
30919 
    iprot.readStructEnd()
30920 
 
30921 
  def write(self, oprot):
30922 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30923 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30924 
      return
30925 
    oprot.writeStructBegin('getAllPrivateDealsComparison_args')
30926 
    oprot.writeFieldStop()
30927 
    oprot.writeStructEnd()
30928 
 
30929 
  def validate(self):
30930 
    return
30931 
 
30932 
 
30933 
  def __repr__(self):
30934 
    L = ['%s=%r' % (key, value)
30935 
      for key, value in self.__dict__.iteritems()]
30936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30937 
 
30938 
  def __eq__(self, other):
30939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30940 
 
30941 
  def __ne__(self, other):
30942 
    return not (self == other)
30943 
 
30944 
class getAllPrivateDealsComparison_result:
30945 
  """
30946 
  Attributes:
30947 
   - success
30948 
  """
30949 
 
30950 
  thrift_spec = (
30951 
    (0, TType.LIST, 'success', (TType.STRUCT,(PdPriceComp, PdPriceComp.thrift_spec)), None, ), # 0
30952 
  )
30953 
 
30954 
  def __init__(self, success=None,):
30955 
    self.success = success
30956 
 
30957 
  def read(self, iprot):
30958 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30959 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30960 
      return
30961 
    iprot.readStructBegin()
30962 
    while True:
30963 
      (fname, ftype, fid) = iprot.readFieldBegin()
30964 
      if ftype == TType.STOP:
30965 
        break
30966 
      if fid == 0:
30967 
        if ftype == TType.LIST:
30968 
          self.success = []
13493 amit.gupta 30969 
          (_etype706, _size703) = iprot.readListBegin()
30970 
          for _i707 in xrange(_size703):
30971 
            _elem708 = PdPriceComp()
30972 
            _elem708.read(iprot)
30973 
            self.success.append(_elem708)
11905 kshitij.so 30974 
          iprot.readListEnd()
30975 
        else:
30976 
          iprot.skip(ftype)
30977 
      else:
30978 
        iprot.skip(ftype)
30979 
      iprot.readFieldEnd()
30980 
    iprot.readStructEnd()
30981 
 
30982 
  def write(self, oprot):
30983 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30984 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30985 
      return
30986 
    oprot.writeStructBegin('getAllPrivateDealsComparison_result')
30987 
    if self.success is not None:
30988 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30989 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 30990 
      for iter709 in self.success:
30991 
        iter709.write(oprot)
11905 kshitij.so 30992 
      oprot.writeListEnd()
30993 
      oprot.writeFieldEnd()
30994 
    oprot.writeFieldStop()
30995 
    oprot.writeStructEnd()
30996 
 
30997 
  def validate(self):
30998 
    return
30999 
 
31000 
 
31001 
  def __repr__(self):
31002 
    L = ['%s=%r' % (key, value)
31003 
      for key, value in self.__dict__.iteritems()]
31004 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31005 
 
31006 
  def __eq__(self, other):
31007 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31008 
 
31009 
  def __ne__(self, other):
31010 
    return not (self == other)
12133 kshitij.so 31011 
 
31012 
class getAllSnapdealMarketplaceItem_args:
31013 
 
31014 
  thrift_spec = (
31015 
  )
31016 
 
31017 
  def read(self, iprot):
31018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31020 
      return
31021 
    iprot.readStructBegin()
31022 
    while True:
31023 
      (fname, ftype, fid) = iprot.readFieldBegin()
31024 
      if ftype == TType.STOP:
31025 
        break
31026 
      else:
31027 
        iprot.skip(ftype)
31028 
      iprot.readFieldEnd()
31029 
    iprot.readStructEnd()
31030 
 
31031 
  def write(self, oprot):
31032 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31033 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31034 
      return
31035 
    oprot.writeStructBegin('getAllSnapdealMarketplaceItem_args')
31036 
    oprot.writeFieldStop()
31037 
    oprot.writeStructEnd()
31038 
 
31039 
  def validate(self):
31040 
    return
31041 
 
31042 
 
31043 
  def __repr__(self):
31044 
    L = ['%s=%r' % (key, value)
31045 
      for key, value in self.__dict__.iteritems()]
31046 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31047 
 
31048 
  def __eq__(self, other):
31049 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31050 
 
31051 
  def __ne__(self, other):
31052 
    return not (self == other)
31053 
 
31054 
class getAllSnapdealMarketplaceItem_result:
31055 
  """
31056 
  Attributes:
31057 
   - success
31058 
  """
31059 
 
31060 
  thrift_spec = (
31061 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItem, SnapdealItem.thrift_spec)), None, ), # 0
31062 
  )
31063 
 
31064 
  def __init__(self, success=None,):
31065 
    self.success = success
31066 
 
31067 
  def read(self, iprot):
31068 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31069 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31070 
      return
31071 
    iprot.readStructBegin()
31072 
    while True:
31073 
      (fname, ftype, fid) = iprot.readFieldBegin()
31074 
      if ftype == TType.STOP:
31075 
        break
31076 
      if fid == 0:
31077 
        if ftype == TType.LIST:
31078 
          self.success = []
13493 amit.gupta 31079 
          (_etype713, _size710) = iprot.readListBegin()
31080 
          for _i714 in xrange(_size710):
31081 
            _elem715 = SnapdealItem()
31082 
            _elem715.read(iprot)
31083 
            self.success.append(_elem715)
12133 kshitij.so 31084 
          iprot.readListEnd()
31085 
        else:
31086 
          iprot.skip(ftype)
31087 
      else:
31088 
        iprot.skip(ftype)
31089 
      iprot.readFieldEnd()
31090 
    iprot.readStructEnd()
31091 
 
31092 
  def write(self, oprot):
31093 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31094 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31095 
      return
31096 
    oprot.writeStructBegin('getAllSnapdealMarketplaceItem_result')
31097 
    if self.success is not None:
31098 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31099 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 31100 
      for iter716 in self.success:
31101 
        iter716.write(oprot)
12133 kshitij.so 31102 
      oprot.writeListEnd()
31103 
      oprot.writeFieldEnd()
31104 
    oprot.writeFieldStop()
31105 
    oprot.writeStructEnd()
31106 
 
31107 
  def validate(self):
31108 
    return
31109 
 
31110 
 
31111 
  def __repr__(self):
31112 
    L = ['%s=%r' % (key, value)
31113 
      for key, value in self.__dict__.iteritems()]
31114 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31115 
 
31116 
  def __eq__(self, other):
31117 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31118 
 
31119 
  def __ne__(self, other):
31120 
    return not (self == other)
31121 
 
31122 
class getAllFlipkartMarketplaceItem_args:
31123 
 
31124 
  thrift_spec = (
31125 
  )
31126 
 
31127 
  def read(self, iprot):
31128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31130 
      return
31131 
    iprot.readStructBegin()
31132 
    while True:
31133 
      (fname, ftype, fid) = iprot.readFieldBegin()
31134 
      if ftype == TType.STOP:
31135 
        break
31136 
      else:
31137 
        iprot.skip(ftype)
31138 
      iprot.readFieldEnd()
31139 
    iprot.readStructEnd()
31140 
 
31141 
  def write(self, oprot):
31142 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31143 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31144 
      return
31145 
    oprot.writeStructBegin('getAllFlipkartMarketplaceItem_args')
31146 
    oprot.writeFieldStop()
31147 
    oprot.writeStructEnd()
31148 
 
31149 
  def validate(self):
31150 
    return
31151 
 
31152 
 
31153 
  def __repr__(self):
31154 
    L = ['%s=%r' % (key, value)
31155 
      for key, value in self.__dict__.iteritems()]
31156 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31157 
 
31158 
  def __eq__(self, other):
31159 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31160 
 
31161 
  def __ne__(self, other):
31162 
    return not (self == other)
31163 
 
31164 
class getAllFlipkartMarketplaceItem_result:
31165 
  """
31166 
  Attributes:
31167 
   - success
31168 
  """
31169 
 
31170 
  thrift_spec = (
31171 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartItem, FlipkartItem.thrift_spec)), None, ), # 0
31172 
  )
31173 
 
31174 
  def __init__(self, success=None,):
31175 
    self.success = success
31176 
 
31177 
  def read(self, iprot):
31178 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31179 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31180 
      return
31181 
    iprot.readStructBegin()
31182 
    while True:
31183 
      (fname, ftype, fid) = iprot.readFieldBegin()
31184 
      if ftype == TType.STOP:
31185 
        break
31186 
      if fid == 0:
31187 
        if ftype == TType.LIST:
31188 
          self.success = []
13493 amit.gupta 31189 
          (_etype720, _size717) = iprot.readListBegin()
31190 
          for _i721 in xrange(_size717):
31191 
            _elem722 = FlipkartItem()
31192 
            _elem722.read(iprot)
31193 
            self.success.append(_elem722)
12133 kshitij.so 31194 
          iprot.readListEnd()
31195 
        else:
31196 
          iprot.skip(ftype)
31197 
      else:
31198 
        iprot.skip(ftype)
31199 
      iprot.readFieldEnd()
31200 
    iprot.readStructEnd()
31201 
 
31202 
  def write(self, oprot):
31203 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31204 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31205 
      return
31206 
    oprot.writeStructBegin('getAllFlipkartMarketplaceItem_result')
31207 
    if self.success is not None:
31208 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31209 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 31210 
      for iter723 in self.success:
31211 
        iter723.write(oprot)
12133 kshitij.so 31212 
      oprot.writeListEnd()
31213 
      oprot.writeFieldEnd()
31214 
    oprot.writeFieldStop()
31215 
    oprot.writeStructEnd()
31216 
 
31217 
  def validate(self):
31218 
    return
31219 
 
31220 
 
31221 
  def __repr__(self):
31222 
    L = ['%s=%r' % (key, value)
31223 
      for key, value in self.__dict__.iteritems()]
31224 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31225 
 
31226 
  def __eq__(self, other):
31227 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31228 
 
31229 
  def __ne__(self, other):
31230 
    return not (self == other)
12243 kshitij.so 31231 
 
31232 
class addCompetitorScraping_args:
31233 
  """
31234 
  Attributes:
31235 
   - competitorPricingMap
31236 
  """
31237 
 
31238 
  thrift_spec = (
31239 
    None, # 0
31240 
    (1, TType.MAP, 'competitorPricingMap', (TType.I64,None,TType.STRUCT,(CompetitorPricing, CompetitorPricing.thrift_spec)), None, ), # 1
31241 
  )
31242 
 
31243 
  def __init__(self, competitorPricingMap=None,):
31244 
    self.competitorPricingMap = competitorPricingMap
31245 
 
31246 
  def read(self, iprot):
31247 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31248 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31249 
      return
31250 
    iprot.readStructBegin()
31251 
    while True:
31252 
      (fname, ftype, fid) = iprot.readFieldBegin()
31253 
      if ftype == TType.STOP:
31254 
        break
31255 
      if fid == 1:
31256 
        if ftype == TType.MAP:
31257 
          self.competitorPricingMap = {}
13493 amit.gupta 31258 
          (_ktype725, _vtype726, _size724 ) = iprot.readMapBegin()
31259 
          for _i728 in xrange(_size724):
31260 
            _key729 = iprot.readI64();
31261 
            _val730 = CompetitorPricing()
31262 
            _val730.read(iprot)
31263 
            self.competitorPricingMap[_key729] = _val730
12243 kshitij.so 31264 
          iprot.readMapEnd()
31265 
        else:
31266 
          iprot.skip(ftype)
31267 
      else:
31268 
        iprot.skip(ftype)
31269 
      iprot.readFieldEnd()
31270 
    iprot.readStructEnd()
31271 
 
31272 
  def write(self, oprot):
31273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31275 
      return
31276 
    oprot.writeStructBegin('addCompetitorScraping_args')
31277 
    if self.competitorPricingMap is not None:
31278 
      oprot.writeFieldBegin('competitorPricingMap', TType.MAP, 1)
31279 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.competitorPricingMap))
13493 amit.gupta 31280 
      for kiter731,viter732 in self.competitorPricingMap.items():
31281 
        oprot.writeI64(kiter731)
31282 
        viter732.write(oprot)
12243 kshitij.so 31283 
      oprot.writeMapEnd()
31284 
      oprot.writeFieldEnd()
31285 
    oprot.writeFieldStop()
31286 
    oprot.writeStructEnd()
31287 
 
31288 
  def validate(self):
31289 
    return
31290 
 
31291 
 
31292 
  def __repr__(self):
31293 
    L = ['%s=%r' % (key, value)
31294 
      for key, value in self.__dict__.iteritems()]
31295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31296 
 
31297 
  def __eq__(self, other):
31298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31299 
 
31300 
  def __ne__(self, other):
31301 
    return not (self == other)
31302 
 
31303 
class addCompetitorScraping_result:
31304 
 
31305 
  thrift_spec = (
31306 
  )
31307 
 
31308 
  def read(self, iprot):
31309 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31310 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31311 
      return
31312 
    iprot.readStructBegin()
31313 
    while True:
31314 
      (fname, ftype, fid) = iprot.readFieldBegin()
31315 
      if ftype == TType.STOP:
31316 
        break
31317 
      else:
31318 
        iprot.skip(ftype)
31319 
      iprot.readFieldEnd()
31320 
    iprot.readStructEnd()
31321 
 
31322 
  def write(self, oprot):
31323 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31324 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31325 
      return
31326 
    oprot.writeStructBegin('addCompetitorScraping_result')
31327 
    oprot.writeFieldStop()
31328 
    oprot.writeStructEnd()
31329 
 
31330 
  def validate(self):
31331 
    return
31332 
 
31333 
 
31334 
  def __repr__(self):
31335 
    L = ['%s=%r' % (key, value)
31336 
      for key, value in self.__dict__.iteritems()]
31337 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31338 
 
31339 
  def __eq__(self, other):
31340 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31341 
 
31342 
  def __ne__(self, other):
31343 
    return not (self == other)
31344 
 
31345 
class getPreviousCompetitorScraping_args:
31346 
  """
31347 
  Attributes:
31348 
   - delta
31349 
  """
31350 
 
31351 
  thrift_spec = (
31352 
    None, # 0
31353 
    (1, TType.I64, 'delta', None, None, ), # 1
31354 
  )
31355 
 
31356 
  def __init__(self, delta=None,):
31357 
    self.delta = delta
31358 
 
31359 
  def read(self, iprot):
31360 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31361 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31362 
      return
31363 
    iprot.readStructBegin()
31364 
    while True:
31365 
      (fname, ftype, fid) = iprot.readFieldBegin()
31366 
      if ftype == TType.STOP:
31367 
        break
31368 
      if fid == 1:
31369 
        if ftype == TType.I64:
31370 
          self.delta = iprot.readI64();
31371 
        else:
31372 
          iprot.skip(ftype)
31373 
      else:
31374 
        iprot.skip(ftype)
31375 
      iprot.readFieldEnd()
31376 
    iprot.readStructEnd()
31377 
 
31378 
  def write(self, oprot):
31379 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31380 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31381 
      return
31382 
    oprot.writeStructBegin('getPreviousCompetitorScraping_args')
31383 
    if self.delta is not None:
31384 
      oprot.writeFieldBegin('delta', TType.I64, 1)
31385 
      oprot.writeI64(self.delta)
31386 
      oprot.writeFieldEnd()
31387 
    oprot.writeFieldStop()
31388 
    oprot.writeStructEnd()
31389 
 
31390 
  def validate(self):
31391 
    return
31392 
 
31393 
 
31394 
  def __repr__(self):
31395 
    L = ['%s=%r' % (key, value)
31396 
      for key, value in self.__dict__.iteritems()]
31397 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31398 
 
31399 
  def __eq__(self, other):
31400 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31401 
 
31402 
  def __ne__(self, other):
31403 
    return not (self == other)
31404 
 
31405 
class getPreviousCompetitorScraping_result:
31406 
  """
31407 
  Attributes:
31408 
   - success
31409 
  """
31410 
 
31411 
  thrift_spec = (
31412 
    (0, TType.LIST, 'success', (TType.STRUCT,(CompetitorPricing, CompetitorPricing.thrift_spec)), None, ), # 0
31413 
  )
31414 
 
31415 
  def __init__(self, success=None,):
31416 
    self.success = success
31417 
 
31418 
  def read(self, iprot):
31419 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31420 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31421 
      return
31422 
    iprot.readStructBegin()
31423 
    while True:
31424 
      (fname, ftype, fid) = iprot.readFieldBegin()
31425 
      if ftype == TType.STOP:
31426 
        break
31427 
      if fid == 0:
31428 
        if ftype == TType.LIST:
31429 
          self.success = []
13493 amit.gupta 31430 
          (_etype736, _size733) = iprot.readListBegin()
31431 
          for _i737 in xrange(_size733):
31432 
            _elem738 = CompetitorPricing()
31433 
            _elem738.read(iprot)
31434 
            self.success.append(_elem738)
12243 kshitij.so 31435 
          iprot.readListEnd()
31436 
        else:
31437 
          iprot.skip(ftype)
31438 
      else:
31439 
        iprot.skip(ftype)
31440 
      iprot.readFieldEnd()
31441 
    iprot.readStructEnd()
31442 
 
31443 
  def write(self, oprot):
31444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31446 
      return
31447 
    oprot.writeStructBegin('getPreviousCompetitorScraping_result')
31448 
    if self.success is not None:
31449 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31450 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 31451 
      for iter739 in self.success:
31452 
        iter739.write(oprot)
12243 kshitij.so 31453 
      oprot.writeListEnd()
31454 
      oprot.writeFieldEnd()
31455 
    oprot.writeFieldStop()
31456 
    oprot.writeStructEnd()
31457 
 
31458 
  def validate(self):
31459 
    return
31460 
 
31461 
 
31462 
  def __repr__(self):
31463 
    L = ['%s=%r' % (key, value)
31464 
      for key, value in self.__dict__.iteritems()]
31465 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31466 
 
31467 
  def __eq__(self, other):
31468 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31469 
 
31470 
  def __ne__(self, other):
31471 
    return not (self == other)
12256 kshitij.so 31472 
 
31473 
class getUploadResultById_args:
31474 
  """
31475 
  Attributes:
31476 
   - uploadId
31477 
  """
31478 
 
31479 
  thrift_spec = (
31480 
    None, # 0
31481 
    (1, TType.I64, 'uploadId', None, None, ), # 1
31482 
  )
31483 
 
31484 
  def __init__(self, uploadId=None,):
31485 
    self.uploadId = uploadId
31486 
 
31487 
  def read(self, iprot):
31488 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31489 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31490 
      return
31491 
    iprot.readStructBegin()
31492 
    while True:
31493 
      (fname, ftype, fid) = iprot.readFieldBegin()
31494 
      if ftype == TType.STOP:
31495 
        break
31496 
      if fid == 1:
31497 
        if ftype == TType.I64:
31498 
          self.uploadId = iprot.readI64();
31499 
        else:
31500 
          iprot.skip(ftype)
31501 
      else:
31502 
        iprot.skip(ftype)
31503 
      iprot.readFieldEnd()
31504 
    iprot.readStructEnd()
31505 
 
31506 
  def write(self, oprot):
31507 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31508 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31509 
      return
31510 
    oprot.writeStructBegin('getUploadResultById_args')
31511 
    if self.uploadId is not None:
31512 
      oprot.writeFieldBegin('uploadId', TType.I64, 1)
31513 
      oprot.writeI64(self.uploadId)
31514 
      oprot.writeFieldEnd()
31515 
    oprot.writeFieldStop()
31516 
    oprot.writeStructEnd()
31517 
 
31518 
  def validate(self):
31519 
    return
31520 
 
31521 
 
31522 
  def __repr__(self):
31523 
    L = ['%s=%r' % (key, value)
31524 
      for key, value in self.__dict__.iteritems()]
31525 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31526 
 
31527 
  def __eq__(self, other):
31528 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31529 
 
31530 
  def __ne__(self, other):
31531 
    return not (self == other)
31532 
 
31533 
class getUploadResultById_result:
31534 
  """
31535 
  Attributes:
31536 
   - success
31537 
  """
31538 
 
31539 
  thrift_spec = (
31540 
    (0, TType.LIST, 'success', (TType.STRUCT,(CompetitorPricing, CompetitorPricing.thrift_spec)), None, ), # 0
31541 
  )
31542 
 
31543 
  def __init__(self, success=None,):
31544 
    self.success = success
31545 
 
31546 
  def read(self, iprot):
31547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31549 
      return
31550 
    iprot.readStructBegin()
31551 
    while True:
31552 
      (fname, ftype, fid) = iprot.readFieldBegin()
31553 
      if ftype == TType.STOP:
31554 
        break
31555 
      if fid == 0:
31556 
        if ftype == TType.LIST:
31557 
          self.success = []
13493 amit.gupta 31558 
          (_etype743, _size740) = iprot.readListBegin()
31559 
          for _i744 in xrange(_size740):
31560 
            _elem745 = CompetitorPricing()
31561 
            _elem745.read(iprot)
31562 
            self.success.append(_elem745)
12256 kshitij.so 31563 
          iprot.readListEnd()
31564 
        else:
31565 
          iprot.skip(ftype)
31566 
      else:
31567 
        iprot.skip(ftype)
31568 
      iprot.readFieldEnd()
31569 
    iprot.readStructEnd()
31570 
 
31571 
  def write(self, oprot):
31572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31574 
      return
31575 
    oprot.writeStructBegin('getUploadResultById_result')
31576 
    if self.success is not None:
31577 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31578 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 31579 
      for iter746 in self.success:
31580 
        iter746.write(oprot)
12256 kshitij.so 31581 
      oprot.writeListEnd()
31582 
      oprot.writeFieldEnd()
31583 
    oprot.writeFieldStop()
31584 
    oprot.writeStructEnd()
31585 
 
31586 
  def validate(self):
31587 
    return
31588 
 
31589 
 
31590 
  def __repr__(self):
31591 
    L = ['%s=%r' % (key, value)
31592 
      for key, value in self.__dict__.iteritems()]
31593 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31594 
 
31595 
  def __eq__(self, other):
31596 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31597 
 
31598 
  def __ne__(self, other):
31599 
    return not (self == other)
12363 kshitij.so 31600 
 
31601 
class addAmazonPromotion_args:
31602 
  """
31603 
  Attributes:
31604 
   - amazonPromotions
31605 
  """
31606 
 
31607 
  thrift_spec = (
31608 
    None, # 0
31609 
    (1, TType.MAP, 'amazonPromotions', (TType.STRING,None,TType.STRUCT,(AmazonPromotion, AmazonPromotion.thrift_spec)), None, ), # 1
31610 
  )
31611 
 
31612 
  def __init__(self, amazonPromotions=None,):
31613 
    self.amazonPromotions = amazonPromotions
31614 
 
31615 
  def read(self, iprot):
31616 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31617 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31618 
      return
31619 
    iprot.readStructBegin()
31620 
    while True:
31621 
      (fname, ftype, fid) = iprot.readFieldBegin()
31622 
      if ftype == TType.STOP:
31623 
        break
31624 
      if fid == 1:
31625 
        if ftype == TType.MAP:
31626 
          self.amazonPromotions = {}
13493 amit.gupta 31627 
          (_ktype748, _vtype749, _size747 ) = iprot.readMapBegin()
31628 
          for _i751 in xrange(_size747):
31629 
            _key752 = iprot.readString();
31630 
            _val753 = AmazonPromotion()
31631 
            _val753.read(iprot)
31632 
            self.amazonPromotions[_key752] = _val753
12363 kshitij.so 31633 
          iprot.readMapEnd()
31634 
        else:
31635 
          iprot.skip(ftype)
31636 
      else:
31637 
        iprot.skip(ftype)
31638 
      iprot.readFieldEnd()
31639 
    iprot.readStructEnd()
31640 
 
31641 
  def write(self, oprot):
31642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31644 
      return
31645 
    oprot.writeStructBegin('addAmazonPromotion_args')
31646 
    if self.amazonPromotions is not None:
31647 
      oprot.writeFieldBegin('amazonPromotions', TType.MAP, 1)
31648 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.amazonPromotions))
13493 amit.gupta 31649 
      for kiter754,viter755 in self.amazonPromotions.items():
31650 
        oprot.writeString(kiter754)
31651 
        viter755.write(oprot)
12363 kshitij.so 31652 
      oprot.writeMapEnd()
31653 
      oprot.writeFieldEnd()
31654 
    oprot.writeFieldStop()
31655 
    oprot.writeStructEnd()
31656 
 
31657 
  def validate(self):
31658 
    return
31659 
 
31660 
 
31661 
  def __repr__(self):
31662 
    L = ['%s=%r' % (key, value)
31663 
      for key, value in self.__dict__.iteritems()]
31664 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31665 
 
31666 
  def __eq__(self, other):
31667 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31668 
 
31669 
  def __ne__(self, other):
31670 
    return not (self == other)
31671 
 
31672 
class addAmazonPromotion_result:
31673 
  """
31674 
  Attributes:
31675 
   - success
12947 kshitij.so 31676 
   - cex
12363 kshitij.so 31677 
  """
31678 
 
31679 
  thrift_spec = (
12947 kshitij.so 31680 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
31681 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12363 kshitij.so 31682 
  )
31683 
 
12947 kshitij.so 31684 
  def __init__(self, success=None, cex=None,):
12363 kshitij.so 31685 
    self.success = success
12947 kshitij.so 31686 
    self.cex = cex
12363 kshitij.so 31687 
 
31688 
  def read(self, iprot):
31689 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31690 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31691 
      return
31692 
    iprot.readStructBegin()
31693 
    while True:
31694 
      (fname, ftype, fid) = iprot.readFieldBegin()
31695 
      if ftype == TType.STOP:
31696 
        break
31697 
      if fid == 0:
12947 kshitij.so 31698 
        if ftype == TType.LIST:
31699 
          self.success = []
13493 amit.gupta 31700 
          (_etype759, _size756) = iprot.readListBegin()
31701 
          for _i760 in xrange(_size756):
31702 
            _elem761 = iprot.readString();
31703 
            self.success.append(_elem761)
12947 kshitij.so 31704 
          iprot.readListEnd()
12363 kshitij.so 31705 
        else:
31706 
          iprot.skip(ftype)
12947 kshitij.so 31707 
      elif fid == 1:
31708 
        if ftype == TType.STRUCT:
31709 
          self.cex = CatalogServiceException()
31710 
          self.cex.read(iprot)
31711 
        else:
31712 
          iprot.skip(ftype)
12363 kshitij.so 31713 
      else:
31714 
        iprot.skip(ftype)
31715 
      iprot.readFieldEnd()
31716 
    iprot.readStructEnd()
31717 
 
31718 
  def write(self, oprot):
31719 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31720 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31721 
      return
31722 
    oprot.writeStructBegin('addAmazonPromotion_result')
31723 
    if self.success is not None:
12947 kshitij.so 31724 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31725 
      oprot.writeListBegin(TType.STRING, len(self.success))
13493 amit.gupta 31726 
      for iter762 in self.success:
31727 
        oprot.writeString(iter762)
12947 kshitij.so 31728 
      oprot.writeListEnd()
12363 kshitij.so 31729 
      oprot.writeFieldEnd()
12947 kshitij.so 31730 
    if self.cex is not None:
31731 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
31732 
      self.cex.write(oprot)
31733 
      oprot.writeFieldEnd()
12363 kshitij.so 31734 
    oprot.writeFieldStop()
31735 
    oprot.writeStructEnd()
31736 
 
31737 
  def validate(self):
31738 
    return
31739 
 
31740 
 
31741 
  def __repr__(self):
31742 
    L = ['%s=%r' % (key, value)
31743 
      for key, value in self.__dict__.iteritems()]
31744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31745 
 
31746 
  def __eq__(self, other):
31747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31748 
 
31749 
  def __ne__(self, other):
31750 
    return not (self == other)
31751 
 
31752 
class getAmazonPromotion_args:
31753 
  """
31754 
  Attributes:
31755 
   - startDate
31756 
   - endDate
31757 
  """
31758 
 
31759 
  thrift_spec = (
31760 
    None, # 0
31761 
    (1, TType.I64, 'startDate', None, None, ), # 1
31762 
    (2, TType.I64, 'endDate', None, None, ), # 2
31763 
  )
31764 
 
31765 
  def __init__(self, startDate=None, endDate=None,):
31766 
    self.startDate = startDate
31767 
    self.endDate = endDate
31768 
 
31769 
  def read(self, iprot):
31770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31772 
      return
31773 
    iprot.readStructBegin()
31774 
    while True:
31775 
      (fname, ftype, fid) = iprot.readFieldBegin()
31776 
      if ftype == TType.STOP:
31777 
        break
31778 
      if fid == 1:
31779 
        if ftype == TType.I64:
31780 
          self.startDate = iprot.readI64();
31781 
        else:
31782 
          iprot.skip(ftype)
31783 
      elif fid == 2:
31784 
        if ftype == TType.I64:
31785 
          self.endDate = iprot.readI64();
31786 
        else:
31787 
          iprot.skip(ftype)
31788 
      else:
31789 
        iprot.skip(ftype)
31790 
      iprot.readFieldEnd()
31791 
    iprot.readStructEnd()
31792 
 
31793 
  def write(self, oprot):
31794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31796 
      return
31797 
    oprot.writeStructBegin('getAmazonPromotion_args')
31798 
    if self.startDate is not None:
31799 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
31800 
      oprot.writeI64(self.startDate)
31801 
      oprot.writeFieldEnd()
31802 
    if self.endDate is not None:
31803 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
31804 
      oprot.writeI64(self.endDate)
31805 
      oprot.writeFieldEnd()
31806 
    oprot.writeFieldStop()
31807 
    oprot.writeStructEnd()
31808 
 
31809 
  def validate(self):
31810 
    return
31811 
 
31812 
 
31813 
  def __repr__(self):
31814 
    L = ['%s=%r' % (key, value)
31815 
      for key, value in self.__dict__.iteritems()]
31816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31817 
 
31818 
  def __eq__(self, other):
31819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31820 
 
31821 
  def __ne__(self, other):
31822 
    return not (self == other)
31823 
 
31824 
class getAmazonPromotion_result:
31825 
  """
31826 
  Attributes:
31827 
   - success
31828 
  """
31829 
 
31830 
  thrift_spec = (
31831 
    (0, TType.LIST, 'success', (TType.STRUCT,(AmazonPromotion, AmazonPromotion.thrift_spec)), None, ), # 0
31832 
  )
31833 
 
31834 
  def __init__(self, success=None,):
31835 
    self.success = success
31836 
 
31837 
  def read(self, iprot):
31838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31840 
      return
31841 
    iprot.readStructBegin()
31842 
    while True:
31843 
      (fname, ftype, fid) = iprot.readFieldBegin()
31844 
      if ftype == TType.STOP:
31845 
        break
31846 
      if fid == 0:
31847 
        if ftype == TType.LIST:
31848 
          self.success = []
13493 amit.gupta 31849 
          (_etype766, _size763) = iprot.readListBegin()
31850 
          for _i767 in xrange(_size763):
31851 
            _elem768 = AmazonPromotion()
31852 
            _elem768.read(iprot)
31853 
            self.success.append(_elem768)
12363 kshitij.so 31854 
          iprot.readListEnd()
31855 
        else:
31856 
          iprot.skip(ftype)
31857 
      else:
31858 
        iprot.skip(ftype)
31859 
      iprot.readFieldEnd()
31860 
    iprot.readStructEnd()
31861 
 
31862 
  def write(self, oprot):
31863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31865 
      return
31866 
    oprot.writeStructBegin('getAmazonPromotion_result')
31867 
    if self.success is not None:
31868 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31869 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 31870 
      for iter769 in self.success:
31871 
        iter769.write(oprot)
12363 kshitij.so 31872 
      oprot.writeListEnd()
31873 
      oprot.writeFieldEnd()
31874 
    oprot.writeFieldStop()
31875 
    oprot.writeStructEnd()
31876 
 
31877 
  def validate(self):
31878 
    return
31879 
 
31880 
 
31881 
  def __repr__(self):
31882 
    L = ['%s=%r' % (key, value)
31883 
      for key, value in self.__dict__.iteritems()]
31884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31885 
 
31886 
  def __eq__(self, other):
31887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31888 
 
31889 
  def __ne__(self, other):
31890 
    return not (self == other)
31891 
 
31892 
class updateAmazonPromotion_args:
31893 
  """
31894 
  Attributes:
31895 
   - amazonPromotions
31896 
  """
31897 
 
31898 
  thrift_spec = (
31899 
    None, # 0
31900 
    (1, TType.LIST, 'amazonPromotions', (TType.STRUCT,(AmazonPromotion, AmazonPromotion.thrift_spec)), None, ), # 1
31901 
  )
31902 
 
31903 
  def __init__(self, amazonPromotions=None,):
31904 
    self.amazonPromotions = amazonPromotions
31905 
 
31906 
  def read(self, iprot):
31907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31909 
      return
31910 
    iprot.readStructBegin()
31911 
    while True:
31912 
      (fname, ftype, fid) = iprot.readFieldBegin()
31913 
      if ftype == TType.STOP:
31914 
        break
31915 
      if fid == 1:
31916 
        if ftype == TType.LIST:
31917 
          self.amazonPromotions = []
13493 amit.gupta 31918 
          (_etype773, _size770) = iprot.readListBegin()
31919 
          for _i774 in xrange(_size770):
31920 
            _elem775 = AmazonPromotion()
31921 
            _elem775.read(iprot)
31922 
            self.amazonPromotions.append(_elem775)
12363 kshitij.so 31923 
          iprot.readListEnd()
31924 
        else:
31925 
          iprot.skip(ftype)
31926 
      else:
31927 
        iprot.skip(ftype)
31928 
      iprot.readFieldEnd()
31929 
    iprot.readStructEnd()
31930 
 
31931 
  def write(self, oprot):
31932 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31933 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31934 
      return
31935 
    oprot.writeStructBegin('updateAmazonPromotion_args')
31936 
    if self.amazonPromotions is not None:
31937 
      oprot.writeFieldBegin('amazonPromotions', TType.LIST, 1)
31938 
      oprot.writeListBegin(TType.STRUCT, len(self.amazonPromotions))
13493 amit.gupta 31939 
      for iter776 in self.amazonPromotions:
31940 
        iter776.write(oprot)
12363 kshitij.so 31941 
      oprot.writeListEnd()
31942 
      oprot.writeFieldEnd()
31943 
    oprot.writeFieldStop()
31944 
    oprot.writeStructEnd()
31945 
 
31946 
  def validate(self):
31947 
    return
31948 
 
31949 
 
31950 
  def __repr__(self):
31951 
    L = ['%s=%r' % (key, value)
31952 
      for key, value in self.__dict__.iteritems()]
31953 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31954 
 
31955 
  def __eq__(self, other):
31956 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31957 
 
31958 
  def __ne__(self, other):
31959 
    return not (self == other)
31960 
 
31961 
class updateAmazonPromotion_result:
31962 
  """
31963 
  Attributes:
31964 
   - success
31965 
  """
31966 
 
31967 
  thrift_spec = (
31968 
    (0, TType.BOOL, 'success', None, None, ), # 0
31969 
  )
31970 
 
31971 
  def __init__(self, success=None,):
31972 
    self.success = success
31973 
 
31974 
  def read(self, iprot):
31975 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31976 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31977 
      return
31978 
    iprot.readStructBegin()
31979 
    while True:
31980 
      (fname, ftype, fid) = iprot.readFieldBegin()
31981 
      if ftype == TType.STOP:
31982 
        break
31983 
      if fid == 0:
31984 
        if ftype == TType.BOOL:
31985 
          self.success = iprot.readBool();
31986 
        else:
31987 
          iprot.skip(ftype)
31988 
      else:
31989 
        iprot.skip(ftype)
31990 
      iprot.readFieldEnd()
31991 
    iprot.readStructEnd()
31992 
 
31993 
  def write(self, oprot):
31994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31996 
      return
31997 
    oprot.writeStructBegin('updateAmazonPromotion_result')
31998 
    if self.success is not None:
31999 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
32000 
      oprot.writeBool(self.success)
32001 
      oprot.writeFieldEnd()
32002 
    oprot.writeFieldStop()
32003 
    oprot.writeStructEnd()
32004 
 
32005 
  def validate(self):
32006 
    return
32007 
 
32008 
 
32009 
  def __repr__(self):
32010 
    L = ['%s=%r' % (key, value)
32011 
      for key, value in self.__dict__.iteritems()]
32012 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32013 
 
32014 
  def __eq__(self, other):
32015 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32016 
 
32017 
  def __ne__(self, other):
32018 
    return not (self == other)
12567 amit.gupta 32019 
 
32020 
class markPartiallyActive_args:
32021 
  """
32022 
  Attributes:
32023 
   - itemId
32024 
   - categoryId
32025 
  """
32026 
 
32027 
  thrift_spec = (
32028 
    None, # 0
32029 
    (1, TType.I64, 'itemId', None, None, ), # 1
32030 
    (2, TType.I64, 'categoryId', None, None, ), # 2
32031 
  )
32032 
 
32033 
  def __init__(self, itemId=None, categoryId=None,):
32034 
    self.itemId = itemId
32035 
    self.categoryId = categoryId
32036 
 
32037 
  def read(self, iprot):
32038 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32039 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32040 
      return
32041 
    iprot.readStructBegin()
32042 
    while True:
32043 
      (fname, ftype, fid) = iprot.readFieldBegin()
32044 
      if ftype == TType.STOP:
32045 
        break
32046 
      if fid == 1:
32047 
        if ftype == TType.I64:
32048 
          self.itemId = iprot.readI64();
32049 
        else:
32050 
          iprot.skip(ftype)
32051 
      elif fid == 2:
32052 
        if ftype == TType.I64:
32053 
          self.categoryId = iprot.readI64();
32054 
        else:
32055 
          iprot.skip(ftype)
32056 
      else:
32057 
        iprot.skip(ftype)
32058 
      iprot.readFieldEnd()
32059 
    iprot.readStructEnd()
32060 
 
32061 
  def write(self, oprot):
32062 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32063 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32064 
      return
32065 
    oprot.writeStructBegin('markPartiallyActive_args')
32066 
    if self.itemId is not None:
32067 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
32068 
      oprot.writeI64(self.itemId)
32069 
      oprot.writeFieldEnd()
32070 
    if self.categoryId is not None:
32071 
      oprot.writeFieldBegin('categoryId', TType.I64, 2)
32072 
      oprot.writeI64(self.categoryId)
32073 
      oprot.writeFieldEnd()
32074 
    oprot.writeFieldStop()
32075 
    oprot.writeStructEnd()
32076 
 
32077 
  def validate(self):
32078 
    return
32079 
 
32080 
 
32081 
  def __repr__(self):
32082 
    L = ['%s=%r' % (key, value)
32083 
      for key, value in self.__dict__.iteritems()]
32084 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32085 
 
32086 
  def __eq__(self, other):
32087 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32088 
 
32089 
  def __ne__(self, other):
32090 
    return not (self == other)
32091 
 
32092 
class markPartiallyActive_result:
32093 
  """
32094 
  Attributes:
32095 
   - success
32096 
  """
32097 
 
32098 
  thrift_spec = (
32099 
    (0, TType.BOOL, 'success', None, None, ), # 0
32100 
  )
32101 
 
32102 
  def __init__(self, success=None,):
32103 
    self.success = success
32104 
 
32105 
  def read(self, iprot):
32106 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32107 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32108 
      return
32109 
    iprot.readStructBegin()
32110 
    while True:
32111 
      (fname, ftype, fid) = iprot.readFieldBegin()
32112 
      if ftype == TType.STOP:
32113 
        break
32114 
      if fid == 0:
32115 
        if ftype == TType.BOOL:
32116 
          self.success = iprot.readBool();
32117 
        else:
32118 
          iprot.skip(ftype)
32119 
      else:
32120 
        iprot.skip(ftype)
32121 
      iprot.readFieldEnd()
32122 
    iprot.readStructEnd()
32123 
 
32124 
  def write(self, oprot):
32125 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32126 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32127 
      return
32128 
    oprot.writeStructBegin('markPartiallyActive_result')
32129 
    if self.success is not None:
32130 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
32131 
      oprot.writeBool(self.success)
32132 
      oprot.writeFieldEnd()
32133 
    oprot.writeFieldStop()
32134 
    oprot.writeStructEnd()
32135 
 
32136 
  def validate(self):
32137 
    return
32138 
 
32139 
 
32140 
  def __repr__(self):
32141 
    L = ['%s=%r' % (key, value)
32142 
      for key, value in self.__dict__.iteritems()]
32143 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32144 
 
32145 
  def __eq__(self, other):
32146 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32147 
 
32148 
  def __ne__(self, other):
32149 
    return not (self == other)
32150 
 
32151 
class updateItemStateVat_args:
32152 
  """
32153 
  Attributes:
32154 
   - itemId
32155 
   - statevat
32156 
  """
32157 
 
32158 
  thrift_spec = (
32159 
    None, # 0
32160 
    (1, TType.I64, 'itemId', None, None, ), # 1
32161 
    (2, TType.MAP, 'statevat', (TType.I64,None,TType.DOUBLE,None), None, ), # 2
32162 
  )
32163 
 
32164 
  def __init__(self, itemId=None, statevat=None,):
32165 
    self.itemId = itemId
32166 
    self.statevat = statevat
32167 
 
32168 
  def read(self, iprot):
32169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32171 
      return
32172 
    iprot.readStructBegin()
32173 
    while True:
32174 
      (fname, ftype, fid) = iprot.readFieldBegin()
32175 
      if ftype == TType.STOP:
32176 
        break
32177 
      if fid == 1:
32178 
        if ftype == TType.I64:
32179 
          self.itemId = iprot.readI64();
32180 
        else:
32181 
          iprot.skip(ftype)
32182 
      elif fid == 2:
32183 
        if ftype == TType.MAP:
32184 
          self.statevat = {}
13493 amit.gupta 32185 
          (_ktype778, _vtype779, _size777 ) = iprot.readMapBegin()
32186 
          for _i781 in xrange(_size777):
32187 
            _key782 = iprot.readI64();
32188 
            _val783 = iprot.readDouble();
32189 
            self.statevat[_key782] = _val783
12567 amit.gupta 32190 
          iprot.readMapEnd()
32191 
        else:
32192 
          iprot.skip(ftype)
32193 
      else:
32194 
        iprot.skip(ftype)
32195 
      iprot.readFieldEnd()
32196 
    iprot.readStructEnd()
32197 
 
32198 
  def write(self, oprot):
32199 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32200 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32201 
      return
32202 
    oprot.writeStructBegin('updateItemStateVat_args')
32203 
    if self.itemId is not None:
32204 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
32205 
      oprot.writeI64(self.itemId)
32206 
      oprot.writeFieldEnd()
32207 
    if self.statevat is not None:
32208 
      oprot.writeFieldBegin('statevat', TType.MAP, 2)
32209 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.statevat))
13493 amit.gupta 32210 
      for kiter784,viter785 in self.statevat.items():
32211 
        oprot.writeI64(kiter784)
32212 
        oprot.writeDouble(viter785)
12567 amit.gupta 32213 
      oprot.writeMapEnd()
32214 
      oprot.writeFieldEnd()
32215 
    oprot.writeFieldStop()
32216 
    oprot.writeStructEnd()
32217 
 
32218 
  def validate(self):
32219 
    return
32220 
 
32221 
 
32222 
  def __repr__(self):
32223 
    L = ['%s=%r' % (key, value)
32224 
      for key, value in self.__dict__.iteritems()]
32225 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32226 
 
32227 
  def __eq__(self, other):
32228 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32229 
 
32230 
  def __ne__(self, other):
32231 
    return not (self == other)
32232 
 
32233 
class updateItemStateVat_result:
32234 
  """
32235 
  Attributes:
32236 
   - success
32237 
  """
32238 
 
32239 
  thrift_spec = (
32240 
    (0, TType.BOOL, 'success', None, None, ), # 0
32241 
  )
32242 
 
32243 
  def __init__(self, success=None,):
32244 
    self.success = success
32245 
 
32246 
  def read(self, iprot):
32247 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32248 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32249 
      return
32250 
    iprot.readStructBegin()
32251 
    while True:
32252 
      (fname, ftype, fid) = iprot.readFieldBegin()
32253 
      if ftype == TType.STOP:
32254 
        break
32255 
      if fid == 0:
32256 
        if ftype == TType.BOOL:
32257 
          self.success = iprot.readBool();
32258 
        else:
32259 
          iprot.skip(ftype)
32260 
      else:
32261 
        iprot.skip(ftype)
32262 
      iprot.readFieldEnd()
32263 
    iprot.readStructEnd()
32264 
 
32265 
  def write(self, oprot):
32266 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32267 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32268 
      return
32269 
    oprot.writeStructBegin('updateItemStateVat_result')
32270 
    if self.success is not None:
32271 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
32272 
      oprot.writeBool(self.success)
32273 
      oprot.writeFieldEnd()
32274 
    oprot.writeFieldStop()
32275 
    oprot.writeStructEnd()
32276 
 
32277 
  def validate(self):
32278 
    return
32279 
 
32280 
 
32281 
  def __repr__(self):
32282 
    L = ['%s=%r' % (key, value)
32283 
      for key, value in self.__dict__.iteritems()]
32284 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32285 
 
32286 
  def __eq__(self, other):
32287 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32288 
 
32289 
  def __ne__(self, other):
32290 
    return not (self == other)
12620 amit.gupta 32291 
 
32292 
class getExAffiliateItemInfo_args:
32293 
 
32294 
  thrift_spec = (
32295 
  )
32296 
 
32297 
  def read(self, iprot):
32298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32300 
      return
32301 
    iprot.readStructBegin()
32302 
    while True:
32303 
      (fname, ftype, fid) = iprot.readFieldBegin()
32304 
      if ftype == TType.STOP:
32305 
        break
32306 
      else:
32307 
        iprot.skip(ftype)
32308 
      iprot.readFieldEnd()
32309 
    iprot.readStructEnd()
32310 
 
32311 
  def write(self, oprot):
32312 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32313 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32314 
      return
32315 
    oprot.writeStructBegin('getExAffiliateItemInfo_args')
32316 
    oprot.writeFieldStop()
32317 
    oprot.writeStructEnd()
32318 
 
32319 
  def validate(self):
32320 
    return
32321 
 
32322 
 
32323 
  def __repr__(self):
32324 
    L = ['%s=%r' % (key, value)
32325 
      for key, value in self.__dict__.iteritems()]
32326 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32327 
 
32328 
  def __eq__(self, other):
32329 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32330 
 
32331 
  def __ne__(self, other):
32332 
    return not (self == other)
32333 
 
32334 
class getExAffiliateItemInfo_result:
32335 
  """
32336 
  Attributes:
32337 
   - success
32338 
  """
32339 
 
32340 
  thrift_spec = (
32341 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRUCT,(ExclusiveAffiliateItemInfo, ExclusiveAffiliateItemInfo.thrift_spec)), None, ), # 0
32342 
  )
32343 
 
32344 
  def __init__(self, success=None,):
32345 
    self.success = success
32346 
 
32347 
  def read(self, iprot):
32348 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32349 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32350 
      return
32351 
    iprot.readStructBegin()
32352 
    while True:
32353 
      (fname, ftype, fid) = iprot.readFieldBegin()
32354 
      if ftype == TType.STOP:
32355 
        break
32356 
      if fid == 0:
32357 
        if ftype == TType.MAP:
32358 
          self.success = {}
13493 amit.gupta 32359 
          (_ktype787, _vtype788, _size786 ) = iprot.readMapBegin()
32360 
          for _i790 in xrange(_size786):
32361 
            _key791 = iprot.readI64();
32362 
            _val792 = ExclusiveAffiliateItemInfo()
32363 
            _val792.read(iprot)
32364 
            self.success[_key791] = _val792
12620 amit.gupta 32365 
          iprot.readMapEnd()
32366 
        else:
32367 
          iprot.skip(ftype)
32368 
      else:
32369 
        iprot.skip(ftype)
32370 
      iprot.readFieldEnd()
32371 
    iprot.readStructEnd()
32372 
 
32373 
  def write(self, oprot):
32374 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32375 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32376 
      return
32377 
    oprot.writeStructBegin('getExAffiliateItemInfo_result')
32378 
    if self.success is not None:
32379 
      oprot.writeFieldBegin('success', TType.MAP, 0)
32380 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.success))
13493 amit.gupta 32381 
      for kiter793,viter794 in self.success.items():
32382 
        oprot.writeI64(kiter793)
32383 
        viter794.write(oprot)
12620 amit.gupta 32384 
      oprot.writeMapEnd()
32385 
      oprot.writeFieldEnd()
32386 
    oprot.writeFieldStop()
32387 
    oprot.writeStructEnd()
32388 
 
32389 
  def validate(self):
32390 
    return
32391 
 
32392 
 
32393 
  def __repr__(self):
32394 
    L = ['%s=%r' % (key, value)
32395 
      for key, value in self.__dict__.iteritems()]
32396 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32397 
 
32398 
  def __eq__(self, other):
32399 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32400 
 
32401 
  def __ne__(self, other):
32402 
    return not (self == other)
12888 kshitij.so 32403 
 
32404 
class getAllItemstoListOnFbg_args:
32405 
 
32406 
  thrift_spec = (
32407 
  )
32408 
 
32409 
  def read(self, iprot):
32410 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32411 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32412 
      return
32413 
    iprot.readStructBegin()
32414 
    while True:
32415 
      (fname, ftype, fid) = iprot.readFieldBegin()
32416 
      if ftype == TType.STOP:
32417 
        break
32418 
      else:
32419 
        iprot.skip(ftype)
32420 
      iprot.readFieldEnd()
32421 
    iprot.readStructEnd()
32422 
 
32423 
  def write(self, oprot):
32424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32426 
      return
32427 
    oprot.writeStructBegin('getAllItemstoListOnFbg_args')
32428 
    oprot.writeFieldStop()
32429 
    oprot.writeStructEnd()
32430 
 
32431 
  def validate(self):
32432 
    return
32433 
 
32434 
 
32435 
  def __repr__(self):
32436 
    L = ['%s=%r' % (key, value)
32437 
      for key, value in self.__dict__.iteritems()]
32438 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32439 
 
32440 
  def __eq__(self, other):
32441 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32442 
 
32443 
  def __ne__(self, other):
32444 
    return not (self == other)
32445 
 
32446 
class getAllItemstoListOnFbg_result:
32447 
  """
32448 
  Attributes:
32449 
   - success
32450 
  """
32451 
 
32452 
  thrift_spec = (
32453 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
32454 
  )
32455 
 
32456 
  def __init__(self, success=None,):
32457 
    self.success = success
32458 
 
32459 
  def read(self, iprot):
32460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32462 
      return
32463 
    iprot.readStructBegin()
32464 
    while True:
32465 
      (fname, ftype, fid) = iprot.readFieldBegin()
32466 
      if ftype == TType.STOP:
32467 
        break
32468 
      if fid == 0:
32469 
        if ftype == TType.LIST:
32470 
          self.success = []
13493 amit.gupta 32471 
          (_etype798, _size795) = iprot.readListBegin()
32472 
          for _i799 in xrange(_size795):
32473 
            _elem800 = Amazonlisted()
32474 
            _elem800.read(iprot)
32475 
            self.success.append(_elem800)
12888 kshitij.so 32476 
          iprot.readListEnd()
32477 
        else:
32478 
          iprot.skip(ftype)
32479 
      else:
32480 
        iprot.skip(ftype)
32481 
      iprot.readFieldEnd()
32482 
    iprot.readStructEnd()
32483 
 
32484 
  def write(self, oprot):
32485 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32486 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32487 
      return
32488 
    oprot.writeStructBegin('getAllItemstoListOnFbg_result')
32489 
    if self.success is not None:
32490 
      oprot.writeFieldBegin('success', TType.LIST, 0)
32491 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 32492 
      for iter801 in self.success:
32493 
        iter801.write(oprot)
12888 kshitij.so 32494 
      oprot.writeListEnd()
32495 
      oprot.writeFieldEnd()
32496 
    oprot.writeFieldStop()
32497 
    oprot.writeStructEnd()
32498 
 
32499 
  def validate(self):
32500 
    return
32501 
 
32502 
 
32503 
  def __repr__(self):
32504 
    L = ['%s=%r' % (key, value)
32505 
      for key, value in self.__dict__.iteritems()]
32506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32507 
 
32508 
  def __eq__(self, other):
32509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32510 
 
32511 
  def __ne__(self, other):
32512 
    return not (self == other)
12892 kshitij.so 32513 
 
32514 
class getAllFbgListedItems_args:
32515 
 
32516 
  thrift_spec = (
32517 
  )
32518 
 
32519 
  def read(self, iprot):
32520 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32521 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32522 
      return
32523 
    iprot.readStructBegin()
32524 
    while True:
32525 
      (fname, ftype, fid) = iprot.readFieldBegin()
32526 
      if ftype == TType.STOP:
32527 
        break
32528 
      else:
32529 
        iprot.skip(ftype)
32530 
      iprot.readFieldEnd()
32531 
    iprot.readStructEnd()
32532 
 
32533 
  def write(self, oprot):
32534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32536 
      return
32537 
    oprot.writeStructBegin('getAllFbgListedItems_args')
32538 
    oprot.writeFieldStop()
32539 
    oprot.writeStructEnd()
32540 
 
32541 
  def validate(self):
32542 
    return
32543 
 
32544 
 
32545 
  def __repr__(self):
32546 
    L = ['%s=%r' % (key, value)
32547 
      for key, value in self.__dict__.iteritems()]
32548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32549 
 
32550 
  def __eq__(self, other):
32551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32552 
 
32553 
  def __ne__(self, other):
32554 
    return not (self == other)
32555 
 
32556 
class getAllFbgListedItems_result:
32557 
  """
32558 
  Attributes:
32559 
   - success
32560 
  """
32561 
 
32562 
  thrift_spec = (
32563 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
32564 
  )
32565 
 
32566 
  def __init__(self, success=None,):
32567 
    self.success = success
32568 
 
32569 
  def read(self, iprot):
32570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32572 
      return
32573 
    iprot.readStructBegin()
32574 
    while True:
32575 
      (fname, ftype, fid) = iprot.readFieldBegin()
32576 
      if ftype == TType.STOP:
32577 
        break
32578 
      if fid == 0:
32579 
        if ftype == TType.LIST:
32580 
          self.success = []
13493 amit.gupta 32581 
          (_etype805, _size802) = iprot.readListBegin()
32582 
          for _i806 in xrange(_size802):
32583 
            _elem807 = Amazonlisted()
32584 
            _elem807.read(iprot)
32585 
            self.success.append(_elem807)
12892 kshitij.so 32586 
          iprot.readListEnd()
32587 
        else:
32588 
          iprot.skip(ftype)
32589 
      else:
32590 
        iprot.skip(ftype)
32591 
      iprot.readFieldEnd()
32592 
    iprot.readStructEnd()
32593 
 
32594 
  def write(self, oprot):
32595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32597 
      return
32598 
    oprot.writeStructBegin('getAllFbgListedItems_result')
32599 
    if self.success is not None:
32600 
      oprot.writeFieldBegin('success', TType.LIST, 0)
32601 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 32602 
      for iter808 in self.success:
32603 
        iter808.write(oprot)
12892 kshitij.so 32604 
      oprot.writeListEnd()
32605 
      oprot.writeFieldEnd()
32606 
    oprot.writeFieldStop()
32607 
    oprot.writeStructEnd()
32608 
 
32609 
  def validate(self):
32610 
    return
32611 
 
32612 
 
32613 
  def __repr__(self):
32614 
    L = ['%s=%r' % (key, value)
32615 
      for key, value in self.__dict__.iteritems()]
32616 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32617 
 
32618 
  def __eq__(self, other):
32619 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32620 
 
32621 
  def __ne__(self, other):
32622 
    return not (self == other)
13136 amit.gupta 32623 
 
32624 
class checkServices_args:
32625 
  """
32626 
  Attributes:
32627 
   - lines
32628 
  """
32629 
 
32630 
  thrift_spec = (
32631 
    None, # 0
32632 
    (1, TType.MAP, 'lines', (TType.I64,None,TType.MAP,(TType.STRING,None,TType.I64,None)), None, ), # 1
32633 
  )
32634 
 
32635 
  def __init__(self, lines=None,):
32636 
    self.lines = lines
32637 
 
32638 
  def read(self, iprot):
32639 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32640 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32641 
      return
32642 
    iprot.readStructBegin()
32643 
    while True:
32644 
      (fname, ftype, fid) = iprot.readFieldBegin()
32645 
      if ftype == TType.STOP:
32646 
        break
32647 
      if fid == 1:
32648 
        if ftype == TType.MAP:
32649 
          self.lines = {}
13493 amit.gupta 32650 
          (_ktype810, _vtype811, _size809 ) = iprot.readMapBegin()
32651 
          for _i813 in xrange(_size809):
32652 
            _key814 = iprot.readI64();
32653 
            _val815 = {}
32654 
            (_ktype817, _vtype818, _size816 ) = iprot.readMapBegin()
32655 
            for _i820 in xrange(_size816):
32656 
              _key821 = iprot.readString();
32657 
              _val822 = iprot.readI64();
32658 
              _val815[_key821] = _val822
13136 amit.gupta 32659 
            iprot.readMapEnd()
13493 amit.gupta 32660 
            self.lines[_key814] = _val815
13136 amit.gupta 32661 
          iprot.readMapEnd()
32662 
        else:
32663 
          iprot.skip(ftype)
32664 
      else:
32665 
        iprot.skip(ftype)
32666 
      iprot.readFieldEnd()
32667 
    iprot.readStructEnd()
32668 
 
32669 
  def write(self, oprot):
32670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32672 
      return
32673 
    oprot.writeStructBegin('checkServices_args')
32674 
    if self.lines is not None:
32675 
      oprot.writeFieldBegin('lines', TType.MAP, 1)
32676 
      oprot.writeMapBegin(TType.I64, TType.MAP, len(self.lines))
13493 amit.gupta 32677 
      for kiter823,viter824 in self.lines.items():
32678 
        oprot.writeI64(kiter823)
32679 
        oprot.writeMapBegin(TType.STRING, TType.I64, len(viter824))
32680 
        for kiter825,viter826 in viter824.items():
32681 
          oprot.writeString(kiter825)
32682 
          oprot.writeI64(viter826)
13136 amit.gupta 32683 
        oprot.writeMapEnd()
32684 
      oprot.writeMapEnd()
32685 
      oprot.writeFieldEnd()
32686 
    oprot.writeFieldStop()
32687 
    oprot.writeStructEnd()
32688 
 
32689 
  def validate(self):
32690 
    return
32691 
 
32692 
 
32693 
  def __repr__(self):
32694 
    L = ['%s=%r' % (key, value)
32695 
      for key, value in self.__dict__.iteritems()]
32696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32697 
 
32698 
  def __eq__(self, other):
32699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32700 
 
32701 
  def __ne__(self, other):
32702 
    return not (self == other)
32703 
 
32704 
class checkServices_result:
32705 
  """
32706 
  Attributes:
32707 
   - success
32708 
   - cex
32709 
  """
32710 
 
32711 
  thrift_spec = (
32712 
    (0, TType.MAP, 'success', (TType.I64,None,TType.MAP,(TType.STRING,None,TType.I64,None)), None, ), # 0
32713 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
32714 
  )
32715 
 
32716 
  def __init__(self, success=None, cex=None,):
32717 
    self.success = success
32718 
    self.cex = cex
32719 
 
32720 
  def read(self, iprot):
32721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32723 
      return
32724 
    iprot.readStructBegin()
32725 
    while True:
32726 
      (fname, ftype, fid) = iprot.readFieldBegin()
32727 
      if ftype == TType.STOP:
32728 
        break
32729 
      if fid == 0:
32730 
        if ftype == TType.MAP:
32731 
          self.success = {}
13493 amit.gupta 32732 
          (_ktype828, _vtype829, _size827 ) = iprot.readMapBegin()
32733 
          for _i831 in xrange(_size827):
32734 
            _key832 = iprot.readI64();
32735 
            _val833 = {}
32736 
            (_ktype835, _vtype836, _size834 ) = iprot.readMapBegin()
32737 
            for _i838 in xrange(_size834):
32738 
              _key839 = iprot.readString();
32739 
              _val840 = iprot.readI64();
32740 
              _val833[_key839] = _val840
13136 amit.gupta 32741 
            iprot.readMapEnd()
13493 amit.gupta 32742 
            self.success[_key832] = _val833
13136 amit.gupta 32743 
          iprot.readMapEnd()
32744 
        else:
32745 
          iprot.skip(ftype)
32746 
      elif fid == 1:
32747 
        if ftype == TType.STRUCT:
32748 
          self.cex = CatalogServiceException()
32749 
          self.cex.read(iprot)
32750 
        else:
32751 
          iprot.skip(ftype)
32752 
      else:
32753 
        iprot.skip(ftype)
32754 
      iprot.readFieldEnd()
32755 
    iprot.readStructEnd()
32756 
 
32757 
  def write(self, oprot):
32758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32760 
      return
32761 
    oprot.writeStructBegin('checkServices_result')
32762 
    if self.success is not None:
32763 
      oprot.writeFieldBegin('success', TType.MAP, 0)
32764 
      oprot.writeMapBegin(TType.I64, TType.MAP, len(self.success))
13493 amit.gupta 32765 
      for kiter841,viter842 in self.success.items():
32766 
        oprot.writeI64(kiter841)
32767 
        oprot.writeMapBegin(TType.STRING, TType.I64, len(viter842))
32768 
        for kiter843,viter844 in viter842.items():
32769 
          oprot.writeString(kiter843)
32770 
          oprot.writeI64(viter844)
13136 amit.gupta 32771 
        oprot.writeMapEnd()
32772 
      oprot.writeMapEnd()
32773 
      oprot.writeFieldEnd()
32774 
    if self.cex is not None:
32775 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
32776 
      self.cex.write(oprot)
32777 
      oprot.writeFieldEnd()
32778 
    oprot.writeFieldStop()
32779 
    oprot.writeStructEnd()
32780 
 
32781 
  def validate(self):
32782 
    return
32783 
 
32784 
 
32785 
  def __repr__(self):
32786 
    L = ['%s=%r' % (key, value)
32787 
      for key, value in self.__dict__.iteritems()]
32788 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32789 
 
32790 
  def __eq__(self, other):
32791 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32792 
 
32793 
  def __ne__(self, other):
32794 
    return not (self == other)
13709 manish.sha 32795 
 
32796 
class addHsItem_args:
32797 
  """
32798 
  Attributes:
32799 
   - hsItems
32800 
  """
32801 
 
32802 
  thrift_spec = (
32803 
    None, # 0
32804 
    (1, TType.LIST, 'hsItems', (TType.STRUCT,(HsItem, HsItem.thrift_spec)), None, ), # 1
32805 
  )
32806 
 
32807 
  def __init__(self, hsItems=None,):
32808 
    self.hsItems = hsItems
32809 
 
32810 
  def read(self, iprot):
32811 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32812 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32813 
      return
32814 
    iprot.readStructBegin()
32815 
    while True:
32816 
      (fname, ftype, fid) = iprot.readFieldBegin()
32817 
      if ftype == TType.STOP:
32818 
        break
32819 
      if fid == 1:
32820 
        if ftype == TType.LIST:
32821 
          self.hsItems = []
32822 
          (_etype848, _size845) = iprot.readListBegin()
32823 
          for _i849 in xrange(_size845):
32824 
            _elem850 = HsItem()
32825 
            _elem850.read(iprot)
32826 
            self.hsItems.append(_elem850)
32827 
          iprot.readListEnd()
32828 
        else:
32829 
          iprot.skip(ftype)
32830 
      else:
32831 
        iprot.skip(ftype)
32832 
      iprot.readFieldEnd()
32833 
    iprot.readStructEnd()
32834 
 
32835 
  def write(self, oprot):
32836 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32837 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32838 
      return
32839 
    oprot.writeStructBegin('addHsItem_args')
32840 
    if self.hsItems is not None:
32841 
      oprot.writeFieldBegin('hsItems', TType.LIST, 1)
32842 
      oprot.writeListBegin(TType.STRUCT, len(self.hsItems))
32843 
      for iter851 in self.hsItems:
32844 
        iter851.write(oprot)
32845 
      oprot.writeListEnd()
32846 
      oprot.writeFieldEnd()
32847 
    oprot.writeFieldStop()
32848 
    oprot.writeStructEnd()
32849 
 
32850 
  def validate(self):
32851 
    return
32852 
 
32853 
 
32854 
  def __repr__(self):
32855 
    L = ['%s=%r' % (key, value)
32856 
      for key, value in self.__dict__.iteritems()]
32857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32858 
 
32859 
  def __eq__(self, other):
32860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32861 
 
32862 
  def __ne__(self, other):
32863 
    return not (self == other)
32864 
 
32865 
class addHsItem_result:
32866 
 
32867 
  thrift_spec = (
32868 
  )
32869 
 
32870 
  def read(self, iprot):
32871 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32872 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32873 
      return
32874 
    iprot.readStructBegin()
32875 
    while True:
32876 
      (fname, ftype, fid) = iprot.readFieldBegin()
32877 
      if ftype == TType.STOP:
32878 
        break
32879 
      else:
32880 
        iprot.skip(ftype)
32881 
      iprot.readFieldEnd()
32882 
    iprot.readStructEnd()
32883 
 
32884 
  def write(self, oprot):
32885 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32886 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32887 
      return
32888 
    oprot.writeStructBegin('addHsItem_result')
32889 
    oprot.writeFieldStop()
32890 
    oprot.writeStructEnd()
32891 
 
32892 
  def validate(self):
32893 
    return
32894 
 
32895 
 
32896 
  def __repr__(self):
32897 
    L = ['%s=%r' % (key, value)
32898 
      for key, value in self.__dict__.iteritems()]
32899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32900 
 
32901 
  def __eq__(self, other):
32902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32903 
 
32904 
  def __ne__(self, other):
32905 
    return not (self == other)
32906 
 
32907 
class getHsItem_args:
32908 
  """
32909 
  Attributes:
32910 
   - hsItemId
32911 
  """
32912 
 
32913 
  thrift_spec = (
32914 
    None, # 0
32915 
    (1, TType.STRING, 'hsItemId', None, None, ), # 1
32916 
  )
32917 
 
32918 
  def __init__(self, hsItemId=None,):
32919 
    self.hsItemId = hsItemId
32920 
 
32921 
  def read(self, iprot):
32922 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32923 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32924 
      return
32925 
    iprot.readStructBegin()
32926 
    while True:
32927 
      (fname, ftype, fid) = iprot.readFieldBegin()
32928 
      if ftype == TType.STOP:
32929 
        break
32930 
      if fid == 1:
32931 
        if ftype == TType.STRING:
32932 
          self.hsItemId = iprot.readString();
32933 
        else:
32934 
          iprot.skip(ftype)
32935 
      else:
32936 
        iprot.skip(ftype)
32937 
      iprot.readFieldEnd()
32938 
    iprot.readStructEnd()
32939 
 
32940 
  def write(self, oprot):
32941 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32942 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32943 
      return
32944 
    oprot.writeStructBegin('getHsItem_args')
32945 
    if self.hsItemId is not None:
32946 
      oprot.writeFieldBegin('hsItemId', TType.STRING, 1)
32947 
      oprot.writeString(self.hsItemId)
32948 
      oprot.writeFieldEnd()
32949 
    oprot.writeFieldStop()
32950 
    oprot.writeStructEnd()
32951 
 
32952 
  def validate(self):
32953 
    return
32954 
 
32955 
 
32956 
  def __repr__(self):
32957 
    L = ['%s=%r' % (key, value)
32958 
      for key, value in self.__dict__.iteritems()]
32959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32960 
 
32961 
  def __eq__(self, other):
32962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32963 
 
32964 
  def __ne__(self, other):
32965 
    return not (self == other)
32966 
 
32967 
class getHsItem_result:
32968 
  """
32969 
  Attributes:
32970 
   - success
32971 
  """
32972 
 
32973 
  thrift_spec = (
32974 
    (0, TType.STRUCT, 'success', (HsItem, HsItem.thrift_spec), None, ), # 0
32975 
  )
32976 
 
32977 
  def __init__(self, success=None,):
32978 
    self.success = success
32979 
 
32980 
  def read(self, iprot):
32981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32983 
      return
32984 
    iprot.readStructBegin()
32985 
    while True:
32986 
      (fname, ftype, fid) = iprot.readFieldBegin()
32987 
      if ftype == TType.STOP:
32988 
        break
32989 
      if fid == 0:
32990 
        if ftype == TType.STRUCT:
32991 
          self.success = HsItem()
32992 
          self.success.read(iprot)
32993 
        else:
32994 
          iprot.skip(ftype)
32995 
      else:
32996 
        iprot.skip(ftype)
32997 
      iprot.readFieldEnd()
32998 
    iprot.readStructEnd()
32999 
 
33000 
  def write(self, oprot):
33001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33003 
      return
33004 
    oprot.writeStructBegin('getHsItem_result')
33005 
    if self.success is not None:
33006 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
33007 
      self.success.write(oprot)
33008 
      oprot.writeFieldEnd()
33009 
    oprot.writeFieldStop()
33010 
    oprot.writeStructEnd()
33011 
 
33012 
  def validate(self):
33013 
    return
33014 
 
33015 
 
33016 
  def __repr__(self):
33017 
    L = ['%s=%r' % (key, value)
33018 
      for key, value in self.__dict__.iteritems()]
33019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33020 
 
33021 
  def __eq__(self, other):
33022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33023 
 
33024 
  def __ne__(self, other):
33025 
    return not (self == other)
33026 
 
33027 
class updateHsItem_args:
33028 
  """
33029 
  Attributes:
33030 
   - hsItem
33031 
  """
33032 
 
33033 
  thrift_spec = (
33034 
    None, # 0
33035 
    (1, TType.STRUCT, 'hsItem', (HsItem, HsItem.thrift_spec), None, ), # 1
33036 
  )
33037 
 
33038 
  def __init__(self, hsItem=None,):
33039 
    self.hsItem = hsItem
33040 
 
33041 
  def read(self, iprot):
33042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33044 
      return
33045 
    iprot.readStructBegin()
33046 
    while True:
33047 
      (fname, ftype, fid) = iprot.readFieldBegin()
33048 
      if ftype == TType.STOP:
33049 
        break
33050 
      if fid == 1:
33051 
        if ftype == TType.STRUCT:
33052 
          self.hsItem = HsItem()
33053 
          self.hsItem.read(iprot)
33054 
        else:
33055 
          iprot.skip(ftype)
33056 
      else:
33057 
        iprot.skip(ftype)
33058 
      iprot.readFieldEnd()
33059 
    iprot.readStructEnd()
33060 
 
33061 
  def write(self, oprot):
33062 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33063 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33064 
      return
33065 
    oprot.writeStructBegin('updateHsItem_args')
33066 
    if self.hsItem is not None:
33067 
      oprot.writeFieldBegin('hsItem', TType.STRUCT, 1)
33068 
      self.hsItem.write(oprot)
33069 
      oprot.writeFieldEnd()
33070 
    oprot.writeFieldStop()
33071 
    oprot.writeStructEnd()
33072 
 
33073 
  def validate(self):
33074 
    return
33075 
 
33076 
 
33077 
  def __repr__(self):
33078 
    L = ['%s=%r' % (key, value)
33079 
      for key, value in self.__dict__.iteritems()]
33080 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33081 
 
33082 
  def __eq__(self, other):
33083 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33084 
 
33085 
  def __ne__(self, other):
33086 
    return not (self == other)
33087 
 
33088 
class updateHsItem_result:
33089 
 
33090 
  thrift_spec = (
33091 
  )
33092 
 
33093 
  def read(self, iprot):
33094 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33095 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33096 
      return
33097 
    iprot.readStructBegin()
33098 
    while True:
33099 
      (fname, ftype, fid) = iprot.readFieldBegin()
33100 
      if ftype == TType.STOP:
33101 
        break
33102 
      else:
33103 
        iprot.skip(ftype)
33104 
      iprot.readFieldEnd()
33105 
    iprot.readStructEnd()
33106 
 
33107 
  def write(self, oprot):
33108 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33109 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33110 
      return
33111 
    oprot.writeStructBegin('updateHsItem_result')
33112 
    oprot.writeFieldStop()
33113 
    oprot.writeStructEnd()
33114 
 
33115 
  def validate(self):
33116 
    return
33117 
 
33118 
 
33119 
  def __repr__(self):
33120 
    L = ['%s=%r' % (key, value)
33121 
      for key, value in self.__dict__.iteritems()]
33122 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33123 
 
33124 
  def __eq__(self, other):
33125 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33126 
 
33127 
  def __ne__(self, other):
33128 
    return not (self == other)
14182 kshitij.so 33129 
 
33130 
class getPricingForDtr_args:
33131 
  """
33132 
  Attributes:
33133 
   - catalogItemId
33134 
  """
33135 
 
33136 
  thrift_spec = (
33137 
    None, # 0
33138 
    (1, TType.I64, 'catalogItemId', None, None, ), # 1
33139 
  )
33140 
 
33141 
  def __init__(self, catalogItemId=None,):
33142 
    self.catalogItemId = catalogItemId
33143 
 
33144 
  def read(self, iprot):
33145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33147 
      return
33148 
    iprot.readStructBegin()
33149 
    while True:
33150 
      (fname, ftype, fid) = iprot.readFieldBegin()
33151 
      if ftype == TType.STOP:
33152 
        break
33153 
      if fid == 1:
33154 
        if ftype == TType.I64:
33155 
          self.catalogItemId = iprot.readI64();
33156 
        else:
33157 
          iprot.skip(ftype)
33158 
      else:
33159 
        iprot.skip(ftype)
33160 
      iprot.readFieldEnd()
33161 
    iprot.readStructEnd()
33162 
 
33163 
  def write(self, oprot):
33164 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33165 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33166 
      return
33167 
    oprot.writeStructBegin('getPricingForDtr_args')
33168 
    if self.catalogItemId is not None:
33169 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 1)
33170 
      oprot.writeI64(self.catalogItemId)
33171 
      oprot.writeFieldEnd()
33172 
    oprot.writeFieldStop()
33173 
    oprot.writeStructEnd()
33174 
 
33175 
  def validate(self):
33176 
    return
33177 
 
33178 
 
33179 
  def __repr__(self):
33180 
    L = ['%s=%r' % (key, value)
33181 
      for key, value in self.__dict__.iteritems()]
33182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33183 
 
33184 
  def __eq__(self, other):
33185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33186 
 
33187 
  def __ne__(self, other):
33188 
    return not (self == other)
33189 
 
33190 
class getPricingForDtr_result:
33191 
  """
33192 
  Attributes:
33193 
   - success
33194 
  """
33195 
 
33196 
  thrift_spec = (
33197 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
33198 
  )
33199 
 
33200 
  def __init__(self, success=None,):
33201 
    self.success = success
33202 
 
33203 
  def read(self, iprot):
33204 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33205 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33206 
      return
33207 
    iprot.readStructBegin()
33208 
    while True:
33209 
      (fname, ftype, fid) = iprot.readFieldBegin()
33210 
      if ftype == TType.STOP:
33211 
        break
33212 
      if fid == 0:
33213 
        if ftype == TType.STRUCT:
33214 
          self.success = Item()
33215 
          self.success.read(iprot)
33216 
        else:
33217 
          iprot.skip(ftype)
33218 
      else:
33219 
        iprot.skip(ftype)
33220 
      iprot.readFieldEnd()
33221 
    iprot.readStructEnd()
33222 
 
33223 
  def write(self, oprot):
33224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33226 
      return
33227 
    oprot.writeStructBegin('getPricingForDtr_result')
33228 
    if self.success is not None:
33229 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
33230 
      self.success.write(oprot)
33231 
      oprot.writeFieldEnd()
33232 
    oprot.writeFieldStop()
33233 
    oprot.writeStructEnd()
33234 
 
33235 
  def validate(self):
33236 
    return
33237 
 
33238 
 
33239 
  def __repr__(self):
33240 
    L = ['%s=%r' % (key, value)
33241 
      for key, value in self.__dict__.iteritems()]
33242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33243 
 
33244 
  def __eq__(self, other):
33245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33246 
 
33247 
  def __ne__(self, other):
33248 
    return not (self == other)