Subversion Repositories SmartDukaan

Rev

Rev 18150 | Rev 18719 | 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 
 
15702 kshitij.so 1324 
  def getAllItemstoListOnFbd(self, ):
1325 
    pass
14182 kshitij.so 1326 
 
15706 kshitij.so 1327 
  def getAllFbdListedItems(self, ):
1328 
    pass
15702 kshitij.so 1329 
 
18150 kshitij.so 1330 
  def getBulkPricingForItems(self, itemIds):
1331 
    """
1332 
    Parameters:
1333 
     - itemIds
1334 
    """
1335 
    pass
15706 kshitij.so 1336 
 
18150 kshitij.so 1337 
  def addBulkPricingForItem(self, bulkItemPricing):
1338 
    """
1339 
    Parameters:
1340 
     - bulkItemPricing
1341 
    """
1342 
    pass
1343 
 
1344 
  def deleteBulkPricingForItemById(self, id):
1345 
    """
1346 
    Parameters:
1347 
     - id
1348 
    """
1349 
    pass
1350 
 
1351 
  def deleteBulkPricingForItem(self, item_id):
1352 
    """
1353 
    Parameters:
1354 
     - item_id
1355 
    """
1356 
    pass
1357 
 
1358 
  def getBulkPricingByItemId(self, item_id):
1359 
    """
1360 
    Parameters:
1361 
     - item_id
1362 
    """
1363 
    pass
1364 
 
18602 kshitij.so 1365 
  def updateBulkPricesOnProduction(self, item_id, bulkItemPricingList):
1366 
    """
1367 
    Parameters:
1368 
     - item_id
1369 
     - bulkItemPricingList
1370 
    """
1371 
    pass
18150 kshitij.so 1372 
 
18602 kshitij.so 1373 
 
5944 mandeep.dh 1374 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
1375 
  def __init__(self, iprot, oprot=None):
1376 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
1377 
 
1378 
  def addItem(self, item):
1379 
    """
1380 
    Availability and inventory attributes
1381 
 
1382 
    Parameters:
1383 
     - item
1384 
    """
1385 
    self.send_addItem(item)
1386 
    return self.recv_addItem()
1387 
 
1388 
  def send_addItem(self, item):
1389 
    self._oprot.writeMessageBegin('addItem', TMessageType.CALL, self._seqid)
1390 
    args = addItem_args()
1391 
    args.item = item
1392 
    args.write(self._oprot)
1393 
    self._oprot.writeMessageEnd()
1394 
    self._oprot.trans.flush()
1395 
 
1396 
  def recv_addItem(self, ):
1397 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1398 
    if mtype == TMessageType.EXCEPTION:
1399 
      x = TApplicationException()
1400 
      x.read(self._iprot)
1401 
      self._iprot.readMessageEnd()
1402 
      raise x
1403 
    result = addItem_result()
1404 
    result.read(self._iprot)
1405 
    self._iprot.readMessageEnd()
1406 
    if result.success is not None:
1407 
      return result.success
1408 
    if result.cex is not None:
1409 
      raise result.cex
1410 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItem failed: unknown result");
1411 
 
1412 
  def updateItem(self, item):
1413 
    """
1414 
    Parameters:
1415 
     - item
1416 
    """
1417 
    self.send_updateItem(item)
1418 
    return self.recv_updateItem()
1419 
 
1420 
  def send_updateItem(self, item):
1421 
    self._oprot.writeMessageBegin('updateItem', TMessageType.CALL, self._seqid)
1422 
    args = updateItem_args()
1423 
    args.item = item
1424 
    args.write(self._oprot)
1425 
    self._oprot.writeMessageEnd()
1426 
    self._oprot.trans.flush()
1427 
 
1428 
  def recv_updateItem(self, ):
1429 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1430 
    if mtype == TMessageType.EXCEPTION:
1431 
      x = TApplicationException()
1432 
      x.read(self._iprot)
1433 
      self._iprot.readMessageEnd()
1434 
      raise x
1435 
    result = updateItem_result()
1436 
    result.read(self._iprot)
1437 
    self._iprot.readMessageEnd()
1438 
    if result.success is not None:
1439 
      return result.success
1440 
    if result.cex is not None:
1441 
      raise result.cex
1442 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItem failed: unknown result");
1443 
 
1444 
  def isActive(self, itemId):
1445 
    """
1446 
    Checks if the item given to the corresponding itemId is active. If it's active,
1447 
    whether it's risky and if it's risky, its inventory position.
1448 
 
1449 
    Parameters:
1450 
     - itemId
1451 
    """
1452 
    self.send_isActive(itemId)
1453 
    return self.recv_isActive()
1454 
 
1455 
  def send_isActive(self, itemId):
1456 
    self._oprot.writeMessageBegin('isActive', TMessageType.CALL, self._seqid)
1457 
    args = isActive_args()
1458 
    args.itemId = itemId
1459 
    args.write(self._oprot)
1460 
    self._oprot.writeMessageEnd()
1461 
    self._oprot.trans.flush()
1462 
 
1463 
  def recv_isActive(self, ):
1464 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1465 
    if mtype == TMessageType.EXCEPTION:
1466 
      x = TApplicationException()
1467 
      x.read(self._iprot)
1468 
      self._iprot.readMessageEnd()
1469 
      raise x
1470 
    result = isActive_result()
1471 
    result.read(self._iprot)
1472 
    self._iprot.readMessageEnd()
1473 
    if result.success is not None:
1474 
      return result.success
1475 
    if result.isex is not None:
1476 
      raise result.isex
1477 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isActive failed: unknown result");
1478 
 
7438 amit.gupta 1479 
  def getItemsStatus(self, itemIds):
1480 
    """
1481 
    Parameters:
1482 
     - itemIds
1483 
    """
1484 
    self.send_getItemsStatus(itemIds)
1485 
    return self.recv_getItemsStatus()
1486 
 
1487 
  def send_getItemsStatus(self, itemIds):
1488 
    self._oprot.writeMessageBegin('getItemsStatus', TMessageType.CALL, self._seqid)
1489 
    args = getItemsStatus_args()
1490 
    args.itemIds = itemIds
1491 
    args.write(self._oprot)
1492 
    self._oprot.writeMessageEnd()
1493 
    self._oprot.trans.flush()
1494 
 
1495 
  def recv_getItemsStatus(self, ):
1496 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1497 
    if mtype == TMessageType.EXCEPTION:
1498 
      x = TApplicationException()
1499 
      x.read(self._iprot)
1500 
      self._iprot.readMessageEnd()
1501 
      raise x
1502 
    result = getItemsStatus_result()
1503 
    result.read(self._iprot)
1504 
    self._iprot.readMessageEnd()
1505 
    if result.success is not None:
1506 
      return result.success
1507 
    if result.isex is not None:
1508 
      raise result.isex
1509 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsStatus failed: unknown result");
1510 
 
5944 mandeep.dh 1511 
  def getItemStatusDescription(self, itemId):
1512 
    """
1513 
    Parameters:
1514 
     - itemId
1515 
    """
1516 
    self.send_getItemStatusDescription(itemId)
1517 
    return self.recv_getItemStatusDescription()
1518 
 
1519 
  def send_getItemStatusDescription(self, itemId):
1520 
    self._oprot.writeMessageBegin('getItemStatusDescription', TMessageType.CALL, self._seqid)
1521 
    args = getItemStatusDescription_args()
1522 
    args.itemId = itemId
1523 
    args.write(self._oprot)
1524 
    self._oprot.writeMessageEnd()
1525 
    self._oprot.trans.flush()
1526 
 
1527 
  def recv_getItemStatusDescription(self, ):
1528 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1529 
    if mtype == TMessageType.EXCEPTION:
1530 
      x = TApplicationException()
1531 
      x.read(self._iprot)
1532 
      self._iprot.readMessageEnd()
1533 
      raise x
1534 
    result = getItemStatusDescription_result()
1535 
    result.read(self._iprot)
1536 
    self._iprot.readMessageEnd()
1537 
    if result.success is not None:
1538 
      return result.success
1539 
    if result.isex is not None:
1540 
      raise result.isex
1541 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStatusDescription failed: unknown result");
1542 
 
1543 
  def startItemOn(self, item_id, timestamp):
1544 
    """
1545 
    Parameters:
1546 
     - item_id
1547 
     - timestamp
1548 
    """
1549 
    self.send_startItemOn(item_id, timestamp)
1550 
    self.recv_startItemOn()
1551 
 
1552 
  def send_startItemOn(self, item_id, timestamp):
1553 
    self._oprot.writeMessageBegin('startItemOn', TMessageType.CALL, self._seqid)
1554 
    args = startItemOn_args()
1555 
    args.item_id = item_id
1556 
    args.timestamp = timestamp
1557 
    args.write(self._oprot)
1558 
    self._oprot.writeMessageEnd()
1559 
    self._oprot.trans.flush()
1560 
 
1561 
  def recv_startItemOn(self, ):
1562 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1563 
    if mtype == TMessageType.EXCEPTION:
1564 
      x = TApplicationException()
1565 
      x.read(self._iprot)
1566 
      self._iprot.readMessageEnd()
1567 
      raise x
1568 
    result = startItemOn_result()
1569 
    result.read(self._iprot)
1570 
    self._iprot.readMessageEnd()
1571 
    if result.cex is not None:
1572 
      raise result.cex
1573 
    return
1574 
 
1575 
  def retireItemOn(self, item_id, timestamp):
1576 
    """
1577 
    Parameters:
1578 
     - item_id
1579 
     - timestamp
1580 
    """
1581 
    self.send_retireItemOn(item_id, timestamp)
1582 
    self.recv_retireItemOn()
1583 
 
1584 
  def send_retireItemOn(self, item_id, timestamp):
1585 
    self._oprot.writeMessageBegin('retireItemOn', TMessageType.CALL, self._seqid)
1586 
    args = retireItemOn_args()
1587 
    args.item_id = item_id
1588 
    args.timestamp = timestamp
1589 
    args.write(self._oprot)
1590 
    self._oprot.writeMessageEnd()
1591 
    self._oprot.trans.flush()
1592 
 
1593 
  def recv_retireItemOn(self, ):
1594 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1595 
    if mtype == TMessageType.EXCEPTION:
1596 
      x = TApplicationException()
1597 
      x.read(self._iprot)
1598 
      self._iprot.readMessageEnd()
1599 
      raise x
1600 
    result = retireItemOn_result()
1601 
    result.read(self._iprot)
1602 
    self._iprot.readMessageEnd()
1603 
    if result.cex is not None:
1604 
      raise result.cex
1605 
    return
1606 
 
1607 
  def changeItemStatus(self, item_id, timestamp, newstatus):
1608 
    """
1609 
    Parameters:
1610 
     - item_id
1611 
     - timestamp
1612 
     - newstatus
1613 
    """
1614 
    self.send_changeItemStatus(item_id, timestamp, newstatus)
1615 
    self.recv_changeItemStatus()
1616 
 
1617 
  def send_changeItemStatus(self, item_id, timestamp, newstatus):
1618 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
1619 
    args = changeItemStatus_args()
1620 
    args.item_id = item_id
1621 
    args.timestamp = timestamp
1622 
    args.newstatus = newstatus
1623 
    args.write(self._oprot)
1624 
    self._oprot.writeMessageEnd()
1625 
    self._oprot.trans.flush()
1626 
 
1627 
  def recv_changeItemStatus(self, ):
1628 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1629 
    if mtype == TMessageType.EXCEPTION:
1630 
      x = TApplicationException()
1631 
      x.read(self._iprot)
1632 
      self._iprot.readMessageEnd()
1633 
      raise x
1634 
    result = changeItemStatus_result()
1635 
    result.read(self._iprot)
1636 
    self._iprot.readMessageEnd()
1637 
    if result.cex is not None:
1638 
      raise result.cex
1639 
    return
1640 
 
1641 
  def getItem(self, item_id):
1642 
    """
1643 
    Parameters:
1644 
     - item_id
1645 
    """
1646 
    self.send_getItem(item_id)
1647 
    return self.recv_getItem()
1648 
 
1649 
  def send_getItem(self, item_id):
1650 
    self._oprot.writeMessageBegin('getItem', TMessageType.CALL, self._seqid)
1651 
    args = getItem_args()
1652 
    args.item_id = item_id
1653 
    args.write(self._oprot)
1654 
    self._oprot.writeMessageEnd()
1655 
    self._oprot.trans.flush()
1656 
 
1657 
  def recv_getItem(self, ):
1658 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1659 
    if mtype == TMessageType.EXCEPTION:
1660 
      x = TApplicationException()
1661 
      x.read(self._iprot)
1662 
      self._iprot.readMessageEnd()
1663 
      raise x
1664 
    result = getItem_result()
1665 
    result.read(self._iprot)
1666 
    self._iprot.readMessageEnd()
1667 
    if result.success is not None:
1668 
      return result.success
1669 
    if result.cex is not None:
1670 
      raise result.cex
1671 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItem failed: unknown result");
1672 
 
13493 amit.gupta 1673 
  def getItems(self, item_ids):
1674 
    """
1675 
    Parameters:
1676 
     - item_ids
1677 
    """
1678 
    self.send_getItems(item_ids)
1679 
    return self.recv_getItems()
1680 
 
1681 
  def send_getItems(self, item_ids):
1682 
    self._oprot.writeMessageBegin('getItems', TMessageType.CALL, self._seqid)
1683 
    args = getItems_args()
1684 
    args.item_ids = item_ids
1685 
    args.write(self._oprot)
1686 
    self._oprot.writeMessageEnd()
1687 
    self._oprot.trans.flush()
1688 
 
1689 
  def recv_getItems(self, ):
1690 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1691 
    if mtype == TMessageType.EXCEPTION:
1692 
      x = TApplicationException()
1693 
      x.read(self._iprot)
1694 
      self._iprot.readMessageEnd()
1695 
      raise x
1696 
    result = getItems_result()
1697 
    result.read(self._iprot)
1698 
    self._iprot.readMessageEnd()
1699 
    if result.success is not None:
1700 
      return result.success
1701 
    if result.cex is not None:
1702 
      raise result.cex
1703 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItems failed: unknown result");
1704 
 
5944 mandeep.dh 1705 
  def getItemsByCatalogId(self, catalog_item_id):
1706 
    """
1707 
    Parameters:
1708 
     - catalog_item_id
1709 
    """
1710 
    self.send_getItemsByCatalogId(catalog_item_id)
1711 
    return self.recv_getItemsByCatalogId()
1712 
 
1713 
  def send_getItemsByCatalogId(self, catalog_item_id):
1714 
    self._oprot.writeMessageBegin('getItemsByCatalogId', TMessageType.CALL, self._seqid)
1715 
    args = getItemsByCatalogId_args()
1716 
    args.catalog_item_id = catalog_item_id
1717 
    args.write(self._oprot)
1718 
    self._oprot.writeMessageEnd()
1719 
    self._oprot.trans.flush()
1720 
 
1721 
  def recv_getItemsByCatalogId(self, ):
1722 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1723 
    if mtype == TMessageType.EXCEPTION:
1724 
      x = TApplicationException()
1725 
      x.read(self._iprot)
1726 
      self._iprot.readMessageEnd()
1727 
      raise x
1728 
    result = getItemsByCatalogId_result()
1729 
    result.read(self._iprot)
1730 
    self._iprot.readMessageEnd()
1731 
    if result.success is not None:
1732 
      return result.success
1733 
    if result.cex is not None:
1734 
      raise result.cex
1735 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByCatalogId failed: unknown result");
1736 
 
1737 
  def getValidItemsByCatalogId(self, catalog_item_id):
1738 
    """
1739 
    Parameters:
1740 
     - catalog_item_id
1741 
    """
1742 
    self.send_getValidItemsByCatalogId(catalog_item_id)
1743 
    return self.recv_getValidItemsByCatalogId()
1744 
 
1745 
  def send_getValidItemsByCatalogId(self, catalog_item_id):
1746 
    self._oprot.writeMessageBegin('getValidItemsByCatalogId', TMessageType.CALL, self._seqid)
1747 
    args = getValidItemsByCatalogId_args()
1748 
    args.catalog_item_id = catalog_item_id
1749 
    args.write(self._oprot)
1750 
    self._oprot.writeMessageEnd()
1751 
    self._oprot.trans.flush()
1752 
 
1753 
  def recv_getValidItemsByCatalogId(self, ):
1754 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1755 
    if mtype == TMessageType.EXCEPTION:
1756 
      x = TApplicationException()
1757 
      x.read(self._iprot)
1758 
      self._iprot.readMessageEnd()
1759 
      raise x
1760 
    result = getValidItemsByCatalogId_result()
1761 
    result.read(self._iprot)
1762 
    self._iprot.readMessageEnd()
1763 
    if result.success is not None:
1764 
      return result.success
1765 
    if result.cex is not None:
1766 
      raise result.cex
1767 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidItemsByCatalogId failed: unknown result");
1768 
 
1769 
  def getAllItems(self, isActive):
1770 
    """
1771 
    Parameters:
1772 
     - isActive
1773 
    """
1774 
    self.send_getAllItems(isActive)
1775 
    return self.recv_getAllItems()
1776 
 
1777 
  def send_getAllItems(self, isActive):
1778 
    self._oprot.writeMessageBegin('getAllItems', TMessageType.CALL, self._seqid)
1779 
    args = getAllItems_args()
1780 
    args.isActive = isActive
1781 
    args.write(self._oprot)
1782 
    self._oprot.writeMessageEnd()
1783 
    self._oprot.trans.flush()
1784 
 
1785 
  def recv_getAllItems(self, ):
1786 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1787 
    if mtype == TMessageType.EXCEPTION:
1788 
      x = TApplicationException()
1789 
      x.read(self._iprot)
1790 
      self._iprot.readMessageEnd()
1791 
      raise x
1792 
    result = getAllItems_result()
1793 
    result.read(self._iprot)
1794 
    self._iprot.readMessageEnd()
1795 
    if result.success is not None:
1796 
      return result.success
1797 
    if result.cex is not None:
1798 
      raise result.cex
1799 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItems failed: unknown result");
1800 
 
1801 
  def getAllItemsByStatus(self, itemStatus):
1802 
    """
1803 
    Parameters:
1804 
     - itemStatus
1805 
    """
1806 
    self.send_getAllItemsByStatus(itemStatus)
1807 
    return self.recv_getAllItemsByStatus()
1808 
 
1809 
  def send_getAllItemsByStatus(self, itemStatus):
1810 
    self._oprot.writeMessageBegin('getAllItemsByStatus', TMessageType.CALL, self._seqid)
1811 
    args = getAllItemsByStatus_args()
1812 
    args.itemStatus = itemStatus
1813 
    args.write(self._oprot)
1814 
    self._oprot.writeMessageEnd()
1815 
    self._oprot.trans.flush()
1816 
 
1817 
  def recv_getAllItemsByStatus(self, ):
1818 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1819 
    if mtype == TMessageType.EXCEPTION:
1820 
      x = TApplicationException()
1821 
      x.read(self._iprot)
1822 
      self._iprot.readMessageEnd()
1823 
      raise x
1824 
    result = getAllItemsByStatus_result()
1825 
    result.read(self._iprot)
1826 
    self._iprot.readMessageEnd()
1827 
    if result.success is not None:
1828 
      return result.success
1829 
    if result.cex is not None:
1830 
      raise result.cex
1831 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatus failed: unknown result");
1832 
 
9253 rajveer 1833 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber, isAndroid):
5944 mandeep.dh 1834 
    """
1835 
    Parameters:
1836 
     - entityId
1837 
     - category
1838 
     - brand
1839 
     - modelName
1840 
     - modelNumber
9253 rajveer 1841 
     - isAndroid
5944 mandeep.dh 1842 
    """
9253 rajveer 1843 
    self.send_markItemAsContentComplete(entityId, category, brand, modelName, modelNumber, isAndroid)
5944 mandeep.dh 1844 
    return self.recv_markItemAsContentComplete()
1845 
 
9253 rajveer 1846 
  def send_markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber, isAndroid):
5944 mandeep.dh 1847 
    self._oprot.writeMessageBegin('markItemAsContentComplete', TMessageType.CALL, self._seqid)
1848 
    args = markItemAsContentComplete_args()
1849 
    args.entityId = entityId
1850 
    args.category = category
1851 
    args.brand = brand
1852 
    args.modelName = modelName
1853 
    args.modelNumber = modelNumber
9253 rajveer 1854 
    args.isAndroid = isAndroid
5944 mandeep.dh 1855 
    args.write(self._oprot)
1856 
    self._oprot.writeMessageEnd()
1857 
    self._oprot.trans.flush()
1858 
 
1859 
  def recv_markItemAsContentComplete(self, ):
1860 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1861 
    if mtype == TMessageType.EXCEPTION:
1862 
      x = TApplicationException()
1863 
      x.read(self._iprot)
1864 
      self._iprot.readMessageEnd()
1865 
      raise x
1866 
    result = markItemAsContentComplete_result()
1867 
    result.read(self._iprot)
1868 
    self._iprot.readMessageEnd()
1869 
    if result.success is not None:
1870 
      return result.success
1871 
    if result.cex is not None:
1872 
      raise result.cex
1873 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markItemAsContentComplete failed: unknown result");
1874 
 
12567 amit.gupta 1875 
  def getVatRates(self, itemId, categoryId):
1876 
    """
1877 
    Parameters:
1878 
     - itemId
1879 
     - categoryId
1880 
    """
1881 
    self.send_getVatRates(itemId, categoryId)
1882 
    return self.recv_getVatRates()
1883 
 
1884 
  def send_getVatRates(self, itemId, categoryId):
1885 
    self._oprot.writeMessageBegin('getVatRates', TMessageType.CALL, self._seqid)
1886 
    args = getVatRates_args()
1887 
    args.itemId = itemId
1888 
    args.categoryId = categoryId
1889 
    args.write(self._oprot)
1890 
    self._oprot.writeMessageEnd()
1891 
    self._oprot.trans.flush()
1892 
 
1893 
  def recv_getVatRates(self, ):
1894 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1895 
    if mtype == TMessageType.EXCEPTION:
1896 
      x = TApplicationException()
1897 
      x.read(self._iprot)
1898 
      self._iprot.readMessageEnd()
1899 
      raise x
1900 
    result = getVatRates_result()
1901 
    result.read(self._iprot)
1902 
    self._iprot.readMessageEnd()
1903 
    if result.success is not None:
1904 
      return result.success
1905 
    if result.cex is not None:
1906 
      raise result.cex
1907 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatRates failed: unknown result");
1908 
 
5944 mandeep.dh 1909 
  def getAllItemsInRange(self, offset, limit):
1910 
    """
1911 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
1912 
 
1913 
    Parameters:
1914 
     - offset
1915 
     - limit
1916 
    """
1917 
    self.send_getAllItemsInRange(offset, limit)
1918 
    return self.recv_getAllItemsInRange()
1919 
 
1920 
  def send_getAllItemsInRange(self, offset, limit):
1921 
    self._oprot.writeMessageBegin('getAllItemsInRange', TMessageType.CALL, self._seqid)
1922 
    args = getAllItemsInRange_args()
1923 
    args.offset = offset
1924 
    args.limit = limit
1925 
    args.write(self._oprot)
1926 
    self._oprot.writeMessageEnd()
1927 
    self._oprot.trans.flush()
1928 
 
1929 
  def recv_getAllItemsInRange(self, ):
1930 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1931 
    if mtype == TMessageType.EXCEPTION:
1932 
      x = TApplicationException()
1933 
      x.read(self._iprot)
1934 
      self._iprot.readMessageEnd()
1935 
      raise x
1936 
    result = getAllItemsInRange_result()
1937 
    result.read(self._iprot)
1938 
    self._iprot.readMessageEnd()
1939 
    if result.success is not None:
1940 
      return result.success
1941 
    if result.cex is not None:
1942 
      raise result.cex
1943 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsInRange failed: unknown result");
1944 
 
1945 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1946 
    """
1947 
    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.
1948 
 
1949 
    Parameters:
1950 
     - itemStatus
1951 
     - offset
1952 
     - limit
1953 
    """
1954 
    self.send_getAllItemsByStatusInRange(itemStatus, offset, limit)
1955 
    return self.recv_getAllItemsByStatusInRange()
1956 
 
1957 
  def send_getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1958 
    self._oprot.writeMessageBegin('getAllItemsByStatusInRange', TMessageType.CALL, self._seqid)
1959 
    args = getAllItemsByStatusInRange_args()
1960 
    args.itemStatus = itemStatus
1961 
    args.offset = offset
1962 
    args.limit = limit
1963 
    args.write(self._oprot)
1964 
    self._oprot.writeMessageEnd()
1965 
    self._oprot.trans.flush()
1966 
 
1967 
  def recv_getAllItemsByStatusInRange(self, ):
1968 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1969 
    if mtype == TMessageType.EXCEPTION:
1970 
      x = TApplicationException()
1971 
      x.read(self._iprot)
1972 
      self._iprot.readMessageEnd()
1973 
      raise x
1974 
    result = getAllItemsByStatusInRange_result()
1975 
    result.read(self._iprot)
1976 
    self._iprot.readMessageEnd()
1977 
    if result.success is not None:
1978 
      return result.success
1979 
    if result.cex is not None:
1980 
      raise result.cex
1981 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatusInRange failed: unknown result");
1982 
 
1983 
  def getItemCountByStatus(self, useStatus, itemStatus):
1984 
    """
1985 
    Gets a count of all items by status
1986 
 
1987 
    Parameters:
1988 
     - useStatus
1989 
     - itemStatus
1990 
    """
1991 
    self.send_getItemCountByStatus(useStatus, itemStatus)
1992 
    return self.recv_getItemCountByStatus()
1993 
 
1994 
  def send_getItemCountByStatus(self, useStatus, itemStatus):
1995 
    self._oprot.writeMessageBegin('getItemCountByStatus', TMessageType.CALL, self._seqid)
1996 
    args = getItemCountByStatus_args()
1997 
    args.useStatus = useStatus
1998 
    args.itemStatus = itemStatus
1999 
    args.write(self._oprot)
2000 
    self._oprot.writeMessageEnd()
2001 
    self._oprot.trans.flush()
2002 
 
2003 
  def recv_getItemCountByStatus(self, ):
2004 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2005 
    if mtype == TMessageType.EXCEPTION:
2006 
      x = TApplicationException()
2007 
      x.read(self._iprot)
2008 
      self._iprot.readMessageEnd()
2009 
      raise x
2010 
    result = getItemCountByStatus_result()
2011 
    result.read(self._iprot)
2012 
    self._iprot.readMessageEnd()
2013 
    if result.success is not None:
2014 
      return result.success
2015 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemCountByStatus failed: unknown result");
2016 
 
2017 
  def getBestSellers(self, ):
2018 
    self.send_getBestSellers()
2019 
    return self.recv_getBestSellers()
2020 
 
2021 
  def send_getBestSellers(self, ):
2022 
    self._oprot.writeMessageBegin('getBestSellers', TMessageType.CALL, self._seqid)
2023 
    args = getBestSellers_args()
2024 
    args.write(self._oprot)
2025 
    self._oprot.writeMessageEnd()
2026 
    self._oprot.trans.flush()
2027 
 
2028 
  def recv_getBestSellers(self, ):
2029 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2030 
    if mtype == TMessageType.EXCEPTION:
2031 
      x = TApplicationException()
2032 
      x.read(self._iprot)
2033 
      self._iprot.readMessageEnd()
2034 
      raise x
2035 
    result = getBestSellers_result()
2036 
    result.read(self._iprot)
2037 
    self._iprot.readMessageEnd()
2038 
    if result.success is not None:
2039 
      return result.success
2040 
    if result.isex is not None:
2041 
      raise result.isex
2042 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellers failed: unknown result");
2043 
 
2044 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
2045 
    """
2046 
    Parameters:
2047 
     - beginIndex
2048 
     - totalItems
2049 
     - brand
2050 
     - category
2051 
    """
2052 
    self.send_getBestSellersCatalogIds(beginIndex, totalItems, brand, category)
2053 
    return self.recv_getBestSellersCatalogIds()
2054 
 
2055 
  def send_getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
2056 
    self._oprot.writeMessageBegin('getBestSellersCatalogIds', TMessageType.CALL, self._seqid)
2057 
    args = getBestSellersCatalogIds_args()
2058 
    args.beginIndex = beginIndex
2059 
    args.totalItems = totalItems
2060 
    args.brand = brand
2061 
    args.category = category
2062 
    args.write(self._oprot)
2063 
    self._oprot.writeMessageEnd()
2064 
    self._oprot.trans.flush()
2065 
 
2066 
  def recv_getBestSellersCatalogIds(self, ):
2067 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2068 
    if mtype == TMessageType.EXCEPTION:
2069 
      x = TApplicationException()
2070 
      x.read(self._iprot)
2071 
      self._iprot.readMessageEnd()
2072 
      raise x
2073 
    result = getBestSellersCatalogIds_result()
2074 
    result.read(self._iprot)
2075 
    self._iprot.readMessageEnd()
2076 
    if result.success is not None:
2077 
      return result.success
2078 
    if result.cex is not None:
2079 
      raise result.cex
2080 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCatalogIds failed: unknown result");
2081 
 
2082 
  def getBestSellersCount(self, ):
2083 
    self.send_getBestSellersCount()
2084 
    return self.recv_getBestSellersCount()
2085 
 
2086 
  def send_getBestSellersCount(self, ):
2087 
    self._oprot.writeMessageBegin('getBestSellersCount', TMessageType.CALL, self._seqid)
2088 
    args = getBestSellersCount_args()
2089 
    args.write(self._oprot)
2090 
    self._oprot.writeMessageEnd()
2091 
    self._oprot.trans.flush()
2092 
 
2093 
  def recv_getBestSellersCount(self, ):
2094 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2095 
    if mtype == TMessageType.EXCEPTION:
2096 
      x = TApplicationException()
2097 
      x.read(self._iprot)
2098 
      self._iprot.readMessageEnd()
2099 
      raise x
2100 
    result = getBestSellersCount_result()
2101 
    result.read(self._iprot)
2102 
    self._iprot.readMessageEnd()
2103 
    if result.success is not None:
2104 
      return result.success
2105 
    if result.cex is not None:
2106 
      raise result.cex
2107 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCount failed: unknown result");
2108 
 
2109 
  def getBestDeals(self, ):
2110 
    self.send_getBestDeals()
2111 
    return self.recv_getBestDeals()
2112 
 
2113 
  def send_getBestDeals(self, ):
2114 
    self._oprot.writeMessageBegin('getBestDeals', TMessageType.CALL, self._seqid)
2115 
    args = getBestDeals_args()
2116 
    args.write(self._oprot)
2117 
    self._oprot.writeMessageEnd()
2118 
    self._oprot.trans.flush()
2119 
 
2120 
  def recv_getBestDeals(self, ):
2121 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2122 
    if mtype == TMessageType.EXCEPTION:
2123 
      x = TApplicationException()
2124 
      x.read(self._iprot)
2125 
      self._iprot.readMessageEnd()
2126 
      raise x
2127 
    result = getBestDeals_result()
2128 
    result.read(self._iprot)
2129 
    self._iprot.readMessageEnd()
2130 
    if result.success is not None:
2131 
      return result.success
2132 
    if result.isex is not None:
2133 
      raise result.isex
2134 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDeals failed: unknown result");
2135 
 
2136 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
2137 
    """
2138 
    Parameters:
2139 
     - beginIndex
2140 
     - totalItems
2141 
     - brand
2142 
     - category
2143 
    """
2144 
    self.send_getBestDealsCatalogIds(beginIndex, totalItems, brand, category)
2145 
    return self.recv_getBestDealsCatalogIds()
2146 
 
2147 
  def send_getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
2148 
    self._oprot.writeMessageBegin('getBestDealsCatalogIds', TMessageType.CALL, self._seqid)
2149 
    args = getBestDealsCatalogIds_args()
2150 
    args.beginIndex = beginIndex
2151 
    args.totalItems = totalItems
2152 
    args.brand = brand
2153 
    args.category = category
2154 
    args.write(self._oprot)
2155 
    self._oprot.writeMessageEnd()
2156 
    self._oprot.trans.flush()
2157 
 
2158 
  def recv_getBestDealsCatalogIds(self, ):
2159 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2160 
    if mtype == TMessageType.EXCEPTION:
2161 
      x = TApplicationException()
2162 
      x.read(self._iprot)
2163 
      self._iprot.readMessageEnd()
2164 
      raise x
2165 
    result = getBestDealsCatalogIds_result()
2166 
    result.read(self._iprot)
2167 
    self._iprot.readMessageEnd()
2168 
    if result.success is not None:
2169 
      return result.success
2170 
    if result.cex is not None:
2171 
      raise result.cex
2172 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCatalogIds failed: unknown result");
2173 
 
2174 
  def getBestDealsCount(self, ):
2175 
    self.send_getBestDealsCount()
2176 
    return self.recv_getBestDealsCount()
2177 
 
2178 
  def send_getBestDealsCount(self, ):
2179 
    self._oprot.writeMessageBegin('getBestDealsCount', TMessageType.CALL, self._seqid)
2180 
    args = getBestDealsCount_args()
2181 
    args.write(self._oprot)
2182 
    self._oprot.writeMessageEnd()
2183 
    self._oprot.trans.flush()
2184 
 
2185 
  def recv_getBestDealsCount(self, ):
2186 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2187 
    if mtype == TMessageType.EXCEPTION:
2188 
      x = TApplicationException()
2189 
      x.read(self._iprot)
2190 
      self._iprot.readMessageEnd()
2191 
      raise x
2192 
    result = getBestDealsCount_result()
2193 
    result.read(self._iprot)
2194 
    self._iprot.readMessageEnd()
2195 
    if result.success is not None:
2196 
      return result.success
2197 
    if result.cex is not None:
2198 
      raise result.cex
2199 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCount failed: unknown result");
2200 
 
2201 
  def getComingSoon(self, ):
2202 
    self.send_getComingSoon()
2203 
    return self.recv_getComingSoon()
2204 
 
2205 
  def send_getComingSoon(self, ):
2206 
    self._oprot.writeMessageBegin('getComingSoon', TMessageType.CALL, self._seqid)
2207 
    args = getComingSoon_args()
2208 
    args.write(self._oprot)
2209 
    self._oprot.writeMessageEnd()
2210 
    self._oprot.trans.flush()
2211 
 
2212 
  def recv_getComingSoon(self, ):
2213 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2214 
    if mtype == TMessageType.EXCEPTION:
2215 
      x = TApplicationException()
2216 
      x.read(self._iprot)
2217 
      self._iprot.readMessageEnd()
2218 
      raise x
2219 
    result = getComingSoon_result()
2220 
    result.read(self._iprot)
2221 
    self._iprot.readMessageEnd()
2222 
    if result.success is not None:
2223 
      return result.success
2224 
    if result.isex is not None:
2225 
      raise result.isex
2226 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoon failed: unknown result");
2227 
 
2228 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
2229 
    """
2230 
    Parameters:
2231 
     - beginIndex
2232 
     - totalItems
2233 
     - brand
2234 
     - category
2235 
    """
2236 
    self.send_getComingSoonCatalogIds(beginIndex, totalItems, brand, category)
2237 
    return self.recv_getComingSoonCatalogIds()
2238 
 
2239 
  def send_getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
2240 
    self._oprot.writeMessageBegin('getComingSoonCatalogIds', TMessageType.CALL, self._seqid)
2241 
    args = getComingSoonCatalogIds_args()
2242 
    args.beginIndex = beginIndex
2243 
    args.totalItems = totalItems
2244 
    args.brand = brand
2245 
    args.category = category
2246 
    args.write(self._oprot)
2247 
    self._oprot.writeMessageEnd()
2248 
    self._oprot.trans.flush()
2249 
 
2250 
  def recv_getComingSoonCatalogIds(self, ):
2251 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2252 
    if mtype == TMessageType.EXCEPTION:
2253 
      x = TApplicationException()
2254 
      x.read(self._iprot)
2255 
      self._iprot.readMessageEnd()
2256 
      raise x
2257 
    result = getComingSoonCatalogIds_result()
2258 
    result.read(self._iprot)
2259 
    self._iprot.readMessageEnd()
2260 
    if result.success is not None:
2261 
      return result.success
2262 
    if result.cex is not None:
2263 
      raise result.cex
2264 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCatalogIds failed: unknown result");
2265 
 
2266 
  def getComingSoonCount(self, ):
2267 
    self.send_getComingSoonCount()
2268 
    return self.recv_getComingSoonCount()
2269 
 
2270 
  def send_getComingSoonCount(self, ):
2271 
    self._oprot.writeMessageBegin('getComingSoonCount', TMessageType.CALL, self._seqid)
2272 
    args = getComingSoonCount_args()
2273 
    args.write(self._oprot)
2274 
    self._oprot.writeMessageEnd()
2275 
    self._oprot.trans.flush()
2276 
 
2277 
  def recv_getComingSoonCount(self, ):
2278 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2279 
    if mtype == TMessageType.EXCEPTION:
2280 
      x = TApplicationException()
2281 
      x.read(self._iprot)
2282 
      self._iprot.readMessageEnd()
2283 
      raise x
2284 
    result = getComingSoonCount_result()
2285 
    result.read(self._iprot)
2286 
    self._iprot.readMessageEnd()
2287 
    if result.success is not None:
2288 
      return result.success
2289 
    if result.cex is not None:
2290 
      raise result.cex
2291 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCount failed: unknown result");
2292 
 
2293 
  def getLatestArrivals(self, ):
2294 
    """
2295 
    Returns a list of items sorted in the descending order by start date.
2296 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
2297 
    """
2298 
    self.send_getLatestArrivals()
2299 
    return self.recv_getLatestArrivals()
2300 
 
2301 
  def send_getLatestArrivals(self, ):
2302 
    self._oprot.writeMessageBegin('getLatestArrivals', TMessageType.CALL, self._seqid)
2303 
    args = getLatestArrivals_args()
2304 
    args.write(self._oprot)
2305 
    self._oprot.writeMessageEnd()
2306 
    self._oprot.trans.flush()
2307 
 
2308 
  def recv_getLatestArrivals(self, ):
2309 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2310 
    if mtype == TMessageType.EXCEPTION:
2311 
      x = TApplicationException()
2312 
      x.read(self._iprot)
2313 
      self._iprot.readMessageEnd()
2314 
      raise x
2315 
    result = getLatestArrivals_result()
2316 
    result.read(self._iprot)
2317 
    self._iprot.readMessageEnd()
2318 
    if result.success is not None:
2319 
      return result.success
2320 
    if result.isex is not None:
2321 
      raise result.isex
2322 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivals failed: unknown result");
2323 
 
2324 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
2325 
    """
2326 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
2327 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
2328 
 
2329 
    Parameters:
2330 
     - beginIndex
2331 
     - totalItems
2332 
     - brand
2333 
     - categories
2334 
    """
2335 
    self.send_getLatestArrivalsCatalogIds(beginIndex, totalItems, brand, categories)
2336 
    return self.recv_getLatestArrivalsCatalogIds()
2337 
 
2338 
  def send_getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
2339 
    self._oprot.writeMessageBegin('getLatestArrivalsCatalogIds', TMessageType.CALL, self._seqid)
2340 
    args = getLatestArrivalsCatalogIds_args()
2341 
    args.beginIndex = beginIndex
2342 
    args.totalItems = totalItems
2343 
    args.brand = brand
2344 
    args.categories = categories
2345 
    args.write(self._oprot)
2346 
    self._oprot.writeMessageEnd()
2347 
    self._oprot.trans.flush()
2348 
 
2349 
  def recv_getLatestArrivalsCatalogIds(self, ):
2350 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2351 
    if mtype == TMessageType.EXCEPTION:
2352 
      x = TApplicationException()
2353 
      x.read(self._iprot)
2354 
      self._iprot.readMessageEnd()
2355 
      raise x
2356 
    result = getLatestArrivalsCatalogIds_result()
2357 
    result.read(self._iprot)
2358 
    self._iprot.readMessageEnd()
2359 
    if result.success is not None:
2360 
      return result.success
2361 
    if result.cex is not None:
2362 
      raise result.cex
2363 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCatalogIds failed: unknown result");
2364 
 
2365 
  def getLatestArrivalsCount(self, ):
2366 
    """
2367 
    Get the total number of latest arrivals we are willing to show.
2368 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
2369 
    """
2370 
    self.send_getLatestArrivalsCount()
2371 
    return self.recv_getLatestArrivalsCount()
2372 
 
2373 
  def send_getLatestArrivalsCount(self, ):
2374 
    self._oprot.writeMessageBegin('getLatestArrivalsCount', TMessageType.CALL, self._seqid)
2375 
    args = getLatestArrivalsCount_args()
2376 
    args.write(self._oprot)
2377 
    self._oprot.writeMessageEnd()
2378 
    self._oprot.trans.flush()
2379 
 
2380 
  def recv_getLatestArrivalsCount(self, ):
2381 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2382 
    if mtype == TMessageType.EXCEPTION:
2383 
      x = TApplicationException()
2384 
      x.read(self._iprot)
2385 
      self._iprot.readMessageEnd()
2386 
      raise x
2387 
    result = getLatestArrivalsCount_result()
2388 
    result.read(self._iprot)
2389 
    self._iprot.readMessageEnd()
2390 
    if result.success is not None:
2391 
      return result.success
2392 
    if result.cex is not None:
2393 
      raise result.cex
2394 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCount failed: unknown result");
2395 
 
2396 
  def generateNewEntityID(self, ):
2397 
    self.send_generateNewEntityID()
2398 
    return self.recv_generateNewEntityID()
2399 
 
2400 
  def send_generateNewEntityID(self, ):
2401 
    self._oprot.writeMessageBegin('generateNewEntityID', TMessageType.CALL, self._seqid)
2402 
    args = generateNewEntityID_args()
2403 
    args.write(self._oprot)
2404 
    self._oprot.writeMessageEnd()
2405 
    self._oprot.trans.flush()
2406 
 
2407 
  def recv_generateNewEntityID(self, ):
2408 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2409 
    if mtype == TMessageType.EXCEPTION:
2410 
      x = TApplicationException()
2411 
      x.read(self._iprot)
2412 
      self._iprot.readMessageEnd()
2413 
      raise x
2414 
    result = generateNewEntityID_result()
2415 
    result.read(self._iprot)
2416 
    self._iprot.readMessageEnd()
2417 
    if result.success is not None:
2418 
      return result.success
2419 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateNewEntityID failed: unknown result");
2420 
 
2421 
  def addCategory(self, category):
2422 
    """
2423 
    All category related functions
2424 
 
2425 
    Parameters:
2426 
     - category
2427 
    """
2428 
    self.send_addCategory(category)
2429 
    return self.recv_addCategory()
2430 
 
2431 
  def send_addCategory(self, category):
2432 
    self._oprot.writeMessageBegin('addCategory', TMessageType.CALL, self._seqid)
2433 
    args = addCategory_args()
2434 
    args.category = category
2435 
    args.write(self._oprot)
2436 
    self._oprot.writeMessageEnd()
2437 
    self._oprot.trans.flush()
2438 
 
2439 
  def recv_addCategory(self, ):
2440 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2441 
    if mtype == TMessageType.EXCEPTION:
2442 
      x = TApplicationException()
2443 
      x.read(self._iprot)
2444 
      self._iprot.readMessageEnd()
2445 
      raise x
2446 
    result = addCategory_result()
2447 
    result.read(self._iprot)
2448 
    self._iprot.readMessageEnd()
2449 
    if result.success is not None:
2450 
      return result.success
2451 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addCategory failed: unknown result");
2452 
 
2453 
  def getCategory(self, id):
2454 
    """
2455 
    Parameters:
2456 
     - id
2457 
    """
2458 
    self.send_getCategory(id)
2459 
    return self.recv_getCategory()
2460 
 
2461 
  def send_getCategory(self, id):
2462 
    self._oprot.writeMessageBegin('getCategory', TMessageType.CALL, self._seqid)
2463 
    args = getCategory_args()
2464 
    args.id = id
2465 
    args.write(self._oprot)
2466 
    self._oprot.writeMessageEnd()
2467 
    self._oprot.trans.flush()
2468 
 
2469 
  def recv_getCategory(self, ):
2470 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2471 
    if mtype == TMessageType.EXCEPTION:
2472 
      x = TApplicationException()
2473 
      x.read(self._iprot)
2474 
      self._iprot.readMessageEnd()
2475 
      raise x
2476 
    result = getCategory_result()
2477 
    result.read(self._iprot)
2478 
    self._iprot.readMessageEnd()
2479 
    if result.success is not None:
2480 
      return result.success
2481 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCategory failed: unknown result");
2482 
 
2483 
  def getAllCategories(self, ):
2484 
    self.send_getAllCategories()
2485 
    return self.recv_getAllCategories()
2486 
 
2487 
  def send_getAllCategories(self, ):
2488 
    self._oprot.writeMessageBegin('getAllCategories', TMessageType.CALL, self._seqid)
2489 
    args = getAllCategories_args()
2490 
    args.write(self._oprot)
2491 
    self._oprot.writeMessageEnd()
2492 
    self._oprot.trans.flush()
2493 
 
2494 
  def recv_getAllCategories(self, ):
2495 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2496 
    if mtype == TMessageType.EXCEPTION:
2497 
      x = TApplicationException()
2498 
      x.read(self._iprot)
2499 
      self._iprot.readMessageEnd()
2500 
      raise x
2501 
    result = getAllCategories_result()
2502 
    result.read(self._iprot)
2503 
    self._iprot.readMessageEnd()
2504 
    if result.success is not None:
2505 
      return result.success
2506 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCategories failed: unknown result");
2507 
 
2508 
  def getAllSimilarItems(self, itemId):
2509 
    """
2510 
    Returns the list of similar items.
2511 
 
2512 
    Parameters:
2513 
     - itemId
2514 
    """
2515 
    self.send_getAllSimilarItems(itemId)
2516 
    return self.recv_getAllSimilarItems()
2517 
 
2518 
  def send_getAllSimilarItems(self, itemId):
2519 
    self._oprot.writeMessageBegin('getAllSimilarItems', TMessageType.CALL, self._seqid)
2520 
    args = getAllSimilarItems_args()
2521 
    args.itemId = itemId
2522 
    args.write(self._oprot)
2523 
    self._oprot.writeMessageEnd()
2524 
    self._oprot.trans.flush()
2525 
 
2526 
  def recv_getAllSimilarItems(self, ):
2527 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2528 
    if mtype == TMessageType.EXCEPTION:
2529 
      x = TApplicationException()
2530 
      x.read(self._iprot)
2531 
      self._iprot.readMessageEnd()
2532 
      raise x
2533 
    result = getAllSimilarItems_result()
2534 
    result.read(self._iprot)
2535 
    self._iprot.readMessageEnd()
2536 
    if result.success is not None:
2537 
      return result.success
2538 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSimilarItems failed: unknown result");
2539 
 
2540 
  def addSimilarItem(self, itemId, catalogItemId):
2541 
    """
2542 
    Adds similar item.
2543 
 
2544 
    Parameters:
2545 
     - itemId
2546 
     - catalogItemId
2547 
    """
2548 
    self.send_addSimilarItem(itemId, catalogItemId)
2549 
    return self.recv_addSimilarItem()
2550 
 
2551 
  def send_addSimilarItem(self, itemId, catalogItemId):
2552 
    self._oprot.writeMessageBegin('addSimilarItem', TMessageType.CALL, self._seqid)
2553 
    args = addSimilarItem_args()
2554 
    args.itemId = itemId
2555 
    args.catalogItemId = catalogItemId
2556 
    args.write(self._oprot)
2557 
    self._oprot.writeMessageEnd()
2558 
    self._oprot.trans.flush()
2559 
 
2560 
  def recv_addSimilarItem(self, ):
2561 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2562 
    if mtype == TMessageType.EXCEPTION:
2563 
      x = TApplicationException()
2564 
      x.read(self._iprot)
2565 
      self._iprot.readMessageEnd()
2566 
      raise x
2567 
    result = addSimilarItem_result()
2568 
    result.read(self._iprot)
2569 
    self._iprot.readMessageEnd()
2570 
    if result.success is not None:
2571 
      return result.success
2572 
    if result.cex is not None:
2573 
      raise result.cex
2574 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSimilarItem failed: unknown result");
2575 
 
6512 kshitij.so 2576 
  def addTag(self, displayName, itemId):
2577 
    """
2578 
    Tag Related
2579 
 
2580 
    Parameters:
2581 
     - displayName
2582 
     - itemId
2583 
    """
2584 
    self.send_addTag(displayName, itemId)
2585 
    return self.recv_addTag()
2586 
 
2587 
  def send_addTag(self, displayName, itemId):
2588 
    self._oprot.writeMessageBegin('addTag', TMessageType.CALL, self._seqid)
2589 
    args = addTag_args()
2590 
    args.displayName = displayName
2591 
    args.itemId = itemId
2592 
    args.write(self._oprot)
2593 
    self._oprot.writeMessageEnd()
2594 
    self._oprot.trans.flush()
2595 
 
2596 
  def recv_addTag(self, ):
2597 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2598 
    if mtype == TMessageType.EXCEPTION:
2599 
      x = TApplicationException()
2600 
      x.read(self._iprot)
2601 
      self._iprot.readMessageEnd()
2602 
      raise x
2603 
    result = addTag_result()
2604 
    result.read(self._iprot)
2605 
    self._iprot.readMessageEnd()
2606 
    if result.success is not None:
2607 
      return result.success
2608 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTag failed: unknown result");
2609 
 
2610 
  def deleteEntityTag(self, displayName, itemId):
2611 
    """
2612 
    Parameters:
2613 
     - displayName
2614 
     - itemId
2615 
    """
2616 
    self.send_deleteEntityTag(displayName, itemId)
2617 
    return self.recv_deleteEntityTag()
2618 
 
2619 
  def send_deleteEntityTag(self, displayName, itemId):
2620 
    self._oprot.writeMessageBegin('deleteEntityTag', TMessageType.CALL, self._seqid)
2621 
    args = deleteEntityTag_args()
2622 
    args.displayName = displayName
2623 
    args.itemId = itemId
2624 
    args.write(self._oprot)
2625 
    self._oprot.writeMessageEnd()
2626 
    self._oprot.trans.flush()
2627 
 
2628 
  def recv_deleteEntityTag(self, ):
2629 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2630 
    if mtype == TMessageType.EXCEPTION:
2631 
      x = TApplicationException()
2632 
      x.read(self._iprot)
2633 
      self._iprot.readMessageEnd()
2634 
      raise x
2635 
    result = deleteEntityTag_result()
2636 
    result.read(self._iprot)
2637 
    self._iprot.readMessageEnd()
2638 
    if result.success is not None:
2639 
      return result.success
2640 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteEntityTag failed: unknown result");
2641 
 
2642 
  def deleteTag(self, displayName):
2643 
    """
2644 
    Parameters:
2645 
     - displayName
2646 
    """
2647 
    self.send_deleteTag(displayName)
2648 
    return self.recv_deleteTag()
2649 
 
2650 
  def send_deleteTag(self, displayName):
2651 
    self._oprot.writeMessageBegin('deleteTag', TMessageType.CALL, self._seqid)
2652 
    args = deleteTag_args()
2653 
    args.displayName = displayName
2654 
    args.write(self._oprot)
2655 
    self._oprot.writeMessageEnd()
2656 
    self._oprot.trans.flush()
2657 
 
2658 
  def recv_deleteTag(self, ):
2659 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2660 
    if mtype == TMessageType.EXCEPTION:
2661 
      x = TApplicationException()
2662 
      x.read(self._iprot)
2663 
      self._iprot.readMessageEnd()
2664 
      raise x
2665 
    result = deleteTag_result()
2666 
    result.read(self._iprot)
2667 
    self._iprot.readMessageEnd()
2668 
    if result.success is not None:
2669 
      return result.success
2670 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteTag failed: unknown result");
2671 
 
2672 
  def getAllTags(self, ):
2673 
    self.send_getAllTags()
2674 
    return self.recv_getAllTags()
2675 
 
2676 
  def send_getAllTags(self, ):
2677 
    self._oprot.writeMessageBegin('getAllTags', TMessageType.CALL, self._seqid)
2678 
    args = getAllTags_args()
2679 
    args.write(self._oprot)
2680 
    self._oprot.writeMessageEnd()
2681 
    self._oprot.trans.flush()
2682 
 
2683 
  def recv_getAllTags(self, ):
2684 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2685 
    if mtype == TMessageType.EXCEPTION:
2686 
      x = TApplicationException()
2687 
      x.read(self._iprot)
2688 
      self._iprot.readMessageEnd()
2689 
      raise x
2690 
    result = getAllTags_result()
2691 
    result.read(self._iprot)
2692 
    self._iprot.readMessageEnd()
2693 
    if result.success is not None:
2694 
      return result.success
2695 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllTags failed: unknown result");
2696 
 
2697 
  def getAllEntitiesByTagName(self, displayName):
2698 
    """
2699 
    Parameters:
2700 
     - displayName
2701 
    """
2702 
    self.send_getAllEntitiesByTagName(displayName)
2703 
    return self.recv_getAllEntitiesByTagName()
2704 
 
2705 
  def send_getAllEntitiesByTagName(self, displayName):
2706 
    self._oprot.writeMessageBegin('getAllEntitiesByTagName', TMessageType.CALL, self._seqid)
2707 
    args = getAllEntitiesByTagName_args()
2708 
    args.displayName = displayName
2709 
    args.write(self._oprot)
2710 
    self._oprot.writeMessageEnd()
2711 
    self._oprot.trans.flush()
2712 
 
2713 
  def recv_getAllEntitiesByTagName(self, ):
2714 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2715 
    if mtype == TMessageType.EXCEPTION:
2716 
      x = TApplicationException()
2717 
      x.read(self._iprot)
2718 
      self._iprot.readMessageEnd()
2719 
      raise x
2720 
    result = getAllEntitiesByTagName_result()
2721 
    result.read(self._iprot)
2722 
    self._iprot.readMessageEnd()
2723 
    if result.success is not None:
2724 
      return result.success
2725 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntitiesByTagName failed: unknown result");
2726 
 
6845 amit.gupta 2727 
  def getAllEntityTags(self, ):
2728 
    self.send_getAllEntityTags()
2729 
    return self.recv_getAllEntityTags()
2730 
 
2731 
  def send_getAllEntityTags(self, ):
2732 
    self._oprot.writeMessageBegin('getAllEntityTags', TMessageType.CALL, self._seqid)
2733 
    args = getAllEntityTags_args()
2734 
    args.write(self._oprot)
2735 
    self._oprot.writeMessageEnd()
2736 
    self._oprot.trans.flush()
2737 
 
2738 
  def recv_getAllEntityTags(self, ):
2739 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2740 
    if mtype == TMessageType.EXCEPTION:
2741 
      x = TApplicationException()
2742 
      x.read(self._iprot)
2743 
      self._iprot.readMessageEnd()
2744 
      raise x
2745 
    result = getAllEntityTags_result()
2746 
    result.read(self._iprot)
2747 
    self._iprot.readMessageEnd()
2748 
    if result.success is not None:
2749 
      return result.success
2750 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntityTags failed: unknown result");
2751 
 
8590 kshitij.so 2752 
  def addBanner(self, bannerCongregate):
6850 kshitij.so 2753 
    """
8579 kshitij.so 2754 
    Banner Related
2755 
 
6850 kshitij.so 2756 
    Parameters:
8590 kshitij.so 2757 
     - bannerCongregate
6850 kshitij.so 2758 
    """
8590 kshitij.so 2759 
    self.send_addBanner(bannerCongregate)
10097 kshitij.so 2760 
    return self.recv_addBanner()
6850 kshitij.so 2761 
 
8590 kshitij.so 2762 
  def send_addBanner(self, bannerCongregate):
6850 kshitij.so 2763 
    self._oprot.writeMessageBegin('addBanner', TMessageType.CALL, self._seqid)
2764 
    args = addBanner_args()
8590 kshitij.so 2765 
    args.bannerCongregate = bannerCongregate
6850 kshitij.so 2766 
    args.write(self._oprot)
2767 
    self._oprot.writeMessageEnd()
2768 
    self._oprot.trans.flush()
2769 
 
2770 
  def recv_addBanner(self, ):
2771 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2772 
    if mtype == TMessageType.EXCEPTION:
2773 
      x = TApplicationException()
2774 
      x.read(self._iprot)
2775 
      self._iprot.readMessageEnd()
2776 
      raise x
2777 
    result = addBanner_result()
2778 
    result.read(self._iprot)
2779 
    self._iprot.readMessageEnd()
10097 kshitij.so 2780 
    if result.success is not None:
2781 
      return result.success
2782 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBanner failed: unknown result");
6850 kshitij.so 2783 
 
8579 kshitij.so 2784 
  def updateBanner(self, banner):
2785 
    """
2786 
    Parameters:
2787 
     - banner
2788 
    """
2789 
    self.send_updateBanner(banner)
2790 
    return self.recv_updateBanner()
2791 
 
2792 
  def send_updateBanner(self, banner):
2793 
    self._oprot.writeMessageBegin('updateBanner', TMessageType.CALL, self._seqid)
2794 
    args = updateBanner_args()
2795 
    args.banner = banner
2796 
    args.write(self._oprot)
2797 
    self._oprot.writeMessageEnd()
2798 
    self._oprot.trans.flush()
2799 
 
2800 
  def recv_updateBanner(self, ):
2801 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2802 
    if mtype == TMessageType.EXCEPTION:
2803 
      x = TApplicationException()
2804 
      x.read(self._iprot)
2805 
      self._iprot.readMessageEnd()
2806 
      raise x
2807 
    result = updateBanner_result()
2808 
    result.read(self._iprot)
2809 
    self._iprot.readMessageEnd()
2810 
    if result.success is not None:
2811 
      return result.success
2812 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBanner failed: unknown result");
2813 
 
6850 kshitij.so 2814 
  def getAllBanners(self, ):
2815 
    self.send_getAllBanners()
2816 
    return self.recv_getAllBanners()
2817 
 
2818 
  def send_getAllBanners(self, ):
2819 
    self._oprot.writeMessageBegin('getAllBanners', TMessageType.CALL, self._seqid)
2820 
    args = getAllBanners_args()
2821 
    args.write(self._oprot)
2822 
    self._oprot.writeMessageEnd()
2823 
    self._oprot.trans.flush()
2824 
 
2825 
  def recv_getAllBanners(self, ):
2826 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2827 
    if mtype == TMessageType.EXCEPTION:
2828 
      x = TApplicationException()
2829 
      x.read(self._iprot)
2830 
      self._iprot.readMessageEnd()
2831 
      raise x
2832 
    result = getAllBanners_result()
2833 
    result.read(self._iprot)
2834 
    self._iprot.readMessageEnd()
2835 
    if result.success is not None:
2836 
      return result.success
2837 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBanners failed: unknown result");
2838 
 
9155 kshitij.so 2839 
  def deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 2840 
    """
2841 
    Parameters:
2842 
     - bannerName
9155 kshitij.so 2843 
     - bannerType
6850 kshitij.so 2844 
    """
9155 kshitij.so 2845 
    self.send_deleteBanner(bannerName, bannerType)
6850 kshitij.so 2846 
    return self.recv_deleteBanner()
2847 
 
9155 kshitij.so 2848 
  def send_deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 2849 
    self._oprot.writeMessageBegin('deleteBanner', TMessageType.CALL, self._seqid)
2850 
    args = deleteBanner_args()
2851 
    args.bannerName = bannerName
9155 kshitij.so 2852 
    args.bannerType = bannerType
6850 kshitij.so 2853 
    args.write(self._oprot)
2854 
    self._oprot.writeMessageEnd()
2855 
    self._oprot.trans.flush()
2856 
 
2857 
  def recv_deleteBanner(self, ):
2858 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2859 
    if mtype == TMessageType.EXCEPTION:
2860 
      x = TApplicationException()
2861 
      x.read(self._iprot)
2862 
      self._iprot.readMessageEnd()
2863 
      raise x
2864 
    result = deleteBanner_result()
2865 
    result.read(self._iprot)
2866 
    self._iprot.readMessageEnd()
2867 
    if result.success is not None:
2868 
      return result.success
2869 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBanner failed: unknown result");
2870 
 
9155 kshitij.so 2871 
  def getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 2872 
    """
2873 
    Parameters:
2874 
     - bannerName
9155 kshitij.so 2875 
     - bannerType
6850 kshitij.so 2876 
    """
9155 kshitij.so 2877 
    self.send_getBannerDetails(bannerName, bannerType)
6850 kshitij.so 2878 
    return self.recv_getBannerDetails()
2879 
 
9155 kshitij.so 2880 
  def send_getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 2881 
    self._oprot.writeMessageBegin('getBannerDetails', TMessageType.CALL, self._seqid)
2882 
    args = getBannerDetails_args()
2883 
    args.bannerName = bannerName
9155 kshitij.so 2884 
    args.bannerType = bannerType
6850 kshitij.so 2885 
    args.write(self._oprot)
2886 
    self._oprot.writeMessageEnd()
2887 
    self._oprot.trans.flush()
2888 
 
2889 
  def recv_getBannerDetails(self, ):
2890 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2891 
    if mtype == TMessageType.EXCEPTION:
2892 
      x = TApplicationException()
2893 
      x.read(self._iprot)
2894 
      self._iprot.readMessageEnd()
2895 
      raise x
2896 
    result = getBannerDetails_result()
2897 
    result.read(self._iprot)
2898 
    self._iprot.readMessageEnd()
2899 
    if result.success is not None:
2900 
      return result.success
2901 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerDetails failed: unknown result");
2902 
 
2903 
  def getActiveBanners(self, ):
2904 
    self.send_getActiveBanners()
2905 
    return self.recv_getActiveBanners()
2906 
 
2907 
  def send_getActiveBanners(self, ):
2908 
    self._oprot.writeMessageBegin('getActiveBanners', TMessageType.CALL, self._seqid)
2909 
    args = getActiveBanners_args()
2910 
    args.write(self._oprot)
2911 
    self._oprot.writeMessageEnd()
2912 
    self._oprot.trans.flush()
2913 
 
2914 
  def recv_getActiveBanners(self, ):
2915 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2916 
    if mtype == TMessageType.EXCEPTION:
2917 
      x = TApplicationException()
2918 
      x.read(self._iprot)
2919 
      self._iprot.readMessageEnd()
2920 
      raise x
2921 
    result = getActiveBanners_result()
2922 
    result.read(self._iprot)
2923 
    self._iprot.readMessageEnd()
2924 
    if result.success is not None:
2925 
      return result.success
2926 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBanners failed: unknown result");
2927 
 
8579 kshitij.so 2928 
  def addBannerMap(self, bannerMaps):
6849 kshitij.so 2929 
    """
2930 
    Parameters:
8579 kshitij.so 2931 
     - bannerMaps
6849 kshitij.so 2932 
    """
8579 kshitij.so 2933 
    self.send_addBannerMap(bannerMaps)
6849 kshitij.so 2934 
    return self.recv_addBannerMap()
2935 
 
8579 kshitij.so 2936 
  def send_addBannerMap(self, bannerMaps):
6849 kshitij.so 2937 
    self._oprot.writeMessageBegin('addBannerMap', TMessageType.CALL, self._seqid)
2938 
    args = addBannerMap_args()
8579 kshitij.so 2939 
    args.bannerMaps = bannerMaps
6849 kshitij.so 2940 
    args.write(self._oprot)
2941 
    self._oprot.writeMessageEnd()
2942 
    self._oprot.trans.flush()
2943 
 
2944 
  def recv_addBannerMap(self, ):
2945 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2946 
    if mtype == TMessageType.EXCEPTION:
2947 
      x = TApplicationException()
2948 
      x.read(self._iprot)
2949 
      self._iprot.readMessageEnd()
2950 
      raise x
2951 
    result = addBannerMap_result()
2952 
    result.read(self._iprot)
2953 
    self._iprot.readMessageEnd()
2954 
    if result.success is not None:
2955 
      return result.success
2956 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBannerMap failed: unknown result");
2957 
 
8579 kshitij.so 2958 
  def updateBannerMap(self, bannerMap):
2959 
    """
2960 
    Parameters:
2961 
     - bannerMap
2962 
    """
2963 
    self.send_updateBannerMap(bannerMap)
2964 
    return self.recv_updateBannerMap()
2965 
 
2966 
  def send_updateBannerMap(self, bannerMap):
2967 
    self._oprot.writeMessageBegin('updateBannerMap', TMessageType.CALL, self._seqid)
2968 
    args = updateBannerMap_args()
2969 
    args.bannerMap = bannerMap
2970 
    args.write(self._oprot)
2971 
    self._oprot.writeMessageEnd()
2972 
    self._oprot.trans.flush()
2973 
 
2974 
  def recv_updateBannerMap(self, ):
2975 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2976 
    if mtype == TMessageType.EXCEPTION:
2977 
      x = TApplicationException()
2978 
      x.read(self._iprot)
2979 
      self._iprot.readMessageEnd()
2980 
      raise x
2981 
    result = updateBannerMap_result()
2982 
    result.read(self._iprot)
2983 
    self._iprot.readMessageEnd()
2984 
    if result.success is not None:
2985 
      return result.success
2986 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBannerMap failed: unknown result");
2987 
 
6849 kshitij.so 2988 
  def deleteBannerMap(self, bannerName):
2989 
    """
2990 
    Parameters:
2991 
     - bannerName
2992 
    """
2993 
    self.send_deleteBannerMap(bannerName)
2994 
    return self.recv_deleteBannerMap()
2995 
 
2996 
  def send_deleteBannerMap(self, bannerName):
2997 
    self._oprot.writeMessageBegin('deleteBannerMap', TMessageType.CALL, self._seqid)
2998 
    args = deleteBannerMap_args()
2999 
    args.bannerName = bannerName
3000 
    args.write(self._oprot)
3001 
    self._oprot.writeMessageEnd()
3002 
    self._oprot.trans.flush()
3003 
 
3004 
  def recv_deleteBannerMap(self, ):
3005 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3006 
    if mtype == TMessageType.EXCEPTION:
3007 
      x = TApplicationException()
3008 
      x.read(self._iprot)
3009 
      self._iprot.readMessageEnd()
3010 
      raise x
3011 
    result = deleteBannerMap_result()
3012 
    result.read(self._iprot)
3013 
    self._iprot.readMessageEnd()
3014 
    if result.success is not None:
3015 
      return result.success
3016 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBannerMap failed: unknown result");
3017 
 
9155 kshitij.so 3018 
  def getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 3019 
    """
3020 
    Parameters:
3021 
     - bannerName
9155 kshitij.so 3022 
     - bannerType
6849 kshitij.so 3023 
    """
9155 kshitij.so 3024 
    self.send_getBannerMapDetails(bannerName, bannerType)
6849 kshitij.so 3025 
    return self.recv_getBannerMapDetails()
3026 
 
9155 kshitij.so 3027 
  def send_getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 3028 
    self._oprot.writeMessageBegin('getBannerMapDetails', TMessageType.CALL, self._seqid)
3029 
    args = getBannerMapDetails_args()
3030 
    args.bannerName = bannerName
9155 kshitij.so 3031 
    args.bannerType = bannerType
6849 kshitij.so 3032 
    args.write(self._oprot)
3033 
    self._oprot.writeMessageEnd()
3034 
    self._oprot.trans.flush()
3035 
 
3036 
  def recv_getBannerMapDetails(self, ):
3037 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3038 
    if mtype == TMessageType.EXCEPTION:
3039 
      x = TApplicationException()
3040 
      x.read(self._iprot)
3041 
      self._iprot.readMessageEnd()
3042 
      raise x
3043 
    result = getBannerMapDetails_result()
3044 
    result.read(self._iprot)
3045 
    self._iprot.readMessageEnd()
3046 
    if result.success is not None:
3047 
      return result.success
3048 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerMapDetails failed: unknown result");
3049 
 
8579 kshitij.so 3050 
  def addBannerUri(self, bannerUriMappings):
3051 
    """
3052 
    Parameters:
3053 
     - bannerUriMappings
3054 
    """
3055 
    self.send_addBannerUri(bannerUriMappings)
3056 
    self.recv_addBannerUri()
3057 
 
3058 
  def send_addBannerUri(self, bannerUriMappings):
3059 
    self._oprot.writeMessageBegin('addBannerUri', TMessageType.CALL, self._seqid)
3060 
    args = addBannerUri_args()
3061 
    args.bannerUriMappings = bannerUriMappings
3062 
    args.write(self._oprot)
3063 
    self._oprot.writeMessageEnd()
3064 
    self._oprot.trans.flush()
3065 
 
3066 
  def recv_addBannerUri(self, ):
3067 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3068 
    if mtype == TMessageType.EXCEPTION:
3069 
      x = TApplicationException()
3070 
      x.read(self._iprot)
3071 
      self._iprot.readMessageEnd()
3072 
      raise x
3073 
    result = addBannerUri_result()
3074 
    result.read(self._iprot)
3075 
    self._iprot.readMessageEnd()
3076 
    return
3077 
 
9155 kshitij.so 3078 
  def getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 3079 
    """
3080 
    Parameters:
3081 
     - bannerName
9155 kshitij.so 3082 
     - bannerType
8579 kshitij.so 3083 
    """
9155 kshitij.so 3084 
    self.send_getUriMapping(bannerName, bannerType)
8579 kshitij.so 3085 
    return self.recv_getUriMapping()
3086 
 
9155 kshitij.so 3087 
  def send_getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 3088 
    self._oprot.writeMessageBegin('getUriMapping', TMessageType.CALL, self._seqid)
3089 
    args = getUriMapping_args()
3090 
    args.bannerName = bannerName
9155 kshitij.so 3091 
    args.bannerType = bannerType
8579 kshitij.so 3092 
    args.write(self._oprot)
3093 
    self._oprot.writeMessageEnd()
3094 
    self._oprot.trans.flush()
3095 
 
3096 
  def recv_getUriMapping(self, ):
3097 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3098 
    if mtype == TMessageType.EXCEPTION:
3099 
      x = TApplicationException()
3100 
      x.read(self._iprot)
3101 
      self._iprot.readMessageEnd()
3102 
      raise x
3103 
    result = getUriMapping_result()
3104 
    result.read(self._iprot)
3105 
    self._iprot.readMessageEnd()
3106 
    if result.success is not None:
3107 
      return result.success
3108 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUriMapping failed: unknown result");
3109 
 
3110 
  def addCampaign(self, campaign):
3111 
    """
3112 
    Parameters:
3113 
     - campaign
3114 
    """
3115 
    self.send_addCampaign(campaign)
3116 
    self.recv_addCampaign()
3117 
 
3118 
  def send_addCampaign(self, campaign):
3119 
    self._oprot.writeMessageBegin('addCampaign', TMessageType.CALL, self._seqid)
3120 
    args = addCampaign_args()
3121 
    args.campaign = campaign
3122 
    args.write(self._oprot)
3123 
    self._oprot.writeMessageEnd()
3124 
    self._oprot.trans.flush()
3125 
 
3126 
  def recv_addCampaign(self, ):
3127 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3128 
    if mtype == TMessageType.EXCEPTION:
3129 
      x = TApplicationException()
3130 
      x.read(self._iprot)
3131 
      self._iprot.readMessageEnd()
3132 
      raise x
3133 
    result = addCampaign_result()
3134 
    result.read(self._iprot)
3135 
    self._iprot.readMessageEnd()
3136 
    return
3137 
 
3138 
  def getCampaigns(self, campaignName):
3139 
    """
3140 
    Parameters:
3141 
     - campaignName
3142 
    """
3143 
    self.send_getCampaigns(campaignName)
3144 
    return self.recv_getCampaigns()
3145 
 
3146 
  def send_getCampaigns(self, campaignName):
3147 
    self._oprot.writeMessageBegin('getCampaigns', TMessageType.CALL, self._seqid)
3148 
    args = getCampaigns_args()
3149 
    args.campaignName = campaignName
3150 
    args.write(self._oprot)
3151 
    self._oprot.writeMessageEnd()
3152 
    self._oprot.trans.flush()
3153 
 
3154 
  def recv_getCampaigns(self, ):
3155 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3156 
    if mtype == TMessageType.EXCEPTION:
3157 
      x = TApplicationException()
3158 
      x.read(self._iprot)
3159 
      self._iprot.readMessageEnd()
3160 
      raise x
3161 
    result = getCampaigns_result()
3162 
    result.read(self._iprot)
3163 
    self._iprot.readMessageEnd()
3164 
    if result.success is not None:
3165 
      return result.success
3166 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCampaigns failed: unknown result");
3167 
 
3168 
  def deleteCampaign(self, campaignId):
3169 
    """
3170 
    Parameters:
3171 
     - campaignId
3172 
    """
3173 
    self.send_deleteCampaign(campaignId)
3174 
    self.recv_deleteCampaign()
3175 
 
3176 
  def send_deleteCampaign(self, campaignId):
3177 
    self._oprot.writeMessageBegin('deleteCampaign', TMessageType.CALL, self._seqid)
3178 
    args = deleteCampaign_args()
3179 
    args.campaignId = campaignId
3180 
    args.write(self._oprot)
3181 
    self._oprot.writeMessageEnd()
3182 
    self._oprot.trans.flush()
3183 
 
3184 
  def recv_deleteCampaign(self, ):
3185 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3186 
    if mtype == TMessageType.EXCEPTION:
3187 
      x = TApplicationException()
3188 
      x.read(self._iprot)
3189 
      self._iprot.readMessageEnd()
3190 
      raise x
3191 
    result = deleteCampaign_result()
3192 
    result.read(self._iprot)
3193 
    self._iprot.readMessageEnd()
3194 
    return
3195 
 
3196 
  def getAllCampaigns(self, ):
3197 
    self.send_getAllCampaigns()
3198 
    return self.recv_getAllCampaigns()
3199 
 
3200 
  def send_getAllCampaigns(self, ):
3201 
    self._oprot.writeMessageBegin('getAllCampaigns', TMessageType.CALL, self._seqid)
3202 
    args = getAllCampaigns_args()
3203 
    args.write(self._oprot)
3204 
    self._oprot.writeMessageEnd()
3205 
    self._oprot.trans.flush()
3206 
 
3207 
  def recv_getAllCampaigns(self, ):
3208 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3209 
    if mtype == TMessageType.EXCEPTION:
3210 
      x = TApplicationException()
3211 
      x.read(self._iprot)
3212 
      self._iprot.readMessageEnd()
3213 
      raise x
3214 
    result = getAllCampaigns_result()
3215 
    result.read(self._iprot)
3216 
    self._iprot.readMessageEnd()
3217 
    if result.success is not None:
3218 
      return result.success
3219 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCampaigns failed: unknown result");
3220 
 
9155 kshitij.so 3221 
  def getActiveBannersForMobileSite(self, ):
3222 
    self.send_getActiveBannersForMobileSite()
3223 
    return self.recv_getActiveBannersForMobileSite()
3224 
 
3225 
  def send_getActiveBannersForMobileSite(self, ):
3226 
    self._oprot.writeMessageBegin('getActiveBannersForMobileSite', TMessageType.CALL, self._seqid)
3227 
    args = getActiveBannersForMobileSite_args()
3228 
    args.write(self._oprot)
3229 
    self._oprot.writeMessageEnd()
3230 
    self._oprot.trans.flush()
3231 
 
3232 
  def recv_getActiveBannersForMobileSite(self, ):
3233 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3234 
    if mtype == TMessageType.EXCEPTION:
3235 
      x = TApplicationException()
3236 
      x.read(self._iprot)
3237 
      self._iprot.readMessageEnd()
3238 
      raise x
3239 
    result = getActiveBannersForMobileSite_result()
3240 
    result.read(self._iprot)
3241 
    self._iprot.readMessageEnd()
3242 
    if result.success is not None:
3243 
      return result.success
3244 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBannersForMobileSite failed: unknown result");
3245 
 
5944 mandeep.dh 3246 
  def deleteSimilarItem(self, itemId, catalogItemId):
3247 
    """
3248 
    Delete similar item.
3249 
 
3250 
    Parameters:
3251 
     - itemId
3252 
     - catalogItemId
3253 
    """
3254 
    self.send_deleteSimilarItem(itemId, catalogItemId)
3255 
    return self.recv_deleteSimilarItem()
3256 
 
3257 
  def send_deleteSimilarItem(self, itemId, catalogItemId):
3258 
    self._oprot.writeMessageBegin('deleteSimilarItem', TMessageType.CALL, self._seqid)
3259 
    args = deleteSimilarItem_args()
3260 
    args.itemId = itemId
3261 
    args.catalogItemId = catalogItemId
3262 
    args.write(self._oprot)
3263 
    self._oprot.writeMessageEnd()
3264 
    self._oprot.trans.flush()
3265 
 
3266 
  def recv_deleteSimilarItem(self, ):
3267 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3268 
    if mtype == TMessageType.EXCEPTION:
3269 
      x = TApplicationException()
3270 
      x.read(self._iprot)
3271 
      self._iprot.readMessageEnd()
3272 
      raise x
3273 
    result = deleteSimilarItem_result()
3274 
    result.read(self._iprot)
3275 
    self._iprot.readMessageEnd()
3276 
    if result.success is not None:
3277 
      return result.success
3278 
    if result.cex is not None:
3279 
      raise result.cex
3280 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteSimilarItem failed: unknown result");
3281 
 
3282 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
3283 
    """
3284 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
3285 
    If yes, returns the itemId else returns 0
3286 
 
3287 
    Parameters:
3288 
     - brand
3289 
     - modelNumber
3290 
     - modelName
3291 
     - color
3292 
    """
3293 
    self.send_checkSimilarItem(brand, modelNumber, modelName, color)
3294 
    return self.recv_checkSimilarItem()
3295 
 
3296 
  def send_checkSimilarItem(self, brand, modelNumber, modelName, color):
3297 
    self._oprot.writeMessageBegin('checkSimilarItem', TMessageType.CALL, self._seqid)
3298 
    args = checkSimilarItem_args()
3299 
    args.brand = brand
3300 
    args.modelNumber = modelNumber
3301 
    args.modelName = modelName
3302 
    args.color = color
3303 
    args.write(self._oprot)
3304 
    self._oprot.writeMessageEnd()
3305 
    self._oprot.trans.flush()
3306 
 
3307 
  def recv_checkSimilarItem(self, ):
3308 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3309 
    if mtype == TMessageType.EXCEPTION:
3310 
      x = TApplicationException()
3311 
      x.read(self._iprot)
3312 
      self._iprot.readMessageEnd()
3313 
      raise x
3314 
    result = checkSimilarItem_result()
3315 
    result.read(self._iprot)
3316 
    self._iprot.readMessageEnd()
3317 
    if result.success is not None:
3318 
      return result.success
3319 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkSimilarItem failed: unknown result");
3320 
 
3321 
  def validateRiskyStatus(self, itemId):
3322 
    """
3323 
    Check wether item is risky and change status if inventory is not available for risky items
3324 
 
3325 
    Parameters:
3326 
     - itemId
3327 
    """
3328 
    self.send_validateRiskyStatus(itemId)
3329 
    self.recv_validateRiskyStatus()
3330 
 
3331 
  def send_validateRiskyStatus(self, itemId):
3332 
    self._oprot.writeMessageBegin('validateRiskyStatus', TMessageType.CALL, self._seqid)
3333 
    args = validateRiskyStatus_args()
3334 
    args.itemId = itemId
3335 
    args.write(self._oprot)
3336 
    self._oprot.writeMessageEnd()
3337 
    self._oprot.trans.flush()
3338 
 
3339 
  def recv_validateRiskyStatus(self, ):
3340 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3341 
    if mtype == TMessageType.EXCEPTION:
3342 
      x = TApplicationException()
3343 
      x.read(self._iprot)
3344 
      self._iprot.readMessageEnd()
3345 
      raise x
3346 
    result = validateRiskyStatus_result()
3347 
    result.read(self._iprot)
3348 
    self._iprot.readMessageEnd()
3349 
    return
3350 
 
3351 
  def changeItemRiskyFlag(self, itemId, risky):
3352 
    """
3353 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
3354 
 
3355 
    Parameters:
3356 
     - itemId
3357 
     - risky
3358 
    """
3359 
    self.send_changeItemRiskyFlag(itemId, risky)
3360 
    self.recv_changeItemRiskyFlag()
3361 
 
3362 
  def send_changeItemRiskyFlag(self, itemId, risky):
3363 
    self._oprot.writeMessageBegin('changeItemRiskyFlag', TMessageType.CALL, self._seqid)
3364 
    args = changeItemRiskyFlag_args()
3365 
    args.itemId = itemId
3366 
    args.risky = risky
3367 
    args.write(self._oprot)
3368 
    self._oprot.writeMessageEnd()
3369 
    self._oprot.trans.flush()
3370 
 
3371 
  def recv_changeItemRiskyFlag(self, ):
3372 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3373 
    if mtype == TMessageType.EXCEPTION:
3374 
      x = TApplicationException()
3375 
      x.read(self._iprot)
3376 
      self._iprot.readMessageEnd()
3377 
      raise x
3378 
    result = changeItemRiskyFlag_result()
3379 
    result.read(self._iprot)
3380 
    self._iprot.readMessageEnd()
3381 
    return
3382 
 
3383 
  def getItemsByRiskyFlag(self, ):
3384 
    """
3385 
    Returns list of items marked as risky.
3386 
    """
3387 
    self.send_getItemsByRiskyFlag()
3388 
    return self.recv_getItemsByRiskyFlag()
3389 
 
3390 
  def send_getItemsByRiskyFlag(self, ):
3391 
    self._oprot.writeMessageBegin('getItemsByRiskyFlag', TMessageType.CALL, self._seqid)
3392 
    args = getItemsByRiskyFlag_args()
3393 
    args.write(self._oprot)
3394 
    self._oprot.writeMessageEnd()
3395 
    self._oprot.trans.flush()
3396 
 
3397 
  def recv_getItemsByRiskyFlag(self, ):
3398 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3399 
    if mtype == TMessageType.EXCEPTION:
3400 
      x = TApplicationException()
3401 
      x.read(self._iprot)
3402 
      self._iprot.readMessageEnd()
3403 
      raise x
3404 
    result = getItemsByRiskyFlag_result()
3405 
    result.read(self._iprot)
3406 
    self._iprot.readMessageEnd()
3407 
    if result.success is not None:
3408 
      return result.success
3409 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByRiskyFlag failed: unknown result");
3410 
 
3411 
  def getItemsForMasterSheet(self, category, brand):
3412 
    """
3413 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
3414 
 
3415 
    Parameters:
3416 
     - category
3417 
     - brand
3418 
    """
3419 
    self.send_getItemsForMasterSheet(category, brand)
3420 
    return self.recv_getItemsForMasterSheet()
3421 
 
3422 
  def send_getItemsForMasterSheet(self, category, brand):
3423 
    self._oprot.writeMessageBegin('getItemsForMasterSheet', TMessageType.CALL, self._seqid)
3424 
    args = getItemsForMasterSheet_args()
3425 
    args.category = category
3426 
    args.brand = brand
3427 
    args.write(self._oprot)
3428 
    self._oprot.writeMessageEnd()
3429 
    self._oprot.trans.flush()
3430 
 
3431 
  def recv_getItemsForMasterSheet(self, ):
3432 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3433 
    if mtype == TMessageType.EXCEPTION:
3434 
      x = TApplicationException()
3435 
      x.read(self._iprot)
3436 
      self._iprot.readMessageEnd()
3437 
      raise x
3438 
    result = getItemsForMasterSheet_result()
3439 
    result.read(self._iprot)
3440 
    self._iprot.readMessageEnd()
3441 
    if result.success is not None:
3442 
      return result.success
3443 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsForMasterSheet failed: unknown result");
3444 
 
3445 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
3446 
    """
3447 
    Returns list of catalog ids of items with same similarity index as of the given itemId
3448 
 
3449 
    Parameters:
3450 
     - beginIndex
3451 
     - totalItems
3452 
     - itemId
3453 
    """
3454 
    self.send_getSimilarItemsCatalogIds(beginIndex, totalItems, itemId)
3455 
    return self.recv_getSimilarItemsCatalogIds()
3456 
 
3457 
  def send_getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
3458 
    self._oprot.writeMessageBegin('getSimilarItemsCatalogIds', TMessageType.CALL, self._seqid)
3459 
    args = getSimilarItemsCatalogIds_args()
3460 
    args.beginIndex = beginIndex
3461 
    args.totalItems = totalItems
3462 
    args.itemId = itemId
3463 
    args.write(self._oprot)
3464 
    self._oprot.writeMessageEnd()
3465 
    self._oprot.trans.flush()
3466 
 
3467 
  def recv_getSimilarItemsCatalogIds(self, ):
3468 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3469 
    if mtype == TMessageType.EXCEPTION:
3470 
      x = TApplicationException()
3471 
      x.read(self._iprot)
3472 
      self._iprot.readMessageEnd()
3473 
      raise x
3474 
    result = getSimilarItemsCatalogIds_result()
3475 
    result.read(self._iprot)
3476 
    self._iprot.readMessageEnd()
3477 
    if result.success is not None:
3478 
      return result.success
3479 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSimilarItemsCatalogIds failed: unknown result");
3480 
 
3481 
  def addProductNotification(self, itemId, email):
3482 
    """
3483 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
3484 
 
3485 
    Parameters:
3486 
     - itemId
3487 
     - email
3488 
    """
3489 
    self.send_addProductNotification(itemId, email)
3490 
    return self.recv_addProductNotification()
3491 
 
3492 
  def send_addProductNotification(self, itemId, email):
3493 
    self._oprot.writeMessageBegin('addProductNotification', TMessageType.CALL, self._seqid)
3494 
    args = addProductNotification_args()
3495 
    args.itemId = itemId
3496 
    args.email = email
3497 
    args.write(self._oprot)
3498 
    self._oprot.writeMessageEnd()
3499 
    self._oprot.trans.flush()
3500 
 
3501 
  def recv_addProductNotification(self, ):
3502 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3503 
    if mtype == TMessageType.EXCEPTION:
3504 
      x = TApplicationException()
3505 
      x.read(self._iprot)
3506 
      self._iprot.readMessageEnd()
3507 
      raise x
3508 
    result = addProductNotification_result()
3509 
    result.read(self._iprot)
3510 
    self._iprot.readMessageEnd()
3511 
    if result.success is not None:
3512 
      return result.success
3513 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductNotification failed: unknown result");
3514 
 
3515 
  def sendProductNotifications(self, ):
3516 
    """
3517 
    Send the product notifications to the users for items which has stock.
3518 
    """
3519 
    self.send_sendProductNotifications()
3520 
    return self.recv_sendProductNotifications()
3521 
 
3522 
  def send_sendProductNotifications(self, ):
3523 
    self._oprot.writeMessageBegin('sendProductNotifications', TMessageType.CALL, self._seqid)
3524 
    args = sendProductNotifications_args()
3525 
    args.write(self._oprot)
3526 
    self._oprot.writeMessageEnd()
3527 
    self._oprot.trans.flush()
3528 
 
3529 
  def recv_sendProductNotifications(self, ):
3530 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3531 
    if mtype == TMessageType.EXCEPTION:
3532 
      x = TApplicationException()
3533 
      x.read(self._iprot)
3534 
      self._iprot.readMessageEnd()
3535 
      raise x
3536 
    result = sendProductNotifications_result()
3537 
    result.read(self._iprot)
3538 
    self._iprot.readMessageEnd()
3539 
    if result.success is not None:
3540 
      return result.success
3541 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendProductNotifications failed: unknown result");
3542 
 
3543 
  def getAllBrandsByCategory(self, categoryId):
3544 
    """
3545 
    Returns list of brand names for a given category Id
3546 
 
3547 
    Parameters:
3548 
     - categoryId
3549 
    """
3550 
    self.send_getAllBrandsByCategory(categoryId)
3551 
    return self.recv_getAllBrandsByCategory()
3552 
 
3553 
  def send_getAllBrandsByCategory(self, categoryId):
3554 
    self._oprot.writeMessageBegin('getAllBrandsByCategory', TMessageType.CALL, self._seqid)
3555 
    args = getAllBrandsByCategory_args()
3556 
    args.categoryId = categoryId
3557 
    args.write(self._oprot)
3558 
    self._oprot.writeMessageEnd()
3559 
    self._oprot.trans.flush()
3560 
 
3561 
  def recv_getAllBrandsByCategory(self, ):
3562 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3563 
    if mtype == TMessageType.EXCEPTION:
3564 
      x = TApplicationException()
3565 
      x.read(self._iprot)
3566 
      self._iprot.readMessageEnd()
3567 
      raise x
3568 
    result = getAllBrandsByCategory_result()
3569 
    result.read(self._iprot)
3570 
    self._iprot.readMessageEnd()
3571 
    if result.success is not None:
3572 
      return result.success
3573 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrandsByCategory failed: unknown result");
3574 
 
3575 
  def getAllBrands(self, ):
3576 
    """
3577 
    Returns list of brand names
3578 
    """
3579 
    self.send_getAllBrands()
3580 
    return self.recv_getAllBrands()
3581 
 
3582 
  def send_getAllBrands(self, ):
3583 
    self._oprot.writeMessageBegin('getAllBrands', TMessageType.CALL, self._seqid)
3584 
    args = getAllBrands_args()
3585 
    args.write(self._oprot)
3586 
    self._oprot.writeMessageEnd()
3587 
    self._oprot.trans.flush()
3588 
 
3589 
  def recv_getAllBrands(self, ):
3590 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3591 
    if mtype == TMessageType.EXCEPTION:
3592 
      x = TApplicationException()
3593 
      x.read(self._iprot)
3594 
      self._iprot.readMessageEnd()
3595 
      raise x
3596 
    result = getAllBrands_result()
3597 
    result.read(self._iprot)
3598 
    self._iprot.readMessageEnd()
3599 
    if result.success is not None:
3600 
      return result.success
3601 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrands failed: unknown result");
3602 
 
3603 
  def getAllSources(self, ):
3604 
    """
3605 
    Return list of all sources
3606 
    """
3607 
    self.send_getAllSources()
3608 
    return self.recv_getAllSources()
3609 
 
3610 
  def send_getAllSources(self, ):
3611 
    self._oprot.writeMessageBegin('getAllSources', TMessageType.CALL, self._seqid)
3612 
    args = getAllSources_args()
3613 
    args.write(self._oprot)
3614 
    self._oprot.writeMessageEnd()
3615 
    self._oprot.trans.flush()
3616 
 
3617 
  def recv_getAllSources(self, ):
3618 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3619 
    if mtype == TMessageType.EXCEPTION:
3620 
      x = TApplicationException()
3621 
      x.read(self._iprot)
3622 
      self._iprot.readMessageEnd()
3623 
      raise x
3624 
    result = getAllSources_result()
3625 
    result.read(self._iprot)
3626 
    self._iprot.readMessageEnd()
3627 
    if result.success is not None:
3628 
      return result.success
3629 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSources failed: unknown result");
3630 
 
3631 
  def getItemPricingBySource(self, itemId, sourceId):
3632 
    """
3633 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
3634 
 
3635 
    Parameters:
3636 
     - itemId
3637 
     - sourceId
3638 
    """
3639 
    self.send_getItemPricingBySource(itemId, sourceId)
3640 
    return self.recv_getItemPricingBySource()
3641 
 
3642 
  def send_getItemPricingBySource(self, itemId, sourceId):
3643 
    self._oprot.writeMessageBegin('getItemPricingBySource', TMessageType.CALL, self._seqid)
3644 
    args = getItemPricingBySource_args()
3645 
    args.itemId = itemId
3646 
    args.sourceId = sourceId
3647 
    args.write(self._oprot)
3648 
    self._oprot.writeMessageEnd()
3649 
    self._oprot.trans.flush()
3650 
 
3651 
  def recv_getItemPricingBySource(self, ):
3652 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3653 
    if mtype == TMessageType.EXCEPTION:
3654 
      x = TApplicationException()
3655 
      x.read(self._iprot)
3656 
      self._iprot.readMessageEnd()
3657 
      raise x
3658 
    result = getItemPricingBySource_result()
3659 
    result.read(self._iprot)
3660 
    self._iprot.readMessageEnd()
3661 
    if result.success is not None:
3662 
      return result.success
3663 
    if result.cex is not None:
3664 
      raise result.cex
3665 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricingBySource failed: unknown result");
3666 
 
3667 
  def addSourceItemPricing(self, sourceItemPricing):
3668 
    """
3669 
    Adds prices to be displayed corresponding to the item if user comes from a source.
3670 
    If item is not found or source is not found, it will throw exception.
3671 
 
3672 
    Parameters:
3673 
     - sourceItemPricing
3674 
    """
3675 
    self.send_addSourceItemPricing(sourceItemPricing)
3676 
    self.recv_addSourceItemPricing()
3677 
 
3678 
  def send_addSourceItemPricing(self, sourceItemPricing):
3679 
    self._oprot.writeMessageBegin('addSourceItemPricing', TMessageType.CALL, self._seqid)
3680 
    args = addSourceItemPricing_args()
3681 
    args.sourceItemPricing = sourceItemPricing
3682 
    args.write(self._oprot)
3683 
    self._oprot.writeMessageEnd()
3684 
    self._oprot.trans.flush()
3685 
 
3686 
  def recv_addSourceItemPricing(self, ):
3687 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3688 
    if mtype == TMessageType.EXCEPTION:
3689 
      x = TApplicationException()
3690 
      x.read(self._iprot)
3691 
      self._iprot.readMessageEnd()
3692 
      raise x
3693 
    result = addSourceItemPricing_result()
3694 
    result.read(self._iprot)
3695 
    self._iprot.readMessageEnd()
3696 
    if result.cex is not None:
3697 
      raise result.cex
3698 
    return
3699 
 
3700 
  def getAllSourcePricing(self, itemId):
3701 
    """
3702 
    Returns the list of source pricing information of an item.
3703 
    Raises an exception if item not found corresponding to itemId
3704 
 
3705 
    Parameters:
3706 
     - itemId
3707 
    """
3708 
    self.send_getAllSourcePricing(itemId)
3709 
    return self.recv_getAllSourcePricing()
3710 
 
3711 
  def send_getAllSourcePricing(self, itemId):
3712 
    self._oprot.writeMessageBegin('getAllSourcePricing', TMessageType.CALL, self._seqid)
3713 
    args = getAllSourcePricing_args()
3714 
    args.itemId = itemId
3715 
    args.write(self._oprot)
3716 
    self._oprot.writeMessageEnd()
3717 
    self._oprot.trans.flush()
3718 
 
3719 
  def recv_getAllSourcePricing(self, ):
3720 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3721 
    if mtype == TMessageType.EXCEPTION:
3722 
      x = TApplicationException()
3723 
      x.read(self._iprot)
3724 
      self._iprot.readMessageEnd()
3725 
      raise x
3726 
    result = getAllSourcePricing_result()
3727 
    result.read(self._iprot)
3728 
    self._iprot.readMessageEnd()
3729 
    if result.success is not None:
3730 
      return result.success
3731 
    if result.cex is not None:
3732 
      raise result.cex
3733 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSourcePricing failed: unknown result");
3734 
 
3735 
  def getItemForSource(self, item_id, sourceId):
3736 
    """
3737 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
3738 
 
3739 
    Parameters:
3740 
     - item_id
3741 
     - sourceId
3742 
    """
3743 
    self.send_getItemForSource(item_id, sourceId)
3744 
    return self.recv_getItemForSource()
3745 
 
3746 
  def send_getItemForSource(self, item_id, sourceId):
3747 
    self._oprot.writeMessageBegin('getItemForSource', TMessageType.CALL, self._seqid)
3748 
    args = getItemForSource_args()
3749 
    args.item_id = item_id
3750 
    args.sourceId = sourceId
3751 
    args.write(self._oprot)
3752 
    self._oprot.writeMessageEnd()
3753 
    self._oprot.trans.flush()
3754 
 
3755 
  def recv_getItemForSource(self, ):
3756 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3757 
    if mtype == TMessageType.EXCEPTION:
3758 
      x = TApplicationException()
3759 
      x.read(self._iprot)
3760 
      self._iprot.readMessageEnd()
3761 
      raise x
3762 
    result = getItemForSource_result()
3763 
    result.read(self._iprot)
3764 
    self._iprot.readMessageEnd()
3765 
    if result.success is not None:
3766 
      return result.success
3767 
    if result.cex is not None:
3768 
      raise result.cex
3769 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemForSource failed: unknown result");
3770 
 
3771 
  def searchItemsInRange(self, searchTerms, offset, limit):
3772 
    """
3773 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
3774 
 
3775 
    Parameters:
3776 
     - searchTerms
3777 
     - offset
3778 
     - limit
3779 
    """
3780 
    self.send_searchItemsInRange(searchTerms, offset, limit)
3781 
    return self.recv_searchItemsInRange()
3782 
 
3783 
  def send_searchItemsInRange(self, searchTerms, offset, limit):
3784 
    self._oprot.writeMessageBegin('searchItemsInRange', TMessageType.CALL, self._seqid)
3785 
    args = searchItemsInRange_args()
3786 
    args.searchTerms = searchTerms
3787 
    args.offset = offset
3788 
    args.limit = limit
3789 
    args.write(self._oprot)
3790 
    self._oprot.writeMessageEnd()
3791 
    self._oprot.trans.flush()
3792 
 
3793 
  def recv_searchItemsInRange(self, ):
3794 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3795 
    if mtype == TMessageType.EXCEPTION:
3796 
      x = TApplicationException()
3797 
      x.read(self._iprot)
3798 
      self._iprot.readMessageEnd()
3799 
      raise x
3800 
    result = searchItemsInRange_result()
3801 
    result.read(self._iprot)
3802 
    self._iprot.readMessageEnd()
3803 
    if result.success is not None:
3804 
      return result.success
3805 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchItemsInRange failed: unknown result");
3806 
 
3807 
  def getSearchResultCount(self, searchTerms):
3808 
    """
3809 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
3810 
 
3811 
    Parameters:
3812 
     - searchTerms
3813 
    """
3814 
    self.send_getSearchResultCount(searchTerms)
3815 
    return self.recv_getSearchResultCount()
3816 
 
3817 
  def send_getSearchResultCount(self, searchTerms):
3818 
    self._oprot.writeMessageBegin('getSearchResultCount', TMessageType.CALL, self._seqid)
3819 
    args = getSearchResultCount_args()
3820 
    args.searchTerms = searchTerms
3821 
    args.write(self._oprot)
3822 
    self._oprot.writeMessageEnd()
3823 
    self._oprot.trans.flush()
3824 
 
3825 
  def recv_getSearchResultCount(self, ):
3826 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3827 
    if mtype == TMessageType.EXCEPTION:
3828 
      x = TApplicationException()
3829 
      x.read(self._iprot)
3830 
      self._iprot.readMessageEnd()
3831 
      raise x
3832 
    result = getSearchResultCount_result()
3833 
    result.read(self._iprot)
3834 
    self._iprot.readMessageEnd()
3835 
    if result.success is not None:
3836 
      return result.success
3837 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSearchResultCount failed: unknown result");
3838 
 
3839 
  def getProductNotifications(self, startDateTime):
3840 
    """
3841 
    Returns a list of product notifications added after a supplied datetime
3842 
 
3843 
    Parameters:
3844 
     - startDateTime
3845 
    """
3846 
    self.send_getProductNotifications(startDateTime)
3847 
    return self.recv_getProductNotifications()
3848 
 
3849 
  def send_getProductNotifications(self, startDateTime):
3850 
    self._oprot.writeMessageBegin('getProductNotifications', TMessageType.CALL, self._seqid)
3851 
    args = getProductNotifications_args()
3852 
    args.startDateTime = startDateTime
3853 
    args.write(self._oprot)
3854 
    self._oprot.writeMessageEnd()
3855 
    self._oprot.trans.flush()
3856 
 
3857 
  def recv_getProductNotifications(self, ):
3858 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3859 
    if mtype == TMessageType.EXCEPTION:
3860 
      x = TApplicationException()
3861 
      x.read(self._iprot)
3862 
      self._iprot.readMessageEnd()
3863 
      raise x
3864 
    result = getProductNotifications_result()
3865 
    result.read(self._iprot)
3866 
    self._iprot.readMessageEnd()
3867 
    if result.success is not None:
3868 
      return result.success
3869 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotifications failed: unknown result");
3870 
 
7897 amar.kumar 3871 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3872 
    """
3873 
    Returns a list of count of requests for product notification against each item
3874 
 
3875 
    Parameters:
3876 
     - startDateTime
7897 amar.kumar 3877 
     - categoryId
5944 mandeep.dh 3878 
    """
7897 amar.kumar 3879 
    self.send_getProductNotificationRequestCount(startDateTime, categoryId)
5944 mandeep.dh 3880 
    return self.recv_getProductNotificationRequestCount()
3881 
 
7897 amar.kumar 3882 
  def send_getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3883 
    self._oprot.writeMessageBegin('getProductNotificationRequestCount', TMessageType.CALL, self._seqid)
3884 
    args = getProductNotificationRequestCount_args()
3885 
    args.startDateTime = startDateTime
7897 amar.kumar 3886 
    args.categoryId = categoryId
5944 mandeep.dh 3887 
    args.write(self._oprot)
3888 
    self._oprot.writeMessageEnd()
3889 
    self._oprot.trans.flush()
3890 
 
3891 
  def recv_getProductNotificationRequestCount(self, ):
3892 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3893 
    if mtype == TMessageType.EXCEPTION:
3894 
      x = TApplicationException()
3895 
      x.read(self._iprot)
3896 
      self._iprot.readMessageEnd()
3897 
      raise x
3898 
    result = getProductNotificationRequestCount_result()
3899 
    result.read(self._iprot)
3900 
    self._iprot.readMessageEnd()
3901 
    if result.success is not None:
3902 
      return result.success
3903 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotificationRequestCount failed: unknown result");
3904 
 
3905 
  def addAuthorizationLog(self, itemId, username, reason):
3906 
    """
3907 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
3908 
 
3909 
    Parameters:
3910 
     - itemId
3911 
     - username
3912 
     - reason
3913 
    """
3914 
    self.send_addAuthorizationLog(itemId, username, reason)
3915 
    return self.recv_addAuthorizationLog()
3916 
 
3917 
  def send_addAuthorizationLog(self, itemId, username, reason):
3918 
    self._oprot.writeMessageBegin('addAuthorizationLog', TMessageType.CALL, self._seqid)
3919 
    args = addAuthorizationLog_args()
3920 
    args.itemId = itemId
3921 
    args.username = username
3922 
    args.reason = reason
3923 
    args.write(self._oprot)
3924 
    self._oprot.writeMessageEnd()
3925 
    self._oprot.trans.flush()
3926 
 
3927 
  def recv_addAuthorizationLog(self, ):
3928 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3929 
    if mtype == TMessageType.EXCEPTION:
3930 
      x = TApplicationException()
3931 
      x.read(self._iprot)
3932 
      self._iprot.readMessageEnd()
3933 
      raise x
3934 
    result = addAuthorizationLog_result()
3935 
    result.read(self._iprot)
3936 
    self._iprot.readMessageEnd()
3937 
    if result.success is not None:
3938 
      return result.success
3939 
    if result.cex is not None:
3940 
      raise result.cex
3941 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAuthorizationLog failed: unknown result");
3942 
 
3943 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3944 
    """
3945 
    Parameters:
3946 
     - catalog_item_id
3947 
     - voucherType
3948 
     - voucherAmount
3949 
    """
3950 
    self.send_addupdateVoucherForItem(catalog_item_id, voucherType, voucherAmount)
3951 
    return self.recv_addupdateVoucherForItem()
3952 
 
3953 
  def send_addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3954 
    self._oprot.writeMessageBegin('addupdateVoucherForItem', TMessageType.CALL, self._seqid)
3955 
    args = addupdateVoucherForItem_args()
3956 
    args.catalog_item_id = catalog_item_id
3957 
    args.voucherType = voucherType
3958 
    args.voucherAmount = voucherAmount
3959 
    args.write(self._oprot)
3960 
    self._oprot.writeMessageEnd()
3961 
    self._oprot.trans.flush()
3962 
 
3963 
  def recv_addupdateVoucherForItem(self, ):
3964 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3965 
    if mtype == TMessageType.EXCEPTION:
3966 
      x = TApplicationException()
3967 
      x.read(self._iprot)
3968 
      self._iprot.readMessageEnd()
3969 
      raise x
3970 
    result = addupdateVoucherForItem_result()
3971 
    result.read(self._iprot)
3972 
    self._iprot.readMessageEnd()
3973 
    if result.success is not None:
3974 
      return result.success
3975 
    if result.cex is not None:
3976 
      raise result.cex
3977 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addupdateVoucherForItem failed: unknown result");
3978 
 
3979 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
3980 
    """
3981 
    Parameters:
3982 
     - catalog_item_id
3983 
     - voucherType
3984 
    """
3985 
    self.send_deleteVoucherForItem(catalog_item_id, voucherType)
3986 
    return self.recv_deleteVoucherForItem()
3987 
 
3988 
  def send_deleteVoucherForItem(self, catalog_item_id, voucherType):
3989 
    self._oprot.writeMessageBegin('deleteVoucherForItem', TMessageType.CALL, self._seqid)
3990 
    args = deleteVoucherForItem_args()
3991 
    args.catalog_item_id = catalog_item_id
3992 
    args.voucherType = voucherType
3993 
    args.write(self._oprot)
3994 
    self._oprot.writeMessageEnd()
3995 
    self._oprot.trans.flush()
3996 
 
3997 
  def recv_deleteVoucherForItem(self, ):
3998 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3999 
    if mtype == TMessageType.EXCEPTION:
4000 
      x = TApplicationException()
4001 
      x.read(self._iprot)
4002 
      self._iprot.readMessageEnd()
4003 
      raise x
4004 
    result = deleteVoucherForItem_result()
4005 
    result.read(self._iprot)
4006 
    self._iprot.readMessageEnd()
4007 
    if result.success is not None:
4008 
      return result.success
4009 
    if result.cex is not None:
4010 
      raise result.cex
4011 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteVoucherForItem failed: unknown result");
4012 
 
4013 
  def getVoucherAmount(self, itemId, voucherType):
4014 
    """
4015 
    Parameters:
4016 
     - itemId
4017 
     - voucherType
4018 
    """
4019 
    self.send_getVoucherAmount(itemId, voucherType)
4020 
    return self.recv_getVoucherAmount()
4021 
 
4022 
  def send_getVoucherAmount(self, itemId, voucherType):
4023 
    self._oprot.writeMessageBegin('getVoucherAmount', TMessageType.CALL, self._seqid)
4024 
    args = getVoucherAmount_args()
4025 
    args.itemId = itemId
4026 
    args.voucherType = voucherType
4027 
    args.write(self._oprot)
4028 
    self._oprot.writeMessageEnd()
4029 
    self._oprot.trans.flush()
4030 
 
4031 
  def recv_getVoucherAmount(self, ):
4032 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4033 
    if mtype == TMessageType.EXCEPTION:
4034 
      x = TApplicationException()
4035 
      x.read(self._iprot)
4036 
      self._iprot.readMessageEnd()
4037 
      raise x
4038 
    result = getVoucherAmount_result()
4039 
    result.read(self._iprot)
4040 
    self._iprot.readMessageEnd()
4041 
    if result.success is not None:
4042 
      return result.success
4043 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVoucherAmount failed: unknown result");
4044 
 
4045 
  def getAllItemVouchers(self, itemId):
4046 
    """
4047 
    Parameters:
4048 
     - itemId
4049 
    """
4050 
    self.send_getAllItemVouchers(itemId)
4051 
    return self.recv_getAllItemVouchers()
4052 
 
4053 
  def send_getAllItemVouchers(self, itemId):
4054 
    self._oprot.writeMessageBegin('getAllItemVouchers', TMessageType.CALL, self._seqid)
4055 
    args = getAllItemVouchers_args()
4056 
    args.itemId = itemId
4057 
    args.write(self._oprot)
4058 
    self._oprot.writeMessageEnd()
4059 
    self._oprot.trans.flush()
4060 
 
4061 
  def recv_getAllItemVouchers(self, ):
4062 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4063 
    if mtype == TMessageType.EXCEPTION:
4064 
      x = TApplicationException()
4065 
      x.read(self._iprot)
4066 
      self._iprot.readMessageEnd()
4067 
      raise x
4068 
    result = getAllItemVouchers_result()
4069 
    result.read(self._iprot)
4070 
    self._iprot.readMessageEnd()
4071 
    if result.success is not None:
4072 
      return result.success
4073 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemVouchers failed: unknown result");
4074 
 
4075 
  def isValidCatalogItemId(self, catalog_item_id):
4076 
    """
4077 
    Parameters:
4078 
     - catalog_item_id
4079 
    """
4080 
    self.send_isValidCatalogItemId(catalog_item_id)
4081 
    return self.recv_isValidCatalogItemId()
4082 
 
4083 
  def send_isValidCatalogItemId(self, catalog_item_id):
4084 
    self._oprot.writeMessageBegin('isValidCatalogItemId', TMessageType.CALL, self._seqid)
4085 
    args = isValidCatalogItemId_args()
4086 
    args.catalog_item_id = catalog_item_id
4087 
    args.write(self._oprot)
4088 
    self._oprot.writeMessageEnd()
4089 
    self._oprot.trans.flush()
4090 
 
4091 
  def recv_isValidCatalogItemId(self, ):
4092 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4093 
    if mtype == TMessageType.EXCEPTION:
4094 
      x = TApplicationException()
4095 
      x.read(self._iprot)
4096 
      self._iprot.readMessageEnd()
4097 
      raise x
4098 
    result = isValidCatalogItemId_result()
4099 
    result.read(self._iprot)
4100 
    self._iprot.readMessageEnd()
4101 
    if result.success is not None:
4102 
      return result.success
4103 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isValidCatalogItemId failed: unknown result");
4104 
 
7330 amit.gupta 4105 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 4106 
    """
4107 
    Parameters:
4108 
     - itemId
7330 amit.gupta 4109 
     - stateId
6039 amit.gupta 4110 
     - price
4111 
    """
7330 amit.gupta 4112 
    self.send_getVatPercentageForItem(itemId, stateId, price)
6039 amit.gupta 4113 
    return self.recv_getVatPercentageForItem()
5944 mandeep.dh 4114 
 
7330 amit.gupta 4115 
  def send_getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 4116 
    self._oprot.writeMessageBegin('getVatPercentageForItem', TMessageType.CALL, self._seqid)
4117 
    args = getVatPercentageForItem_args()
4118 
    args.itemId = itemId
7330 amit.gupta 4119 
    args.stateId = stateId
6039 amit.gupta 4120 
    args.price = price
4121 
    args.write(self._oprot)
4122 
    self._oprot.writeMessageEnd()
4123 
    self._oprot.trans.flush()
4124 
 
4125 
  def recv_getVatPercentageForItem(self, ):
4126 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4127 
    if mtype == TMessageType.EXCEPTION:
4128 
      x = TApplicationException()
4129 
      x.read(self._iprot)
4130 
      self._iprot.readMessageEnd()
4131 
      raise x
4132 
    result = getVatPercentageForItem_result()
4133 
    result.read(self._iprot)
4134 
    self._iprot.readMessageEnd()
4135 
    if result.success is not None:
4136 
      return result.success
7340 amit.gupta 4137 
    if result.cex is not None:
4138 
      raise result.cex
6039 amit.gupta 4139 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatPercentageForItem failed: unknown result");
4140 
 
4141 
  def getVatAmountForItem(self, itemId, price):
4142 
    """
4143 
    Parameters:
4144 
     - itemId
4145 
     - price
4146 
    """
4147 
    self.send_getVatAmountForItem(itemId, price)
4148 
    return self.recv_getVatAmountForItem()
4149 
 
4150 
  def send_getVatAmountForItem(self, itemId, price):
4151 
    self._oprot.writeMessageBegin('getVatAmountForItem', TMessageType.CALL, self._seqid)
4152 
    args = getVatAmountForItem_args()
4153 
    args.itemId = itemId
4154 
    args.price = price
4155 
    args.write(self._oprot)
4156 
    self._oprot.writeMessageEnd()
4157 
    self._oprot.trans.flush()
4158 
 
4159 
  def recv_getVatAmountForItem(self, ):
4160 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4161 
    if mtype == TMessageType.EXCEPTION:
4162 
      x = TApplicationException()
4163 
      x.read(self._iprot)
4164 
      self._iprot.readMessageEnd()
4165 
      raise x
4166 
    result = getVatAmountForItem_result()
4167 
    result.read(self._iprot)
4168 
    self._iprot.readMessageEnd()
4169 
    if result.success is not None:
4170 
      return result.success
4171 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatAmountForItem failed: unknown result");
4172 
 
6531 vikram.rag 4173 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
4174 
    """
4175 
    Parameters:
4176 
     - offset
4177 
     - limit
4178 
    """
4179 
    self.send_getAllIgnoredInventoryUpdateItemsList(offset, limit)
4180 
    return self.recv_getAllIgnoredInventoryUpdateItemsList()
6039 amit.gupta 4181 
 
6531 vikram.rag 4182 
  def send_getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
4183 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryUpdateItemsList', TMessageType.CALL, self._seqid)
4184 
    args = getAllIgnoredInventoryUpdateItemsList_args()
4185 
    args.offset = offset
4186 
    args.limit = limit
4187 
    args.write(self._oprot)
4188 
    self._oprot.writeMessageEnd()
4189 
    self._oprot.trans.flush()
4190 
 
4191 
  def recv_getAllIgnoredInventoryUpdateItemsList(self, ):
4192 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4193 
    if mtype == TMessageType.EXCEPTION:
4194 
      x = TApplicationException()
4195 
      x.read(self._iprot)
4196 
      self._iprot.readMessageEnd()
4197 
      raise x
4198 
    result = getAllIgnoredInventoryUpdateItemsList_result()
4199 
    result.read(self._iprot)
4200 
    self._iprot.readMessageEnd()
4201 
    if result.success is not None:
4202 
      return result.success
4203 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryUpdateItemsList failed: unknown result");
4204 
 
6821 amar.kumar 4205 
  def getAllAliveItems(self, ):
4206 
    self.send_getAllAliveItems()
4207 
    return self.recv_getAllAliveItems()
4208 
 
4209 
  def send_getAllAliveItems(self, ):
4210 
    self._oprot.writeMessageBegin('getAllAliveItems', TMessageType.CALL, self._seqid)
4211 
    args = getAllAliveItems_args()
4212 
    args.write(self._oprot)
4213 
    self._oprot.writeMessageEnd()
4214 
    self._oprot.trans.flush()
4215 
 
4216 
  def recv_getAllAliveItems(self, ):
4217 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4218 
    if mtype == TMessageType.EXCEPTION:
4219 
      x = TApplicationException()
4220 
      x.read(self._iprot)
4221 
      self._iprot.readMessageEnd()
4222 
      raise x
4223 
    result = getAllAliveItems_result()
4224 
    result.read(self._iprot)
4225 
    self._iprot.readMessageEnd()
4226 
    if result.success is not None:
4227 
      return result.success
4228 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAliveItems failed: unknown result");
4229 
 
6921 anupam.sin 4230 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 4231 
    """
4232 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 4233 
 
6805 anupam.sin 4234 
    Parameters:
4235 
     - itemId
6921 anupam.sin 4236 
     - price
6805 anupam.sin 4237 
     - insurerId
4238 
     - quantity
4239 
    """
6921 anupam.sin 4240 
    self.send_getInsuranceAmount(itemId, price, insurerId, quantity)
6805 anupam.sin 4241 
    return self.recv_getInsuranceAmount()
4242 
 
6921 anupam.sin 4243 
  def send_getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 4244 
    self._oprot.writeMessageBegin('getInsuranceAmount', TMessageType.CALL, self._seqid)
4245 
    args = getInsuranceAmount_args()
4246 
    args.itemId = itemId
6921 anupam.sin 4247 
    args.price = price
6805 anupam.sin 4248 
    args.insurerId = insurerId
4249 
    args.quantity = quantity
4250 
    args.write(self._oprot)
4251 
    self._oprot.writeMessageEnd()
4252 
    self._oprot.trans.flush()
4253 
 
4254 
  def recv_getInsuranceAmount(self, ):
4255 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4256 
    if mtype == TMessageType.EXCEPTION:
4257 
      x = TApplicationException()
4258 
      x.read(self._iprot)
4259 
      self._iprot.readMessageEnd()
4260 
      raise x
4261 
    result = getInsuranceAmount_result()
4262 
    result.read(self._iprot)
4263 
    self._iprot.readMessageEnd()
4264 
    if result.success is not None:
4265 
      return result.success
4266 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsuranceAmount failed: unknown result");
4267 
 
4268 
  def getInsurer(self, insurerId):
4269 
    """
4270 
    Parameters:
4271 
     - insurerId
4272 
    """
4273 
    self.send_getInsurer(insurerId)
4274 
    return self.recv_getInsurer()
4275 
 
4276 
  def send_getInsurer(self, insurerId):
4277 
    self._oprot.writeMessageBegin('getInsurer', TMessageType.CALL, self._seqid)
4278 
    args = getInsurer_args()
4279 
    args.insurerId = insurerId
4280 
    args.write(self._oprot)
4281 
    self._oprot.writeMessageEnd()
4282 
    self._oprot.trans.flush()
4283 
 
4284 
  def recv_getInsurer(self, ):
4285 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4286 
    if mtype == TMessageType.EXCEPTION:
4287 
      x = TApplicationException()
4288 
      x.read(self._iprot)
4289 
      self._iprot.readMessageEnd()
4290 
      raise x
4291 
    result = getInsurer_result()
4292 
    result.read(self._iprot)
4293 
    self._iprot.readMessageEnd()
4294 
    if result.success is not None:
4295 
      return result.success
4296 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsurer failed: unknown result");
4297 
 
6838 vikram.rag 4298 
  def getAllInsurers(self, ):
4299 
    self.send_getAllInsurers()
4300 
    return self.recv_getAllInsurers()
6805 anupam.sin 4301 
 
6838 vikram.rag 4302 
  def send_getAllInsurers(self, ):
4303 
    self._oprot.writeMessageBegin('getAllInsurers', TMessageType.CALL, self._seqid)
4304 
    args = getAllInsurers_args()
4305 
    args.write(self._oprot)
4306 
    self._oprot.writeMessageEnd()
4307 
    self._oprot.trans.flush()
4308 
 
4309 
  def recv_getAllInsurers(self, ):
4310 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4311 
    if mtype == TMessageType.EXCEPTION:
4312 
      x = TApplicationException()
4313 
      x.read(self._iprot)
4314 
      self._iprot.readMessageEnd()
4315 
      raise x
4316 
    result = getAllInsurers_result()
4317 
    result.read(self._iprot)
4318 
    self._iprot.readMessageEnd()
4319 
    if result.success is not None:
4320 
      return result.success
4321 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllInsurers failed: unknown result");
4322 
 
6962 rajveer 4323 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
4324 
    """
4325 
    Parameters:
4326 
     - insurerId
4327 
     - amount
4328 
    """
4329 
    self.send_updateInsuranceDeclaredAmount(insurerId, amount)
4330 
    self.recv_updateInsuranceDeclaredAmount()
6838 vikram.rag 4331 
 
6962 rajveer 4332 
  def send_updateInsuranceDeclaredAmount(self, insurerId, amount):
4333 
    self._oprot.writeMessageBegin('updateInsuranceDeclaredAmount', TMessageType.CALL, self._seqid)
4334 
    args = updateInsuranceDeclaredAmount_args()
4335 
    args.insurerId = insurerId
4336 
    args.amount = amount
4337 
    args.write(self._oprot)
4338 
    self._oprot.writeMessageEnd()
4339 
    self._oprot.trans.flush()
4340 
 
4341 
  def recv_updateInsuranceDeclaredAmount(self, ):
4342 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4343 
    if mtype == TMessageType.EXCEPTION:
4344 
      x = TApplicationException()
4345 
      x.read(self._iprot)
4346 
      self._iprot.readMessageEnd()
4347 
      raise x
4348 
    result = updateInsuranceDeclaredAmount_result()
4349 
    result.read(self._iprot)
4350 
    self._iprot.readMessageEnd()
4351 
    return
4352 
 
7190 amar.kumar 4353 
  def getFreebieForItem(self, itemId):
4354 
    """
4355 
    Parameters:
4356 
     - itemId
4357 
    """
4358 
    self.send_getFreebieForItem(itemId)
4359 
    return self.recv_getFreebieForItem()
6962 rajveer 4360 
 
7190 amar.kumar 4361 
  def send_getFreebieForItem(self, itemId):
4362 
    self._oprot.writeMessageBegin('getFreebieForItem', TMessageType.CALL, self._seqid)
4363 
    args = getFreebieForItem_args()
4364 
    args.itemId = itemId
4365 
    args.write(self._oprot)
4366 
    self._oprot.writeMessageEnd()
4367 
    self._oprot.trans.flush()
4368 
 
4369 
  def recv_getFreebieForItem(self, ):
4370 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4371 
    if mtype == TMessageType.EXCEPTION:
4372 
      x = TApplicationException()
4373 
      x.read(self._iprot)
4374 
      self._iprot.readMessageEnd()
4375 
      raise x
4376 
    result = getFreebieForItem_result()
4377 
    result.read(self._iprot)
4378 
    self._iprot.readMessageEnd()
4379 
    if result.success is not None:
4380 
      return result.success
4381 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFreebieForItem failed: unknown result");
4382 
 
4383 
  def addOrUpdateFreebieForItem(self, freebieItem):
4384 
    """
4385 
    Parameters:
4386 
     - freebieItem
4387 
    """
4388 
    self.send_addOrUpdateFreebieForItem(freebieItem)
4389 
    self.recv_addOrUpdateFreebieForItem()
4390 
 
4391 
  def send_addOrUpdateFreebieForItem(self, freebieItem):
4392 
    self._oprot.writeMessageBegin('addOrUpdateFreebieForItem', TMessageType.CALL, self._seqid)
4393 
    args = addOrUpdateFreebieForItem_args()
4394 
    args.freebieItem = freebieItem
4395 
    args.write(self._oprot)
4396 
    self._oprot.writeMessageEnd()
4397 
    self._oprot.trans.flush()
4398 
 
4399 
  def recv_addOrUpdateFreebieForItem(self, ):
4400 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4401 
    if mtype == TMessageType.EXCEPTION:
4402 
      x = TApplicationException()
4403 
      x.read(self._iprot)
4404 
      self._iprot.readMessageEnd()
4405 
      raise x
4406 
    result = addOrUpdateFreebieForItem_result()
4407 
    result.read(self._iprot)
4408 
    self._iprot.readMessageEnd()
4409 
    return
4410 
 
7272 amit.gupta 4411 
  def addOrUpdateBrandInfo(self, brandInfo):
4412 
    """
4413 
    Parameters:
4414 
     - brandInfo
4415 
    """
4416 
    self.send_addOrUpdateBrandInfo(brandInfo)
4417 
    self.recv_addOrUpdateBrandInfo()
4418 
 
4419 
  def send_addOrUpdateBrandInfo(self, brandInfo):
4420 
    self._oprot.writeMessageBegin('addOrUpdateBrandInfo', TMessageType.CALL, self._seqid)
4421 
    args = addOrUpdateBrandInfo_args()
4422 
    args.brandInfo = brandInfo
4423 
    args.write(self._oprot)
4424 
    self._oprot.writeMessageEnd()
4425 
    self._oprot.trans.flush()
4426 
 
4427 
  def recv_addOrUpdateBrandInfo(self, ):
4428 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4429 
    if mtype == TMessageType.EXCEPTION:
4430 
      x = TApplicationException()
4431 
      x.read(self._iprot)
4432 
      self._iprot.readMessageEnd()
4433 
      raise x
4434 
    result = addOrUpdateBrandInfo_result()
4435 
    result.read(self._iprot)
4436 
    self._iprot.readMessageEnd()
4437 
    return
4438 
 
4439 
  def getBrandInfo(self, ):
4440 
    self.send_getBrandInfo()
4441 
    return self.recv_getBrandInfo()
4442 
 
4443 
  def send_getBrandInfo(self, ):
4444 
    self._oprot.writeMessageBegin('getBrandInfo', TMessageType.CALL, self._seqid)
4445 
    args = getBrandInfo_args()
4446 
    args.write(self._oprot)
4447 
    self._oprot.writeMessageEnd()
4448 
    self._oprot.trans.flush()
4449 
 
4450 
  def recv_getBrandInfo(self, ):
4451 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4452 
    if mtype == TMessageType.EXCEPTION:
4453 
      x = TApplicationException()
4454 
      x.read(self._iprot)
4455 
      self._iprot.readMessageEnd()
4456 
      raise x
4457 
    result = getBrandInfo_result()
4458 
    result.read(self._iprot)
4459 
    self._iprot.readMessageEnd()
4460 
    if result.success is not None:
4461 
      return result.success
4462 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrandInfo failed: unknown result");
4463 
 
7256 rajveer 4464 
  def getStorePricing(self, itemId):
4465 
    """
4466 
    Parameters:
4467 
     - itemId
4468 
    """
4469 
    self.send_getStorePricing(itemId)
4470 
    return self.recv_getStorePricing()
7190 amar.kumar 4471 
 
7256 rajveer 4472 
  def send_getStorePricing(self, itemId):
4473 
    self._oprot.writeMessageBegin('getStorePricing', TMessageType.CALL, self._seqid)
4474 
    args = getStorePricing_args()
4475 
    args.itemId = itemId
4476 
    args.write(self._oprot)
4477 
    self._oprot.writeMessageEnd()
4478 
    self._oprot.trans.flush()
4479 
 
4480 
  def recv_getStorePricing(self, ):
4481 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4482 
    if mtype == TMessageType.EXCEPTION:
4483 
      x = TApplicationException()
4484 
      x.read(self._iprot)
4485 
      self._iprot.readMessageEnd()
4486 
      raise x
4487 
    result = getStorePricing_result()
4488 
    result.read(self._iprot)
4489 
    self._iprot.readMessageEnd()
4490 
    if result.success is not None:
4491 
      return result.success
4492 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricing failed: unknown result");
4493 
 
7306 rajveer 4494 
  def getStorePricings(self, itemIds):
4495 
    """
4496 
    Parameters:
4497 
     - itemIds
4498 
    """
4499 
    self.send_getStorePricings(itemIds)
4500 
    return self.recv_getStorePricings()
4501 
 
4502 
  def send_getStorePricings(self, itemIds):
4503 
    self._oprot.writeMessageBegin('getStorePricings', TMessageType.CALL, self._seqid)
4504 
    args = getStorePricings_args()
4505 
    args.itemIds = itemIds
4506 
    args.write(self._oprot)
4507 
    self._oprot.writeMessageEnd()
4508 
    self._oprot.trans.flush()
4509 
 
4510 
  def recv_getStorePricings(self, ):
4511 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4512 
    if mtype == TMessageType.EXCEPTION:
4513 
      x = TApplicationException()
4514 
      x.read(self._iprot)
4515 
      self._iprot.readMessageEnd()
4516 
      raise x
4517 
    result = getStorePricings_result()
4518 
    result.read(self._iprot)
4519 
    self._iprot.readMessageEnd()
4520 
    if result.success is not None:
4521 
      return result.success
4522 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricings failed: unknown result");
4523 
 
7382 rajveer 4524 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 4525 
    """
4526 
    Parameters:
4527 
     - sp
7382 rajveer 4528 
     - allColors
7265 rajveer 4529 
    """
7382 rajveer 4530 
    self.send_updateStorePricing(sp, allColors)
7265 rajveer 4531 
    self.recv_updateStorePricing()
7256 rajveer 4532 
 
7382 rajveer 4533 
  def send_updateStorePricing(self, sp, allColors):
7265 rajveer 4534 
    self._oprot.writeMessageBegin('updateStorePricing', TMessageType.CALL, self._seqid)
4535 
    args = updateStorePricing_args()
4536 
    args.sp = sp
7382 rajveer 4537 
    args.allColors = allColors
7265 rajveer 4538 
    args.write(self._oprot)
4539 
    self._oprot.writeMessageEnd()
4540 
    self._oprot.trans.flush()
4541 
 
4542 
  def recv_updateStorePricing(self, ):
4543 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4544 
    if mtype == TMessageType.EXCEPTION:
4545 
      x = TApplicationException()
4546 
      x.read(self._iprot)
4547 
      self._iprot.readMessageEnd()
4548 
      raise x
4549 
    result = updateStorePricing_result()
4550 
    result.read(self._iprot)
4551 
    self._iprot.readMessageEnd()
4552 
    return
4553 
 
7281 kshitij.so 4554 
  def getAllAmazonListedItems(self, ):
4555 
    self.send_getAllAmazonListedItems()
4556 
    return self.recv_getAllAmazonListedItems()
7265 rajveer 4557 
 
7281 kshitij.so 4558 
  def send_getAllAmazonListedItems(self, ):
4559 
    self._oprot.writeMessageBegin('getAllAmazonListedItems', TMessageType.CALL, self._seqid)
4560 
    args = getAllAmazonListedItems_args()
4561 
    args.write(self._oprot)
4562 
    self._oprot.writeMessageEnd()
4563 
    self._oprot.trans.flush()
4564 
 
4565 
  def recv_getAllAmazonListedItems(self, ):
4566 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4567 
    if mtype == TMessageType.EXCEPTION:
4568 
      x = TApplicationException()
4569 
      x.read(self._iprot)
4570 
      self._iprot.readMessageEnd()
4571 
      raise x
4572 
    result = getAllAmazonListedItems_result()
4573 
    result.read(self._iprot)
4574 
    self._iprot.readMessageEnd()
4575 
    if result.success is not None:
4576 
      return result.success
4577 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonListedItems failed: unknown result");
4578 
 
8619 kshitij.so 4579 
  def searchAmazonItems(self, searchTerm, offset, limit):
4580 
    """
4581 
    Parameters:
4582 
     - searchTerm
4583 
     - offset
4584 
     - limit
4585 
    """
4586 
    self.send_searchAmazonItems(searchTerm, offset, limit)
4587 
    return self.recv_searchAmazonItems()
4588 
 
4589 
  def send_searchAmazonItems(self, searchTerm, offset, limit):
4590 
    self._oprot.writeMessageBegin('searchAmazonItems', TMessageType.CALL, self._seqid)
4591 
    args = searchAmazonItems_args()
4592 
    args.searchTerm = searchTerm
4593 
    args.offset = offset
4594 
    args.limit = limit
4595 
    args.write(self._oprot)
4596 
    self._oprot.writeMessageEnd()
4597 
    self._oprot.trans.flush()
4598 
 
4599 
  def recv_searchAmazonItems(self, ):
4600 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4601 
    if mtype == TMessageType.EXCEPTION:
4602 
      x = TApplicationException()
4603 
      x.read(self._iprot)
4604 
      self._iprot.readMessageEnd()
4605 
      raise x
4606 
    result = searchAmazonItems_result()
4607 
    result.read(self._iprot)
4608 
    self._iprot.readMessageEnd()
4609 
    if result.success is not None:
4610 
      return result.success
4611 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchAmazonItems failed: unknown result");
4612 
 
4613 
  def getAmazonSearchResultCount(self, searchTerm):
4614 
    """
4615 
    Parameters:
4616 
     - searchTerm
4617 
    """
4618 
    self.send_getAmazonSearchResultCount(searchTerm)
4619 
    return self.recv_getAmazonSearchResultCount()
4620 
 
4621 
  def send_getAmazonSearchResultCount(self, searchTerm):
4622 
    self._oprot.writeMessageBegin('getAmazonSearchResultCount', TMessageType.CALL, self._seqid)
4623 
    args = getAmazonSearchResultCount_args()
4624 
    args.searchTerm = searchTerm
4625 
    args.write(self._oprot)
4626 
    self._oprot.writeMessageEnd()
4627 
    self._oprot.trans.flush()
4628 
 
4629 
  def recv_getAmazonSearchResultCount(self, ):
4630 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4631 
    if mtype == TMessageType.EXCEPTION:
4632 
      x = TApplicationException()
4633 
      x.read(self._iprot)
4634 
      self._iprot.readMessageEnd()
4635 
      raise x
4636 
    result = getAmazonSearchResultCount_result()
4637 
    result.read(self._iprot)
4638 
    self._iprot.readMessageEnd()
4639 
    if result.success is not None:
4640 
      return result.success
4641 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonSearchResultCount failed: unknown result");
4642 
 
4643 
  def getCountForAmazonlistedItems(self, ):
4644 
    self.send_getCountForAmazonlistedItems()
4645 
    return self.recv_getCountForAmazonlistedItems()
4646 
 
4647 
  def send_getCountForAmazonlistedItems(self, ):
4648 
    self._oprot.writeMessageBegin('getCountForAmazonlistedItems', TMessageType.CALL, self._seqid)
4649 
    args = getCountForAmazonlistedItems_args()
4650 
    args.write(self._oprot)
4651 
    self._oprot.writeMessageEnd()
4652 
    self._oprot.trans.flush()
4653 
 
4654 
  def recv_getCountForAmazonlistedItems(self, ):
4655 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4656 
    if mtype == TMessageType.EXCEPTION:
4657 
      x = TApplicationException()
4658 
      x.read(self._iprot)
4659 
      self._iprot.readMessageEnd()
4660 
      raise x
4661 
    result = getCountForAmazonlistedItems_result()
4662 
    result.read(self._iprot)
4663 
    self._iprot.readMessageEnd()
4664 
    if result.success is not None:
4665 
      return result.success
4666 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForAmazonlistedItems failed: unknown result");
4667 
 
7281 kshitij.so 4668 
  def getAmazonItemDetails(self, itemId):
4669 
    """
4670 
    Parameters:
4671 
     - itemId
4672 
    """
4673 
    self.send_getAmazonItemDetails(itemId)
4674 
    return self.recv_getAmazonItemDetails()
4675 
 
4676 
  def send_getAmazonItemDetails(self, itemId):
4677 
    self._oprot.writeMessageBegin('getAmazonItemDetails', TMessageType.CALL, self._seqid)
4678 
    args = getAmazonItemDetails_args()
4679 
    args.itemId = itemId
4680 
    args.write(self._oprot)
4681 
    self._oprot.writeMessageEnd()
4682 
    self._oprot.trans.flush()
4683 
 
4684 
  def recv_getAmazonItemDetails(self, ):
4685 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4686 
    if mtype == TMessageType.EXCEPTION:
4687 
      x = TApplicationException()
4688 
      x.read(self._iprot)
4689 
      self._iprot.readMessageEnd()
4690 
      raise x
4691 
    result = getAmazonItemDetails_result()
4692 
    result.read(self._iprot)
4693 
    self._iprot.readMessageEnd()
4694 
    if result.success is not None:
4695 
      return result.success
4696 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonItemDetails failed: unknown result");
4697 
 
8168 kshitij.so 4698 
  def updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4699 
    """
4700 
    Parameters:
8168 kshitij.so 4701 
     - amazonlisted
7281 kshitij.so 4702 
    """
8168 kshitij.so 4703 
    self.send_updateAmazonItemDetails(amazonlisted)
7281 kshitij.so 4704 
    self.recv_updateAmazonItemDetails()
4705 
 
8168 kshitij.so 4706 
  def send_updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4707 
    self._oprot.writeMessageBegin('updateAmazonItemDetails', TMessageType.CALL, self._seqid)
4708 
    args = updateAmazonItemDetails_args()
8168 kshitij.so 4709 
    args.amazonlisted = amazonlisted
7281 kshitij.so 4710 
    args.write(self._oprot)
4711 
    self._oprot.writeMessageEnd()
4712 
    self._oprot.trans.flush()
4713 
 
4714 
  def recv_updateAmazonItemDetails(self, ):
4715 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4716 
    if mtype == TMessageType.EXCEPTION:
4717 
      x = TApplicationException()
4718 
      x.read(self._iprot)
4719 
      self._iprot.readMessageEnd()
4720 
      raise x
4721 
    result = updateAmazonItemDetails_result()
4722 
    result.read(self._iprot)
4723 
    self._iprot.readMessageEnd()
4724 
    return
4725 
 
4726 
  def addAmazonItem(self, amazonlisted):
4727 
    """
4728 
    Parameters:
4729 
     - amazonlisted
4730 
    """
4731 
    self.send_addAmazonItem(amazonlisted)
4732 
    self.recv_addAmazonItem()
4733 
 
4734 
  def send_addAmazonItem(self, amazonlisted):
4735 
    self._oprot.writeMessageBegin('addAmazonItem', TMessageType.CALL, self._seqid)
4736 
    args = addAmazonItem_args()
4737 
    args.amazonlisted = amazonlisted
4738 
    args.write(self._oprot)
4739 
    self._oprot.writeMessageEnd()
4740 
    self._oprot.trans.flush()
4741 
 
4742 
  def recv_addAmazonItem(self, ):
4743 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4744 
    if mtype == TMessageType.EXCEPTION:
4745 
      x = TApplicationException()
4746 
      x.read(self._iprot)
4747 
      self._iprot.readMessageEnd()
4748 
      raise x
4749 
    result = addAmazonItem_result()
4750 
    result.read(self._iprot)
4751 
    self._iprot.readMessageEnd()
4752 
    return
4753 
 
7291 vikram.rag 4754 
  def getAsinItems(self, ):
4755 
    self.send_getAsinItems()
4756 
    return self.recv_getAsinItems()
7281 kshitij.so 4757 
 
7291 vikram.rag 4758 
  def send_getAsinItems(self, ):
4759 
    self._oprot.writeMessageBegin('getAsinItems', TMessageType.CALL, self._seqid)
4760 
    args = getAsinItems_args()
4761 
    args.write(self._oprot)
4762 
    self._oprot.writeMessageEnd()
4763 
    self._oprot.trans.flush()
4764 
 
4765 
  def recv_getAsinItems(self, ):
4766 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4767 
    if mtype == TMessageType.EXCEPTION:
4768 
      x = TApplicationException()
4769 
      x.read(self._iprot)
4770 
      self._iprot.readMessageEnd()
4771 
      raise x
4772 
    result = getAsinItems_result()
4773 
    result.read(self._iprot)
4774 
    self._iprot.readMessageEnd()
4775 
    if result.success is not None:
4776 
      return result.success
4777 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAsinItems failed: unknown result");
4778 
 
4779 
  def getAllFbaListedItems(self, ):
4780 
    self.send_getAllFbaListedItems()
4781 
    return self.recv_getAllFbaListedItems()
4782 
 
4783 
  def send_getAllFbaListedItems(self, ):
4784 
    self._oprot.writeMessageBegin('getAllFbaListedItems', TMessageType.CALL, self._seqid)
4785 
    args = getAllFbaListedItems_args()
4786 
    args.write(self._oprot)
4787 
    self._oprot.writeMessageEnd()
4788 
    self._oprot.trans.flush()
4789 
 
4790 
  def recv_getAllFbaListedItems(self, ):
4791 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4792 
    if mtype == TMessageType.EXCEPTION:
4793 
      x = TApplicationException()
4794 
      x.read(self._iprot)
4795 
      self._iprot.readMessageEnd()
4796 
      raise x
4797 
    result = getAllFbaListedItems_result()
4798 
    result.read(self._iprot)
4799 
    self._iprot.readMessageEnd()
4800 
    if result.success is not None:
4801 
      return result.success
4802 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbaListedItems failed: unknown result");
4803 
 
4804 
  def getAllNonFbaListedItems(self, ):
4805 
    self.send_getAllNonFbaListedItems()
4806 
    return self.recv_getAllNonFbaListedItems()
4807 
 
4808 
  def send_getAllNonFbaListedItems(self, ):
4809 
    self._oprot.writeMessageBegin('getAllNonFbaListedItems', TMessageType.CALL, self._seqid)
4810 
    args = getAllNonFbaListedItems_args()
4811 
    args.write(self._oprot)
4812 
    self._oprot.writeMessageEnd()
4813 
    self._oprot.trans.flush()
4814 
 
4815 
  def recv_getAllNonFbaListedItems(self, ):
4816 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4817 
    if mtype == TMessageType.EXCEPTION:
4818 
      x = TApplicationException()
4819 
      x.read(self._iprot)
4820 
      self._iprot.readMessageEnd()
4821 
      raise x
4822 
    result = getAllNonFbaListedItems_result()
4823 
    result.read(self._iprot)
4824 
    self._iprot.readMessageEnd()
4825 
    if result.success is not None:
4826 
      return result.success
4827 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllNonFbaListedItems failed: unknown result");
4828 
 
7460 kshitij.so 4829 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
4830 
    """
4831 
    Parameters:
4832 
     - itemId
4833 
     - holdInventory
4834 
     - defaultInventory
4835 
    """
4836 
    self.send_updateItemInventory(itemId, holdInventory, defaultInventory)
4837 
    return self.recv_updateItemInventory()
7291 vikram.rag 4838 
 
7460 kshitij.so 4839 
  def send_updateItemInventory(self, itemId, holdInventory, defaultInventory):
4840 
    self._oprot.writeMessageBegin('updateItemInventory', TMessageType.CALL, self._seqid)
4841 
    args = updateItemInventory_args()
4842 
    args.itemId = itemId
4843 
    args.holdInventory = holdInventory
4844 
    args.defaultInventory = defaultInventory
4845 
    args.write(self._oprot)
4846 
    self._oprot.writeMessageEnd()
4847 
    self._oprot.trans.flush()
4848 
 
4849 
  def recv_updateItemInventory(self, ):
4850 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4851 
    if mtype == TMessageType.EXCEPTION:
4852 
      x = TApplicationException()
4853 
      x.read(self._iprot)
4854 
      self._iprot.readMessageEnd()
4855 
      raise x
4856 
    result = updateItemInventory_result()
4857 
    result.read(self._iprot)
4858 
    self._iprot.readMessageEnd()
4859 
    if result.success is not None:
4860 
      return result.success
4861 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItemInventory failed: unknown result");
4862 
 
7770 kshitij.so 4863 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4864 
    """
4865 
    Parameters:
4866 
     - type
4867 
     - sku
4868 
     - timestamp
4869 
    """
4870 
    self.send_updateTimestampForAmazonFeeds(type, sku, timestamp)
4871 
    return self.recv_updateTimestampForAmazonFeeds()
7460 kshitij.so 4872 
 
7770 kshitij.so 4873 
  def send_updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4874 
    self._oprot.writeMessageBegin('updateTimestampForAmazonFeeds', TMessageType.CALL, self._seqid)
4875 
    args = updateTimestampForAmazonFeeds_args()
4876 
    args.type = type
4877 
    args.sku = sku
4878 
    args.timestamp = timestamp
4879 
    args.write(self._oprot)
4880 
    self._oprot.writeMessageEnd()
4881 
    self._oprot.trans.flush()
4882 
 
4883 
  def recv_updateTimestampForAmazonFeeds(self, ):
4884 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4885 
    if mtype == TMessageType.EXCEPTION:
4886 
      x = TApplicationException()
4887 
      x.read(self._iprot)
4888 
      self._iprot.readMessageEnd()
4889 
      raise x
4890 
    result = updateTimestampForAmazonFeeds_result()
4891 
    result.read(self._iprot)
4892 
    self._iprot.readMessageEnd()
4893 
    if result.success is not None:
4894 
      return result.success
4895 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateTimestampForAmazonFeeds failed: unknown result");
4896 
 
7897 amar.kumar 4897 
  def getAllParentCategories(self, ):
4898 
    self.send_getAllParentCategories()
4899 
    return self.recv_getAllParentCategories()
7770 kshitij.so 4900 
 
7897 amar.kumar 4901 
  def send_getAllParentCategories(self, ):
4902 
    self._oprot.writeMessageBegin('getAllParentCategories', TMessageType.CALL, self._seqid)
4903 
    args = getAllParentCategories_args()
4904 
    args.write(self._oprot)
4905 
    self._oprot.writeMessageEnd()
4906 
    self._oprot.trans.flush()
4907 
 
4908 
  def recv_getAllParentCategories(self, ):
4909 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4910 
    if mtype == TMessageType.EXCEPTION:
4911 
      x = TApplicationException()
4912 
      x.read(self._iprot)
4913 
      self._iprot.readMessageEnd()
4914 
      raise x
4915 
    result = getAllParentCategories_result()
4916 
    result.read(self._iprot)
4917 
    self._iprot.readMessageEnd()
4918 
    if result.success is not None:
4919 
      return result.success
4920 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllParentCategories failed: unknown result");
4921 
 
7977 kshitij.so 4922 
  def addPageViewEvent(self, pageViewEvents):
4923 
    """
4924 
    Parameters:
4925 
     - pageViewEvents
4926 
    """
4927 
    self.send_addPageViewEvent(pageViewEvents)
4928 
    self.recv_addPageViewEvent()
7897 amar.kumar 4929 
 
7977 kshitij.so 4930 
  def send_addPageViewEvent(self, pageViewEvents):
4931 
    self._oprot.writeMessageBegin('addPageViewEvent', TMessageType.CALL, self._seqid)
4932 
    args = addPageViewEvent_args()
4933 
    args.pageViewEvents = pageViewEvents
4934 
    args.write(self._oprot)
4935 
    self._oprot.writeMessageEnd()
4936 
    self._oprot.trans.flush()
4937 
 
4938 
  def recv_addPageViewEvent(self, ):
4939 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4940 
    if mtype == TMessageType.EXCEPTION:
4941 
      x = TApplicationException()
4942 
      x.read(self._iprot)
4943 
      self._iprot.readMessageEnd()
4944 
      raise x
4945 
    result = addPageViewEvent_result()
4946 
    result.read(self._iprot)
4947 
    self._iprot.readMessageEnd()
4948 
    return
4949 
 
4950 
  def addCartEvent(self, cartEvents):
4951 
    """
4952 
    Parameters:
4953 
     - cartEvents
4954 
    """
4955 
    self.send_addCartEvent(cartEvents)
4956 
    self.recv_addCartEvent()
4957 
 
4958 
  def send_addCartEvent(self, cartEvents):
4959 
    self._oprot.writeMessageBegin('addCartEvent', TMessageType.CALL, self._seqid)
4960 
    args = addCartEvent_args()
4961 
    args.cartEvents = cartEvents
4962 
    args.write(self._oprot)
4963 
    self._oprot.writeMessageEnd()
4964 
    self._oprot.trans.flush()
4965 
 
4966 
  def recv_addCartEvent(self, ):
4967 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4968 
    if mtype == TMessageType.EXCEPTION:
4969 
      x = TApplicationException()
4970 
      x.read(self._iprot)
4971 
      self._iprot.readMessageEnd()
4972 
      raise x
4973 
    result = addCartEvent_result()
4974 
    result.read(self._iprot)
4975 
    self._iprot.readMessageEnd()
4976 
    return
4977 
 
8182 amar.kumar 4978 
  def addEbayItem(self, ebayItem):
4979 
    """
4980 
    Parameters:
4981 
     - ebayItem
4982 
    """
4983 
    self.send_addEbayItem(ebayItem)
4984 
    self.recv_addEbayItem()
4985 
 
4986 
  def send_addEbayItem(self, ebayItem):
4987 
    self._oprot.writeMessageBegin('addEbayItem', TMessageType.CALL, self._seqid)
4988 
    args = addEbayItem_args()
4989 
    args.ebayItem = ebayItem
4990 
    args.write(self._oprot)
4991 
    self._oprot.writeMessageEnd()
4992 
    self._oprot.trans.flush()
4993 
 
4994 
  def recv_addEbayItem(self, ):
4995 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4996 
    if mtype == TMessageType.EXCEPTION:
4997 
      x = TApplicationException()
4998 
      x.read(self._iprot)
4999 
      self._iprot.readMessageEnd()
5000 
      raise x
5001 
    result = addEbayItem_result()
5002 
    result.read(self._iprot)
5003 
    self._iprot.readMessageEnd()
5004 
    return
5005 
 
5006 
  def getEbayItem(self, listingId):
5007 
    """
5008 
    Parameters:
5009 
     - listingId
5010 
    """
5011 
    self.send_getEbayItem(listingId)
5012 
    return self.recv_getEbayItem()
5013 
 
5014 
  def send_getEbayItem(self, listingId):
5015 
    self._oprot.writeMessageBegin('getEbayItem', TMessageType.CALL, self._seqid)
5016 
    args = getEbayItem_args()
5017 
    args.listingId = listingId
5018 
    args.write(self._oprot)
5019 
    self._oprot.writeMessageEnd()
5020 
    self._oprot.trans.flush()
5021 
 
5022 
  def recv_getEbayItem(self, ):
5023 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5024 
    if mtype == TMessageType.EXCEPTION:
5025 
      x = TApplicationException()
5026 
      x.read(self._iprot)
5027 
      self._iprot.readMessageEnd()
5028 
      raise x
5029 
    result = getEbayItem_result()
5030 
    result.read(self._iprot)
5031 
    self._iprot.readMessageEnd()
5032 
    if result.success is not None:
5033 
      return result.success
5034 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEbayItem failed: unknown result");
5035 
 
5036 
  def updateEbayItem(self, ebayItem):
5037 
    """
5038 
    Parameters:
5039 
     - ebayItem
5040 
    """
5041 
    self.send_updateEbayItem(ebayItem)
5042 
    self.recv_updateEbayItem()
5043 
 
5044 
  def send_updateEbayItem(self, ebayItem):
5045 
    self._oprot.writeMessageBegin('updateEbayItem', TMessageType.CALL, self._seqid)
5046 
    args = updateEbayItem_args()
5047 
    args.ebayItem = ebayItem
5048 
    args.write(self._oprot)
5049 
    self._oprot.writeMessageEnd()
5050 
    self._oprot.trans.flush()
5051 
 
5052 
  def recv_updateEbayItem(self, ):
5053 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5054 
    if mtype == TMessageType.EXCEPTION:
5055 
      x = TApplicationException()
5056 
      x.read(self._iprot)
5057 
      self._iprot.readMessageEnd()
5058 
      raise x
5059 
    result = updateEbayItem_result()
5060 
    result.read(self._iprot)
5061 
    self._iprot.readMessageEnd()
5062 
    return
5063 
 
8139 kshitij.so 5064 
  def getAmazonListedItems(self, offset, limit):
5065 
    """
5066 
    Parameters:
5067 
     - offset
5068 
     - limit
5069 
    """
5070 
    self.send_getAmazonListedItems(offset, limit)
5071 
    return self.recv_getAmazonListedItems()
7977 kshitij.so 5072 
 
8139 kshitij.so 5073 
  def send_getAmazonListedItems(self, offset, limit):
5074 
    self._oprot.writeMessageBegin('getAmazonListedItems', TMessageType.CALL, self._seqid)
5075 
    args = getAmazonListedItems_args()
5076 
    args.offset = offset
5077 
    args.limit = limit
5078 
    args.write(self._oprot)
5079 
    self._oprot.writeMessageEnd()
5080 
    self._oprot.trans.flush()
5081 
 
5082 
  def recv_getAmazonListedItems(self, ):
5083 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5084 
    if mtype == TMessageType.EXCEPTION:
5085 
      x = TApplicationException()
5086 
      x.read(self._iprot)
5087 
      self._iprot.readMessageEnd()
5088 
      raise x
5089 
    result = getAmazonListedItems_result()
5090 
    result.read(self._iprot)
5091 
    self._iprot.readMessageEnd()
5092 
    if result.success is not None:
5093 
      return result.success
5094 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonListedItems failed: unknown result");
5095 
 
8168 kshitij.so 5096 
  def updateAmazonAttributesInBulk(self, amazonlisted):
5097 
    """
5098 
    Parameters:
5099 
     - amazonlisted
5100 
    """
5101 
    self.send_updateAmazonAttributesInBulk(amazonlisted)
5102 
    return self.recv_updateAmazonAttributesInBulk()
8139 kshitij.so 5103 
 
8168 kshitij.so 5104 
  def send_updateAmazonAttributesInBulk(self, amazonlisted):
5105 
    self._oprot.writeMessageBegin('updateAmazonAttributesInBulk', TMessageType.CALL, self._seqid)
5106 
    args = updateAmazonAttributesInBulk_args()
5107 
    args.amazonlisted = amazonlisted
5108 
    args.write(self._oprot)
5109 
    self._oprot.writeMessageEnd()
5110 
    self._oprot.trans.flush()
5111 
 
5112 
  def recv_updateAmazonAttributesInBulk(self, ):
5113 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5114 
    if mtype == TMessageType.EXCEPTION:
5115 
      x = TApplicationException()
5116 
      x.read(self._iprot)
5117 
      self._iprot.readMessageEnd()
5118 
      raise x
5119 
    result = updateAmazonAttributesInBulk_result()
5120 
    result.read(self._iprot)
5121 
    self._iprot.readMessageEnd()
5122 
    if result.success is not None:
5123 
      return result.success
5124 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateAmazonAttributesInBulk failed: unknown result");
5125 
 
8379 vikram.rag 5126 
  def getAllItemstoListOnFba(self, ):
5127 
    self.send_getAllItemstoListOnFba()
5128 
    return self.recv_getAllItemstoListOnFba()
8168 kshitij.so 5129 
 
8379 vikram.rag 5130 
  def send_getAllItemstoListOnFba(self, ):
5131 
    self._oprot.writeMessageBegin('getAllItemstoListOnFba', TMessageType.CALL, self._seqid)
5132 
    args = getAllItemstoListOnFba_args()
5133 
    args.write(self._oprot)
5134 
    self._oprot.writeMessageEnd()
5135 
    self._oprot.trans.flush()
5136 
 
5137 
  def recv_getAllItemstoListOnFba(self, ):
5138 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5139 
    if mtype == TMessageType.EXCEPTION:
5140 
      x = TApplicationException()
5141 
      x.read(self._iprot)
5142 
      self._iprot.readMessageEnd()
5143 
      raise x
5144 
    result = getAllItemstoListOnFba_result()
5145 
    result.read(self._iprot)
5146 
    self._iprot.readMessageEnd()
5147 
    if result.success is not None:
5148 
      return result.success
5149 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnFba failed: unknown result");
5150 
 
5151 
  def getAllItemstoListOnNonFba(self, ):
5152 
    self.send_getAllItemstoListOnNonFba()
5153 
    return self.recv_getAllItemstoListOnNonFba()
5154 
 
5155 
  def send_getAllItemstoListOnNonFba(self, ):
5156 
    self._oprot.writeMessageBegin('getAllItemstoListOnNonFba', TMessageType.CALL, self._seqid)
5157 
    args = getAllItemstoListOnNonFba_args()
5158 
    args.write(self._oprot)
5159 
    self._oprot.writeMessageEnd()
5160 
    self._oprot.trans.flush()
5161 
 
5162 
  def recv_getAllItemstoListOnNonFba(self, ):
5163 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5164 
    if mtype == TMessageType.EXCEPTION:
5165 
      x = TApplicationException()
5166 
      x.read(self._iprot)
5167 
      self._iprot.readMessageEnd()
5168 
      raise x
5169 
    result = getAllItemstoListOnNonFba_result()
5170 
    result.read(self._iprot)
5171 
    self._iprot.readMessageEnd()
5172 
    if result.success is not None:
5173 
      return result.success
5174 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnNonFba failed: unknown result");
5175 
 
8619 kshitij.so 5176 
  def updateAsin(self, item):
5177 
    """
5178 
    Parameters:
5179 
     - item
5180 
    """
5181 
    self.send_updateAsin(item)
5182 
    self.recv_updateAsin()
8616 vikram.rag 5183 
 
8619 kshitij.so 5184 
  def send_updateAsin(self, item):
5185 
    self._oprot.writeMessageBegin('updateAsin', TMessageType.CALL, self._seqid)
5186 
    args = updateAsin_args()
5187 
    args.item = item
5188 
    args.write(self._oprot)
5189 
    self._oprot.writeMessageEnd()
5190 
    self._oprot.trans.flush()
5191 
 
5192 
  def recv_updateAsin(self, ):
5193 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5194 
    if mtype == TMessageType.EXCEPTION:
5195 
      x = TApplicationException()
5196 
      x.read(self._iprot)
5197 
      self._iprot.readMessageEnd()
5198 
      raise x
5199 
    result = updateAsin_result()
5200 
    result.read(self._iprot)
5201 
    self._iprot.readMessageEnd()
5202 
    return
5203 
 
8739 vikram.rag 5204 
  def addOrUpdateSnapdealItem(self, snapdealitem):
5205 
    """
5206 
    Parameters:
5207 
     - snapdealitem
5208 
    """
5209 
    self.send_addOrUpdateSnapdealItem(snapdealitem)
5210 
    return self.recv_addOrUpdateSnapdealItem()
8619 kshitij.so 5211 
 
8739 vikram.rag 5212 
  def send_addOrUpdateSnapdealItem(self, snapdealitem):
5213 
    self._oprot.writeMessageBegin('addOrUpdateSnapdealItem', TMessageType.CALL, self._seqid)
5214 
    args = addOrUpdateSnapdealItem_args()
5215 
    args.snapdealitem = snapdealitem
5216 
    args.write(self._oprot)
5217 
    self._oprot.writeMessageEnd()
5218 
    self._oprot.trans.flush()
5219 
 
5220 
  def recv_addOrUpdateSnapdealItem(self, ):
5221 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5222 
    if mtype == TMessageType.EXCEPTION:
5223 
      x = TApplicationException()
5224 
      x.read(self._iprot)
5225 
      self._iprot.readMessageEnd()
5226 
      raise x
5227 
    result = addOrUpdateSnapdealItem_result()
5228 
    result.read(self._iprot)
5229 
    self._iprot.readMessageEnd()
5230 
    if result.success is not None:
5231 
      return result.success
5232 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addOrUpdateSnapdealItem failed: unknown result");
5233 
 
5234 
  def getSnapdealItem(self, item_id):
5235 
    """
5236 
    Parameters:
5237 
     - item_id
5238 
    """
5239 
    self.send_getSnapdealItem(item_id)
5240 
    return self.recv_getSnapdealItem()
5241 
 
5242 
  def send_getSnapdealItem(self, item_id):
5243 
    self._oprot.writeMessageBegin('getSnapdealItem', TMessageType.CALL, self._seqid)
5244 
    args = getSnapdealItem_args()
5245 
    args.item_id = item_id
5246 
    args.write(self._oprot)
5247 
    self._oprot.writeMessageEnd()
5248 
    self._oprot.trans.flush()
5249 
 
5250 
  def recv_getSnapdealItem(self, ):
5251 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5252 
    if mtype == TMessageType.EXCEPTION:
5253 
      x = TApplicationException()
5254 
      x.read(self._iprot)
5255 
      self._iprot.readMessageEnd()
5256 
      raise x
5257 
    result = getSnapdealItem_result()
5258 
    result.read(self._iprot)
5259 
    self._iprot.readMessageEnd()
5260 
    if result.success is not None:
5261 
      return result.success
5262 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItem failed: unknown result");
5263 
 
9242 kshitij.so 5264 
  def getSnapdealItemDetails(self, item_id):
5265 
    """
5266 
    Parameters:
5267 
     - item_id
5268 
    """
5269 
    self.send_getSnapdealItemDetails(item_id)
5270 
    return self.recv_getSnapdealItemDetails()
5271 
 
5272 
  def send_getSnapdealItemDetails(self, item_id):
5273 
    self._oprot.writeMessageBegin('getSnapdealItemDetails', TMessageType.CALL, self._seqid)
5274 
    args = getSnapdealItemDetails_args()
5275 
    args.item_id = item_id
5276 
    args.write(self._oprot)
5277 
    self._oprot.writeMessageEnd()
5278 
    self._oprot.trans.flush()
5279 
 
5280 
  def recv_getSnapdealItemDetails(self, ):
5281 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5282 
    if mtype == TMessageType.EXCEPTION:
5283 
      x = TApplicationException()
5284 
      x.read(self._iprot)
5285 
      self._iprot.readMessageEnd()
5286 
      raise x
5287 
    result = getSnapdealItemDetails_result()
5288 
    result.read(self._iprot)
5289 
    self._iprot.readMessageEnd()
5290 
    if result.success is not None:
5291 
      return result.success
5292 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItemDetails failed: unknown result");
5293 
 
8739 vikram.rag 5294 
  def getAllSnapdealItems(self, ):
5295 
    self.send_getAllSnapdealItems()
5296 
    return self.recv_getAllSnapdealItems()
5297 
 
5298 
  def send_getAllSnapdealItems(self, ):
5299 
    self._oprot.writeMessageBegin('getAllSnapdealItems', TMessageType.CALL, self._seqid)
5300 
    args = getAllSnapdealItems_args()
5301 
    args.write(self._oprot)
5302 
    self._oprot.writeMessageEnd()
5303 
    self._oprot.trans.flush()
5304 
 
5305 
  def recv_getAllSnapdealItems(self, ):
5306 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5307 
    if mtype == TMessageType.EXCEPTION:
5308 
      x = TApplicationException()
5309 
      x.read(self._iprot)
5310 
      self._iprot.readMessageEnd()
5311 
      raise x
5312 
    result = getAllSnapdealItems_result()
5313 
    result.read(self._iprot)
5314 
    self._iprot.readMessageEnd()
5315 
    if result.success is not None:
5316 
      return result.success
5317 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSnapdealItems failed: unknown result");
5318 
 
9242 kshitij.so 5319 
  def getSnapdealItems(self, offset, limit):
5320 
    """
5321 
    Parameters:
5322 
     - offset
5323 
     - limit
5324 
    """
5325 
    self.send_getSnapdealItems(offset, limit)
5326 
    return self.recv_getSnapdealItems()
8739 vikram.rag 5327 
 
9242 kshitij.so 5328 
  def send_getSnapdealItems(self, offset, limit):
5329 
    self._oprot.writeMessageBegin('getSnapdealItems', TMessageType.CALL, self._seqid)
5330 
    args = getSnapdealItems_args()
5331 
    args.offset = offset
5332 
    args.limit = limit
5333 
    args.write(self._oprot)
5334 
    self._oprot.writeMessageEnd()
5335 
    self._oprot.trans.flush()
5336 
 
5337 
  def recv_getSnapdealItems(self, ):
5338 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5339 
    if mtype == TMessageType.EXCEPTION:
5340 
      x = TApplicationException()
5341 
      x.read(self._iprot)
5342 
      self._iprot.readMessageEnd()
5343 
      raise x
5344 
    result = getSnapdealItems_result()
5345 
    result.read(self._iprot)
5346 
    self._iprot.readMessageEnd()
5347 
    if result.success is not None:
5348 
      return result.success
5349 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItems failed: unknown result");
5350 
 
5351 
  def searchSnapdealItems(self, searchTerm, offset, limit):
5352 
    """
5353 
    Parameters:
5354 
     - searchTerm
5355 
     - offset
5356 
     - limit
5357 
    """
5358 
    self.send_searchSnapdealItems(searchTerm, offset, limit)
5359 
    return self.recv_searchSnapdealItems()
5360 
 
5361 
  def send_searchSnapdealItems(self, searchTerm, offset, limit):
5362 
    self._oprot.writeMessageBegin('searchSnapdealItems', TMessageType.CALL, self._seqid)
5363 
    args = searchSnapdealItems_args()
5364 
    args.searchTerm = searchTerm
5365 
    args.offset = offset
5366 
    args.limit = limit
5367 
    args.write(self._oprot)
5368 
    self._oprot.writeMessageEnd()
5369 
    self._oprot.trans.flush()
5370 
 
5371 
  def recv_searchSnapdealItems(self, ):
5372 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5373 
    if mtype == TMessageType.EXCEPTION:
5374 
      x = TApplicationException()
5375 
      x.read(self._iprot)
5376 
      self._iprot.readMessageEnd()
5377 
      raise x
5378 
    result = searchSnapdealItems_result()
5379 
    result.read(self._iprot)
5380 
    self._iprot.readMessageEnd()
5381 
    if result.success is not None:
5382 
      return result.success
5383 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchSnapdealItems failed: unknown result");
5384 
 
5385 
  def getCountForSnapdealItems(self, ):
5386 
    self.send_getCountForSnapdealItems()
5387 
    return self.recv_getCountForSnapdealItems()
5388 
 
5389 
  def send_getCountForSnapdealItems(self, ):
5390 
    self._oprot.writeMessageBegin('getCountForSnapdealItems', TMessageType.CALL, self._seqid)
5391 
    args = getCountForSnapdealItems_args()
5392 
    args.write(self._oprot)
5393 
    self._oprot.writeMessageEnd()
5394 
    self._oprot.trans.flush()
5395 
 
5396 
  def recv_getCountForSnapdealItems(self, ):
5397 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5398 
    if mtype == TMessageType.EXCEPTION:
5399 
      x = TApplicationException()
5400 
      x.read(self._iprot)
5401 
      self._iprot.readMessageEnd()
5402 
      raise x
5403 
    result = getCountForSnapdealItems_result()
5404 
    result.read(self._iprot)
5405 
    self._iprot.readMessageEnd()
5406 
    if result.success is not None:
5407 
      return result.success
5408 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForSnapdealItems failed: unknown result");
5409 
 
5410 
  def getSnapdealSearchResultCount(self, searchTerm):
5411 
    """
5412 
    Parameters:
5413 
     - searchTerm
5414 
    """
5415 
    self.send_getSnapdealSearchResultCount(searchTerm)
5416 
    return self.recv_getSnapdealSearchResultCount()
5417 
 
5418 
  def send_getSnapdealSearchResultCount(self, searchTerm):
5419 
    self._oprot.writeMessageBegin('getSnapdealSearchResultCount', TMessageType.CALL, self._seqid)
5420 
    args = getSnapdealSearchResultCount_args()
5421 
    args.searchTerm = searchTerm
5422 
    args.write(self._oprot)
5423 
    self._oprot.writeMessageEnd()
5424 
    self._oprot.trans.flush()
5425 
 
5426 
  def recv_getSnapdealSearchResultCount(self, ):
5427 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5428 
    if mtype == TMessageType.EXCEPTION:
5429 
      x = TApplicationException()
5430 
      x.read(self._iprot)
5431 
      self._iprot.readMessageEnd()
5432 
      raise x
5433 
    result = getSnapdealSearchResultCount_result()
5434 
    result.read(self._iprot)
5435 
    self._iprot.readMessageEnd()
5436 
    if result.success is not None:
5437 
      return result.success
5438 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealSearchResultCount failed: unknown result");
5439 
 
9299 kshitij.so 5440 
  def getPrefferedInsurerForItem(self, itemId, insurerType):
5441 
    """
5442 
    Parameters:
5443 
     - itemId
5444 
     - insurerType
5445 
    """
5446 
    self.send_getPrefferedInsurerForItem(itemId, insurerType)
5447 
    return self.recv_getPrefferedInsurerForItem()
9242 kshitij.so 5448 
 
9299 kshitij.so 5449 
  def send_getPrefferedInsurerForItem(self, itemId, insurerType):
5450 
    self._oprot.writeMessageBegin('getPrefferedInsurerForItem', TMessageType.CALL, self._seqid)
5451 
    args = getPrefferedInsurerForItem_args()
5452 
    args.itemId = itemId
5453 
    args.insurerType = insurerType
5454 
    args.write(self._oprot)
5455 
    self._oprot.writeMessageEnd()
5456 
    self._oprot.trans.flush()
5457 
 
5458 
  def recv_getPrefferedInsurerForItem(self, ):
5459 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5460 
    if mtype == TMessageType.EXCEPTION:
5461 
      x = TApplicationException()
5462 
      x.read(self._iprot)
5463 
      self._iprot.readMessageEnd()
5464 
      raise x
5465 
    result = getPrefferedInsurerForItem_result()
5466 
    result.read(self._iprot)
5467 
    self._iprot.readMessageEnd()
5468 
    if result.success is not None:
5469 
      return result.success
5470 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrefferedInsurerForItem failed: unknown result");
5471 
 
9456 vikram.rag 5472 
  def getSnapdealItembySkuAtSnapdeal(self, skuAtSnapdeal):
5473 
    """
5474 
    Parameters:
5475 
     - skuAtSnapdeal
5476 
    """
5477 
    self.send_getSnapdealItembySkuAtSnapdeal(skuAtSnapdeal)
5478 
    return self.recv_getSnapdealItembySkuAtSnapdeal()
9299 kshitij.so 5479 
 
9456 vikram.rag 5480 
  def send_getSnapdealItembySkuAtSnapdeal(self, skuAtSnapdeal):
5481 
    self._oprot.writeMessageBegin('getSnapdealItembySkuAtSnapdeal', TMessageType.CALL, self._seqid)
5482 
    args = getSnapdealItembySkuAtSnapdeal_args()
5483 
    args.skuAtSnapdeal = skuAtSnapdeal
5484 
    args.write(self._oprot)
5485 
    self._oprot.writeMessageEnd()
5486 
    self._oprot.trans.flush()
5487 
 
5488 
  def recv_getSnapdealItembySkuAtSnapdeal(self, ):
5489 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5490 
    if mtype == TMessageType.EXCEPTION:
5491 
      x = TApplicationException()
5492 
      x.read(self._iprot)
5493 
      self._iprot.readMessageEnd()
5494 
      raise x
5495 
    result = getSnapdealItembySkuAtSnapdeal_result()
5496 
    result.read(self._iprot)
5497 
    self._iprot.readMessageEnd()
5498 
    if result.success is not None:
5499 
      return result.success
5500 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItembySkuAtSnapdeal failed: unknown result");
5501 
 
9621 manish.sha 5502 
  def getProductFeedSubmit(self, catalogItemId):
5503 
    """
5504 
    Parameters:
5505 
     - catalogItemId
5506 
    """
5507 
    self.send_getProductFeedSubmit(catalogItemId)
5508 
    return self.recv_getProductFeedSubmit()
9456 vikram.rag 5509 
 
9621 manish.sha 5510 
  def send_getProductFeedSubmit(self, catalogItemId):
5511 
    self._oprot.writeMessageBegin('getProductFeedSubmit', TMessageType.CALL, self._seqid)
5512 
    args = getProductFeedSubmit_args()
5513 
    args.catalogItemId = catalogItemId
5514 
    args.write(self._oprot)
5515 
    self._oprot.writeMessageEnd()
5516 
    self._oprot.trans.flush()
5517 
 
5518 
  def recv_getProductFeedSubmit(self, ):
5519 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5520 
    if mtype == TMessageType.EXCEPTION:
5521 
      x = TApplicationException()
5522 
      x.read(self._iprot)
5523 
      self._iprot.readMessageEnd()
5524 
      raise x
5525 
    result = getProductFeedSubmit_result()
5526 
    result.read(self._iprot)
5527 
    self._iprot.readMessageEnd()
5528 
    if result.success is not None:
5529 
      return result.success
5530 
    if result.cex is not None:
5531 
      raise result.cex
5532 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductFeedSubmit failed: unknown result");
5533 
 
5534 
  def addProductFeedSubmit(self, productFeedSubmit):
5535 
    """
5536 
    Parameters:
5537 
     - productFeedSubmit
5538 
    """
5539 
    self.send_addProductFeedSubmit(productFeedSubmit)
5540 
    return self.recv_addProductFeedSubmit()
5541 
 
5542 
  def send_addProductFeedSubmit(self, productFeedSubmit):
5543 
    self._oprot.writeMessageBegin('addProductFeedSubmit', TMessageType.CALL, self._seqid)
5544 
    args = addProductFeedSubmit_args()
5545 
    args.productFeedSubmit = productFeedSubmit
5546 
    args.write(self._oprot)
5547 
    self._oprot.writeMessageEnd()
5548 
    self._oprot.trans.flush()
5549 
 
5550 
  def recv_addProductFeedSubmit(self, ):
5551 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5552 
    if mtype == TMessageType.EXCEPTION:
5553 
      x = TApplicationException()
5554 
      x.read(self._iprot)
5555 
      self._iprot.readMessageEnd()
5556 
      raise x
5557 
    result = addProductFeedSubmit_result()
5558 
    result.read(self._iprot)
5559 
    self._iprot.readMessageEnd()
5560 
    if result.success is not None:
5561 
      return result.success
5562 
    if result.cex is not None:
5563 
      raise result.cex
5564 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductFeedSubmit failed: unknown result");
5565 
 
5566 
  def updateProductFeedSubmit(self, productFeedSubmit):
5567 
    """
5568 
    Parameters:
5569 
     - productFeedSubmit
5570 
    """
5571 
    self.send_updateProductFeedSubmit(productFeedSubmit)
5572 
    return self.recv_updateProductFeedSubmit()
5573 
 
5574 
  def send_updateProductFeedSubmit(self, productFeedSubmit):
5575 
    self._oprot.writeMessageBegin('updateProductFeedSubmit', TMessageType.CALL, self._seqid)
5576 
    args = updateProductFeedSubmit_args()
5577 
    args.productFeedSubmit = productFeedSubmit
5578 
    args.write(self._oprot)
5579 
    self._oprot.writeMessageEnd()
5580 
    self._oprot.trans.flush()
5581 
 
5582 
  def recv_updateProductFeedSubmit(self, ):
5583 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5584 
    if mtype == TMessageType.EXCEPTION:
5585 
      x = TApplicationException()
5586 
      x.read(self._iprot)
5587 
      self._iprot.readMessageEnd()
5588 
      raise x
5589 
    result = updateProductFeedSubmit_result()
5590 
    result.read(self._iprot)
5591 
    self._iprot.readMessageEnd()
5592 
    if result.success is not None:
5593 
      return result.success
5594 
    if result.cex is not None:
5595 
      raise result.cex
5596 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateProductFeedSubmit failed: unknown result");
5597 
 
5598 
  def deleteProductFeedSubmit(self, catalogItemId):
5599 
    """
5600 
    Parameters:
5601 
     - catalogItemId
5602 
    """
5603 
    self.send_deleteProductFeedSubmit(catalogItemId)
5604 
    return self.recv_deleteProductFeedSubmit()
5605 
 
5606 
  def send_deleteProductFeedSubmit(self, catalogItemId):
5607 
    self._oprot.writeMessageBegin('deleteProductFeedSubmit', TMessageType.CALL, self._seqid)
5608 
    args = deleteProductFeedSubmit_args()
5609 
    args.catalogItemId = catalogItemId
5610 
    args.write(self._oprot)
5611 
    self._oprot.writeMessageEnd()
5612 
    self._oprot.trans.flush()
5613 
 
5614 
  def recv_deleteProductFeedSubmit(self, ):
5615 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5616 
    if mtype == TMessageType.EXCEPTION:
5617 
      x = TApplicationException()
5618 
      x.read(self._iprot)
5619 
      self._iprot.readMessageEnd()
5620 
      raise x
5621 
    result = deleteProductFeedSubmit_result()
5622 
    result.read(self._iprot)
5623 
    self._iprot.readMessageEnd()
5624 
    if result.success is not None:
5625 
      return result.success
5626 
    if result.cex is not None:
5627 
      raise result.cex
5628 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteProductFeedSubmit failed: unknown result");
5629 
 
5630 
  def getAllProductFeedSubmit(self, ):
5631 
    self.send_getAllProductFeedSubmit()
5632 
    return self.recv_getAllProductFeedSubmit()
5633 
 
5634 
  def send_getAllProductFeedSubmit(self, ):
5635 
    self._oprot.writeMessageBegin('getAllProductFeedSubmit', TMessageType.CALL, self._seqid)
5636 
    args = getAllProductFeedSubmit_args()
5637 
    args.write(self._oprot)
5638 
    self._oprot.writeMessageEnd()
5639 
    self._oprot.trans.flush()
5640 
 
5641 
  def recv_getAllProductFeedSubmit(self, ):
5642 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5643 
    if mtype == TMessageType.EXCEPTION:
5644 
      x = TApplicationException()
5645 
      x.read(self._iprot)
5646 
      self._iprot.readMessageEnd()
5647 
      raise x
5648 
    result = getAllProductFeedSubmit_result()
5649 
    result.read(self._iprot)
5650 
    self._iprot.readMessageEnd()
5651 
    if result.success is not None:
5652 
      return result.success
5653 
    if result.cex is not None:
5654 
      raise result.cex
5655 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllProductFeedSubmit failed: unknown result");
5656 
 
9724 kshitij.so 5657 
  def getMarketplacedetailsForItem(self, itemId, sourceId):
5658 
    """
5659 
    Parameters:
5660 
     - itemId
5661 
     - sourceId
5662 
    """
5663 
    self.send_getMarketplacedetailsForItem(itemId, sourceId)
5664 
    return self.recv_getMarketplacedetailsForItem()
9621 manish.sha 5665 
 
9724 kshitij.so 5666 
  def send_getMarketplacedetailsForItem(self, itemId, sourceId):
5667 
    self._oprot.writeMessageBegin('getMarketplacedetailsForItem', TMessageType.CALL, self._seqid)
5668 
    args = getMarketplacedetailsForItem_args()
5669 
    args.itemId = itemId
5670 
    args.sourceId = sourceId
5671 
    args.write(self._oprot)
5672 
    self._oprot.writeMessageEnd()
5673 
    self._oprot.trans.flush()
5674 
 
5675 
  def recv_getMarketplacedetailsForItem(self, ):
5676 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5677 
    if mtype == TMessageType.EXCEPTION:
5678 
      x = TApplicationException()
5679 
      x.read(self._iprot)
5680 
      self._iprot.readMessageEnd()
5681 
      raise x
5682 
    result = getMarketplacedetailsForItem_result()
5683 
    result.read(self._iprot)
5684 
    self._iprot.readMessageEnd()
5685 
    if result.success is not None:
5686 
      return result.success
5687 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMarketplacedetailsForItem failed: unknown result");
5688 
 
5689 
  def updateMarketplaceAttributesForItem(self, marketPlaceItem):
5690 
    """
5691 
    Parameters:
5692 
     - marketPlaceItem
5693 
    """
5694 
    self.send_updateMarketplaceAttributesForItem(marketPlaceItem)
5695 
    return self.recv_updateMarketplaceAttributesForItem()
5696 
 
5697 
  def send_updateMarketplaceAttributesForItem(self, marketPlaceItem):
5698 
    self._oprot.writeMessageBegin('updateMarketplaceAttributesForItem', TMessageType.CALL, self._seqid)
5699 
    args = updateMarketplaceAttributesForItem_args()
5700 
    args.marketPlaceItem = marketPlaceItem
5701 
    args.write(self._oprot)
5702 
    self._oprot.writeMessageEnd()
5703 
    self._oprot.trans.flush()
5704 
 
5705 
  def recv_updateMarketplaceAttributesForItem(self, ):
5706 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5707 
    if mtype == TMessageType.EXCEPTION:
5708 
      x = TApplicationException()
5709 
      x.read(self._iprot)
5710 
      self._iprot.readMessageEnd()
5711 
      raise x
5712 
    result = updateMarketplaceAttributesForItem_result()
5713 
    result.read(self._iprot)
5714 
    self._iprot.readMessageEnd()
5715 
    if result.success is not None:
5716 
      return result.success
5717 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMarketplaceAttributesForItem failed: unknown result");
5718 
 
9779 kshitij.so 5719 
  def getCostingForMarketplace(self, source, item_id):
5720 
    """
5721 
    Parameters:
5722 
     - source
5723 
     - item_id
5724 
    """
5725 
    self.send_getCostingForMarketplace(source, item_id)
5726 
    return self.recv_getCostingForMarketplace()
5727 
 
5728 
  def send_getCostingForMarketplace(self, source, item_id):
5729 
    self._oprot.writeMessageBegin('getCostingForMarketplace', TMessageType.CALL, self._seqid)
5730 
    args = getCostingForMarketplace_args()
5731 
    args.source = source
5732 
    args.item_id = item_id
5733 
    args.write(self._oprot)
5734 
    self._oprot.writeMessageEnd()
5735 
    self._oprot.trans.flush()
5736 
 
5737 
  def recv_getCostingForMarketplace(self, ):
5738 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5739 
    if mtype == TMessageType.EXCEPTION:
5740 
      x = TApplicationException()
5741 
      x.read(self._iprot)
5742 
      self._iprot.readMessageEnd()
5743 
      raise x
5744 
    result = getCostingForMarketplace_result()
5745 
    result.read(self._iprot)
5746 
    self._iprot.readMessageEnd()
5747 
    if result.success is not None:
5748 
      return result.success
5749 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCostingForMarketplace failed: unknown result");
5750 
 
9776 vikram.rag 5751 
  def getMarketPlaceItemsForPriceUpdate(self, source):
5752 
    """
5753 
    Parameters:
5754 
     - source
5755 
    """
5756 
    self.send_getMarketPlaceItemsForPriceUpdate(source)
5757 
    return self.recv_getMarketPlaceItemsForPriceUpdate()
9724 kshitij.so 5758 
 
9776 vikram.rag 5759 
  def send_getMarketPlaceItemsForPriceUpdate(self, source):
5760 
    self._oprot.writeMessageBegin('getMarketPlaceItemsForPriceUpdate', TMessageType.CALL, self._seqid)
5761 
    args = getMarketPlaceItemsForPriceUpdate_args()
5762 
    args.source = source
5763 
    args.write(self._oprot)
5764 
    self._oprot.writeMessageEnd()
5765 
    self._oprot.trans.flush()
5766 
 
5767 
  def recv_getMarketPlaceItemsForPriceUpdate(self, ):
5768 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5769 
    if mtype == TMessageType.EXCEPTION:
5770 
      x = TApplicationException()
5771 
      x.read(self._iprot)
5772 
      self._iprot.readMessageEnd()
5773 
      raise x
5774 
    result = getMarketPlaceItemsForPriceUpdate_result()
5775 
    result.read(self._iprot)
5776 
    self._iprot.readMessageEnd()
5777 
    if result.success is not None:
5778 
      return result.success
5779 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMarketPlaceItemsForPriceUpdate failed: unknown result");
5780 
 
9816 kshitij.so 5781 
  def updateMarketPlacePriceUpdateStatus(self, skulist, timestamp, source):
9776 vikram.rag 5782 
    """
5783 
    Parameters:
5784 
     - skulist
5785 
     - timestamp
9816 kshitij.so 5786 
     - source
9776 vikram.rag 5787 
    """
9816 kshitij.so 5788 
    self.send_updateMarketPlacePriceUpdateStatus(skulist, timestamp, source)
9776 vikram.rag 5789 
    self.recv_updateMarketPlacePriceUpdateStatus()
5790 
 
9816 kshitij.so 5791 
  def send_updateMarketPlacePriceUpdateStatus(self, skulist, timestamp, source):
9776 vikram.rag 5792 
    self._oprot.writeMessageBegin('updateMarketPlacePriceUpdateStatus', TMessageType.CALL, self._seqid)
5793 
    args = updateMarketPlacePriceUpdateStatus_args()
5794 
    args.skulist = skulist
5795 
    args.timestamp = timestamp
9816 kshitij.so 5796 
    args.source = source
9776 vikram.rag 5797 
    args.write(self._oprot)
5798 
    self._oprot.writeMessageEnd()
5799 
    self._oprot.trans.flush()
5800 
 
5801 
  def recv_updateMarketPlacePriceUpdateStatus(self, ):
5802 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5803 
    if mtype == TMessageType.EXCEPTION:
5804 
      x = TApplicationException()
5805 
      x.read(self._iprot)
5806 
      self._iprot.readMessageEnd()
5807 
      raise x
5808 
    result = updateMarketPlacePriceUpdateStatus_result()
5809 
    result.read(self._iprot)
5810 
    self._iprot.readMessageEnd()
5811 
    return
5812 
 
9861 rajveer 5813 
  def updateItemHoldInventory(self, itemHoldMap):
5814 
    """
5815 
    Parameters:
5816 
     - itemHoldMap
5817 
    """
5818 
    self.send_updateItemHoldInventory(itemHoldMap)
5819 
    self.recv_updateItemHoldInventory()
9776 vikram.rag 5820 
 
9861 rajveer 5821 
  def send_updateItemHoldInventory(self, itemHoldMap):
5822 
    self._oprot.writeMessageBegin('updateItemHoldInventory', TMessageType.CALL, self._seqid)
5823 
    args = updateItemHoldInventory_args()
5824 
    args.itemHoldMap = itemHoldMap
5825 
    args.write(self._oprot)
5826 
    self._oprot.writeMessageEnd()
5827 
    self._oprot.trans.flush()
5828 
 
5829 
  def recv_updateItemHoldInventory(self, ):
5830 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5831 
    if mtype == TMessageType.EXCEPTION:
5832 
      x = TApplicationException()
5833 
      x.read(self._iprot)
5834 
      self._iprot.readMessageEnd()
5835 
      raise x
5836 
    result = updateItemHoldInventory_result()
5837 
    result.read(self._iprot)
5838 
    self._iprot.readMessageEnd()
5839 
    return
5840 
 
9895 vikram.rag 5841 
  def updateNlcAtMarketplaces(self, item_id, vendor_id, nlc):
5842 
    """
5843 
    Parameters:
5844 
     - item_id
5845 
     - vendor_id
5846 
     - nlc
5847 
    """
5848 
    self.send_updateNlcAtMarketplaces(item_id, vendor_id, nlc)
5849 
    self.recv_updateNlcAtMarketplaces()
9861 rajveer 5850 
 
9895 vikram.rag 5851 
  def send_updateNlcAtMarketplaces(self, item_id, vendor_id, nlc):
5852 
    self._oprot.writeMessageBegin('updateNlcAtMarketplaces', TMessageType.CALL, self._seqid)
5853 
    args = updateNlcAtMarketplaces_args()
5854 
    args.item_id = item_id
5855 
    args.vendor_id = vendor_id
5856 
    args.nlc = nlc
5857 
    args.write(self._oprot)
5858 
    self._oprot.writeMessageEnd()
5859 
    self._oprot.trans.flush()
5860 
 
5861 
  def recv_updateNlcAtMarketplaces(self, ):
5862 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5863 
    if mtype == TMessageType.EXCEPTION:
5864 
      x = TApplicationException()
5865 
      x.read(self._iprot)
5866 
      self._iprot.readMessageEnd()
5867 
      raise x
5868 
    result = updateNlcAtMarketplaces_result()
5869 
    result.read(self._iprot)
5870 
    self._iprot.readMessageEnd()
5871 
    return
5872 
 
9945 vikram.rag 5873 
  def getAllFlipkartItems(self, ):
5874 
    self.send_getAllFlipkartItems()
5875 
    return self.recv_getAllFlipkartItems()
9895 vikram.rag 5876 
 
9945 vikram.rag 5877 
  def send_getAllFlipkartItems(self, ):
5878 
    self._oprot.writeMessageBegin('getAllFlipkartItems', TMessageType.CALL, self._seqid)
5879 
    args = getAllFlipkartItems_args()
5880 
    args.write(self._oprot)
5881 
    self._oprot.writeMessageEnd()
5882 
    self._oprot.trans.flush()
5883 
 
5884 
  def recv_getAllFlipkartItems(self, ):
5885 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5886 
    if mtype == TMessageType.EXCEPTION:
5887 
      x = TApplicationException()
5888 
      x.read(self._iprot)
5889 
      self._iprot.readMessageEnd()
5890 
      raise x
5891 
    result = getAllFlipkartItems_result()
5892 
    result.read(self._iprot)
5893 
    self._iprot.readMessageEnd()
5894 
    if result.success is not None:
5895 
      return result.success
5896 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFlipkartItems failed: unknown result");
5897 
 
10097 kshitij.so 5898 
  def addOrUpdateFlipkartItem(self, flipkartitem):
5899 
    """
5900 
    Parameters:
5901 
     - flipkartitem
5902 
    """
5903 
    self.send_addOrUpdateFlipkartItem(flipkartitem)
5904 
    return self.recv_addOrUpdateFlipkartItem()
9945 vikram.rag 5905 
 
10097 kshitij.so 5906 
  def send_addOrUpdateFlipkartItem(self, flipkartitem):
5907 
    self._oprot.writeMessageBegin('addOrUpdateFlipkartItem', TMessageType.CALL, self._seqid)
5908 
    args = addOrUpdateFlipkartItem_args()
5909 
    args.flipkartitem = flipkartitem
5910 
    args.write(self._oprot)
5911 
    self._oprot.writeMessageEnd()
5912 
    self._oprot.trans.flush()
5913 
 
5914 
  def recv_addOrUpdateFlipkartItem(self, ):
5915 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5916 
    if mtype == TMessageType.EXCEPTION:
5917 
      x = TApplicationException()
5918 
      x.read(self._iprot)
5919 
      self._iprot.readMessageEnd()
5920 
      raise x
5921 
    result = addOrUpdateFlipkartItem_result()
5922 
    result.read(self._iprot)
5923 
    self._iprot.readMessageEnd()
5924 
    if result.success is not None:
5925 
      return result.success
5926 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addOrUpdateFlipkartItem failed: unknown result");
5927 
 
5928 
  def getFlipkartItem(self, item_id):
5929 
    """
5930 
    Parameters:
5931 
     - item_id
5932 
    """
5933 
    self.send_getFlipkartItem(item_id)
5934 
    return self.recv_getFlipkartItem()
5935 
 
5936 
  def send_getFlipkartItem(self, item_id):
5937 
    self._oprot.writeMessageBegin('getFlipkartItem', TMessageType.CALL, self._seqid)
5938 
    args = getFlipkartItem_args()
5939 
    args.item_id = item_id
5940 
    args.write(self._oprot)
5941 
    self._oprot.writeMessageEnd()
5942 
    self._oprot.trans.flush()
5943 
 
5944 
  def recv_getFlipkartItem(self, ):
5945 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5946 
    if mtype == TMessageType.EXCEPTION:
5947 
      x = TApplicationException()
5948 
      x.read(self._iprot)
5949 
      self._iprot.readMessageEnd()
5950 
      raise x
5951 
    result = getFlipkartItem_result()
5952 
    result.read(self._iprot)
5953 
    self._iprot.readMessageEnd()
5954 
    if result.success is not None:
5955 
      return result.success
5956 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartItem failed: unknown result");
5957 
 
5958 
  def getFlipkartItemDetails(self, item_id):
5959 
    """
5960 
    Parameters:
5961 
     - item_id
5962 
    """
5963 
    self.send_getFlipkartItemDetails(item_id)
5964 
    return self.recv_getFlipkartItemDetails()
5965 
 
5966 
  def send_getFlipkartItemDetails(self, item_id):
5967 
    self._oprot.writeMessageBegin('getFlipkartItemDetails', TMessageType.CALL, self._seqid)
5968 
    args = getFlipkartItemDetails_args()
5969 
    args.item_id = item_id
5970 
    args.write(self._oprot)
5971 
    self._oprot.writeMessageEnd()
5972 
    self._oprot.trans.flush()
5973 
 
5974 
  def recv_getFlipkartItemDetails(self, ):
5975 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5976 
    if mtype == TMessageType.EXCEPTION:
5977 
      x = TApplicationException()
5978 
      x.read(self._iprot)
5979 
      self._iprot.readMessageEnd()
5980 
      raise x
5981 
    result = getFlipkartItemDetails_result()
5982 
    result.read(self._iprot)
5983 
    self._iprot.readMessageEnd()
5984 
    if result.success is not None:
5985 
      return result.success
5986 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartItemDetails failed: unknown result");
5987 
 
5988 
  def getFlipkartItems(self, offset, limit):
5989 
    """
5990 
    Parameters:
5991 
     - offset
5992 
     - limit
5993 
    """
5994 
    self.send_getFlipkartItems(offset, limit)
5995 
    return self.recv_getFlipkartItems()
5996 
 
5997 
  def send_getFlipkartItems(self, offset, limit):
5998 
    self._oprot.writeMessageBegin('getFlipkartItems', TMessageType.CALL, self._seqid)
5999 
    args = getFlipkartItems_args()
6000 
    args.offset = offset
6001 
    args.limit = limit
6002 
    args.write(self._oprot)
6003 
    self._oprot.writeMessageEnd()
6004 
    self._oprot.trans.flush()
6005 
 
6006 
  def recv_getFlipkartItems(self, ):
6007 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6008 
    if mtype == TMessageType.EXCEPTION:
6009 
      x = TApplicationException()
6010 
      x.read(self._iprot)
6011 
      self._iprot.readMessageEnd()
6012 
      raise x
6013 
    result = getFlipkartItems_result()
6014 
    result.read(self._iprot)
6015 
    self._iprot.readMessageEnd()
6016 
    if result.success is not None:
6017 
      return result.success
6018 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartItems failed: unknown result");
6019 
 
6020 
  def searchFlipkartItems(self, searchTerm, offset, limit):
6021 
    """
6022 
    Parameters:
6023 
     - searchTerm
6024 
     - offset
6025 
     - limit
6026 
    """
6027 
    self.send_searchFlipkartItems(searchTerm, offset, limit)
6028 
    return self.recv_searchFlipkartItems()
6029 
 
6030 
  def send_searchFlipkartItems(self, searchTerm, offset, limit):
6031 
    self._oprot.writeMessageBegin('searchFlipkartItems', TMessageType.CALL, self._seqid)
6032 
    args = searchFlipkartItems_args()
6033 
    args.searchTerm = searchTerm
6034 
    args.offset = offset
6035 
    args.limit = limit
6036 
    args.write(self._oprot)
6037 
    self._oprot.writeMessageEnd()
6038 
    self._oprot.trans.flush()
6039 
 
6040 
  def recv_searchFlipkartItems(self, ):
6041 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6042 
    if mtype == TMessageType.EXCEPTION:
6043 
      x = TApplicationException()
6044 
      x.read(self._iprot)
6045 
      self._iprot.readMessageEnd()
6046 
      raise x
6047 
    result = searchFlipkartItems_result()
6048 
    result.read(self._iprot)
6049 
    self._iprot.readMessageEnd()
6050 
    if result.success is not None:
6051 
      return result.success
6052 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchFlipkartItems failed: unknown result");
6053 
 
6054 
  def getCountForFlipkartItems(self, ):
6055 
    self.send_getCountForFlipkartItems()
6056 
    return self.recv_getCountForFlipkartItems()
6057 
 
6058 
  def send_getCountForFlipkartItems(self, ):
6059 
    self._oprot.writeMessageBegin('getCountForFlipkartItems', TMessageType.CALL, self._seqid)
6060 
    args = getCountForFlipkartItems_args()
6061 
    args.write(self._oprot)
6062 
    self._oprot.writeMessageEnd()
6063 
    self._oprot.trans.flush()
6064 
 
6065 
  def recv_getCountForFlipkartItems(self, ):
6066 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6067 
    if mtype == TMessageType.EXCEPTION:
6068 
      x = TApplicationException()
6069 
      x.read(self._iprot)
6070 
      self._iprot.readMessageEnd()
6071 
      raise x
6072 
    result = getCountForFlipkartItems_result()
6073 
    result.read(self._iprot)
6074 
    self._iprot.readMessageEnd()
6075 
    if result.success is not None:
6076 
      return result.success
6077 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForFlipkartItems failed: unknown result");
6078 
 
6079 
  def getFlipkartSearchResultCount(self, searchTerm):
6080 
    """
6081 
    Parameters:
6082 
     - searchTerm
6083 
    """
6084 
    self.send_getFlipkartSearchResultCount(searchTerm)
6085 
    return self.recv_getFlipkartSearchResultCount()
6086 
 
6087 
  def send_getFlipkartSearchResultCount(self, searchTerm):
6088 
    self._oprot.writeMessageBegin('getFlipkartSearchResultCount', TMessageType.CALL, self._seqid)
6089 
    args = getFlipkartSearchResultCount_args()
6090 
    args.searchTerm = searchTerm
6091 
    args.write(self._oprot)
6092 
    self._oprot.writeMessageEnd()
6093 
    self._oprot.trans.flush()
6094 
 
6095 
  def recv_getFlipkartSearchResultCount(self, ):
6096 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6097 
    if mtype == TMessageType.EXCEPTION:
6098 
      x = TApplicationException()
6099 
      x.read(self._iprot)
6100 
      self._iprot.readMessageEnd()
6101 
      raise x
6102 
    result = getFlipkartSearchResultCount_result()
6103 
    result.read(self._iprot)
6104 
    self._iprot.readMessageEnd()
6105 
    if result.success is not None:
6106 
      return result.success
6107 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartSearchResultCount failed: unknown result");
6108 
 
6109 
  def getAllFkItems(self, ):
6110 
    self.send_getAllFkItems()
6111 
    return self.recv_getAllFkItems()
6112 
 
6113 
  def send_getAllFkItems(self, ):
6114 
    self._oprot.writeMessageBegin('getAllFkItems', TMessageType.CALL, self._seqid)
6115 
    args = getAllFkItems_args()
6116 
    args.write(self._oprot)
6117 
    self._oprot.writeMessageEnd()
6118 
    self._oprot.trans.flush()
6119 
 
6120 
  def recv_getAllFkItems(self, ):
6121 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6122 
    if mtype == TMessageType.EXCEPTION:
6123 
      x = TApplicationException()
6124 
      x.read(self._iprot)
6125 
      self._iprot.readMessageEnd()
6126 
      raise x
6127 
    result = getAllFkItems_result()
6128 
    result.read(self._iprot)
6129 
    self._iprot.readMessageEnd()
6130 
    if result.success is not None:
6131 
      return result.success
6132 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFkItems failed: unknown result");
6133 
 
10140 vikram.rag 6134 
  def getFlipkartItemBySkyAtFlipkart(self, sku):
6135 
    """
6136 
    Parameters:
6137 
     - sku
6138 
    """
6139 
    self.send_getFlipkartItemBySkyAtFlipkart(sku)
6140 
    return self.recv_getFlipkartItemBySkyAtFlipkart()
10097 kshitij.so 6141 
 
10140 vikram.rag 6142 
  def send_getFlipkartItemBySkyAtFlipkart(self, sku):
6143 
    self._oprot.writeMessageBegin('getFlipkartItemBySkyAtFlipkart', TMessageType.CALL, self._seqid)
6144 
    args = getFlipkartItemBySkyAtFlipkart_args()
6145 
    args.sku = sku
6146 
    args.write(self._oprot)
6147 
    self._oprot.writeMessageEnd()
6148 
    self._oprot.trans.flush()
6149 
 
6150 
  def recv_getFlipkartItemBySkyAtFlipkart(self, ):
6151 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6152 
    if mtype == TMessageType.EXCEPTION:
6153 
      x = TApplicationException()
6154 
      x.read(self._iprot)
6155 
      self._iprot.readMessageEnd()
6156 
      raise x
6157 
    result = getFlipkartItemBySkyAtFlipkart_result()
6158 
    result.read(self._iprot)
6159 
    self._iprot.readMessageEnd()
6160 
    if result.success is not None:
6161 
      return result.success
6162 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartItemBySkyAtFlipkart failed: unknown result");
6163 
 
11015 kshitij.so 6164 
  def getMarketplaceHistory(self, source, offset, itemId):
6165 
    """
6166 
    Parameters:
6167 
     - source
6168 
     - offset
6169 
     - itemId
6170 
    """
6171 
    self.send_getMarketplaceHistory(source, offset, itemId)
6172 
    return self.recv_getMarketplaceHistory()
6173 
 
6174 
  def send_getMarketplaceHistory(self, source, offset, itemId):
6175 
    self._oprot.writeMessageBegin('getMarketplaceHistory', TMessageType.CALL, self._seqid)
6176 
    args = getMarketplaceHistory_args()
6177 
    args.source = source
6178 
    args.offset = offset
6179 
    args.itemId = itemId
6180 
    args.write(self._oprot)
6181 
    self._oprot.writeMessageEnd()
6182 
    self._oprot.trans.flush()
6183 
 
6184 
  def recv_getMarketplaceHistory(self, ):
6185 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6186 
    if mtype == TMessageType.EXCEPTION:
6187 
      x = TApplicationException()
6188 
      x.read(self._iprot)
6189 
      self._iprot.readMessageEnd()
6190 
      raise x
6191 
    result = getMarketplaceHistory_result()
6192 
    result.read(self._iprot)
6193 
    self._iprot.readMessageEnd()
6194 
    if result.success is not None:
6195 
      return result.success
6196 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMarketplaceHistory failed: unknown result");
6197 
 
10909 vikram.rag 6198 
  def getAllFbbListedItems(self, ):
6199 
    self.send_getAllFbbListedItems()
6200 
    return self.recv_getAllFbbListedItems()
10140 vikram.rag 6201 
 
10909 vikram.rag 6202 
  def send_getAllFbbListedItems(self, ):
6203 
    self._oprot.writeMessageBegin('getAllFbbListedItems', TMessageType.CALL, self._seqid)
6204 
    args = getAllFbbListedItems_args()
6205 
    args.write(self._oprot)
6206 
    self._oprot.writeMessageEnd()
6207 
    self._oprot.trans.flush()
6208 
 
6209 
  def recv_getAllFbbListedItems(self, ):
6210 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6211 
    if mtype == TMessageType.EXCEPTION:
6212 
      x = TApplicationException()
6213 
      x.read(self._iprot)
6214 
      self._iprot.readMessageEnd()
6215 
      raise x
6216 
    result = getAllFbbListedItems_result()
6217 
    result.read(self._iprot)
6218 
    self._iprot.readMessageEnd()
6219 
    if result.success is not None:
6220 
      return result.success
6221 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbbListedItems failed: unknown result");
6222 
 
10924 vikram.rag 6223 
  def getAllFbbPricingItems(self, ):
6224 
    self.send_getAllFbbPricingItems()
6225 
    return self.recv_getAllFbbPricingItems()
10909 vikram.rag 6226 
 
10924 vikram.rag 6227 
  def send_getAllFbbPricingItems(self, ):
6228 
    self._oprot.writeMessageBegin('getAllFbbPricingItems', TMessageType.CALL, self._seqid)
6229 
    args = getAllFbbPricingItems_args()
6230 
    args.write(self._oprot)
6231 
    self._oprot.writeMessageEnd()
6232 
    self._oprot.trans.flush()
6233 
 
6234 
  def recv_getAllFbbPricingItems(self, ):
6235 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6236 
    if mtype == TMessageType.EXCEPTION:
6237 
      x = TApplicationException()
6238 
      x.read(self._iprot)
6239 
      self._iprot.readMessageEnd()
6240 
      raise x
6241 
    result = getAllFbbPricingItems_result()
6242 
    result.read(self._iprot)
6243 
    self._iprot.readMessageEnd()
6244 
    if result.success is not None:
6245 
      return result.success
6246 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbbPricingItems failed: unknown result");
6247 
 
11015 kshitij.so 6248 
  def getCountForMarketplaceHistory(self, source, itemId):
6249 
    """
6250 
    Parameters:
6251 
     - source
6252 
     - itemId
6253 
    """
6254 
    self.send_getCountForMarketplaceHistory(source, itemId)
6255 
    return self.recv_getCountForMarketplaceHistory()
10924 vikram.rag 6256 
 
11015 kshitij.so 6257 
  def send_getCountForMarketplaceHistory(self, source, itemId):
6258 
    self._oprot.writeMessageBegin('getCountForMarketplaceHistory', TMessageType.CALL, self._seqid)
6259 
    args = getCountForMarketplaceHistory_args()
6260 
    args.source = source
6261 
    args.itemId = itemId
6262 
    args.write(self._oprot)
6263 
    self._oprot.writeMessageEnd()
6264 
    self._oprot.trans.flush()
6265 
 
6266 
  def recv_getCountForMarketplaceHistory(self, ):
6267 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6268 
    if mtype == TMessageType.EXCEPTION:
6269 
      x = TApplicationException()
6270 
      x.read(self._iprot)
6271 
      self._iprot.readMessageEnd()
6272 
      raise x
6273 
    result = getCountForMarketplaceHistory_result()
6274 
    result.read(self._iprot)
6275 
    self._iprot.readMessageEnd()
6276 
    if result.success is not None:
6277 
      return result.success
6278 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForMarketplaceHistory failed: unknown result");
6279 
 
6280 
  def getMarketplaceHistoryByDate(self, source, startDate, endDate, offset, limit, itemId):
6281 
    """
6282 
    Parameters:
6283 
     - source
6284 
     - startDate
6285 
     - endDate
6286 
     - offset
6287 
     - limit
6288 
     - itemId
6289 
    """
6290 
    self.send_getMarketplaceHistoryByDate(source, startDate, endDate, offset, limit, itemId)
6291 
    return self.recv_getMarketplaceHistoryByDate()
6292 
 
6293 
  def send_getMarketplaceHistoryByDate(self, source, startDate, endDate, offset, limit, itemId):
6294 
    self._oprot.writeMessageBegin('getMarketplaceHistoryByDate', TMessageType.CALL, self._seqid)
6295 
    args = getMarketplaceHistoryByDate_args()
6296 
    args.source = source
6297 
    args.startDate = startDate
6298 
    args.endDate = endDate
6299 
    args.offset = offset
6300 
    args.limit = limit
6301 
    args.itemId = itemId
6302 
    args.write(self._oprot)
6303 
    self._oprot.writeMessageEnd()
6304 
    self._oprot.trans.flush()
6305 
 
6306 
  def recv_getMarketplaceHistoryByDate(self, ):
6307 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6308 
    if mtype == TMessageType.EXCEPTION:
6309 
      x = TApplicationException()
6310 
      x.read(self._iprot)
6311 
      self._iprot.readMessageEnd()
6312 
      raise x
6313 
    result = getMarketplaceHistoryByDate_result()
6314 
    result.read(self._iprot)
6315 
    self._iprot.readMessageEnd()
6316 
    if result.success is not None:
6317 
      return result.success
6318 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMarketplaceHistoryByDate failed: unknown result");
6319 
 
11531 vikram.rag 6320 
  def getPrivateDealDetails(self, item_id):
6321 
    """
6322 
    Parameters:
6323 
     - item_id
6324 
    """
6325 
    self.send_getPrivateDealDetails(item_id)
6326 
    return self.recv_getPrivateDealDetails()
11015 kshitij.so 6327 
 
11531 vikram.rag 6328 
  def send_getPrivateDealDetails(self, item_id):
6329 
    self._oprot.writeMessageBegin('getPrivateDealDetails', TMessageType.CALL, self._seqid)
6330 
    args = getPrivateDealDetails_args()
6331 
    args.item_id = item_id
6332 
    args.write(self._oprot)
6333 
    self._oprot.writeMessageEnd()
6334 
    self._oprot.trans.flush()
6335 
 
6336 
  def recv_getPrivateDealDetails(self, ):
6337 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6338 
    if mtype == TMessageType.EXCEPTION:
6339 
      x = TApplicationException()
6340 
      x.read(self._iprot)
6341 
      self._iprot.readMessageEnd()
6342 
      raise x
6343 
    result = getPrivateDealDetails_result()
6344 
    result.read(self._iprot)
6345 
    self._iprot.readMessageEnd()
6346 
    if result.success is not None:
6347 
      return result.success
6348 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrivateDealDetails failed: unknown result");
6349 
 
6350 
  def getPrivateDealItems(self, offset, limit):
6351 
    """
6352 
    Parameters:
6353 
     - offset
6354 
     - limit
6355 
    """
6356 
    self.send_getPrivateDealItems(offset, limit)
6357 
    return self.recv_getPrivateDealItems()
6358 
 
6359 
  def send_getPrivateDealItems(self, offset, limit):
6360 
    self._oprot.writeMessageBegin('getPrivateDealItems', TMessageType.CALL, self._seqid)
6361 
    args = getPrivateDealItems_args()
6362 
    args.offset = offset
6363 
    args.limit = limit
6364 
    args.write(self._oprot)
6365 
    self._oprot.writeMessageEnd()
6366 
    self._oprot.trans.flush()
6367 
 
6368 
  def recv_getPrivateDealItems(self, ):
6369 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6370 
    if mtype == TMessageType.EXCEPTION:
6371 
      x = TApplicationException()
6372 
      x.read(self._iprot)
6373 
      self._iprot.readMessageEnd()
6374 
      raise x
6375 
    result = getPrivateDealItems_result()
6376 
    result.read(self._iprot)
6377 
    self._iprot.readMessageEnd()
6378 
    if result.success is not None:
6379 
      return result.success
6380 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrivateDealItems failed: unknown result");
6381 
 
11653 amit.gupta 6382 
  def getAllActivePrivateDeals(self, itemIds, daysDelta):
6383 
    """
6384 
    Parameters:
6385 
     - itemIds
6386 
     - daysDelta
6387 
    """
6388 
    self.send_getAllActivePrivateDeals(itemIds, daysDelta)
11592 amit.gupta 6389 
    return self.recv_getAllActivePrivateDeals()
6390 
 
11653 amit.gupta 6391 
  def send_getAllActivePrivateDeals(self, itemIds, daysDelta):
11592 amit.gupta 6392 
    self._oprot.writeMessageBegin('getAllActivePrivateDeals', TMessageType.CALL, self._seqid)
6393 
    args = getAllActivePrivateDeals_args()
11653 amit.gupta 6394 
    args.itemIds = itemIds
6395 
    args.daysDelta = daysDelta
11592 amit.gupta 6396 
    args.write(self._oprot)
6397 
    self._oprot.writeMessageEnd()
6398 
    self._oprot.trans.flush()
6399 
 
6400 
  def recv_getAllActivePrivateDeals(self, ):
6401 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6402 
    if mtype == TMessageType.EXCEPTION:
6403 
      x = TApplicationException()
6404 
      x.read(self._iprot)
6405 
      self._iprot.readMessageEnd()
6406 
      raise x
6407 
    result = getAllActivePrivateDeals_result()
6408 
    result.read(self._iprot)
6409 
    self._iprot.readMessageEnd()
6410 
    if result.success is not None:
6411 
      return result.success
6412 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllActivePrivateDeals failed: unknown result");
6413 
 
11531 vikram.rag 6414 
  def addOrUpdatePrivateDeal(self, privateDeal):
6415 
    """
6416 
    Parameters:
6417 
     - privateDeal
6418 
    """
6419 
    self.send_addOrUpdatePrivateDeal(privateDeal)
6420 
    return self.recv_addOrUpdatePrivateDeal()
6421 
 
6422 
  def send_addOrUpdatePrivateDeal(self, privateDeal):
6423 
    self._oprot.writeMessageBegin('addOrUpdatePrivateDeal', TMessageType.CALL, self._seqid)
6424 
    args = addOrUpdatePrivateDeal_args()
6425 
    args.privateDeal = privateDeal
6426 
    args.write(self._oprot)
6427 
    self._oprot.writeMessageEnd()
6428 
    self._oprot.trans.flush()
6429 
 
6430 
  def recv_addOrUpdatePrivateDeal(self, ):
6431 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6432 
    if mtype == TMessageType.EXCEPTION:
6433 
      x = TApplicationException()
6434 
      x.read(self._iprot)
6435 
      self._iprot.readMessageEnd()
6436 
      raise x
6437 
    result = addOrUpdatePrivateDeal_result()
6438 
    result.read(self._iprot)
6439 
    self._iprot.readMessageEnd()
6440 
    if result.success is not None:
6441 
      return result.success
6442 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addOrUpdatePrivateDeal failed: unknown result");
6443 
 
11635 vikram.rag 6444 
  def getPrivateDealsCatalogIds(self, beginIndex, totalItems):
6445 
    """
6446 
    Parameters:
6447 
     - beginIndex
6448 
     - totalItems
6449 
    """
6450 
    self.send_getPrivateDealsCatalogIds(beginIndex, totalItems)
6451 
    return self.recv_getPrivateDealsCatalogIds()
11531 vikram.rag 6452 
 
11635 vikram.rag 6453 
  def send_getPrivateDealsCatalogIds(self, beginIndex, totalItems):
6454 
    self._oprot.writeMessageBegin('getPrivateDealsCatalogIds', TMessageType.CALL, self._seqid)
6455 
    args = getPrivateDealsCatalogIds_args()
6456 
    args.beginIndex = beginIndex
6457 
    args.totalItems = totalItems
6458 
    args.write(self._oprot)
6459 
    self._oprot.writeMessageEnd()
6460 
    self._oprot.trans.flush()
6461 
 
6462 
  def recv_getPrivateDealsCatalogIds(self, ):
6463 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6464 
    if mtype == TMessageType.EXCEPTION:
6465 
      x = TApplicationException()
6466 
      x.read(self._iprot)
6467 
      self._iprot.readMessageEnd()
6468 
      raise x
6469 
    result = getPrivateDealsCatalogIds_result()
6470 
    result.read(self._iprot)
6471 
    self._iprot.readMessageEnd()
6472 
    if result.success is not None:
6473 
      return result.success
6474 
    if result.cex is not None:
6475 
      raise result.cex
6476 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrivateDealsCatalogIds failed: unknown result");
6477 
 
11645 amit.gupta 6478 
  def getPrivateDealsCount(self, ):
6479 
    self.send_getPrivateDealsCount()
6480 
    return self.recv_getPrivateDealsCount()
11635 vikram.rag 6481 
 
11645 amit.gupta 6482 
  def send_getPrivateDealsCount(self, ):
6483 
    self._oprot.writeMessageBegin('getPrivateDealsCount', TMessageType.CALL, self._seqid)
6484 
    args = getPrivateDealsCount_args()
6485 
    args.write(self._oprot)
6486 
    self._oprot.writeMessageEnd()
6487 
    self._oprot.trans.flush()
6488 
 
6489 
  def recv_getPrivateDealsCount(self, ):
6490 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6491 
    if mtype == TMessageType.EXCEPTION:
6492 
      x = TApplicationException()
6493 
      x.read(self._iprot)
6494 
      self._iprot.readMessageEnd()
6495 
      raise x
6496 
    result = getPrivateDealsCount_result()
6497 
    result.read(self._iprot)
6498 
    self._iprot.readMessageEnd()
6499 
    if result.success is not None:
6500 
      return result.success
6501 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrivateDealsCount failed: unknown result");
6502 
 
11905 kshitij.so 6503 
  def getAmazonOutSyncItems(self, item_id):
6504 
    """
6505 
    Parameters:
6506 
     - item_id
6507 
    """
6508 
    self.send_getAmazonOutSyncItems(item_id)
6509 
    return self.recv_getAmazonOutSyncItems()
11645 amit.gupta 6510 
 
11905 kshitij.so 6511 
  def send_getAmazonOutSyncItems(self, item_id):
6512 
    self._oprot.writeMessageBegin('getAmazonOutSyncItems', TMessageType.CALL, self._seqid)
6513 
    args = getAmazonOutSyncItems_args()
6514 
    args.item_id = item_id
6515 
    args.write(self._oprot)
6516 
    self._oprot.writeMessageEnd()
6517 
    self._oprot.trans.flush()
6518 
 
6519 
  def recv_getAmazonOutSyncItems(self, ):
6520 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6521 
    if mtype == TMessageType.EXCEPTION:
6522 
      x = TApplicationException()
6523 
      x.read(self._iprot)
6524 
      self._iprot.readMessageEnd()
6525 
      raise x
6526 
    result = getAmazonOutSyncItems_result()
6527 
    result.read(self._iprot)
6528 
    self._iprot.readMessageEnd()
6529 
    if result.success is not None:
6530 
      return result.success
6531 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonOutSyncItems failed: unknown result");
6532 
 
6533 
  def getAllPrivateDealsComparison(self, ):
6534 
    self.send_getAllPrivateDealsComparison()
6535 
    return self.recv_getAllPrivateDealsComparison()
6536 
 
6537 
  def send_getAllPrivateDealsComparison(self, ):
6538 
    self._oprot.writeMessageBegin('getAllPrivateDealsComparison', TMessageType.CALL, self._seqid)
6539 
    args = getAllPrivateDealsComparison_args()
6540 
    args.write(self._oprot)
6541 
    self._oprot.writeMessageEnd()
6542 
    self._oprot.trans.flush()
6543 
 
6544 
  def recv_getAllPrivateDealsComparison(self, ):
6545 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6546 
    if mtype == TMessageType.EXCEPTION:
6547 
      x = TApplicationException()
6548 
      x.read(self._iprot)
6549 
      self._iprot.readMessageEnd()
6550 
      raise x
6551 
    result = getAllPrivateDealsComparison_result()
6552 
    result.read(self._iprot)
6553 
    self._iprot.readMessageEnd()
6554 
    if result.success is not None:
6555 
      return result.success
6556 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllPrivateDealsComparison failed: unknown result");
6557 
 
12133 kshitij.so 6558 
  def getAllSnapdealMarketplaceItem(self, ):
6559 
    self.send_getAllSnapdealMarketplaceItem()
6560 
    return self.recv_getAllSnapdealMarketplaceItem()
11905 kshitij.so 6561 
 
12133 kshitij.so 6562 
  def send_getAllSnapdealMarketplaceItem(self, ):
6563 
    self._oprot.writeMessageBegin('getAllSnapdealMarketplaceItem', TMessageType.CALL, self._seqid)
6564 
    args = getAllSnapdealMarketplaceItem_args()
6565 
    args.write(self._oprot)
6566 
    self._oprot.writeMessageEnd()
6567 
    self._oprot.trans.flush()
6568 
 
6569 
  def recv_getAllSnapdealMarketplaceItem(self, ):
6570 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6571 
    if mtype == TMessageType.EXCEPTION:
6572 
      x = TApplicationException()
6573 
      x.read(self._iprot)
6574 
      self._iprot.readMessageEnd()
6575 
      raise x
6576 
    result = getAllSnapdealMarketplaceItem_result()
6577 
    result.read(self._iprot)
6578 
    self._iprot.readMessageEnd()
6579 
    if result.success is not None:
6580 
      return result.success
6581 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSnapdealMarketplaceItem failed: unknown result");
6582 
 
6583 
  def getAllFlipkartMarketplaceItem(self, ):
6584 
    self.send_getAllFlipkartMarketplaceItem()
6585 
    return self.recv_getAllFlipkartMarketplaceItem()
6586 
 
6587 
  def send_getAllFlipkartMarketplaceItem(self, ):
6588 
    self._oprot.writeMessageBegin('getAllFlipkartMarketplaceItem', TMessageType.CALL, self._seqid)
6589 
    args = getAllFlipkartMarketplaceItem_args()
6590 
    args.write(self._oprot)
6591 
    self._oprot.writeMessageEnd()
6592 
    self._oprot.trans.flush()
6593 
 
6594 
  def recv_getAllFlipkartMarketplaceItem(self, ):
6595 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6596 
    if mtype == TMessageType.EXCEPTION:
6597 
      x = TApplicationException()
6598 
      x.read(self._iprot)
6599 
      self._iprot.readMessageEnd()
6600 
      raise x
6601 
    result = getAllFlipkartMarketplaceItem_result()
6602 
    result.read(self._iprot)
6603 
    self._iprot.readMessageEnd()
6604 
    if result.success is not None:
6605 
      return result.success
6606 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFlipkartMarketplaceItem failed: unknown result");
6607 
 
12243 kshitij.so 6608 
  def addCompetitorScraping(self, competitorPricingMap):
6609 
    """
6610 
    Parameters:
6611 
     - competitorPricingMap
6612 
    """
6613 
    self.send_addCompetitorScraping(competitorPricingMap)
6614 
    self.recv_addCompetitorScraping()
12133 kshitij.so 6615 
 
12243 kshitij.so 6616 
  def send_addCompetitorScraping(self, competitorPricingMap):
6617 
    self._oprot.writeMessageBegin('addCompetitorScraping', TMessageType.CALL, self._seqid)
6618 
    args = addCompetitorScraping_args()
6619 
    args.competitorPricingMap = competitorPricingMap
6620 
    args.write(self._oprot)
6621 
    self._oprot.writeMessageEnd()
6622 
    self._oprot.trans.flush()
6623 
 
6624 
  def recv_addCompetitorScraping(self, ):
6625 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6626 
    if mtype == TMessageType.EXCEPTION:
6627 
      x = TApplicationException()
6628 
      x.read(self._iprot)
6629 
      self._iprot.readMessageEnd()
6630 
      raise x
6631 
    result = addCompetitorScraping_result()
6632 
    result.read(self._iprot)
6633 
    self._iprot.readMessageEnd()
6634 
    return
6635 
 
6636 
  def getPreviousCompetitorScraping(self, delta):
6637 
    """
6638 
    Parameters:
6639 
     - delta
6640 
    """
6641 
    self.send_getPreviousCompetitorScraping(delta)
6642 
    return self.recv_getPreviousCompetitorScraping()
6643 
 
6644 
  def send_getPreviousCompetitorScraping(self, delta):
6645 
    self._oprot.writeMessageBegin('getPreviousCompetitorScraping', TMessageType.CALL, self._seqid)
6646 
    args = getPreviousCompetitorScraping_args()
6647 
    args.delta = delta
6648 
    args.write(self._oprot)
6649 
    self._oprot.writeMessageEnd()
6650 
    self._oprot.trans.flush()
6651 
 
6652 
  def recv_getPreviousCompetitorScraping(self, ):
6653 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6654 
    if mtype == TMessageType.EXCEPTION:
6655 
      x = TApplicationException()
6656 
      x.read(self._iprot)
6657 
      self._iprot.readMessageEnd()
6658 
      raise x
6659 
    result = getPreviousCompetitorScraping_result()
6660 
    result.read(self._iprot)
6661 
    self._iprot.readMessageEnd()
6662 
    if result.success is not None:
6663 
      return result.success
6664 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPreviousCompetitorScraping failed: unknown result");
6665 
 
12256 kshitij.so 6666 
  def getUploadResultById(self, uploadId):
6667 
    """
6668 
    Parameters:
6669 
     - uploadId
6670 
    """
6671 
    self.send_getUploadResultById(uploadId)
6672 
    return self.recv_getUploadResultById()
12243 kshitij.so 6673 
 
12256 kshitij.so 6674 
  def send_getUploadResultById(self, uploadId):
6675 
    self._oprot.writeMessageBegin('getUploadResultById', TMessageType.CALL, self._seqid)
6676 
    args = getUploadResultById_args()
6677 
    args.uploadId = uploadId
6678 
    args.write(self._oprot)
6679 
    self._oprot.writeMessageEnd()
6680 
    self._oprot.trans.flush()
6681 
 
6682 
  def recv_getUploadResultById(self, ):
6683 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6684 
    if mtype == TMessageType.EXCEPTION:
6685 
      x = TApplicationException()
6686 
      x.read(self._iprot)
6687 
      self._iprot.readMessageEnd()
6688 
      raise x
6689 
    result = getUploadResultById_result()
6690 
    result.read(self._iprot)
6691 
    self._iprot.readMessageEnd()
6692 
    if result.success is not None:
6693 
      return result.success
6694 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUploadResultById failed: unknown result");
6695 
 
12363 kshitij.so 6696 
  def addAmazonPromotion(self, amazonPromotions):
6697 
    """
6698 
    Parameters:
6699 
     - amazonPromotions
6700 
    """
6701 
    self.send_addAmazonPromotion(amazonPromotions)
6702 
    return self.recv_addAmazonPromotion()
12256 kshitij.so 6703 
 
12363 kshitij.so 6704 
  def send_addAmazonPromotion(self, amazonPromotions):
6705 
    self._oprot.writeMessageBegin('addAmazonPromotion', TMessageType.CALL, self._seqid)
6706 
    args = addAmazonPromotion_args()
6707 
    args.amazonPromotions = amazonPromotions
6708 
    args.write(self._oprot)
6709 
    self._oprot.writeMessageEnd()
6710 
    self._oprot.trans.flush()
6711 
 
6712 
  def recv_addAmazonPromotion(self, ):
6713 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6714 
    if mtype == TMessageType.EXCEPTION:
6715 
      x = TApplicationException()
6716 
      x.read(self._iprot)
6717 
      self._iprot.readMessageEnd()
6718 
      raise x
6719 
    result = addAmazonPromotion_result()
6720 
    result.read(self._iprot)
6721 
    self._iprot.readMessageEnd()
6722 
    if result.success is not None:
6723 
      return result.success
12947 kshitij.so 6724 
    if result.cex is not None:
6725 
      raise result.cex
12363 kshitij.so 6726 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAmazonPromotion failed: unknown result");
6727 
 
6728 
  def getAmazonPromotion(self, startDate, endDate):
6729 
    """
6730 
    Parameters:
6731 
     - startDate
6732 
     - endDate
6733 
    """
6734 
    self.send_getAmazonPromotion(startDate, endDate)
6735 
    return self.recv_getAmazonPromotion()
6736 
 
6737 
  def send_getAmazonPromotion(self, startDate, endDate):
6738 
    self._oprot.writeMessageBegin('getAmazonPromotion', TMessageType.CALL, self._seqid)
6739 
    args = getAmazonPromotion_args()
6740 
    args.startDate = startDate
6741 
    args.endDate = endDate
6742 
    args.write(self._oprot)
6743 
    self._oprot.writeMessageEnd()
6744 
    self._oprot.trans.flush()
6745 
 
6746 
  def recv_getAmazonPromotion(self, ):
6747 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6748 
    if mtype == TMessageType.EXCEPTION:
6749 
      x = TApplicationException()
6750 
      x.read(self._iprot)
6751 
      self._iprot.readMessageEnd()
6752 
      raise x
6753 
    result = getAmazonPromotion_result()
6754 
    result.read(self._iprot)
6755 
    self._iprot.readMessageEnd()
6756 
    if result.success is not None:
6757 
      return result.success
6758 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonPromotion failed: unknown result");
6759 
 
6760 
  def updateAmazonPromotion(self, amazonPromotions):
6761 
    """
6762 
    Parameters:
6763 
     - amazonPromotions
6764 
    """
6765 
    self.send_updateAmazonPromotion(amazonPromotions)
6766 
    return self.recv_updateAmazonPromotion()
6767 
 
6768 
  def send_updateAmazonPromotion(self, amazonPromotions):
6769 
    self._oprot.writeMessageBegin('updateAmazonPromotion', TMessageType.CALL, self._seqid)
6770 
    args = updateAmazonPromotion_args()
6771 
    args.amazonPromotions = amazonPromotions
6772 
    args.write(self._oprot)
6773 
    self._oprot.writeMessageEnd()
6774 
    self._oprot.trans.flush()
6775 
 
6776 
  def recv_updateAmazonPromotion(self, ):
6777 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6778 
    if mtype == TMessageType.EXCEPTION:
6779 
      x = TApplicationException()
6780 
      x.read(self._iprot)
6781 
      self._iprot.readMessageEnd()
6782 
      raise x
6783 
    result = updateAmazonPromotion_result()
6784 
    result.read(self._iprot)
6785 
    self._iprot.readMessageEnd()
6786 
    if result.success is not None:
6787 
      return result.success
6788 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateAmazonPromotion failed: unknown result");
6789 
 
12567 amit.gupta 6790 
  def markPartiallyActive(self, itemId, categoryId):
6791 
    """
6792 
    Parameters:
6793 
     - itemId
6794 
     - categoryId
6795 
    """
6796 
    self.send_markPartiallyActive(itemId, categoryId)
6797 
    return self.recv_markPartiallyActive()
12363 kshitij.so 6798 
 
12567 amit.gupta 6799 
  def send_markPartiallyActive(self, itemId, categoryId):
6800 
    self._oprot.writeMessageBegin('markPartiallyActive', TMessageType.CALL, self._seqid)
6801 
    args = markPartiallyActive_args()
6802 
    args.itemId = itemId
6803 
    args.categoryId = categoryId
6804 
    args.write(self._oprot)
6805 
    self._oprot.writeMessageEnd()
6806 
    self._oprot.trans.flush()
6807 
 
6808 
  def recv_markPartiallyActive(self, ):
6809 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6810 
    if mtype == TMessageType.EXCEPTION:
6811 
      x = TApplicationException()
6812 
      x.read(self._iprot)
6813 
      self._iprot.readMessageEnd()
6814 
      raise x
6815 
    result = markPartiallyActive_result()
6816 
    result.read(self._iprot)
6817 
    self._iprot.readMessageEnd()
6818 
    if result.success is not None:
6819 
      return result.success
6820 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markPartiallyActive failed: unknown result");
6821 
 
6822 
  def updateItemStateVat(self, itemId, statevat):
6823 
    """
6824 
    Parameters:
6825 
     - itemId
6826 
     - statevat
6827 
    """
6828 
    self.send_updateItemStateVat(itemId, statevat)
6829 
    return self.recv_updateItemStateVat()
6830 
 
6831 
  def send_updateItemStateVat(self, itemId, statevat):
6832 
    self._oprot.writeMessageBegin('updateItemStateVat', TMessageType.CALL, self._seqid)
6833 
    args = updateItemStateVat_args()
6834 
    args.itemId = itemId
6835 
    args.statevat = statevat
6836 
    args.write(self._oprot)
6837 
    self._oprot.writeMessageEnd()
6838 
    self._oprot.trans.flush()
6839 
 
6840 
  def recv_updateItemStateVat(self, ):
6841 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6842 
    if mtype == TMessageType.EXCEPTION:
6843 
      x = TApplicationException()
6844 
      x.read(self._iprot)
6845 
      self._iprot.readMessageEnd()
6846 
      raise x
6847 
    result = updateItemStateVat_result()
6848 
    result.read(self._iprot)
6849 
    self._iprot.readMessageEnd()
6850 
    if result.success is not None:
6851 
      return result.success
6852 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItemStateVat failed: unknown result");
6853 
 
12620 amit.gupta 6854 
  def getExAffiliateItemInfo(self, ):
6855 
    self.send_getExAffiliateItemInfo()
6856 
    return self.recv_getExAffiliateItemInfo()
12567 amit.gupta 6857 
 
12620 amit.gupta 6858 
  def send_getExAffiliateItemInfo(self, ):
6859 
    self._oprot.writeMessageBegin('getExAffiliateItemInfo', TMessageType.CALL, self._seqid)
6860 
    args = getExAffiliateItemInfo_args()
6861 
    args.write(self._oprot)
6862 
    self._oprot.writeMessageEnd()
6863 
    self._oprot.trans.flush()
6864 
 
6865 
  def recv_getExAffiliateItemInfo(self, ):
6866 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6867 
    if mtype == TMessageType.EXCEPTION:
6868 
      x = TApplicationException()
6869 
      x.read(self._iprot)
6870 
      self._iprot.readMessageEnd()
6871 
      raise x
6872 
    result = getExAffiliateItemInfo_result()
6873 
    result.read(self._iprot)
6874 
    self._iprot.readMessageEnd()
6875 
    if result.success is not None:
6876 
      return result.success
6877 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getExAffiliateItemInfo failed: unknown result");
6878 
 
12888 kshitij.so 6879 
  def getAllItemstoListOnFbg(self, ):
6880 
    self.send_getAllItemstoListOnFbg()
6881 
    return self.recv_getAllItemstoListOnFbg()
12620 amit.gupta 6882 
 
12888 kshitij.so 6883 
  def send_getAllItemstoListOnFbg(self, ):
6884 
    self._oprot.writeMessageBegin('getAllItemstoListOnFbg', TMessageType.CALL, self._seqid)
6885 
    args = getAllItemstoListOnFbg_args()
6886 
    args.write(self._oprot)
6887 
    self._oprot.writeMessageEnd()
6888 
    self._oprot.trans.flush()
6889 
 
6890 
  def recv_getAllItemstoListOnFbg(self, ):
6891 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6892 
    if mtype == TMessageType.EXCEPTION:
6893 
      x = TApplicationException()
6894 
      x.read(self._iprot)
6895 
      self._iprot.readMessageEnd()
6896 
      raise x
6897 
    result = getAllItemstoListOnFbg_result()
6898 
    result.read(self._iprot)
6899 
    self._iprot.readMessageEnd()
6900 
    if result.success is not None:
6901 
      return result.success
6902 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnFbg failed: unknown result");
6903 
 
12892 kshitij.so 6904 
  def getAllFbgListedItems(self, ):
6905 
    self.send_getAllFbgListedItems()
6906 
    return self.recv_getAllFbgListedItems()
12888 kshitij.so 6907 
 
12892 kshitij.so 6908 
  def send_getAllFbgListedItems(self, ):
6909 
    self._oprot.writeMessageBegin('getAllFbgListedItems', TMessageType.CALL, self._seqid)
6910 
    args = getAllFbgListedItems_args()
6911 
    args.write(self._oprot)
6912 
    self._oprot.writeMessageEnd()
6913 
    self._oprot.trans.flush()
6914 
 
6915 
  def recv_getAllFbgListedItems(self, ):
6916 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6917 
    if mtype == TMessageType.EXCEPTION:
6918 
      x = TApplicationException()
6919 
      x.read(self._iprot)
6920 
      self._iprot.readMessageEnd()
6921 
      raise x
6922 
    result = getAllFbgListedItems_result()
6923 
    result.read(self._iprot)
6924 
    self._iprot.readMessageEnd()
6925 
    if result.success is not None:
6926 
      return result.success
6927 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbgListedItems failed: unknown result");
6928 
 
13136 amit.gupta 6929 
  def checkServices(self, lines):
6930 
    """
6931 
    Parameters:
6932 
     - lines
6933 
    """
6934 
    self.send_checkServices(lines)
6935 
    return self.recv_checkServices()
12892 kshitij.so 6936 
 
13136 amit.gupta 6937 
  def send_checkServices(self, lines):
6938 
    self._oprot.writeMessageBegin('checkServices', TMessageType.CALL, self._seqid)
6939 
    args = checkServices_args()
6940 
    args.lines = lines
6941 
    args.write(self._oprot)
6942 
    self._oprot.writeMessageEnd()
6943 
    self._oprot.trans.flush()
6944 
 
6945 
  def recv_checkServices(self, ):
6946 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6947 
    if mtype == TMessageType.EXCEPTION:
6948 
      x = TApplicationException()
6949 
      x.read(self._iprot)
6950 
      self._iprot.readMessageEnd()
6951 
      raise x
6952 
    result = checkServices_result()
6953 
    result.read(self._iprot)
6954 
    self._iprot.readMessageEnd()
6955 
    if result.success is not None:
6956 
      return result.success
6957 
    if result.cex is not None:
6958 
      raise result.cex
6959 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkServices failed: unknown result");
6960 
 
13709 manish.sha 6961 
  def addHsItem(self, hsItems):
6962 
    """
6963 
    Parameters:
6964 
     - hsItems
6965 
    """
6966 
    self.send_addHsItem(hsItems)
6967 
    self.recv_addHsItem()
13136 amit.gupta 6968 
 
13709 manish.sha 6969 
  def send_addHsItem(self, hsItems):
6970 
    self._oprot.writeMessageBegin('addHsItem', TMessageType.CALL, self._seqid)
6971 
    args = addHsItem_args()
6972 
    args.hsItems = hsItems
6973 
    args.write(self._oprot)
6974 
    self._oprot.writeMessageEnd()
6975 
    self._oprot.trans.flush()
6976 
 
6977 
  def recv_addHsItem(self, ):
6978 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6979 
    if mtype == TMessageType.EXCEPTION:
6980 
      x = TApplicationException()
6981 
      x.read(self._iprot)
6982 
      self._iprot.readMessageEnd()
6983 
      raise x
6984 
    result = addHsItem_result()
6985 
    result.read(self._iprot)
6986 
    self._iprot.readMessageEnd()
6987 
    return
6988 
 
6989 
  def getHsItem(self, hsItemId):
6990 
    """
6991 
    Parameters:
6992 
     - hsItemId
6993 
    """
6994 
    self.send_getHsItem(hsItemId)
6995 
    return self.recv_getHsItem()
6996 
 
6997 
  def send_getHsItem(self, hsItemId):
6998 
    self._oprot.writeMessageBegin('getHsItem', TMessageType.CALL, self._seqid)
6999 
    args = getHsItem_args()
7000 
    args.hsItemId = hsItemId
7001 
    args.write(self._oprot)
7002 
    self._oprot.writeMessageEnd()
7003 
    self._oprot.trans.flush()
7004 
 
7005 
  def recv_getHsItem(self, ):
7006 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7007 
    if mtype == TMessageType.EXCEPTION:
7008 
      x = TApplicationException()
7009 
      x.read(self._iprot)
7010 
      self._iprot.readMessageEnd()
7011 
      raise x
7012 
    result = getHsItem_result()
7013 
    result.read(self._iprot)
7014 
    self._iprot.readMessageEnd()
7015 
    if result.success is not None:
7016 
      return result.success
7017 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getHsItem failed: unknown result");
7018 
 
7019 
  def updateHsItem(self, hsItem):
7020 
    """
7021 
    Parameters:
7022 
     - hsItem
7023 
    """
7024 
    self.send_updateHsItem(hsItem)
7025 
    self.recv_updateHsItem()
7026 
 
7027 
  def send_updateHsItem(self, hsItem):
7028 
    self._oprot.writeMessageBegin('updateHsItem', TMessageType.CALL, self._seqid)
7029 
    args = updateHsItem_args()
7030 
    args.hsItem = hsItem
7031 
    args.write(self._oprot)
7032 
    self._oprot.writeMessageEnd()
7033 
    self._oprot.trans.flush()
7034 
 
7035 
  def recv_updateHsItem(self, ):
7036 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7037 
    if mtype == TMessageType.EXCEPTION:
7038 
      x = TApplicationException()
7039 
      x.read(self._iprot)
7040 
      self._iprot.readMessageEnd()
7041 
      raise x
7042 
    result = updateHsItem_result()
7043 
    result.read(self._iprot)
7044 
    self._iprot.readMessageEnd()
7045 
    return
7046 
 
14182 kshitij.so 7047 
  def getPricingForDtr(self, catalogItemId):
7048 
    """
7049 
    Parameters:
7050 
     - catalogItemId
7051 
    """
7052 
    self.send_getPricingForDtr(catalogItemId)
7053 
    return self.recv_getPricingForDtr()
13709 manish.sha 7054 
 
14182 kshitij.so 7055 
  def send_getPricingForDtr(self, catalogItemId):
7056 
    self._oprot.writeMessageBegin('getPricingForDtr', TMessageType.CALL, self._seqid)
7057 
    args = getPricingForDtr_args()
7058 
    args.catalogItemId = catalogItemId
7059 
    args.write(self._oprot)
7060 
    self._oprot.writeMessageEnd()
7061 
    self._oprot.trans.flush()
7062 
 
7063 
  def recv_getPricingForDtr(self, ):
7064 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7065 
    if mtype == TMessageType.EXCEPTION:
7066 
      x = TApplicationException()
7067 
      x.read(self._iprot)
7068 
      self._iprot.readMessageEnd()
7069 
      raise x
7070 
    result = getPricingForDtr_result()
7071 
    result.read(self._iprot)
7072 
    self._iprot.readMessageEnd()
7073 
    if result.success is not None:
7074 
      return result.success
7075 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPricingForDtr failed: unknown result");
7076 
 
15702 kshitij.so 7077 
  def getAllItemstoListOnFbd(self, ):
7078 
    self.send_getAllItemstoListOnFbd()
7079 
    return self.recv_getAllItemstoListOnFbd()
14182 kshitij.so 7080 
 
15702 kshitij.so 7081 
  def send_getAllItemstoListOnFbd(self, ):
7082 
    self._oprot.writeMessageBegin('getAllItemstoListOnFbd', TMessageType.CALL, self._seqid)
7083 
    args = getAllItemstoListOnFbd_args()
7084 
    args.write(self._oprot)
7085 
    self._oprot.writeMessageEnd()
7086 
    self._oprot.trans.flush()
7087 
 
7088 
  def recv_getAllItemstoListOnFbd(self, ):
7089 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7090 
    if mtype == TMessageType.EXCEPTION:
7091 
      x = TApplicationException()
7092 
      x.read(self._iprot)
7093 
      self._iprot.readMessageEnd()
7094 
      raise x
7095 
    result = getAllItemstoListOnFbd_result()
7096 
    result.read(self._iprot)
7097 
    self._iprot.readMessageEnd()
7098 
    if result.success is not None:
7099 
      return result.success
7100 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnFbd failed: unknown result");
7101 
 
15706 kshitij.so 7102 
  def getAllFbdListedItems(self, ):
7103 
    self.send_getAllFbdListedItems()
7104 
    return self.recv_getAllFbdListedItems()
15702 kshitij.so 7105 
 
15706 kshitij.so 7106 
  def send_getAllFbdListedItems(self, ):
7107 
    self._oprot.writeMessageBegin('getAllFbdListedItems', TMessageType.CALL, self._seqid)
7108 
    args = getAllFbdListedItems_args()
7109 
    args.write(self._oprot)
7110 
    self._oprot.writeMessageEnd()
7111 
    self._oprot.trans.flush()
7112 
 
7113 
  def recv_getAllFbdListedItems(self, ):
7114 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7115 
    if mtype == TMessageType.EXCEPTION:
7116 
      x = TApplicationException()
7117 
      x.read(self._iprot)
7118 
      self._iprot.readMessageEnd()
7119 
      raise x
7120 
    result = getAllFbdListedItems_result()
7121 
    result.read(self._iprot)
7122 
    self._iprot.readMessageEnd()
7123 
    if result.success is not None:
7124 
      return result.success
7125 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbdListedItems failed: unknown result");
7126 
 
18150 kshitij.so 7127 
  def getBulkPricingForItems(self, itemIds):
7128 
    """
7129 
    Parameters:
7130 
     - itemIds
7131 
    """
7132 
    self.send_getBulkPricingForItems(itemIds)
7133 
    return self.recv_getBulkPricingForItems()
15706 kshitij.so 7134 
 
18150 kshitij.so 7135 
  def send_getBulkPricingForItems(self, itemIds):
7136 
    self._oprot.writeMessageBegin('getBulkPricingForItems', TMessageType.CALL, self._seqid)
7137 
    args = getBulkPricingForItems_args()
7138 
    args.itemIds = itemIds
7139 
    args.write(self._oprot)
7140 
    self._oprot.writeMessageEnd()
7141 
    self._oprot.trans.flush()
7142 
 
7143 
  def recv_getBulkPricingForItems(self, ):
7144 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7145 
    if mtype == TMessageType.EXCEPTION:
7146 
      x = TApplicationException()
7147 
      x.read(self._iprot)
7148 
      self._iprot.readMessageEnd()
7149 
      raise x
7150 
    result = getBulkPricingForItems_result()
7151 
    result.read(self._iprot)
7152 
    self._iprot.readMessageEnd()
7153 
    if result.success is not None:
7154 
      return result.success
7155 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBulkPricingForItems failed: unknown result");
7156 
 
7157 
  def addBulkPricingForItem(self, bulkItemPricing):
7158 
    """
7159 
    Parameters:
7160 
     - bulkItemPricing
7161 
    """
7162 
    self.send_addBulkPricingForItem(bulkItemPricing)
7163 
    return self.recv_addBulkPricingForItem()
7164 
 
7165 
  def send_addBulkPricingForItem(self, bulkItemPricing):
7166 
    self._oprot.writeMessageBegin('addBulkPricingForItem', TMessageType.CALL, self._seqid)
7167 
    args = addBulkPricingForItem_args()
7168 
    args.bulkItemPricing = bulkItemPricing
7169 
    args.write(self._oprot)
7170 
    self._oprot.writeMessageEnd()
7171 
    self._oprot.trans.flush()
7172 
 
7173 
  def recv_addBulkPricingForItem(self, ):
7174 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7175 
    if mtype == TMessageType.EXCEPTION:
7176 
      x = TApplicationException()
7177 
      x.read(self._iprot)
7178 
      self._iprot.readMessageEnd()
7179 
      raise x
7180 
    result = addBulkPricingForItem_result()
7181 
    result.read(self._iprot)
7182 
    self._iprot.readMessageEnd()
7183 
    if result.success is not None:
7184 
      return result.success
7185 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBulkPricingForItem failed: unknown result");
7186 
 
7187 
  def deleteBulkPricingForItemById(self, id):
7188 
    """
7189 
    Parameters:
7190 
     - id
7191 
    """
7192 
    self.send_deleteBulkPricingForItemById(id)
7193 
    return self.recv_deleteBulkPricingForItemById()
7194 
 
7195 
  def send_deleteBulkPricingForItemById(self, id):
7196 
    self._oprot.writeMessageBegin('deleteBulkPricingForItemById', TMessageType.CALL, self._seqid)
7197 
    args = deleteBulkPricingForItemById_args()
7198 
    args.id = id
7199 
    args.write(self._oprot)
7200 
    self._oprot.writeMessageEnd()
7201 
    self._oprot.trans.flush()
7202 
 
7203 
  def recv_deleteBulkPricingForItemById(self, ):
7204 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7205 
    if mtype == TMessageType.EXCEPTION:
7206 
      x = TApplicationException()
7207 
      x.read(self._iprot)
7208 
      self._iprot.readMessageEnd()
7209 
      raise x
7210 
    result = deleteBulkPricingForItemById_result()
7211 
    result.read(self._iprot)
7212 
    self._iprot.readMessageEnd()
7213 
    if result.success is not None:
7214 
      return result.success
7215 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBulkPricingForItemById failed: unknown result");
7216 
 
7217 
  def deleteBulkPricingForItem(self, item_id):
7218 
    """
7219 
    Parameters:
7220 
     - item_id
7221 
    """
7222 
    self.send_deleteBulkPricingForItem(item_id)
7223 
    return self.recv_deleteBulkPricingForItem()
7224 
 
7225 
  def send_deleteBulkPricingForItem(self, item_id):
7226 
    self._oprot.writeMessageBegin('deleteBulkPricingForItem', TMessageType.CALL, self._seqid)
7227 
    args = deleteBulkPricingForItem_args()
7228 
    args.item_id = item_id
7229 
    args.write(self._oprot)
7230 
    self._oprot.writeMessageEnd()
7231 
    self._oprot.trans.flush()
7232 
 
7233 
  def recv_deleteBulkPricingForItem(self, ):
7234 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7235 
    if mtype == TMessageType.EXCEPTION:
7236 
      x = TApplicationException()
7237 
      x.read(self._iprot)
7238 
      self._iprot.readMessageEnd()
7239 
      raise x
7240 
    result = deleteBulkPricingForItem_result()
7241 
    result.read(self._iprot)
7242 
    self._iprot.readMessageEnd()
7243 
    if result.success is not None:
7244 
      return result.success
7245 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBulkPricingForItem failed: unknown result");
7246 
 
7247 
  def getBulkPricingByItemId(self, item_id):
7248 
    """
7249 
    Parameters:
7250 
     - item_id
7251 
    """
7252 
    self.send_getBulkPricingByItemId(item_id)
7253 
    return self.recv_getBulkPricingByItemId()
7254 
 
7255 
  def send_getBulkPricingByItemId(self, item_id):
7256 
    self._oprot.writeMessageBegin('getBulkPricingByItemId', TMessageType.CALL, self._seqid)
7257 
    args = getBulkPricingByItemId_args()
7258 
    args.item_id = item_id
7259 
    args.write(self._oprot)
7260 
    self._oprot.writeMessageEnd()
7261 
    self._oprot.trans.flush()
7262 
 
7263 
  def recv_getBulkPricingByItemId(self, ):
7264 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7265 
    if mtype == TMessageType.EXCEPTION:
7266 
      x = TApplicationException()
7267 
      x.read(self._iprot)
7268 
      self._iprot.readMessageEnd()
7269 
      raise x
7270 
    result = getBulkPricingByItemId_result()
7271 
    result.read(self._iprot)
7272 
    self._iprot.readMessageEnd()
7273 
    if result.success is not None:
7274 
      return result.success
7275 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBulkPricingByItemId failed: unknown result");
7276 
 
18602 kshitij.so 7277 
  def updateBulkPricesOnProduction(self, item_id, bulkItemPricingList):
7278 
    """
7279 
    Parameters:
7280 
     - item_id
7281 
     - bulkItemPricingList
7282 
    """
7283 
    self.send_updateBulkPricesOnProduction(item_id, bulkItemPricingList)
7284 
    return self.recv_updateBulkPricesOnProduction()
18150 kshitij.so 7285 
 
18602 kshitij.so 7286 
  def send_updateBulkPricesOnProduction(self, item_id, bulkItemPricingList):
7287 
    self._oprot.writeMessageBegin('updateBulkPricesOnProduction', TMessageType.CALL, self._seqid)
7288 
    args = updateBulkPricesOnProduction_args()
7289 
    args.item_id = item_id
7290 
    args.bulkItemPricingList = bulkItemPricingList
7291 
    args.write(self._oprot)
7292 
    self._oprot.writeMessageEnd()
7293 
    self._oprot.trans.flush()
7294 
 
7295 
  def recv_updateBulkPricesOnProduction(self, ):
7296 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7297 
    if mtype == TMessageType.EXCEPTION:
7298 
      x = TApplicationException()
7299 
      x.read(self._iprot)
7300 
      self._iprot.readMessageEnd()
7301 
      raise x
7302 
    result = updateBulkPricesOnProduction_result()
7303 
    result.read(self._iprot)
7304 
    self._iprot.readMessageEnd()
7305 
    if result.success is not None:
7306 
      return result.success
7307 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBulkPricesOnProduction failed: unknown result");
7308 
 
7309 
 
5944 mandeep.dh 7310 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
7311 
  def __init__(self, handler):
7312 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
7313 
    self._processMap["addItem"] = Processor.process_addItem
7314 
    self._processMap["updateItem"] = Processor.process_updateItem
7315 
    self._processMap["isActive"] = Processor.process_isActive
7438 amit.gupta 7316 
    self._processMap["getItemsStatus"] = Processor.process_getItemsStatus
5944 mandeep.dh 7317 
    self._processMap["getItemStatusDescription"] = Processor.process_getItemStatusDescription
7318 
    self._processMap["startItemOn"] = Processor.process_startItemOn
7319 
    self._processMap["retireItemOn"] = Processor.process_retireItemOn
7320 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
7321 
    self._processMap["getItem"] = Processor.process_getItem
13493 amit.gupta 7322 
    self._processMap["getItems"] = Processor.process_getItems
5944 mandeep.dh 7323 
    self._processMap["getItemsByCatalogId"] = Processor.process_getItemsByCatalogId
7324 
    self._processMap["getValidItemsByCatalogId"] = Processor.process_getValidItemsByCatalogId
7325 
    self._processMap["getAllItems"] = Processor.process_getAllItems
7326 
    self._processMap["getAllItemsByStatus"] = Processor.process_getAllItemsByStatus
7327 
    self._processMap["markItemAsContentComplete"] = Processor.process_markItemAsContentComplete
12567 amit.gupta 7328 
    self._processMap["getVatRates"] = Processor.process_getVatRates
5944 mandeep.dh 7329 
    self._processMap["getAllItemsInRange"] = Processor.process_getAllItemsInRange
7330 
    self._processMap["getAllItemsByStatusInRange"] = Processor.process_getAllItemsByStatusInRange
7331 
    self._processMap["getItemCountByStatus"] = Processor.process_getItemCountByStatus
7332 
    self._processMap["getBestSellers"] = Processor.process_getBestSellers
7333 
    self._processMap["getBestSellersCatalogIds"] = Processor.process_getBestSellersCatalogIds
7334 
    self._processMap["getBestSellersCount"] = Processor.process_getBestSellersCount
7335 
    self._processMap["getBestDeals"] = Processor.process_getBestDeals
7336 
    self._processMap["getBestDealsCatalogIds"] = Processor.process_getBestDealsCatalogIds
7337 
    self._processMap["getBestDealsCount"] = Processor.process_getBestDealsCount
7338 
    self._processMap["getComingSoon"] = Processor.process_getComingSoon
7339 
    self._processMap["getComingSoonCatalogIds"] = Processor.process_getComingSoonCatalogIds
7340 
    self._processMap["getComingSoonCount"] = Processor.process_getComingSoonCount
7341 
    self._processMap["getLatestArrivals"] = Processor.process_getLatestArrivals
7342 
    self._processMap["getLatestArrivalsCatalogIds"] = Processor.process_getLatestArrivalsCatalogIds
7343 
    self._processMap["getLatestArrivalsCount"] = Processor.process_getLatestArrivalsCount
7344 
    self._processMap["generateNewEntityID"] = Processor.process_generateNewEntityID
7345 
    self._processMap["addCategory"] = Processor.process_addCategory
7346 
    self._processMap["getCategory"] = Processor.process_getCategory
7347 
    self._processMap["getAllCategories"] = Processor.process_getAllCategories
7348 
    self._processMap["getAllSimilarItems"] = Processor.process_getAllSimilarItems
7349 
    self._processMap["addSimilarItem"] = Processor.process_addSimilarItem
6512 kshitij.so 7350 
    self._processMap["addTag"] = Processor.process_addTag
7351 
    self._processMap["deleteEntityTag"] = Processor.process_deleteEntityTag
7352 
    self._processMap["deleteTag"] = Processor.process_deleteTag
7353 
    self._processMap["getAllTags"] = Processor.process_getAllTags
7354 
    self._processMap["getAllEntitiesByTagName"] = Processor.process_getAllEntitiesByTagName
6845 amit.gupta 7355 
    self._processMap["getAllEntityTags"] = Processor.process_getAllEntityTags
6850 kshitij.so 7356 
    self._processMap["addBanner"] = Processor.process_addBanner
8579 kshitij.so 7357 
    self._processMap["updateBanner"] = Processor.process_updateBanner
6850 kshitij.so 7358 
    self._processMap["getAllBanners"] = Processor.process_getAllBanners
7359 
    self._processMap["deleteBanner"] = Processor.process_deleteBanner
7360 
    self._processMap["getBannerDetails"] = Processor.process_getBannerDetails
7361 
    self._processMap["getActiveBanners"] = Processor.process_getActiveBanners
6849 kshitij.so 7362 
    self._processMap["addBannerMap"] = Processor.process_addBannerMap
8579 kshitij.so 7363 
    self._processMap["updateBannerMap"] = Processor.process_updateBannerMap
6849 kshitij.so 7364 
    self._processMap["deleteBannerMap"] = Processor.process_deleteBannerMap
7365 
    self._processMap["getBannerMapDetails"] = Processor.process_getBannerMapDetails
8579 kshitij.so 7366 
    self._processMap["addBannerUri"] = Processor.process_addBannerUri
7367 
    self._processMap["getUriMapping"] = Processor.process_getUriMapping
7368 
    self._processMap["addCampaign"] = Processor.process_addCampaign
7369 
    self._processMap["getCampaigns"] = Processor.process_getCampaigns
7370 
    self._processMap["deleteCampaign"] = Processor.process_deleteCampaign
7371 
    self._processMap["getAllCampaigns"] = Processor.process_getAllCampaigns
9155 kshitij.so 7372 
    self._processMap["getActiveBannersForMobileSite"] = Processor.process_getActiveBannersForMobileSite
5944 mandeep.dh 7373 
    self._processMap["deleteSimilarItem"] = Processor.process_deleteSimilarItem
7374 
    self._processMap["checkSimilarItem"] = Processor.process_checkSimilarItem
7375 
    self._processMap["validateRiskyStatus"] = Processor.process_validateRiskyStatus
7376 
    self._processMap["changeItemRiskyFlag"] = Processor.process_changeItemRiskyFlag
7377 
    self._processMap["getItemsByRiskyFlag"] = Processor.process_getItemsByRiskyFlag
7378 
    self._processMap["getItemsForMasterSheet"] = Processor.process_getItemsForMasterSheet
7379 
    self._processMap["getSimilarItemsCatalogIds"] = Processor.process_getSimilarItemsCatalogIds
7380 
    self._processMap["addProductNotification"] = Processor.process_addProductNotification
7381 
    self._processMap["sendProductNotifications"] = Processor.process_sendProductNotifications
7382 
    self._processMap["getAllBrandsByCategory"] = Processor.process_getAllBrandsByCategory
7383 
    self._processMap["getAllBrands"] = Processor.process_getAllBrands
7384 
    self._processMap["getAllSources"] = Processor.process_getAllSources
7385 
    self._processMap["getItemPricingBySource"] = Processor.process_getItemPricingBySource
7386 
    self._processMap["addSourceItemPricing"] = Processor.process_addSourceItemPricing
7387 
    self._processMap["getAllSourcePricing"] = Processor.process_getAllSourcePricing
7388 
    self._processMap["getItemForSource"] = Processor.process_getItemForSource
7389 
    self._processMap["searchItemsInRange"] = Processor.process_searchItemsInRange
7390 
    self._processMap["getSearchResultCount"] = Processor.process_getSearchResultCount
7391 
    self._processMap["getProductNotifications"] = Processor.process_getProductNotifications
7392 
    self._processMap["getProductNotificationRequestCount"] = Processor.process_getProductNotificationRequestCount
7393 
    self._processMap["addAuthorizationLog"] = Processor.process_addAuthorizationLog
7394 
    self._processMap["addupdateVoucherForItem"] = Processor.process_addupdateVoucherForItem
7395 
    self._processMap["deleteVoucherForItem"] = Processor.process_deleteVoucherForItem
7396 
    self._processMap["getVoucherAmount"] = Processor.process_getVoucherAmount
7397 
    self._processMap["getAllItemVouchers"] = Processor.process_getAllItemVouchers
7398 
    self._processMap["isValidCatalogItemId"] = Processor.process_isValidCatalogItemId
6039 amit.gupta 7399 
    self._processMap["getVatPercentageForItem"] = Processor.process_getVatPercentageForItem
7400 
    self._processMap["getVatAmountForItem"] = Processor.process_getVatAmountForItem
6531 vikram.rag 7401 
    self._processMap["getAllIgnoredInventoryUpdateItemsList"] = Processor.process_getAllIgnoredInventoryUpdateItemsList
6821 amar.kumar 7402 
    self._processMap["getAllAliveItems"] = Processor.process_getAllAliveItems
6805 anupam.sin 7403 
    self._processMap["getInsuranceAmount"] = Processor.process_getInsuranceAmount
7404 
    self._processMap["getInsurer"] = Processor.process_getInsurer
6838 vikram.rag 7405 
    self._processMap["getAllInsurers"] = Processor.process_getAllInsurers
6962 rajveer 7406 
    self._processMap["updateInsuranceDeclaredAmount"] = Processor.process_updateInsuranceDeclaredAmount
7190 amar.kumar 7407 
    self._processMap["getFreebieForItem"] = Processor.process_getFreebieForItem
7408 
    self._processMap["addOrUpdateFreebieForItem"] = Processor.process_addOrUpdateFreebieForItem
7272 amit.gupta 7409 
    self._processMap["addOrUpdateBrandInfo"] = Processor.process_addOrUpdateBrandInfo
7410 
    self._processMap["getBrandInfo"] = Processor.process_getBrandInfo
7256 rajveer 7411 
    self._processMap["getStorePricing"] = Processor.process_getStorePricing
7306 rajveer 7412 
    self._processMap["getStorePricings"] = Processor.process_getStorePricings
7265 rajveer 7413 
    self._processMap["updateStorePricing"] = Processor.process_updateStorePricing
7281 kshitij.so 7414 
    self._processMap["getAllAmazonListedItems"] = Processor.process_getAllAmazonListedItems
8619 kshitij.so 7415 
    self._processMap["searchAmazonItems"] = Processor.process_searchAmazonItems
7416 
    self._processMap["getAmazonSearchResultCount"] = Processor.process_getAmazonSearchResultCount
7417 
    self._processMap["getCountForAmazonlistedItems"] = Processor.process_getCountForAmazonlistedItems
7281 kshitij.so 7418 
    self._processMap["getAmazonItemDetails"] = Processor.process_getAmazonItemDetails
7419 
    self._processMap["updateAmazonItemDetails"] = Processor.process_updateAmazonItemDetails
7420 
    self._processMap["addAmazonItem"] = Processor.process_addAmazonItem
7291 vikram.rag 7421 
    self._processMap["getAsinItems"] = Processor.process_getAsinItems
7422 
    self._processMap["getAllFbaListedItems"] = Processor.process_getAllFbaListedItems
7423 
    self._processMap["getAllNonFbaListedItems"] = Processor.process_getAllNonFbaListedItems
7460 kshitij.so 7424 
    self._processMap["updateItemInventory"] = Processor.process_updateItemInventory
7770 kshitij.so 7425 
    self._processMap["updateTimestampForAmazonFeeds"] = Processor.process_updateTimestampForAmazonFeeds
7897 amar.kumar 7426 
    self._processMap["getAllParentCategories"] = Processor.process_getAllParentCategories
7977 kshitij.so 7427 
    self._processMap["addPageViewEvent"] = Processor.process_addPageViewEvent
7428 
    self._processMap["addCartEvent"] = Processor.process_addCartEvent
8182 amar.kumar 7429 
    self._processMap["addEbayItem"] = Processor.process_addEbayItem
7430 
    self._processMap["getEbayItem"] = Processor.process_getEbayItem
7431 
    self._processMap["updateEbayItem"] = Processor.process_updateEbayItem
8139 kshitij.so 7432 
    self._processMap["getAmazonListedItems"] = Processor.process_getAmazonListedItems
8168 kshitij.so 7433 
    self._processMap["updateAmazonAttributesInBulk"] = Processor.process_updateAmazonAttributesInBulk
8379 vikram.rag 7434 
    self._processMap["getAllItemstoListOnFba"] = Processor.process_getAllItemstoListOnFba
7435 
    self._processMap["getAllItemstoListOnNonFba"] = Processor.process_getAllItemstoListOnNonFba
8619 kshitij.so 7436 
    self._processMap["updateAsin"] = Processor.process_updateAsin
8739 vikram.rag 7437 
    self._processMap["addOrUpdateSnapdealItem"] = Processor.process_addOrUpdateSnapdealItem
7438 
    self._processMap["getSnapdealItem"] = Processor.process_getSnapdealItem
9242 kshitij.so 7439 
    self._processMap["getSnapdealItemDetails"] = Processor.process_getSnapdealItemDetails
8739 vikram.rag 7440 
    self._processMap["getAllSnapdealItems"] = Processor.process_getAllSnapdealItems
9242 kshitij.so 7441 
    self._processMap["getSnapdealItems"] = Processor.process_getSnapdealItems
7442 
    self._processMap["searchSnapdealItems"] = Processor.process_searchSnapdealItems
7443 
    self._processMap["getCountForSnapdealItems"] = Processor.process_getCountForSnapdealItems
7444 
    self._processMap["getSnapdealSearchResultCount"] = Processor.process_getSnapdealSearchResultCount
9299 kshitij.so 7445 
    self._processMap["getPrefferedInsurerForItem"] = Processor.process_getPrefferedInsurerForItem
9456 vikram.rag 7446 
    self._processMap["getSnapdealItembySkuAtSnapdeal"] = Processor.process_getSnapdealItembySkuAtSnapdeal
9621 manish.sha 7447 
    self._processMap["getProductFeedSubmit"] = Processor.process_getProductFeedSubmit
7448 
    self._processMap["addProductFeedSubmit"] = Processor.process_addProductFeedSubmit
7449 
    self._processMap["updateProductFeedSubmit"] = Processor.process_updateProductFeedSubmit
7450 
    self._processMap["deleteProductFeedSubmit"] = Processor.process_deleteProductFeedSubmit
7451 
    self._processMap["getAllProductFeedSubmit"] = Processor.process_getAllProductFeedSubmit
9724 kshitij.so 7452 
    self._processMap["getMarketplacedetailsForItem"] = Processor.process_getMarketplacedetailsForItem
7453 
    self._processMap["updateMarketplaceAttributesForItem"] = Processor.process_updateMarketplaceAttributesForItem
9779 kshitij.so 7454 
    self._processMap["getCostingForMarketplace"] = Processor.process_getCostingForMarketplace
9776 vikram.rag 7455 
    self._processMap["getMarketPlaceItemsForPriceUpdate"] = Processor.process_getMarketPlaceItemsForPriceUpdate
7456 
    self._processMap["updateMarketPlacePriceUpdateStatus"] = Processor.process_updateMarketPlacePriceUpdateStatus
9861 rajveer 7457 
    self._processMap["updateItemHoldInventory"] = Processor.process_updateItemHoldInventory
9895 vikram.rag 7458 
    self._processMap["updateNlcAtMarketplaces"] = Processor.process_updateNlcAtMarketplaces
9945 vikram.rag 7459 
    self._processMap["getAllFlipkartItems"] = Processor.process_getAllFlipkartItems
10097 kshitij.so 7460 
    self._processMap["addOrUpdateFlipkartItem"] = Processor.process_addOrUpdateFlipkartItem
7461 
    self._processMap["getFlipkartItem"] = Processor.process_getFlipkartItem
7462 
    self._processMap["getFlipkartItemDetails"] = Processor.process_getFlipkartItemDetails
7463 
    self._processMap["getFlipkartItems"] = Processor.process_getFlipkartItems
7464 
    self._processMap["searchFlipkartItems"] = Processor.process_searchFlipkartItems
7465 
    self._processMap["getCountForFlipkartItems"] = Processor.process_getCountForFlipkartItems
7466 
    self._processMap["getFlipkartSearchResultCount"] = Processor.process_getFlipkartSearchResultCount
7467 
    self._processMap["getAllFkItems"] = Processor.process_getAllFkItems
10140 vikram.rag 7468 
    self._processMap["getFlipkartItemBySkyAtFlipkart"] = Processor.process_getFlipkartItemBySkyAtFlipkart
11015 kshitij.so 7469 
    self._processMap["getMarketplaceHistory"] = Processor.process_getMarketplaceHistory
10909 vikram.rag 7470 
    self._processMap["getAllFbbListedItems"] = Processor.process_getAllFbbListedItems
10924 vikram.rag 7471 
    self._processMap["getAllFbbPricingItems"] = Processor.process_getAllFbbPricingItems
11015 kshitij.so 7472 
    self._processMap["getCountForMarketplaceHistory"] = Processor.process_getCountForMarketplaceHistory
7473 
    self._processMap["getMarketplaceHistoryByDate"] = Processor.process_getMarketplaceHistoryByDate
11531 vikram.rag 7474 
    self._processMap["getPrivateDealDetails"] = Processor.process_getPrivateDealDetails
7475 
    self._processMap["getPrivateDealItems"] = Processor.process_getPrivateDealItems
11592 amit.gupta 7476 
    self._processMap["getAllActivePrivateDeals"] = Processor.process_getAllActivePrivateDeals
11531 vikram.rag 7477 
    self._processMap["addOrUpdatePrivateDeal"] = Processor.process_addOrUpdatePrivateDeal
11635 vikram.rag 7478 
    self._processMap["getPrivateDealsCatalogIds"] = Processor.process_getPrivateDealsCatalogIds
11645 amit.gupta 7479 
    self._processMap["getPrivateDealsCount"] = Processor.process_getPrivateDealsCount
11905 kshitij.so 7480 
    self._processMap["getAmazonOutSyncItems"] = Processor.process_getAmazonOutSyncItems
7481 
    self._processMap["getAllPrivateDealsComparison"] = Processor.process_getAllPrivateDealsComparison
12133 kshitij.so 7482 
    self._processMap["getAllSnapdealMarketplaceItem"] = Processor.process_getAllSnapdealMarketplaceItem
7483 
    self._processMap["getAllFlipkartMarketplaceItem"] = Processor.process_getAllFlipkartMarketplaceItem
12243 kshitij.so 7484 
    self._processMap["addCompetitorScraping"] = Processor.process_addCompetitorScraping
7485 
    self._processMap["getPreviousCompetitorScraping"] = Processor.process_getPreviousCompetitorScraping
12256 kshitij.so 7486 
    self._processMap["getUploadResultById"] = Processor.process_getUploadResultById
12363 kshitij.so 7487 
    self._processMap["addAmazonPromotion"] = Processor.process_addAmazonPromotion
7488 
    self._processMap["getAmazonPromotion"] = Processor.process_getAmazonPromotion
7489 
    self._processMap["updateAmazonPromotion"] = Processor.process_updateAmazonPromotion
12567 amit.gupta 7490 
    self._processMap["markPartiallyActive"] = Processor.process_markPartiallyActive
7491 
    self._processMap["updateItemStateVat"] = Processor.process_updateItemStateVat
12620 amit.gupta 7492 
    self._processMap["getExAffiliateItemInfo"] = Processor.process_getExAffiliateItemInfo
12888 kshitij.so 7493 
    self._processMap["getAllItemstoListOnFbg"] = Processor.process_getAllItemstoListOnFbg
12892 kshitij.so 7494 
    self._processMap["getAllFbgListedItems"] = Processor.process_getAllFbgListedItems
13136 amit.gupta 7495 
    self._processMap["checkServices"] = Processor.process_checkServices
13709 manish.sha 7496 
    self._processMap["addHsItem"] = Processor.process_addHsItem
7497 
    self._processMap["getHsItem"] = Processor.process_getHsItem
7498 
    self._processMap["updateHsItem"] = Processor.process_updateHsItem
14182 kshitij.so 7499 
    self._processMap["getPricingForDtr"] = Processor.process_getPricingForDtr
15702 kshitij.so 7500 
    self._processMap["getAllItemstoListOnFbd"] = Processor.process_getAllItemstoListOnFbd
15706 kshitij.so 7501 
    self._processMap["getAllFbdListedItems"] = Processor.process_getAllFbdListedItems
18150 kshitij.so 7502 
    self._processMap["getBulkPricingForItems"] = Processor.process_getBulkPricingForItems
7503 
    self._processMap["addBulkPricingForItem"] = Processor.process_addBulkPricingForItem
7504 
    self._processMap["deleteBulkPricingForItemById"] = Processor.process_deleteBulkPricingForItemById
7505 
    self._processMap["deleteBulkPricingForItem"] = Processor.process_deleteBulkPricingForItem
7506 
    self._processMap["getBulkPricingByItemId"] = Processor.process_getBulkPricingByItemId
18602 kshitij.so 7507 
    self._processMap["updateBulkPricesOnProduction"] = Processor.process_updateBulkPricesOnProduction
5944 mandeep.dh 7508 
 
7509 
  def process(self, iprot, oprot):
7510 
    (name, type, seqid) = iprot.readMessageBegin()
7511 
    if name not in self._processMap:
7512 
      iprot.skip(TType.STRUCT)
7513 
      iprot.readMessageEnd()
7514 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
7515 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
7516 
      x.write(oprot)
7517 
      oprot.writeMessageEnd()
7518 
      oprot.trans.flush()
7519 
      return
7520 
    else:
7521 
      self._processMap[name](self, seqid, iprot, oprot)
7522 
    return True
7523 
 
7524 
  def process_addItem(self, seqid, iprot, oprot):
7525 
    args = addItem_args()
7526 
    args.read(iprot)
7527 
    iprot.readMessageEnd()
7528 
    result = addItem_result()
7529 
    try:
7530 
      result.success = self._handler.addItem(args.item)
7531 
    except CatalogServiceException, cex:
7532 
      result.cex = cex
7533 
    oprot.writeMessageBegin("addItem", TMessageType.REPLY, seqid)
7534 
    result.write(oprot)
7535 
    oprot.writeMessageEnd()
7536 
    oprot.trans.flush()
7537 
 
7538 
  def process_updateItem(self, seqid, iprot, oprot):
7539 
    args = updateItem_args()
7540 
    args.read(iprot)
7541 
    iprot.readMessageEnd()
7542 
    result = updateItem_result()
7543 
    try:
7544 
      result.success = self._handler.updateItem(args.item)
7545 
    except CatalogServiceException, cex:
7546 
      result.cex = cex
7547 
    oprot.writeMessageBegin("updateItem", TMessageType.REPLY, seqid)
7548 
    result.write(oprot)
7549 
    oprot.writeMessageEnd()
7550 
    oprot.trans.flush()
7551 
 
7552 
  def process_isActive(self, seqid, iprot, oprot):
7553 
    args = isActive_args()
7554 
    args.read(iprot)
7555 
    iprot.readMessageEnd()
7556 
    result = isActive_result()
7557 
    try:
7558 
      result.success = self._handler.isActive(args.itemId)
7559 
    except CatalogServiceException, isex:
7560 
      result.isex = isex
7561 
    oprot.writeMessageBegin("isActive", TMessageType.REPLY, seqid)
7562 
    result.write(oprot)
7563 
    oprot.writeMessageEnd()
7564 
    oprot.trans.flush()
7565 
 
7438 amit.gupta 7566 
  def process_getItemsStatus(self, seqid, iprot, oprot):
7567 
    args = getItemsStatus_args()
7568 
    args.read(iprot)
7569 
    iprot.readMessageEnd()
7570 
    result = getItemsStatus_result()
7571 
    try:
7572 
      result.success = self._handler.getItemsStatus(args.itemIds)
7573 
    except CatalogServiceException, isex:
7574 
      result.isex = isex
7575 
    oprot.writeMessageBegin("getItemsStatus", TMessageType.REPLY, seqid)
7576 
    result.write(oprot)
7577 
    oprot.writeMessageEnd()
7578 
    oprot.trans.flush()
7579 
 
5944 mandeep.dh 7580 
  def process_getItemStatusDescription(self, seqid, iprot, oprot):
7581 
    args = getItemStatusDescription_args()
7582 
    args.read(iprot)
7583 
    iprot.readMessageEnd()
7584 
    result = getItemStatusDescription_result()
7585 
    try:
7586 
      result.success = self._handler.getItemStatusDescription(args.itemId)
7587 
    except CatalogServiceException, isex:
7588 
      result.isex = isex
7589 
    oprot.writeMessageBegin("getItemStatusDescription", TMessageType.REPLY, seqid)
7590 
    result.write(oprot)
7591 
    oprot.writeMessageEnd()
7592 
    oprot.trans.flush()
7593 
 
7594 
  def process_startItemOn(self, seqid, iprot, oprot):
7595 
    args = startItemOn_args()
7596 
    args.read(iprot)
7597 
    iprot.readMessageEnd()
7598 
    result = startItemOn_result()
7599 
    try:
7600 
      self._handler.startItemOn(args.item_id, args.timestamp)
7601 
    except CatalogServiceException, cex:
7602 
      result.cex = cex
7603 
    oprot.writeMessageBegin("startItemOn", TMessageType.REPLY, seqid)
7604 
    result.write(oprot)
7605 
    oprot.writeMessageEnd()
7606 
    oprot.trans.flush()
7607 
 
7608 
  def process_retireItemOn(self, seqid, iprot, oprot):
7609 
    args = retireItemOn_args()
7610 
    args.read(iprot)
7611 
    iprot.readMessageEnd()
7612 
    result = retireItemOn_result()
7613 
    try:
7614 
      self._handler.retireItemOn(args.item_id, args.timestamp)
7615 
    except CatalogServiceException, cex:
7616 
      result.cex = cex
7617 
    oprot.writeMessageBegin("retireItemOn", TMessageType.REPLY, seqid)
7618 
    result.write(oprot)
7619 
    oprot.writeMessageEnd()
7620 
    oprot.trans.flush()
7621 
 
7622 
  def process_changeItemStatus(self, seqid, iprot, oprot):
7623 
    args = changeItemStatus_args()
7624 
    args.read(iprot)
7625 
    iprot.readMessageEnd()
7626 
    result = changeItemStatus_result()
7627 
    try:
7628 
      self._handler.changeItemStatus(args.item_id, args.timestamp, args.newstatus)
7629 
    except CatalogServiceException, cex:
7630 
      result.cex = cex
7631 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
7632 
    result.write(oprot)
7633 
    oprot.writeMessageEnd()
7634 
    oprot.trans.flush()
7635 
 
7636 
  def process_getItem(self, seqid, iprot, oprot):
7637 
    args = getItem_args()
7638 
    args.read(iprot)
7639 
    iprot.readMessageEnd()
7640 
    result = getItem_result()
7641 
    try:
7642 
      result.success = self._handler.getItem(args.item_id)
7643 
    except CatalogServiceException, cex:
7644 
      result.cex = cex
7645 
    oprot.writeMessageBegin("getItem", TMessageType.REPLY, seqid)
7646 
    result.write(oprot)
7647 
    oprot.writeMessageEnd()
7648 
    oprot.trans.flush()
7649 
 
13493 amit.gupta 7650 
  def process_getItems(self, seqid, iprot, oprot):
7651 
    args = getItems_args()
7652 
    args.read(iprot)
7653 
    iprot.readMessageEnd()
7654 
    result = getItems_result()
7655 
    try:
7656 
      result.success = self._handler.getItems(args.item_ids)
7657 
    except CatalogServiceException, cex:
7658 
      result.cex = cex
7659 
    oprot.writeMessageBegin("getItems", TMessageType.REPLY, seqid)
7660 
    result.write(oprot)
7661 
    oprot.writeMessageEnd()
7662 
    oprot.trans.flush()
7663 
 
5944 mandeep.dh 7664 
  def process_getItemsByCatalogId(self, seqid, iprot, oprot):
7665 
    args = getItemsByCatalogId_args()
7666 
    args.read(iprot)
7667 
    iprot.readMessageEnd()
7668 
    result = getItemsByCatalogId_result()
7669 
    try:
7670 
      result.success = self._handler.getItemsByCatalogId(args.catalog_item_id)
7671 
    except CatalogServiceException, cex:
7672 
      result.cex = cex
7673 
    oprot.writeMessageBegin("getItemsByCatalogId", TMessageType.REPLY, seqid)
7674 
    result.write(oprot)
7675 
    oprot.writeMessageEnd()
7676 
    oprot.trans.flush()
7677 
 
7678 
  def process_getValidItemsByCatalogId(self, seqid, iprot, oprot):
7679 
    args = getValidItemsByCatalogId_args()
7680 
    args.read(iprot)
7681 
    iprot.readMessageEnd()
7682 
    result = getValidItemsByCatalogId_result()
7683 
    try:
7684 
      result.success = self._handler.getValidItemsByCatalogId(args.catalog_item_id)
7685 
    except CatalogServiceException, cex:
7686 
      result.cex = cex
7687 
    oprot.writeMessageBegin("getValidItemsByCatalogId", TMessageType.REPLY, seqid)
7688 
    result.write(oprot)
7689 
    oprot.writeMessageEnd()
7690 
    oprot.trans.flush()
7691 
 
7692 
  def process_getAllItems(self, seqid, iprot, oprot):
7693 
    args = getAllItems_args()
7694 
    args.read(iprot)
7695 
    iprot.readMessageEnd()
7696 
    result = getAllItems_result()
7697 
    try:
7698 
      result.success = self._handler.getAllItems(args.isActive)
7699 
    except CatalogServiceException, cex:
7700 
      result.cex = cex
7701 
    oprot.writeMessageBegin("getAllItems", TMessageType.REPLY, seqid)
7702 
    result.write(oprot)
7703 
    oprot.writeMessageEnd()
7704 
    oprot.trans.flush()
7705 
 
7706 
  def process_getAllItemsByStatus(self, seqid, iprot, oprot):
7707 
    args = getAllItemsByStatus_args()
7708 
    args.read(iprot)
7709 
    iprot.readMessageEnd()
7710 
    result = getAllItemsByStatus_result()
7711 
    try:
7712 
      result.success = self._handler.getAllItemsByStatus(args.itemStatus)
7713 
    except CatalogServiceException, cex:
7714 
      result.cex = cex
7715 
    oprot.writeMessageBegin("getAllItemsByStatus", TMessageType.REPLY, seqid)
7716 
    result.write(oprot)
7717 
    oprot.writeMessageEnd()
7718 
    oprot.trans.flush()
7719 
 
7720 
  def process_markItemAsContentComplete(self, seqid, iprot, oprot):
7721 
    args = markItemAsContentComplete_args()
7722 
    args.read(iprot)
7723 
    iprot.readMessageEnd()
7724 
    result = markItemAsContentComplete_result()
7725 
    try:
9253 rajveer 7726 
      result.success = self._handler.markItemAsContentComplete(args.entityId, args.category, args.brand, args.modelName, args.modelNumber, args.isAndroid)
5944 mandeep.dh 7727 
    except CatalogServiceException, cex:
7728 
      result.cex = cex
7729 
    oprot.writeMessageBegin("markItemAsContentComplete", TMessageType.REPLY, seqid)
7730 
    result.write(oprot)
7731 
    oprot.writeMessageEnd()
7732 
    oprot.trans.flush()
7733 
 
12567 amit.gupta 7734 
  def process_getVatRates(self, seqid, iprot, oprot):
7735 
    args = getVatRates_args()
7736 
    args.read(iprot)
7737 
    iprot.readMessageEnd()
7738 
    result = getVatRates_result()
7739 
    try:
7740 
      result.success = self._handler.getVatRates(args.itemId, args.categoryId)
7741 
    except CatalogServiceException, cex:
7742 
      result.cex = cex
7743 
    oprot.writeMessageBegin("getVatRates", TMessageType.REPLY, seqid)
7744 
    result.write(oprot)
7745 
    oprot.writeMessageEnd()
7746 
    oprot.trans.flush()
7747 
 
5944 mandeep.dh 7748 
  def process_getAllItemsInRange(self, seqid, iprot, oprot):
7749 
    args = getAllItemsInRange_args()
7750 
    args.read(iprot)
7751 
    iprot.readMessageEnd()
7752 
    result = getAllItemsInRange_result()
7753 
    try:
7754 
      result.success = self._handler.getAllItemsInRange(args.offset, args.limit)
7755 
    except CatalogServiceException, cex:
7756 
      result.cex = cex
7757 
    oprot.writeMessageBegin("getAllItemsInRange", TMessageType.REPLY, seqid)
7758 
    result.write(oprot)
7759 
    oprot.writeMessageEnd()
7760 
    oprot.trans.flush()
7761 
 
7762 
  def process_getAllItemsByStatusInRange(self, seqid, iprot, oprot):
7763 
    args = getAllItemsByStatusInRange_args()
7764 
    args.read(iprot)
7765 
    iprot.readMessageEnd()
7766 
    result = getAllItemsByStatusInRange_result()
7767 
    try:
7768 
      result.success = self._handler.getAllItemsByStatusInRange(args.itemStatus, args.offset, args.limit)
7769 
    except CatalogServiceException, cex:
7770 
      result.cex = cex
7771 
    oprot.writeMessageBegin("getAllItemsByStatusInRange", TMessageType.REPLY, seqid)
7772 
    result.write(oprot)
7773 
    oprot.writeMessageEnd()
7774 
    oprot.trans.flush()
7775 
 
7776 
  def process_getItemCountByStatus(self, seqid, iprot, oprot):
7777 
    args = getItemCountByStatus_args()
7778 
    args.read(iprot)
7779 
    iprot.readMessageEnd()
7780 
    result = getItemCountByStatus_result()
7781 
    result.success = self._handler.getItemCountByStatus(args.useStatus, args.itemStatus)
7782 
    oprot.writeMessageBegin("getItemCountByStatus", TMessageType.REPLY, seqid)
7783 
    result.write(oprot)
7784 
    oprot.writeMessageEnd()
7785 
    oprot.trans.flush()
7786 
 
7787 
  def process_getBestSellers(self, seqid, iprot, oprot):
7788 
    args = getBestSellers_args()
7789 
    args.read(iprot)
7790 
    iprot.readMessageEnd()
7791 
    result = getBestSellers_result()
7792 
    try:
7793 
      result.success = self._handler.getBestSellers()
7794 
    except CatalogServiceException, isex:
7795 
      result.isex = isex
7796 
    oprot.writeMessageBegin("getBestSellers", TMessageType.REPLY, seqid)
7797 
    result.write(oprot)
7798 
    oprot.writeMessageEnd()
7799 
    oprot.trans.flush()
7800 
 
7801 
  def process_getBestSellersCatalogIds(self, seqid, iprot, oprot):
7802 
    args = getBestSellersCatalogIds_args()
7803 
    args.read(iprot)
7804 
    iprot.readMessageEnd()
7805 
    result = getBestSellersCatalogIds_result()
7806 
    try:
7807 
      result.success = self._handler.getBestSellersCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
7808 
    except CatalogServiceException, cex:
7809 
      result.cex = cex
7810 
    oprot.writeMessageBegin("getBestSellersCatalogIds", TMessageType.REPLY, seqid)
7811 
    result.write(oprot)
7812 
    oprot.writeMessageEnd()
7813 
    oprot.trans.flush()
7814 
 
7815 
  def process_getBestSellersCount(self, seqid, iprot, oprot):
7816 
    args = getBestSellersCount_args()
7817 
    args.read(iprot)
7818 
    iprot.readMessageEnd()
7819 
    result = getBestSellersCount_result()
7820 
    try:
7821 
      result.success = self._handler.getBestSellersCount()
7822 
    except CatalogServiceException, cex:
7823 
      result.cex = cex
7824 
    oprot.writeMessageBegin("getBestSellersCount", TMessageType.REPLY, seqid)
7825 
    result.write(oprot)
7826 
    oprot.writeMessageEnd()
7827 
    oprot.trans.flush()
7828 
 
7829 
  def process_getBestDeals(self, seqid, iprot, oprot):
7830 
    args = getBestDeals_args()
7831 
    args.read(iprot)
7832 
    iprot.readMessageEnd()
7833 
    result = getBestDeals_result()
7834 
    try:
7835 
      result.success = self._handler.getBestDeals()
7836 
    except CatalogServiceException, isex:
7837 
      result.isex = isex
7838 
    oprot.writeMessageBegin("getBestDeals", TMessageType.REPLY, seqid)
7839 
    result.write(oprot)
7840 
    oprot.writeMessageEnd()
7841 
    oprot.trans.flush()
7842 
 
7843 
  def process_getBestDealsCatalogIds(self, seqid, iprot, oprot):
7844 
    args = getBestDealsCatalogIds_args()
7845 
    args.read(iprot)
7846 
    iprot.readMessageEnd()
7847 
    result = getBestDealsCatalogIds_result()
7848 
    try:
7849 
      result.success = self._handler.getBestDealsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
7850 
    except CatalogServiceException, cex:
7851 
      result.cex = cex
7852 
    oprot.writeMessageBegin("getBestDealsCatalogIds", TMessageType.REPLY, seqid)
7853 
    result.write(oprot)
7854 
    oprot.writeMessageEnd()
7855 
    oprot.trans.flush()
7856 
 
7857 
  def process_getBestDealsCount(self, seqid, iprot, oprot):
7858 
    args = getBestDealsCount_args()
7859 
    args.read(iprot)
7860 
    iprot.readMessageEnd()
7861 
    result = getBestDealsCount_result()
7862 
    try:
7863 
      result.success = self._handler.getBestDealsCount()
7864 
    except CatalogServiceException, cex:
7865 
      result.cex = cex
7866 
    oprot.writeMessageBegin("getBestDealsCount", TMessageType.REPLY, seqid)
7867 
    result.write(oprot)
7868 
    oprot.writeMessageEnd()
7869 
    oprot.trans.flush()
7870 
 
7871 
  def process_getComingSoon(self, seqid, iprot, oprot):
7872 
    args = getComingSoon_args()
7873 
    args.read(iprot)
7874 
    iprot.readMessageEnd()
7875 
    result = getComingSoon_result()
7876 
    try:
7877 
      result.success = self._handler.getComingSoon()
7878 
    except CatalogServiceException, isex:
7879 
      result.isex = isex
7880 
    oprot.writeMessageBegin("getComingSoon", TMessageType.REPLY, seqid)
7881 
    result.write(oprot)
7882 
    oprot.writeMessageEnd()
7883 
    oprot.trans.flush()
7884 
 
7885 
  def process_getComingSoonCatalogIds(self, seqid, iprot, oprot):
7886 
    args = getComingSoonCatalogIds_args()
7887 
    args.read(iprot)
7888 
    iprot.readMessageEnd()
7889 
    result = getComingSoonCatalogIds_result()
7890 
    try:
7891 
      result.success = self._handler.getComingSoonCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
7892 
    except CatalogServiceException, cex:
7893 
      result.cex = cex
7894 
    oprot.writeMessageBegin("getComingSoonCatalogIds", TMessageType.REPLY, seqid)
7895 
    result.write(oprot)
7896 
    oprot.writeMessageEnd()
7897 
    oprot.trans.flush()
7898 
 
7899 
  def process_getComingSoonCount(self, seqid, iprot, oprot):
7900 
    args = getComingSoonCount_args()
7901 
    args.read(iprot)
7902 
    iprot.readMessageEnd()
7903 
    result = getComingSoonCount_result()
7904 
    try:
7905 
      result.success = self._handler.getComingSoonCount()
7906 
    except CatalogServiceException, cex:
7907 
      result.cex = cex
7908 
    oprot.writeMessageBegin("getComingSoonCount", TMessageType.REPLY, seqid)
7909 
    result.write(oprot)
7910 
    oprot.writeMessageEnd()
7911 
    oprot.trans.flush()
7912 
 
7913 
  def process_getLatestArrivals(self, seqid, iprot, oprot):
7914 
    args = getLatestArrivals_args()
7915 
    args.read(iprot)
7916 
    iprot.readMessageEnd()
7917 
    result = getLatestArrivals_result()
7918 
    try:
7919 
      result.success = self._handler.getLatestArrivals()
7920 
    except CatalogServiceException, isex:
7921 
      result.isex = isex
7922 
    oprot.writeMessageBegin("getLatestArrivals", TMessageType.REPLY, seqid)
7923 
    result.write(oprot)
7924 
    oprot.writeMessageEnd()
7925 
    oprot.trans.flush()
7926 
 
7927 
  def process_getLatestArrivalsCatalogIds(self, seqid, iprot, oprot):
7928 
    args = getLatestArrivalsCatalogIds_args()
7929 
    args.read(iprot)
7930 
    iprot.readMessageEnd()
7931 
    result = getLatestArrivalsCatalogIds_result()
7932 
    try:
7933 
      result.success = self._handler.getLatestArrivalsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.categories)
7934 
    except CatalogServiceException, cex:
7935 
      result.cex = cex
7936 
    oprot.writeMessageBegin("getLatestArrivalsCatalogIds", TMessageType.REPLY, seqid)
7937 
    result.write(oprot)
7938 
    oprot.writeMessageEnd()
7939 
    oprot.trans.flush()
7940 
 
7941 
  def process_getLatestArrivalsCount(self, seqid, iprot, oprot):
7942 
    args = getLatestArrivalsCount_args()
7943 
    args.read(iprot)
7944 
    iprot.readMessageEnd()
7945 
    result = getLatestArrivalsCount_result()
7946 
    try:
7947 
      result.success = self._handler.getLatestArrivalsCount()
7948 
    except CatalogServiceException, cex:
7949 
      result.cex = cex
7950 
    oprot.writeMessageBegin("getLatestArrivalsCount", TMessageType.REPLY, seqid)
7951 
    result.write(oprot)
7952 
    oprot.writeMessageEnd()
7953 
    oprot.trans.flush()
7954 
 
7955 
  def process_generateNewEntityID(self, seqid, iprot, oprot):
7956 
    args = generateNewEntityID_args()
7957 
    args.read(iprot)
7958 
    iprot.readMessageEnd()
7959 
    result = generateNewEntityID_result()
7960 
    result.success = self._handler.generateNewEntityID()
7961 
    oprot.writeMessageBegin("generateNewEntityID", TMessageType.REPLY, seqid)
7962 
    result.write(oprot)
7963 
    oprot.writeMessageEnd()
7964 
    oprot.trans.flush()
7965 
 
7966 
  def process_addCategory(self, seqid, iprot, oprot):
7967 
    args = addCategory_args()
7968 
    args.read(iprot)
7969 
    iprot.readMessageEnd()
7970 
    result = addCategory_result()
7971 
    result.success = self._handler.addCategory(args.category)
7972 
    oprot.writeMessageBegin("addCategory", TMessageType.REPLY, seqid)
7973 
    result.write(oprot)
7974 
    oprot.writeMessageEnd()
7975 
    oprot.trans.flush()
7976 
 
7977 
  def process_getCategory(self, seqid, iprot, oprot):
7978 
    args = getCategory_args()
7979 
    args.read(iprot)
7980 
    iprot.readMessageEnd()
7981 
    result = getCategory_result()
7982 
    result.success = self._handler.getCategory(args.id)
7983 
    oprot.writeMessageBegin("getCategory", TMessageType.REPLY, seqid)
7984 
    result.write(oprot)
7985 
    oprot.writeMessageEnd()
7986 
    oprot.trans.flush()
7987 
 
7988 
  def process_getAllCategories(self, seqid, iprot, oprot):
7989 
    args = getAllCategories_args()
7990 
    args.read(iprot)
7991 
    iprot.readMessageEnd()
7992 
    result = getAllCategories_result()
7993 
    result.success = self._handler.getAllCategories()
7994 
    oprot.writeMessageBegin("getAllCategories", TMessageType.REPLY, seqid)
7995 
    result.write(oprot)
7996 
    oprot.writeMessageEnd()
7997 
    oprot.trans.flush()
7998 
 
7999 
  def process_getAllSimilarItems(self, seqid, iprot, oprot):
8000 
    args = getAllSimilarItems_args()
8001 
    args.read(iprot)
8002 
    iprot.readMessageEnd()
8003 
    result = getAllSimilarItems_result()
8004 
    result.success = self._handler.getAllSimilarItems(args.itemId)
8005 
    oprot.writeMessageBegin("getAllSimilarItems", TMessageType.REPLY, seqid)
8006 
    result.write(oprot)
8007 
    oprot.writeMessageEnd()
8008 
    oprot.trans.flush()
8009 
 
8010 
  def process_addSimilarItem(self, seqid, iprot, oprot):
8011 
    args = addSimilarItem_args()
8012 
    args.read(iprot)
8013 
    iprot.readMessageEnd()
8014 
    result = addSimilarItem_result()
8015 
    try:
8016 
      result.success = self._handler.addSimilarItem(args.itemId, args.catalogItemId)
8017 
    except CatalogServiceException, cex:
8018 
      result.cex = cex
8019 
    oprot.writeMessageBegin("addSimilarItem", TMessageType.REPLY, seqid)
8020 
    result.write(oprot)
8021 
    oprot.writeMessageEnd()
8022 
    oprot.trans.flush()
8023 
 
6512 kshitij.so 8024 
  def process_addTag(self, seqid, iprot, oprot):
8025 
    args = addTag_args()
8026 
    args.read(iprot)
8027 
    iprot.readMessageEnd()
8028 
    result = addTag_result()
8029 
    result.success = self._handler.addTag(args.displayName, args.itemId)
8030 
    oprot.writeMessageBegin("addTag", TMessageType.REPLY, seqid)
8031 
    result.write(oprot)
8032 
    oprot.writeMessageEnd()
8033 
    oprot.trans.flush()
8034 
 
8035 
  def process_deleteEntityTag(self, seqid, iprot, oprot):
8036 
    args = deleteEntityTag_args()
8037 
    args.read(iprot)
8038 
    iprot.readMessageEnd()
8039 
    result = deleteEntityTag_result()
8040 
    result.success = self._handler.deleteEntityTag(args.displayName, args.itemId)
8041 
    oprot.writeMessageBegin("deleteEntityTag", TMessageType.REPLY, seqid)
8042 
    result.write(oprot)
8043 
    oprot.writeMessageEnd()
8044 
    oprot.trans.flush()
8045 
 
8046 
  def process_deleteTag(self, seqid, iprot, oprot):
8047 
    args = deleteTag_args()
8048 
    args.read(iprot)
8049 
    iprot.readMessageEnd()
8050 
    result = deleteTag_result()
8051 
    result.success = self._handler.deleteTag(args.displayName)
8052 
    oprot.writeMessageBegin("deleteTag", TMessageType.REPLY, seqid)
8053 
    result.write(oprot)
8054 
    oprot.writeMessageEnd()
8055 
    oprot.trans.flush()
8056 
 
8057 
  def process_getAllTags(self, seqid, iprot, oprot):
8058 
    args = getAllTags_args()
8059 
    args.read(iprot)
8060 
    iprot.readMessageEnd()
8061 
    result = getAllTags_result()
8062 
    result.success = self._handler.getAllTags()
8063 
    oprot.writeMessageBegin("getAllTags", TMessageType.REPLY, seqid)
8064 
    result.write(oprot)
8065 
    oprot.writeMessageEnd()
8066 
    oprot.trans.flush()
8067 
 
8068 
  def process_getAllEntitiesByTagName(self, seqid, iprot, oprot):
8069 
    args = getAllEntitiesByTagName_args()
8070 
    args.read(iprot)
8071 
    iprot.readMessageEnd()
8072 
    result = getAllEntitiesByTagName_result()
8073 
    result.success = self._handler.getAllEntitiesByTagName(args.displayName)
8074 
    oprot.writeMessageBegin("getAllEntitiesByTagName", TMessageType.REPLY, seqid)
8075 
    result.write(oprot)
8076 
    oprot.writeMessageEnd()
8077 
    oprot.trans.flush()
8078 
 
6845 amit.gupta 8079 
  def process_getAllEntityTags(self, seqid, iprot, oprot):
8080 
    args = getAllEntityTags_args()
8081 
    args.read(iprot)
8082 
    iprot.readMessageEnd()
8083 
    result = getAllEntityTags_result()
8084 
    result.success = self._handler.getAllEntityTags()
8085 
    oprot.writeMessageBegin("getAllEntityTags", TMessageType.REPLY, seqid)
8086 
    result.write(oprot)
8087 
    oprot.writeMessageEnd()
8088 
    oprot.trans.flush()
8089 
 
6850 kshitij.so 8090 
  def process_addBanner(self, seqid, iprot, oprot):
8091 
    args = addBanner_args()
8092 
    args.read(iprot)
8093 
    iprot.readMessageEnd()
8094 
    result = addBanner_result()
10097 kshitij.so 8095 
    result.success = self._handler.addBanner(args.bannerCongregate)
6850 kshitij.so 8096 
    oprot.writeMessageBegin("addBanner", TMessageType.REPLY, seqid)
8097 
    result.write(oprot)
8098 
    oprot.writeMessageEnd()
8099 
    oprot.trans.flush()
8100 
 
8579 kshitij.so 8101 
  def process_updateBanner(self, seqid, iprot, oprot):
8102 
    args = updateBanner_args()
8103 
    args.read(iprot)
8104 
    iprot.readMessageEnd()
8105 
    result = updateBanner_result()
8106 
    result.success = self._handler.updateBanner(args.banner)
8107 
    oprot.writeMessageBegin("updateBanner", TMessageType.REPLY, seqid)
8108 
    result.write(oprot)
8109 
    oprot.writeMessageEnd()
8110 
    oprot.trans.flush()
8111 
 
6850 kshitij.so 8112 
  def process_getAllBanners(self, seqid, iprot, oprot):
8113 
    args = getAllBanners_args()
8114 
    args.read(iprot)
8115 
    iprot.readMessageEnd()
8116 
    result = getAllBanners_result()
8117 
    result.success = self._handler.getAllBanners()
8118 
    oprot.writeMessageBegin("getAllBanners", TMessageType.REPLY, seqid)
8119 
    result.write(oprot)
8120 
    oprot.writeMessageEnd()
8121 
    oprot.trans.flush()
8122 
 
8123 
  def process_deleteBanner(self, seqid, iprot, oprot):
8124 
    args = deleteBanner_args()
8125 
    args.read(iprot)
8126 
    iprot.readMessageEnd()
8127 
    result = deleteBanner_result()
9155 kshitij.so 8128 
    result.success = self._handler.deleteBanner(args.bannerName, args.bannerType)
6850 kshitij.so 8129 
    oprot.writeMessageBegin("deleteBanner", TMessageType.REPLY, seqid)
8130 
    result.write(oprot)
8131 
    oprot.writeMessageEnd()
8132 
    oprot.trans.flush()
8133 
 
8134 
  def process_getBannerDetails(self, seqid, iprot, oprot):
8135 
    args = getBannerDetails_args()
8136 
    args.read(iprot)
8137 
    iprot.readMessageEnd()
8138 
    result = getBannerDetails_result()
9155 kshitij.so 8139 
    result.success = self._handler.getBannerDetails(args.bannerName, args.bannerType)
6850 kshitij.so 8140 
    oprot.writeMessageBegin("getBannerDetails", TMessageType.REPLY, seqid)
8141 
    result.write(oprot)
8142 
    oprot.writeMessageEnd()
8143 
    oprot.trans.flush()
8144 
 
8145 
  def process_getActiveBanners(self, seqid, iprot, oprot):
8146 
    args = getActiveBanners_args()
8147 
    args.read(iprot)
8148 
    iprot.readMessageEnd()
8149 
    result = getActiveBanners_result()
8150 
    result.success = self._handler.getActiveBanners()
8151 
    oprot.writeMessageBegin("getActiveBanners", TMessageType.REPLY, seqid)
8152 
    result.write(oprot)
8153 
    oprot.writeMessageEnd()
8154 
    oprot.trans.flush()
8155 
 
6849 kshitij.so 8156 
  def process_addBannerMap(self, seqid, iprot, oprot):
8157 
    args = addBannerMap_args()
8158 
    args.read(iprot)
8159 
    iprot.readMessageEnd()
8160 
    result = addBannerMap_result()
8579 kshitij.so 8161 
    result.success = self._handler.addBannerMap(args.bannerMaps)
6849 kshitij.so 8162 
    oprot.writeMessageBegin("addBannerMap", TMessageType.REPLY, seqid)
8163 
    result.write(oprot)
8164 
    oprot.writeMessageEnd()
8165 
    oprot.trans.flush()
8166 
 
8579 kshitij.so 8167 
  def process_updateBannerMap(self, seqid, iprot, oprot):
8168 
    args = updateBannerMap_args()
8169 
    args.read(iprot)
8170 
    iprot.readMessageEnd()
8171 
    result = updateBannerMap_result()
8172 
    result.success = self._handler.updateBannerMap(args.bannerMap)
8173 
    oprot.writeMessageBegin("updateBannerMap", TMessageType.REPLY, seqid)
8174 
    result.write(oprot)
8175 
    oprot.writeMessageEnd()
8176 
    oprot.trans.flush()
8177 
 
6849 kshitij.so 8178 
  def process_deleteBannerMap(self, seqid, iprot, oprot):
8179 
    args = deleteBannerMap_args()
8180 
    args.read(iprot)
8181 
    iprot.readMessageEnd()
8182 
    result = deleteBannerMap_result()
8183 
    result.success = self._handler.deleteBannerMap(args.bannerName)
8184 
    oprot.writeMessageBegin("deleteBannerMap", TMessageType.REPLY, seqid)
8185 
    result.write(oprot)
8186 
    oprot.writeMessageEnd()
8187 
    oprot.trans.flush()
8188 
 
8189 
  def process_getBannerMapDetails(self, seqid, iprot, oprot):
8190 
    args = getBannerMapDetails_args()
8191 
    args.read(iprot)
8192 
    iprot.readMessageEnd()
8193 
    result = getBannerMapDetails_result()
9155 kshitij.so 8194 
    result.success = self._handler.getBannerMapDetails(args.bannerName, args.bannerType)
6849 kshitij.so 8195 
    oprot.writeMessageBegin("getBannerMapDetails", TMessageType.REPLY, seqid)
8196 
    result.write(oprot)
8197 
    oprot.writeMessageEnd()
8198 
    oprot.trans.flush()
8199 
 
8579 kshitij.so 8200 
  def process_addBannerUri(self, seqid, iprot, oprot):
8201 
    args = addBannerUri_args()
8202 
    args.read(iprot)
8203 
    iprot.readMessageEnd()
8204 
    result = addBannerUri_result()
8205 
    self._handler.addBannerUri(args.bannerUriMappings)
8206 
    oprot.writeMessageBegin("addBannerUri", TMessageType.REPLY, seqid)
8207 
    result.write(oprot)
8208 
    oprot.writeMessageEnd()
8209 
    oprot.trans.flush()
8210 
 
8211 
  def process_getUriMapping(self, seqid, iprot, oprot):
8212 
    args = getUriMapping_args()
8213 
    args.read(iprot)
8214 
    iprot.readMessageEnd()
8215 
    result = getUriMapping_result()
9155 kshitij.so 8216 
    result.success = self._handler.getUriMapping(args.bannerName, args.bannerType)
8579 kshitij.so 8217 
    oprot.writeMessageBegin("getUriMapping", TMessageType.REPLY, seqid)
8218 
    result.write(oprot)
8219 
    oprot.writeMessageEnd()
8220 
    oprot.trans.flush()
8221 
 
8222 
  def process_addCampaign(self, seqid, iprot, oprot):
8223 
    args = addCampaign_args()
8224 
    args.read(iprot)
8225 
    iprot.readMessageEnd()
8226 
    result = addCampaign_result()
8227 
    self._handler.addCampaign(args.campaign)
8228 
    oprot.writeMessageBegin("addCampaign", TMessageType.REPLY, seqid)
8229 
    result.write(oprot)
8230 
    oprot.writeMessageEnd()
8231 
    oprot.trans.flush()
8232 
 
8233 
  def process_getCampaigns(self, seqid, iprot, oprot):
8234 
    args = getCampaigns_args()
8235 
    args.read(iprot)
8236 
    iprot.readMessageEnd()
8237 
    result = getCampaigns_result()
8238 
    result.success = self._handler.getCampaigns(args.campaignName)
8239 
    oprot.writeMessageBegin("getCampaigns", TMessageType.REPLY, seqid)
8240 
    result.write(oprot)
8241 
    oprot.writeMessageEnd()
8242 
    oprot.trans.flush()
8243 
 
8244 
  def process_deleteCampaign(self, seqid, iprot, oprot):
8245 
    args = deleteCampaign_args()
8246 
    args.read(iprot)
8247 
    iprot.readMessageEnd()
8248 
    result = deleteCampaign_result()
8249 
    self._handler.deleteCampaign(args.campaignId)
8250 
    oprot.writeMessageBegin("deleteCampaign", TMessageType.REPLY, seqid)
8251 
    result.write(oprot)
8252 
    oprot.writeMessageEnd()
8253 
    oprot.trans.flush()
8254 
 
8255 
  def process_getAllCampaigns(self, seqid, iprot, oprot):
8256 
    args = getAllCampaigns_args()
8257 
    args.read(iprot)
8258 
    iprot.readMessageEnd()
8259 
    result = getAllCampaigns_result()
8260 
    result.success = self._handler.getAllCampaigns()
8261 
    oprot.writeMessageBegin("getAllCampaigns", TMessageType.REPLY, seqid)
8262 
    result.write(oprot)
8263 
    oprot.writeMessageEnd()
8264 
    oprot.trans.flush()
8265 
 
9155 kshitij.so 8266 
  def process_getActiveBannersForMobileSite(self, seqid, iprot, oprot):
8267 
    args = getActiveBannersForMobileSite_args()
8268 
    args.read(iprot)
8269 
    iprot.readMessageEnd()
8270 
    result = getActiveBannersForMobileSite_result()
8271 
    result.success = self._handler.getActiveBannersForMobileSite()
8272 
    oprot.writeMessageBegin("getActiveBannersForMobileSite", TMessageType.REPLY, seqid)
8273 
    result.write(oprot)
8274 
    oprot.writeMessageEnd()
8275 
    oprot.trans.flush()
8276 
 
5944 mandeep.dh 8277 
  def process_deleteSimilarItem(self, seqid, iprot, oprot):
8278 
    args = deleteSimilarItem_args()
8279 
    args.read(iprot)
8280 
    iprot.readMessageEnd()
8281 
    result = deleteSimilarItem_result()
8282 
    try:
8283 
      result.success = self._handler.deleteSimilarItem(args.itemId, args.catalogItemId)
8284 
    except CatalogServiceException, cex:
8285 
      result.cex = cex
8286 
    oprot.writeMessageBegin("deleteSimilarItem", TMessageType.REPLY, seqid)
8287 
    result.write(oprot)
8288 
    oprot.writeMessageEnd()
8289 
    oprot.trans.flush()
8290 
 
8291 
  def process_checkSimilarItem(self, seqid, iprot, oprot):
8292 
    args = checkSimilarItem_args()
8293 
    args.read(iprot)
8294 
    iprot.readMessageEnd()
8295 
    result = checkSimilarItem_result()
8296 
    result.success = self._handler.checkSimilarItem(args.brand, args.modelNumber, args.modelName, args.color)
8297 
    oprot.writeMessageBegin("checkSimilarItem", TMessageType.REPLY, seqid)
8298 
    result.write(oprot)
8299 
    oprot.writeMessageEnd()
8300 
    oprot.trans.flush()
8301 
 
8302 
  def process_validateRiskyStatus(self, seqid, iprot, oprot):
8303 
    args = validateRiskyStatus_args()
8304 
    args.read(iprot)
8305 
    iprot.readMessageEnd()
8306 
    result = validateRiskyStatus_result()
8307 
    self._handler.validateRiskyStatus(args.itemId)
8308 
    oprot.writeMessageBegin("validateRiskyStatus", TMessageType.REPLY, seqid)
8309 
    result.write(oprot)
8310 
    oprot.writeMessageEnd()
8311 
    oprot.trans.flush()
8312 
 
8313 
  def process_changeItemRiskyFlag(self, seqid, iprot, oprot):
8314 
    args = changeItemRiskyFlag_args()
8315 
    args.read(iprot)
8316 
    iprot.readMessageEnd()
8317 
    result = changeItemRiskyFlag_result()
8318 
    self._handler.changeItemRiskyFlag(args.itemId, args.risky)
8319 
    oprot.writeMessageBegin("changeItemRiskyFlag", TMessageType.REPLY, seqid)
8320 
    result.write(oprot)
8321 
    oprot.writeMessageEnd()
8322 
    oprot.trans.flush()
8323 
 
8324 
  def process_getItemsByRiskyFlag(self, seqid, iprot, oprot):
8325 
    args = getItemsByRiskyFlag_args()
8326 
    args.read(iprot)
8327 
    iprot.readMessageEnd()
8328 
    result = getItemsByRiskyFlag_result()
8329 
    result.success = self._handler.getItemsByRiskyFlag()
8330 
    oprot.writeMessageBegin("getItemsByRiskyFlag", TMessageType.REPLY, seqid)
8331 
    result.write(oprot)
8332 
    oprot.writeMessageEnd()
8333 
    oprot.trans.flush()
8334 
 
8335 
  def process_getItemsForMasterSheet(self, seqid, iprot, oprot):
8336 
    args = getItemsForMasterSheet_args()
8337 
    args.read(iprot)
8338 
    iprot.readMessageEnd()
8339 
    result = getItemsForMasterSheet_result()
8340 
    result.success = self._handler.getItemsForMasterSheet(args.category, args.brand)
8341 
    oprot.writeMessageBegin("getItemsForMasterSheet", TMessageType.REPLY, seqid)
8342 
    result.write(oprot)
8343 
    oprot.writeMessageEnd()
8344 
    oprot.trans.flush()
8345 
 
8346 
  def process_getSimilarItemsCatalogIds(self, seqid, iprot, oprot):
8347 
    args = getSimilarItemsCatalogIds_args()
8348 
    args.read(iprot)
8349 
    iprot.readMessageEnd()
8350 
    result = getSimilarItemsCatalogIds_result()
8351 
    result.success = self._handler.getSimilarItemsCatalogIds(args.beginIndex, args.totalItems, args.itemId)
8352 
    oprot.writeMessageBegin("getSimilarItemsCatalogIds", TMessageType.REPLY, seqid)
8353 
    result.write(oprot)
8354 
    oprot.writeMessageEnd()
8355 
    oprot.trans.flush()
8356 
 
8357 
  def process_addProductNotification(self, seqid, iprot, oprot):
8358 
    args = addProductNotification_args()
8359 
    args.read(iprot)
8360 
    iprot.readMessageEnd()
8361 
    result = addProductNotification_result()
8362 
    result.success = self._handler.addProductNotification(args.itemId, args.email)
8363 
    oprot.writeMessageBegin("addProductNotification", TMessageType.REPLY, seqid)
8364 
    result.write(oprot)
8365 
    oprot.writeMessageEnd()
8366 
    oprot.trans.flush()
8367 
 
8368 
  def process_sendProductNotifications(self, seqid, iprot, oprot):
8369 
    args = sendProductNotifications_args()
8370 
    args.read(iprot)
8371 
    iprot.readMessageEnd()
8372 
    result = sendProductNotifications_result()
8373 
    result.success = self._handler.sendProductNotifications()
8374 
    oprot.writeMessageBegin("sendProductNotifications", TMessageType.REPLY, seqid)
8375 
    result.write(oprot)
8376 
    oprot.writeMessageEnd()
8377 
    oprot.trans.flush()
8378 
 
8379 
  def process_getAllBrandsByCategory(self, seqid, iprot, oprot):
8380 
    args = getAllBrandsByCategory_args()
8381 
    args.read(iprot)
8382 
    iprot.readMessageEnd()
8383 
    result = getAllBrandsByCategory_result()
8384 
    result.success = self._handler.getAllBrandsByCategory(args.categoryId)
8385 
    oprot.writeMessageBegin("getAllBrandsByCategory", TMessageType.REPLY, seqid)
8386 
    result.write(oprot)
8387 
    oprot.writeMessageEnd()
8388 
    oprot.trans.flush()
8389 
 
8390 
  def process_getAllBrands(self, seqid, iprot, oprot):
8391 
    args = getAllBrands_args()
8392 
    args.read(iprot)
8393 
    iprot.readMessageEnd()
8394 
    result = getAllBrands_result()
8395 
    result.success = self._handler.getAllBrands()
8396 
    oprot.writeMessageBegin("getAllBrands", TMessageType.REPLY, seqid)
8397 
    result.write(oprot)
8398 
    oprot.writeMessageEnd()
8399 
    oprot.trans.flush()
8400 
 
8401 
  def process_getAllSources(self, seqid, iprot, oprot):
8402 
    args = getAllSources_args()
8403 
    args.read(iprot)
8404 
    iprot.readMessageEnd()
8405 
    result = getAllSources_result()
8406 
    result.success = self._handler.getAllSources()
8407 
    oprot.writeMessageBegin("getAllSources", TMessageType.REPLY, seqid)
8408 
    result.write(oprot)
8409 
    oprot.writeMessageEnd()
8410 
    oprot.trans.flush()
8411 
 
8412 
  def process_getItemPricingBySource(self, seqid, iprot, oprot):
8413 
    args = getItemPricingBySource_args()
8414 
    args.read(iprot)
8415 
    iprot.readMessageEnd()
8416 
    result = getItemPricingBySource_result()
8417 
    try:
8418 
      result.success = self._handler.getItemPricingBySource(args.itemId, args.sourceId)
8419 
    except CatalogServiceException, cex:
8420 
      result.cex = cex
8421 
    oprot.writeMessageBegin("getItemPricingBySource", TMessageType.REPLY, seqid)
8422 
    result.write(oprot)
8423 
    oprot.writeMessageEnd()
8424 
    oprot.trans.flush()
8425 
 
8426 
  def process_addSourceItemPricing(self, seqid, iprot, oprot):
8427 
    args = addSourceItemPricing_args()
8428 
    args.read(iprot)
8429 
    iprot.readMessageEnd()
8430 
    result = addSourceItemPricing_result()
8431 
    try:
8432 
      self._handler.addSourceItemPricing(args.sourceItemPricing)
8433 
    except CatalogServiceException, cex:
8434 
      result.cex = cex
8435 
    oprot.writeMessageBegin("addSourceItemPricing", TMessageType.REPLY, seqid)
8436 
    result.write(oprot)
8437 
    oprot.writeMessageEnd()
8438 
    oprot.trans.flush()
8439 
 
8440 
  def process_getAllSourcePricing(self, seqid, iprot, oprot):
8441 
    args = getAllSourcePricing_args()
8442 
    args.read(iprot)
8443 
    iprot.readMessageEnd()
8444 
    result = getAllSourcePricing_result()
8445 
    try:
8446 
      result.success = self._handler.getAllSourcePricing(args.itemId)
8447 
    except CatalogServiceException, cex:
8448 
      result.cex = cex
8449 
    oprot.writeMessageBegin("getAllSourcePricing", TMessageType.REPLY, seqid)
8450 
    result.write(oprot)
8451 
    oprot.writeMessageEnd()
8452 
    oprot.trans.flush()
8453 
 
8454 
  def process_getItemForSource(self, seqid, iprot, oprot):
8455 
    args = getItemForSource_args()
8456 
    args.read(iprot)
8457 
    iprot.readMessageEnd()
8458 
    result = getItemForSource_result()
8459 
    try:
8460 
      result.success = self._handler.getItemForSource(args.item_id, args.sourceId)
8461 
    except CatalogServiceException, cex:
8462 
      result.cex = cex
8463 
    oprot.writeMessageBegin("getItemForSource", TMessageType.REPLY, seqid)
8464 
    result.write(oprot)
8465 
    oprot.writeMessageEnd()
8466 
    oprot.trans.flush()
8467 
 
8468 
  def process_searchItemsInRange(self, seqid, iprot, oprot):
8469 
    args = searchItemsInRange_args()
8470 
    args.read(iprot)
8471 
    iprot.readMessageEnd()
8472 
    result = searchItemsInRange_result()
8473 
    result.success = self._handler.searchItemsInRange(args.searchTerms, args.offset, args.limit)
8474 
    oprot.writeMessageBegin("searchItemsInRange", TMessageType.REPLY, seqid)
8475 
    result.write(oprot)
8476 
    oprot.writeMessageEnd()
8477 
    oprot.trans.flush()
8478 
 
8479 
  def process_getSearchResultCount(self, seqid, iprot, oprot):
8480 
    args = getSearchResultCount_args()
8481 
    args.read(iprot)
8482 
    iprot.readMessageEnd()
8483 
    result = getSearchResultCount_result()
8484 
    result.success = self._handler.getSearchResultCount(args.searchTerms)
8485 
    oprot.writeMessageBegin("getSearchResultCount", TMessageType.REPLY, seqid)
8486 
    result.write(oprot)
8487 
    oprot.writeMessageEnd()
8488 
    oprot.trans.flush()
8489 
 
8490 
  def process_getProductNotifications(self, seqid, iprot, oprot):
8491 
    args = getProductNotifications_args()
8492 
    args.read(iprot)
8493 
    iprot.readMessageEnd()
8494 
    result = getProductNotifications_result()
8495 
    result.success = self._handler.getProductNotifications(args.startDateTime)
8496 
    oprot.writeMessageBegin("getProductNotifications", TMessageType.REPLY, seqid)
8497 
    result.write(oprot)
8498 
    oprot.writeMessageEnd()
8499 
    oprot.trans.flush()
8500 
 
8501 
  def process_getProductNotificationRequestCount(self, seqid, iprot, oprot):
8502 
    args = getProductNotificationRequestCount_args()
8503 
    args.read(iprot)
8504 
    iprot.readMessageEnd()
8505 
    result = getProductNotificationRequestCount_result()
7897 amar.kumar 8506 
    result.success = self._handler.getProductNotificationRequestCount(args.startDateTime, args.categoryId)
5944 mandeep.dh 8507 
    oprot.writeMessageBegin("getProductNotificationRequestCount", TMessageType.REPLY, seqid)
8508 
    result.write(oprot)
8509 
    oprot.writeMessageEnd()
8510 
    oprot.trans.flush()
8511 
 
8512 
  def process_addAuthorizationLog(self, seqid, iprot, oprot):
8513 
    args = addAuthorizationLog_args()
8514 
    args.read(iprot)
8515 
    iprot.readMessageEnd()
8516 
    result = addAuthorizationLog_result()
8517 
    try:
8518 
      result.success = self._handler.addAuthorizationLog(args.itemId, args.username, args.reason)
8519 
    except CatalogServiceException, cex:
8520 
      result.cex = cex
8521 
    oprot.writeMessageBegin("addAuthorizationLog", TMessageType.REPLY, seqid)
8522 
    result.write(oprot)
8523 
    oprot.writeMessageEnd()
8524 
    oprot.trans.flush()
8525 
 
8526 
  def process_addupdateVoucherForItem(self, seqid, iprot, oprot):
8527 
    args = addupdateVoucherForItem_args()
8528 
    args.read(iprot)
8529 
    iprot.readMessageEnd()
8530 
    result = addupdateVoucherForItem_result()
8531 
    try:
8532 
      result.success = self._handler.addupdateVoucherForItem(args.catalog_item_id, args.voucherType, args.voucherAmount)
8533 
    except CatalogServiceException, cex:
8534 
      result.cex = cex
8535 
    oprot.writeMessageBegin("addupdateVoucherForItem", TMessageType.REPLY, seqid)
8536 
    result.write(oprot)
8537 
    oprot.writeMessageEnd()
8538 
    oprot.trans.flush()
8539 
 
8540 
  def process_deleteVoucherForItem(self, seqid, iprot, oprot):
8541 
    args = deleteVoucherForItem_args()
8542 
    args.read(iprot)
8543 
    iprot.readMessageEnd()
8544 
    result = deleteVoucherForItem_result()
8545 
    try:
8546 
      result.success = self._handler.deleteVoucherForItem(args.catalog_item_id, args.voucherType)
8547 
    except CatalogServiceException, cex:
8548 
      result.cex = cex
8549 
    oprot.writeMessageBegin("deleteVoucherForItem", TMessageType.REPLY, seqid)
8550 
    result.write(oprot)
8551 
    oprot.writeMessageEnd()
8552 
    oprot.trans.flush()
8553 
 
8554 
  def process_getVoucherAmount(self, seqid, iprot, oprot):
8555 
    args = getVoucherAmount_args()
8556 
    args.read(iprot)
8557 
    iprot.readMessageEnd()
8558 
    result = getVoucherAmount_result()
8559 
    result.success = self._handler.getVoucherAmount(args.itemId, args.voucherType)
8560 
    oprot.writeMessageBegin("getVoucherAmount", TMessageType.REPLY, seqid)
8561 
    result.write(oprot)
8562 
    oprot.writeMessageEnd()
8563 
    oprot.trans.flush()
8564 
 
8565 
  def process_getAllItemVouchers(self, seqid, iprot, oprot):
8566 
    args = getAllItemVouchers_args()
8567 
    args.read(iprot)
8568 
    iprot.readMessageEnd()
8569 
    result = getAllItemVouchers_result()
8570 
    result.success = self._handler.getAllItemVouchers(args.itemId)
8571 
    oprot.writeMessageBegin("getAllItemVouchers", TMessageType.REPLY, seqid)
8572 
    result.write(oprot)
8573 
    oprot.writeMessageEnd()
8574 
    oprot.trans.flush()
8575 
 
8576 
  def process_isValidCatalogItemId(self, seqid, iprot, oprot):
8577 
    args = isValidCatalogItemId_args()
8578 
    args.read(iprot)
8579 
    iprot.readMessageEnd()
8580 
    result = isValidCatalogItemId_result()
8581 
    result.success = self._handler.isValidCatalogItemId(args.catalog_item_id)
8582 
    oprot.writeMessageBegin("isValidCatalogItemId", TMessageType.REPLY, seqid)
8583 
    result.write(oprot)
8584 
    oprot.writeMessageEnd()
8585 
    oprot.trans.flush()
8586 
 
6039 amit.gupta 8587 
  def process_getVatPercentageForItem(self, seqid, iprot, oprot):
8588 
    args = getVatPercentageForItem_args()
8589 
    args.read(iprot)
8590 
    iprot.readMessageEnd()
8591 
    result = getVatPercentageForItem_result()
7340 amit.gupta 8592 
    try:
8593 
      result.success = self._handler.getVatPercentageForItem(args.itemId, args.stateId, args.price)
8594 
    except CatalogServiceException, cex:
8595 
      result.cex = cex
6039 amit.gupta 8596 
    oprot.writeMessageBegin("getVatPercentageForItem", TMessageType.REPLY, seqid)
8597 
    result.write(oprot)
8598 
    oprot.writeMessageEnd()
8599 
    oprot.trans.flush()
5944 mandeep.dh 8600 
 
6039 amit.gupta 8601 
  def process_getVatAmountForItem(self, seqid, iprot, oprot):
8602 
    args = getVatAmountForItem_args()
8603 
    args.read(iprot)
8604 
    iprot.readMessageEnd()
8605 
    result = getVatAmountForItem_result()
8606 
    result.success = self._handler.getVatAmountForItem(args.itemId, args.price)
8607 
    oprot.writeMessageBegin("getVatAmountForItem", TMessageType.REPLY, seqid)
8608 
    result.write(oprot)
8609 
    oprot.writeMessageEnd()
8610 
    oprot.trans.flush()
8611 
 
6531 vikram.rag 8612 
  def process_getAllIgnoredInventoryUpdateItemsList(self, seqid, iprot, oprot):
8613 
    args = getAllIgnoredInventoryUpdateItemsList_args()
8614 
    args.read(iprot)
8615 
    iprot.readMessageEnd()
8616 
    result = getAllIgnoredInventoryUpdateItemsList_result()
8617 
    result.success = self._handler.getAllIgnoredInventoryUpdateItemsList(args.offset, args.limit)
8618 
    oprot.writeMessageBegin("getAllIgnoredInventoryUpdateItemsList", TMessageType.REPLY, seqid)
8619 
    result.write(oprot)
8620 
    oprot.writeMessageEnd()
8621 
    oprot.trans.flush()
6039 amit.gupta 8622 
 
6821 amar.kumar 8623 
  def process_getAllAliveItems(self, seqid, iprot, oprot):
8624 
    args = getAllAliveItems_args()
8625 
    args.read(iprot)
8626 
    iprot.readMessageEnd()
8627 
    result = getAllAliveItems_result()
8628 
    result.success = self._handler.getAllAliveItems()
8629 
    oprot.writeMessageBegin("getAllAliveItems", TMessageType.REPLY, seqid)
8630 
    result.write(oprot)
8631 
    oprot.writeMessageEnd()
8632 
    oprot.trans.flush()
8633 
 
6805 anupam.sin 8634 
  def process_getInsuranceAmount(self, seqid, iprot, oprot):
8635 
    args = getInsuranceAmount_args()
8636 
    args.read(iprot)
8637 
    iprot.readMessageEnd()
8638 
    result = getInsuranceAmount_result()
6921 anupam.sin 8639 
    result.success = self._handler.getInsuranceAmount(args.itemId, args.price, args.insurerId, args.quantity)
6805 anupam.sin 8640 
    oprot.writeMessageBegin("getInsuranceAmount", TMessageType.REPLY, seqid)
8641 
    result.write(oprot)
8642 
    oprot.writeMessageEnd()
8643 
    oprot.trans.flush()
6531 vikram.rag 8644 
 
6805 anupam.sin 8645 
  def process_getInsurer(self, seqid, iprot, oprot):
8646 
    args = getInsurer_args()
8647 
    args.read(iprot)
8648 
    iprot.readMessageEnd()
8649 
    result = getInsurer_result()
8650 
    result.success = self._handler.getInsurer(args.insurerId)
8651 
    oprot.writeMessageBegin("getInsurer", TMessageType.REPLY, seqid)
8652 
    result.write(oprot)
8653 
    oprot.writeMessageEnd()
8654 
    oprot.trans.flush()
8655 
 
6838 vikram.rag 8656 
  def process_getAllInsurers(self, seqid, iprot, oprot):
8657 
    args = getAllInsurers_args()
8658 
    args.read(iprot)
8659 
    iprot.readMessageEnd()
8660 
    result = getAllInsurers_result()
8661 
    result.success = self._handler.getAllInsurers()
8662 
    oprot.writeMessageBegin("getAllInsurers", TMessageType.REPLY, seqid)
8663 
    result.write(oprot)
8664 
    oprot.writeMessageEnd()
8665 
    oprot.trans.flush()
6805 anupam.sin 8666 
 
6962 rajveer 8667 
  def process_updateInsuranceDeclaredAmount(self, seqid, iprot, oprot):
8668 
    args = updateInsuranceDeclaredAmount_args()
8669 
    args.read(iprot)
8670 
    iprot.readMessageEnd()
8671 
    result = updateInsuranceDeclaredAmount_result()
8672 
    self._handler.updateInsuranceDeclaredAmount(args.insurerId, args.amount)
8673 
    oprot.writeMessageBegin("updateInsuranceDeclaredAmount", TMessageType.REPLY, seqid)
8674 
    result.write(oprot)
8675 
    oprot.writeMessageEnd()
8676 
    oprot.trans.flush()
6838 vikram.rag 8677 
 
7190 amar.kumar 8678 
  def process_getFreebieForItem(self, seqid, iprot, oprot):
8679 
    args = getFreebieForItem_args()
8680 
    args.read(iprot)
8681 
    iprot.readMessageEnd()
8682 
    result = getFreebieForItem_result()
8683 
    result.success = self._handler.getFreebieForItem(args.itemId)
8684 
    oprot.writeMessageBegin("getFreebieForItem", TMessageType.REPLY, seqid)
8685 
    result.write(oprot)
8686 
    oprot.writeMessageEnd()
8687 
    oprot.trans.flush()
6962 rajveer 8688 
 
7190 amar.kumar 8689 
  def process_addOrUpdateFreebieForItem(self, seqid, iprot, oprot):
8690 
    args = addOrUpdateFreebieForItem_args()
8691 
    args.read(iprot)
8692 
    iprot.readMessageEnd()
8693 
    result = addOrUpdateFreebieForItem_result()
8694 
    self._handler.addOrUpdateFreebieForItem(args.freebieItem)
8695 
    oprot.writeMessageBegin("addOrUpdateFreebieForItem", TMessageType.REPLY, seqid)
8696 
    result.write(oprot)
8697 
    oprot.writeMessageEnd()
8698 
    oprot.trans.flush()
8699 
 
7272 amit.gupta 8700 
  def process_addOrUpdateBrandInfo(self, seqid, iprot, oprot):
8701 
    args = addOrUpdateBrandInfo_args()
8702 
    args.read(iprot)
8703 
    iprot.readMessageEnd()
8704 
    result = addOrUpdateBrandInfo_result()
8705 
    self._handler.addOrUpdateBrandInfo(args.brandInfo)
8706 
    oprot.writeMessageBegin("addOrUpdateBrandInfo", TMessageType.REPLY, seqid)
8707 
    result.write(oprot)
8708 
    oprot.writeMessageEnd()
8709 
    oprot.trans.flush()
8710 
 
8711 
  def process_getBrandInfo(self, seqid, iprot, oprot):
8712 
    args = getBrandInfo_args()
8713 
    args.read(iprot)
8714 
    iprot.readMessageEnd()
8715 
    result = getBrandInfo_result()
8716 
    result.success = self._handler.getBrandInfo()
8717 
    oprot.writeMessageBegin("getBrandInfo", TMessageType.REPLY, seqid)
8718 
    result.write(oprot)
8719 
    oprot.writeMessageEnd()
8720 
    oprot.trans.flush()
8721 
 
7256 rajveer 8722 
  def process_getStorePricing(self, seqid, iprot, oprot):
8723 
    args = getStorePricing_args()
8724 
    args.read(iprot)
8725 
    iprot.readMessageEnd()
8726 
    result = getStorePricing_result()
8727 
    result.success = self._handler.getStorePricing(args.itemId)
8728 
    oprot.writeMessageBegin("getStorePricing", TMessageType.REPLY, seqid)
8729 
    result.write(oprot)
8730 
    oprot.writeMessageEnd()
8731 
    oprot.trans.flush()
7190 amar.kumar 8732 
 
7306 rajveer 8733 
  def process_getStorePricings(self, seqid, iprot, oprot):
8734 
    args = getStorePricings_args()
8735 
    args.read(iprot)
8736 
    iprot.readMessageEnd()
8737 
    result = getStorePricings_result()
8738 
    result.success = self._handler.getStorePricings(args.itemIds)
8739 
    oprot.writeMessageBegin("getStorePricings", TMessageType.REPLY, seqid)
8740 
    result.write(oprot)
8741 
    oprot.writeMessageEnd()
8742 
    oprot.trans.flush()
8743 
 
7265 rajveer 8744 
  def process_updateStorePricing(self, seqid, iprot, oprot):
8745 
    args = updateStorePricing_args()
8746 
    args.read(iprot)
8747 
    iprot.readMessageEnd()
8748 
    result = updateStorePricing_result()
7382 rajveer 8749 
    self._handler.updateStorePricing(args.sp, args.allColors)
7265 rajveer 8750 
    oprot.writeMessageBegin("updateStorePricing", TMessageType.REPLY, seqid)
8751 
    result.write(oprot)
8752 
    oprot.writeMessageEnd()
8753 
    oprot.trans.flush()
7256 rajveer 8754 
 
7281 kshitij.so 8755 
  def process_getAllAmazonListedItems(self, seqid, iprot, oprot):
8756 
    args = getAllAmazonListedItems_args()
8757 
    args.read(iprot)
8758 
    iprot.readMessageEnd()
8759 
    result = getAllAmazonListedItems_result()
8760 
    result.success = self._handler.getAllAmazonListedItems()
8761 
    oprot.writeMessageBegin("getAllAmazonListedItems", TMessageType.REPLY, seqid)
8762 
    result.write(oprot)
8763 
    oprot.writeMessageEnd()
8764 
    oprot.trans.flush()
7265 rajveer 8765 
 
8619 kshitij.so 8766 
  def process_searchAmazonItems(self, seqid, iprot, oprot):
8767 
    args = searchAmazonItems_args()
8768 
    args.read(iprot)
8769 
    iprot.readMessageEnd()
8770 
    result = searchAmazonItems_result()
8771 
    result.success = self._handler.searchAmazonItems(args.searchTerm, args.offset, args.limit)
8772 
    oprot.writeMessageBegin("searchAmazonItems", TMessageType.REPLY, seqid)
8773 
    result.write(oprot)
8774 
    oprot.writeMessageEnd()
8775 
    oprot.trans.flush()
8776 
 
8777 
  def process_getAmazonSearchResultCount(self, seqid, iprot, oprot):
8778 
    args = getAmazonSearchResultCount_args()
8779 
    args.read(iprot)
8780 
    iprot.readMessageEnd()
8781 
    result = getAmazonSearchResultCount_result()
8782 
    result.success = self._handler.getAmazonSearchResultCount(args.searchTerm)
8783 
    oprot.writeMessageBegin("getAmazonSearchResultCount", TMessageType.REPLY, seqid)
8784 
    result.write(oprot)
8785 
    oprot.writeMessageEnd()
8786 
    oprot.trans.flush()
8787 
 
8788 
  def process_getCountForAmazonlistedItems(self, seqid, iprot, oprot):
8789 
    args = getCountForAmazonlistedItems_args()
8790 
    args.read(iprot)
8791 
    iprot.readMessageEnd()
8792 
    result = getCountForAmazonlistedItems_result()
8793 
    result.success = self._handler.getCountForAmazonlistedItems()
8794 
    oprot.writeMessageBegin("getCountForAmazonlistedItems", TMessageType.REPLY, seqid)
8795 
    result.write(oprot)
8796 
    oprot.writeMessageEnd()
8797 
    oprot.trans.flush()
8798 
 
7281 kshitij.so 8799 
  def process_getAmazonItemDetails(self, seqid, iprot, oprot):
8800 
    args = getAmazonItemDetails_args()
8801 
    args.read(iprot)
8802 
    iprot.readMessageEnd()
8803 
    result = getAmazonItemDetails_result()
8804 
    result.success = self._handler.getAmazonItemDetails(args.itemId)
8805 
    oprot.writeMessageBegin("getAmazonItemDetails", TMessageType.REPLY, seqid)
8806 
    result.write(oprot)
8807 
    oprot.writeMessageEnd()
8808 
    oprot.trans.flush()
8809 
 
8810 
  def process_updateAmazonItemDetails(self, seqid, iprot, oprot):
8811 
    args = updateAmazonItemDetails_args()
8812 
    args.read(iprot)
8813 
    iprot.readMessageEnd()
8814 
    result = updateAmazonItemDetails_result()
8168 kshitij.so 8815 
    self._handler.updateAmazonItemDetails(args.amazonlisted)
7281 kshitij.so 8816 
    oprot.writeMessageBegin("updateAmazonItemDetails", TMessageType.REPLY, seqid)
8817 
    result.write(oprot)
8818 
    oprot.writeMessageEnd()
8819 
    oprot.trans.flush()
8820 
 
8821 
  def process_addAmazonItem(self, seqid, iprot, oprot):
8822 
    args = addAmazonItem_args()
8823 
    args.read(iprot)
8824 
    iprot.readMessageEnd()
8825 
    result = addAmazonItem_result()
8826 
    self._handler.addAmazonItem(args.amazonlisted)
8827 
    oprot.writeMessageBegin("addAmazonItem", TMessageType.REPLY, seqid)
8828 
    result.write(oprot)
8829 
    oprot.writeMessageEnd()
8830 
    oprot.trans.flush()
8831 
 
7291 vikram.rag 8832 
  def process_getAsinItems(self, seqid, iprot, oprot):
8833 
    args = getAsinItems_args()
8834 
    args.read(iprot)
8835 
    iprot.readMessageEnd()
8836 
    result = getAsinItems_result()
8837 
    result.success = self._handler.getAsinItems()
8838 
    oprot.writeMessageBegin("getAsinItems", TMessageType.REPLY, seqid)
8839 
    result.write(oprot)
8840 
    oprot.writeMessageEnd()
8841 
    oprot.trans.flush()
7281 kshitij.so 8842 
 
7291 vikram.rag 8843 
  def process_getAllFbaListedItems(self, seqid, iprot, oprot):
8844 
    args = getAllFbaListedItems_args()
8845 
    args.read(iprot)
8846 
    iprot.readMessageEnd()
8847 
    result = getAllFbaListedItems_result()
8848 
    result.success = self._handler.getAllFbaListedItems()
8849 
    oprot.writeMessageBegin("getAllFbaListedItems", TMessageType.REPLY, seqid)
8850 
    result.write(oprot)
8851 
    oprot.writeMessageEnd()
8852 
    oprot.trans.flush()
8853 
 
8854 
  def process_getAllNonFbaListedItems(self, seqid, iprot, oprot):
8855 
    args = getAllNonFbaListedItems_args()
8856 
    args.read(iprot)
8857 
    iprot.readMessageEnd()
8858 
    result = getAllNonFbaListedItems_result()
8859 
    result.success = self._handler.getAllNonFbaListedItems()
8860 
    oprot.writeMessageBegin("getAllNonFbaListedItems", TMessageType.REPLY, seqid)
8861 
    result.write(oprot)
8862 
    oprot.writeMessageEnd()
8863 
    oprot.trans.flush()
8864 
 
7460 kshitij.so 8865 
  def process_updateItemInventory(self, seqid, iprot, oprot):
8866 
    args = updateItemInventory_args()
8867 
    args.read(iprot)
8868 
    iprot.readMessageEnd()
8869 
    result = updateItemInventory_result()
8870 
    result.success = self._handler.updateItemInventory(args.itemId, args.holdInventory, args.defaultInventory)
8871 
    oprot.writeMessageBegin("updateItemInventory", TMessageType.REPLY, seqid)
8872 
    result.write(oprot)
8873 
    oprot.writeMessageEnd()
8874 
    oprot.trans.flush()
7291 vikram.rag 8875 
 
7770 kshitij.so 8876 
  def process_updateTimestampForAmazonFeeds(self, seqid, iprot, oprot):
8877 
    args = updateTimestampForAmazonFeeds_args()
8878 
    args.read(iprot)
8879 
    iprot.readMessageEnd()
8880 
    result = updateTimestampForAmazonFeeds_result()
8881 
    result.success = self._handler.updateTimestampForAmazonFeeds(args.type, args.sku, args.timestamp)
8882 
    oprot.writeMessageBegin("updateTimestampForAmazonFeeds", TMessageType.REPLY, seqid)
8883 
    result.write(oprot)
8884 
    oprot.writeMessageEnd()
8885 
    oprot.trans.flush()
7460 kshitij.so 8886 
 
7897 amar.kumar 8887 
  def process_getAllParentCategories(self, seqid, iprot, oprot):
8888 
    args = getAllParentCategories_args()
8889 
    args.read(iprot)
8890 
    iprot.readMessageEnd()
8891 
    result = getAllParentCategories_result()
8892 
    result.success = self._handler.getAllParentCategories()
8893 
    oprot.writeMessageBegin("getAllParentCategories", TMessageType.REPLY, seqid)
8894 
    result.write(oprot)
8895 
    oprot.writeMessageEnd()
8896 
    oprot.trans.flush()
7770 kshitij.so 8897 
 
7977 kshitij.so 8898 
  def process_addPageViewEvent(self, seqid, iprot, oprot):
8899 
    args = addPageViewEvent_args()
8900 
    args.read(iprot)
8901 
    iprot.readMessageEnd()
8902 
    result = addPageViewEvent_result()
8903 
    self._handler.addPageViewEvent(args.pageViewEvents)
8904 
    oprot.writeMessageBegin("addPageViewEvent", TMessageType.REPLY, seqid)
8905 
    result.write(oprot)
8906 
    oprot.writeMessageEnd()
8907 
    oprot.trans.flush()
7897 amar.kumar 8908 
 
7977 kshitij.so 8909 
  def process_addCartEvent(self, seqid, iprot, oprot):
8910 
    args = addCartEvent_args()
8911 
    args.read(iprot)
8912 
    iprot.readMessageEnd()
8913 
    result = addCartEvent_result()
8914 
    self._handler.addCartEvent(args.cartEvents)
8915 
    oprot.writeMessageBegin("addCartEvent", TMessageType.REPLY, seqid)
8916 
    result.write(oprot)
8917 
    oprot.writeMessageEnd()
8918 
    oprot.trans.flush()
8919 
 
8182 amar.kumar 8920 
  def process_addEbayItem(self, seqid, iprot, oprot):
8921 
    args = addEbayItem_args()
8922 
    args.read(iprot)
8923 
    iprot.readMessageEnd()
8924 
    result = addEbayItem_result()
8925 
    self._handler.addEbayItem(args.ebayItem)
8926 
    oprot.writeMessageBegin("addEbayItem", TMessageType.REPLY, seqid)
8927 
    result.write(oprot)
8928 
    oprot.writeMessageEnd()
8929 
    oprot.trans.flush()
8930 
 
8931 
  def process_getEbayItem(self, seqid, iprot, oprot):
8932 
    args = getEbayItem_args()
8933 
    args.read(iprot)
8934 
    iprot.readMessageEnd()
8935 
    result = getEbayItem_result()
8936 
    result.success = self._handler.getEbayItem(args.listingId)
8937 
    oprot.writeMessageBegin("getEbayItem", TMessageType.REPLY, seqid)
8938 
    result.write(oprot)
8939 
    oprot.writeMessageEnd()
8940 
    oprot.trans.flush()
8941 
 
8942 
  def process_updateEbayItem(self, seqid, iprot, oprot):
8943 
    args = updateEbayItem_args()
8944 
    args.read(iprot)
8945 
    iprot.readMessageEnd()
8946 
    result = updateEbayItem_result()
8947 
    self._handler.updateEbayItem(args.ebayItem)
8948 
    oprot.writeMessageBegin("updateEbayItem", TMessageType.REPLY, seqid)
8949 
    result.write(oprot)
8950 
    oprot.writeMessageEnd()
8951 
    oprot.trans.flush()
8952 
 
8139 kshitij.so 8953 
  def process_getAmazonListedItems(self, seqid, iprot, oprot):
8954 
    args = getAmazonListedItems_args()
8955 
    args.read(iprot)
8956 
    iprot.readMessageEnd()
8957 
    result = getAmazonListedItems_result()
8958 
    result.success = self._handler.getAmazonListedItems(args.offset, args.limit)
8959 
    oprot.writeMessageBegin("getAmazonListedItems", TMessageType.REPLY, seqid)
8960 
    result.write(oprot)
8961 
    oprot.writeMessageEnd()
8962 
    oprot.trans.flush()
7977 kshitij.so 8963 
 
8168 kshitij.so 8964 
  def process_updateAmazonAttributesInBulk(self, seqid, iprot, oprot):
8965 
    args = updateAmazonAttributesInBulk_args()
8966 
    args.read(iprot)
8967 
    iprot.readMessageEnd()
8968 
    result = updateAmazonAttributesInBulk_result()
8969 
    result.success = self._handler.updateAmazonAttributesInBulk(args.amazonlisted)
8970 
    oprot.writeMessageBegin("updateAmazonAttributesInBulk", TMessageType.REPLY, seqid)
8971 
    result.write(oprot)
8972 
    oprot.writeMessageEnd()
8973 
    oprot.trans.flush()
8139 kshitij.so 8974 
 
8379 vikram.rag 8975 
  def process_getAllItemstoListOnFba(self, seqid, iprot, oprot):
8976 
    args = getAllItemstoListOnFba_args()
8977 
    args.read(iprot)
8978 
    iprot.readMessageEnd()
8979 
    result = getAllItemstoListOnFba_result()
8980 
    result.success = self._handler.getAllItemstoListOnFba()
8981 
    oprot.writeMessageBegin("getAllItemstoListOnFba", TMessageType.REPLY, seqid)
8982 
    result.write(oprot)
8983 
    oprot.writeMessageEnd()
8984 
    oprot.trans.flush()
8168 kshitij.so 8985 
 
8379 vikram.rag 8986 
  def process_getAllItemstoListOnNonFba(self, seqid, iprot, oprot):
8987 
    args = getAllItemstoListOnNonFba_args()
8988 
    args.read(iprot)
8989 
    iprot.readMessageEnd()
8990 
    result = getAllItemstoListOnNonFba_result()
8991 
    result.success = self._handler.getAllItemstoListOnNonFba()
8992 
    oprot.writeMessageBegin("getAllItemstoListOnNonFba", TMessageType.REPLY, seqid)
8993 
    result.write(oprot)
8994 
    oprot.writeMessageEnd()
8995 
    oprot.trans.flush()
8996 
 
8619 kshitij.so 8997 
  def process_updateAsin(self, seqid, iprot, oprot):
8998 
    args = updateAsin_args()
8999 
    args.read(iprot)
9000 
    iprot.readMessageEnd()
9001 
    result = updateAsin_result()
9002 
    self._handler.updateAsin(args.item)
9003 
    oprot.writeMessageBegin("updateAsin", TMessageType.REPLY, seqid)
9004 
    result.write(oprot)
9005 
    oprot.writeMessageEnd()
9006 
    oprot.trans.flush()
8616 vikram.rag 9007 
 
8739 vikram.rag 9008 
  def process_addOrUpdateSnapdealItem(self, seqid, iprot, oprot):
9009 
    args = addOrUpdateSnapdealItem_args()
9010 
    args.read(iprot)
9011 
    iprot.readMessageEnd()
9012 
    result = addOrUpdateSnapdealItem_result()
9013 
    result.success = self._handler.addOrUpdateSnapdealItem(args.snapdealitem)
9014 
    oprot.writeMessageBegin("addOrUpdateSnapdealItem", TMessageType.REPLY, seqid)
9015 
    result.write(oprot)
9016 
    oprot.writeMessageEnd()
9017 
    oprot.trans.flush()
8619 kshitij.so 9018 
 
8739 vikram.rag 9019 
  def process_getSnapdealItem(self, seqid, iprot, oprot):
9020 
    args = getSnapdealItem_args()
9021 
    args.read(iprot)
9022 
    iprot.readMessageEnd()
9023 
    result = getSnapdealItem_result()
9024 
    result.success = self._handler.getSnapdealItem(args.item_id)
9025 
    oprot.writeMessageBegin("getSnapdealItem", TMessageType.REPLY, seqid)
9026 
    result.write(oprot)
9027 
    oprot.writeMessageEnd()
9028 
    oprot.trans.flush()
9029 
 
9242 kshitij.so 9030 
  def process_getSnapdealItemDetails(self, seqid, iprot, oprot):
9031 
    args = getSnapdealItemDetails_args()
9032 
    args.read(iprot)
9033 
    iprot.readMessageEnd()
9034 
    result = getSnapdealItemDetails_result()
9035 
    result.success = self._handler.getSnapdealItemDetails(args.item_id)
9036 
    oprot.writeMessageBegin("getSnapdealItemDetails", TMessageType.REPLY, seqid)
9037 
    result.write(oprot)
9038 
    oprot.writeMessageEnd()
9039 
    oprot.trans.flush()
9040 
 
8739 vikram.rag 9041 
  def process_getAllSnapdealItems(self, seqid, iprot, oprot):
9042 
    args = getAllSnapdealItems_args()
9043 
    args.read(iprot)
9044 
    iprot.readMessageEnd()
9045 
    result = getAllSnapdealItems_result()
9046 
    result.success = self._handler.getAllSnapdealItems()
9047 
    oprot.writeMessageBegin("getAllSnapdealItems", TMessageType.REPLY, seqid)
9048 
    result.write(oprot)
9049 
    oprot.writeMessageEnd()
9050 
    oprot.trans.flush()
9051 
 
9242 kshitij.so 9052 
  def process_getSnapdealItems(self, seqid, iprot, oprot):
9053 
    args = getSnapdealItems_args()
9054 
    args.read(iprot)
9055 
    iprot.readMessageEnd()
9056 
    result = getSnapdealItems_result()
9057 
    result.success = self._handler.getSnapdealItems(args.offset, args.limit)
9058 
    oprot.writeMessageBegin("getSnapdealItems", TMessageType.REPLY, seqid)
9059 
    result.write(oprot)
9060 
    oprot.writeMessageEnd()
9061 
    oprot.trans.flush()
8739 vikram.rag 9062 
 
9242 kshitij.so 9063 
  def process_searchSnapdealItems(self, seqid, iprot, oprot):
9064 
    args = searchSnapdealItems_args()
9065 
    args.read(iprot)
9066 
    iprot.readMessageEnd()
9067 
    result = searchSnapdealItems_result()
9068 
    result.success = self._handler.searchSnapdealItems(args.searchTerm, args.offset, args.limit)
9069 
    oprot.writeMessageBegin("searchSnapdealItems", TMessageType.REPLY, seqid)
9070 
    result.write(oprot)
9071 
    oprot.writeMessageEnd()
9072 
    oprot.trans.flush()
9073 
 
9074 
  def process_getCountForSnapdealItems(self, seqid, iprot, oprot):
9075 
    args = getCountForSnapdealItems_args()
9076 
    args.read(iprot)
9077 
    iprot.readMessageEnd()
9078 
    result = getCountForSnapdealItems_result()
9079 
    result.success = self._handler.getCountForSnapdealItems()
9080 
    oprot.writeMessageBegin("getCountForSnapdealItems", TMessageType.REPLY, seqid)
9081 
    result.write(oprot)
9082 
    oprot.writeMessageEnd()
9083 
    oprot.trans.flush()
9084 
 
9085 
  def process_getSnapdealSearchResultCount(self, seqid, iprot, oprot):
9086 
    args = getSnapdealSearchResultCount_args()
9087 
    args.read(iprot)
9088 
    iprot.readMessageEnd()
9089 
    result = getSnapdealSearchResultCount_result()
9090 
    result.success = self._handler.getSnapdealSearchResultCount(args.searchTerm)
9091 
    oprot.writeMessageBegin("getSnapdealSearchResultCount", TMessageType.REPLY, seqid)
9092 
    result.write(oprot)
9093 
    oprot.writeMessageEnd()
9094 
    oprot.trans.flush()
9095 
 
9299 kshitij.so 9096 
  def process_getPrefferedInsurerForItem(self, seqid, iprot, oprot):
9097 
    args = getPrefferedInsurerForItem_args()
9098 
    args.read(iprot)
9099 
    iprot.readMessageEnd()
9100 
    result = getPrefferedInsurerForItem_result()
9101 
    result.success = self._handler.getPrefferedInsurerForItem(args.itemId, args.insurerType)
9102 
    oprot.writeMessageBegin("getPrefferedInsurerForItem", TMessageType.REPLY, seqid)
9103 
    result.write(oprot)
9104 
    oprot.writeMessageEnd()
9105 
    oprot.trans.flush()
9242 kshitij.so 9106 
 
9456 vikram.rag 9107 
  def process_getSnapdealItembySkuAtSnapdeal(self, seqid, iprot, oprot):
9108 
    args = getSnapdealItembySkuAtSnapdeal_args()
9109 
    args.read(iprot)
9110 
    iprot.readMessageEnd()
9111 
    result = getSnapdealItembySkuAtSnapdeal_result()
9112 
    result.success = self._handler.getSnapdealItembySkuAtSnapdeal(args.skuAtSnapdeal)
9113 
    oprot.writeMessageBegin("getSnapdealItembySkuAtSnapdeal", TMessageType.REPLY, seqid)
9114 
    result.write(oprot)
9115 
    oprot.writeMessageEnd()
9116 
    oprot.trans.flush()
9299 kshitij.so 9117 
 
9621 manish.sha 9118 
  def process_getProductFeedSubmit(self, seqid, iprot, oprot):
9119 
    args = getProductFeedSubmit_args()
9120 
    args.read(iprot)
9121 
    iprot.readMessageEnd()
9122 
    result = getProductFeedSubmit_result()
9123 
    try:
9124 
      result.success = self._handler.getProductFeedSubmit(args.catalogItemId)
9125 
    except CatalogServiceException, cex:
9126 
      result.cex = cex
9127 
    oprot.writeMessageBegin("getProductFeedSubmit", TMessageType.REPLY, seqid)
9128 
    result.write(oprot)
9129 
    oprot.writeMessageEnd()
9130 
    oprot.trans.flush()
9456 vikram.rag 9131 
 
9621 manish.sha 9132 
  def process_addProductFeedSubmit(self, seqid, iprot, oprot):
9133 
    args = addProductFeedSubmit_args()
9134 
    args.read(iprot)
9135 
    iprot.readMessageEnd()
9136 
    result = addProductFeedSubmit_result()
9137 
    try:
9138 
      result.success = self._handler.addProductFeedSubmit(args.productFeedSubmit)
9139 
    except CatalogServiceException, cex:
9140 
      result.cex = cex
9141 
    oprot.writeMessageBegin("addProductFeedSubmit", TMessageType.REPLY, seqid)
9142 
    result.write(oprot)
9143 
    oprot.writeMessageEnd()
9144 
    oprot.trans.flush()
9145 
 
9146 
  def process_updateProductFeedSubmit(self, seqid, iprot, oprot):
9147 
    args = updateProductFeedSubmit_args()
9148 
    args.read(iprot)
9149 
    iprot.readMessageEnd()
9150 
    result = updateProductFeedSubmit_result()
9151 
    try:
9152 
      result.success = self._handler.updateProductFeedSubmit(args.productFeedSubmit)
9153 
    except CatalogServiceException, cex:
9154 
      result.cex = cex
9155 
    oprot.writeMessageBegin("updateProductFeedSubmit", TMessageType.REPLY, seqid)
9156 
    result.write(oprot)
9157 
    oprot.writeMessageEnd()
9158 
    oprot.trans.flush()
9159 
 
9160 
  def process_deleteProductFeedSubmit(self, seqid, iprot, oprot):
9161 
    args = deleteProductFeedSubmit_args()
9162 
    args.read(iprot)
9163 
    iprot.readMessageEnd()
9164 
    result = deleteProductFeedSubmit_result()
9165 
    try:
9166 
      result.success = self._handler.deleteProductFeedSubmit(args.catalogItemId)
9167 
    except CatalogServiceException, cex:
9168 
      result.cex = cex
9169 
    oprot.writeMessageBegin("deleteProductFeedSubmit", TMessageType.REPLY, seqid)
9170 
    result.write(oprot)
9171 
    oprot.writeMessageEnd()
9172 
    oprot.trans.flush()
9173 
 
9174 
  def process_getAllProductFeedSubmit(self, seqid, iprot, oprot):
9175 
    args = getAllProductFeedSubmit_args()
9176 
    args.read(iprot)
9177 
    iprot.readMessageEnd()
9178 
    result = getAllProductFeedSubmit_result()
9179 
    try:
9180 
      result.success = self._handler.getAllProductFeedSubmit()
9181 
    except CatalogServiceException, cex:
9182 
      result.cex = cex
9183 
    oprot.writeMessageBegin("getAllProductFeedSubmit", TMessageType.REPLY, seqid)
9184 
    result.write(oprot)
9185 
    oprot.writeMessageEnd()
9186 
    oprot.trans.flush()
9187 
 
9724 kshitij.so 9188 
  def process_getMarketplacedetailsForItem(self, seqid, iprot, oprot):
9189 
    args = getMarketplacedetailsForItem_args()
9190 
    args.read(iprot)
9191 
    iprot.readMessageEnd()
9192 
    result = getMarketplacedetailsForItem_result()
9193 
    result.success = self._handler.getMarketplacedetailsForItem(args.itemId, args.sourceId)
9194 
    oprot.writeMessageBegin("getMarketplacedetailsForItem", TMessageType.REPLY, seqid)
9195 
    result.write(oprot)
9196 
    oprot.writeMessageEnd()
9197 
    oprot.trans.flush()
9621 manish.sha 9198 
 
9724 kshitij.so 9199 
  def process_updateMarketplaceAttributesForItem(self, seqid, iprot, oprot):
9200 
    args = updateMarketplaceAttributesForItem_args()
9201 
    args.read(iprot)
9202 
    iprot.readMessageEnd()
9203 
    result = updateMarketplaceAttributesForItem_result()
9204 
    result.success = self._handler.updateMarketplaceAttributesForItem(args.marketPlaceItem)
9205 
    oprot.writeMessageBegin("updateMarketplaceAttributesForItem", TMessageType.REPLY, seqid)
9206 
    result.write(oprot)
9207 
    oprot.writeMessageEnd()
9208 
    oprot.trans.flush()
9209 
 
9779 kshitij.so 9210 
  def process_getCostingForMarketplace(self, seqid, iprot, oprot):
9211 
    args = getCostingForMarketplace_args()
9212 
    args.read(iprot)
9213 
    iprot.readMessageEnd()
9214 
    result = getCostingForMarketplace_result()
9215 
    result.success = self._handler.getCostingForMarketplace(args.source, args.item_id)
9216 
    oprot.writeMessageBegin("getCostingForMarketplace", TMessageType.REPLY, seqid)
9217 
    result.write(oprot)
9218 
    oprot.writeMessageEnd()
9219 
    oprot.trans.flush()
9220 
 
9776 vikram.rag 9221 
  def process_getMarketPlaceItemsForPriceUpdate(self, seqid, iprot, oprot):
9222 
    args = getMarketPlaceItemsForPriceUpdate_args()
9223 
    args.read(iprot)
9224 
    iprot.readMessageEnd()
9225 
    result = getMarketPlaceItemsForPriceUpdate_result()
9226 
    result.success = self._handler.getMarketPlaceItemsForPriceUpdate(args.source)
9227 
    oprot.writeMessageBegin("getMarketPlaceItemsForPriceUpdate", TMessageType.REPLY, seqid)
9228 
    result.write(oprot)
9229 
    oprot.writeMessageEnd()
9230 
    oprot.trans.flush()
9724 kshitij.so 9231 
 
9776 vikram.rag 9232 
  def process_updateMarketPlacePriceUpdateStatus(self, seqid, iprot, oprot):
9233 
    args = updateMarketPlacePriceUpdateStatus_args()
9234 
    args.read(iprot)
9235 
    iprot.readMessageEnd()
9236 
    result = updateMarketPlacePriceUpdateStatus_result()
9816 kshitij.so 9237 
    self._handler.updateMarketPlacePriceUpdateStatus(args.skulist, args.timestamp, args.source)
9776 vikram.rag 9238 
    oprot.writeMessageBegin("updateMarketPlacePriceUpdateStatus", TMessageType.REPLY, seqid)
9239 
    result.write(oprot)
9240 
    oprot.writeMessageEnd()
9241 
    oprot.trans.flush()
9242 
 
9861 rajveer 9243 
  def process_updateItemHoldInventory(self, seqid, iprot, oprot):
9244 
    args = updateItemHoldInventory_args()
9245 
    args.read(iprot)
9246 
    iprot.readMessageEnd()
9247 
    result = updateItemHoldInventory_result()
9248 
    self._handler.updateItemHoldInventory(args.itemHoldMap)
9249 
    oprot.writeMessageBegin("updateItemHoldInventory", TMessageType.REPLY, seqid)
9250 
    result.write(oprot)
9251 
    oprot.writeMessageEnd()
9252 
    oprot.trans.flush()
9776 vikram.rag 9253 
 
9895 vikram.rag 9254 
  def process_updateNlcAtMarketplaces(self, seqid, iprot, oprot):
9255 
    args = updateNlcAtMarketplaces_args()
9256 
    args.read(iprot)
9257 
    iprot.readMessageEnd()
9258 
    result = updateNlcAtMarketplaces_result()
9259 
    self._handler.updateNlcAtMarketplaces(args.item_id, args.vendor_id, args.nlc)
9260 
    oprot.writeMessageBegin("updateNlcAtMarketplaces", TMessageType.REPLY, seqid)
9261 
    result.write(oprot)
9262 
    oprot.writeMessageEnd()
9263 
    oprot.trans.flush()
9861 rajveer 9264 
 
9945 vikram.rag 9265 
  def process_getAllFlipkartItems(self, seqid, iprot, oprot):
9266 
    args = getAllFlipkartItems_args()
9267 
    args.read(iprot)
9268 
    iprot.readMessageEnd()
9269 
    result = getAllFlipkartItems_result()
9270 
    result.success = self._handler.getAllFlipkartItems()
9271 
    oprot.writeMessageBegin("getAllFlipkartItems", TMessageType.REPLY, seqid)
9272 
    result.write(oprot)
9273 
    oprot.writeMessageEnd()
9274 
    oprot.trans.flush()
9895 vikram.rag 9275 
 
10097 kshitij.so 9276 
  def process_addOrUpdateFlipkartItem(self, seqid, iprot, oprot):
9277 
    args = addOrUpdateFlipkartItem_args()
9278 
    args.read(iprot)
9279 
    iprot.readMessageEnd()
9280 
    result = addOrUpdateFlipkartItem_result()
9281 
    result.success = self._handler.addOrUpdateFlipkartItem(args.flipkartitem)
9282 
    oprot.writeMessageBegin("addOrUpdateFlipkartItem", TMessageType.REPLY, seqid)
9283 
    result.write(oprot)
9284 
    oprot.writeMessageEnd()
9285 
    oprot.trans.flush()
9945 vikram.rag 9286 
 
10097 kshitij.so 9287 
  def process_getFlipkartItem(self, seqid, iprot, oprot):
9288 
    args = getFlipkartItem_args()
9289 
    args.read(iprot)
9290 
    iprot.readMessageEnd()
9291 
    result = getFlipkartItem_result()
9292 
    result.success = self._handler.getFlipkartItem(args.item_id)
9293 
    oprot.writeMessageBegin("getFlipkartItem", TMessageType.REPLY, seqid)
9294 
    result.write(oprot)
9295 
    oprot.writeMessageEnd()
9296 
    oprot.trans.flush()
9297 
 
9298 
  def process_getFlipkartItemDetails(self, seqid, iprot, oprot):
9299 
    args = getFlipkartItemDetails_args()
9300 
    args.read(iprot)
9301 
    iprot.readMessageEnd()
9302 
    result = getFlipkartItemDetails_result()
9303 
    result.success = self._handler.getFlipkartItemDetails(args.item_id)
9304 
    oprot.writeMessageBegin("getFlipkartItemDetails", TMessageType.REPLY, seqid)
9305 
    result.write(oprot)
9306 
    oprot.writeMessageEnd()
9307 
    oprot.trans.flush()
9308 
 
9309 
  def process_getFlipkartItems(self, seqid, iprot, oprot):
9310 
    args = getFlipkartItems_args()
9311 
    args.read(iprot)
9312 
    iprot.readMessageEnd()
9313 
    result = getFlipkartItems_result()
9314 
    result.success = self._handler.getFlipkartItems(args.offset, args.limit)
9315 
    oprot.writeMessageBegin("getFlipkartItems", TMessageType.REPLY, seqid)
9316 
    result.write(oprot)
9317 
    oprot.writeMessageEnd()
9318 
    oprot.trans.flush()
9319 
 
9320 
  def process_searchFlipkartItems(self, seqid, iprot, oprot):
9321 
    args = searchFlipkartItems_args()
9322 
    args.read(iprot)
9323 
    iprot.readMessageEnd()
9324 
    result = searchFlipkartItems_result()
9325 
    result.success = self._handler.searchFlipkartItems(args.searchTerm, args.offset, args.limit)
9326 
    oprot.writeMessageBegin("searchFlipkartItems", TMessageType.REPLY, seqid)
9327 
    result.write(oprot)
9328 
    oprot.writeMessageEnd()
9329 
    oprot.trans.flush()
9330 
 
9331 
  def process_getCountForFlipkartItems(self, seqid, iprot, oprot):
9332 
    args = getCountForFlipkartItems_args()
9333 
    args.read(iprot)
9334 
    iprot.readMessageEnd()
9335 
    result = getCountForFlipkartItems_result()
9336 
    result.success = self._handler.getCountForFlipkartItems()
9337 
    oprot.writeMessageBegin("getCountForFlipkartItems", TMessageType.REPLY, seqid)
9338 
    result.write(oprot)
9339 
    oprot.writeMessageEnd()
9340 
    oprot.trans.flush()
9341 
 
9342 
  def process_getFlipkartSearchResultCount(self, seqid, iprot, oprot):
9343 
    args = getFlipkartSearchResultCount_args()
9344 
    args.read(iprot)
9345 
    iprot.readMessageEnd()
9346 
    result = getFlipkartSearchResultCount_result()
9347 
    result.success = self._handler.getFlipkartSearchResultCount(args.searchTerm)
9348 
    oprot.writeMessageBegin("getFlipkartSearchResultCount", TMessageType.REPLY, seqid)
9349 
    result.write(oprot)
9350 
    oprot.writeMessageEnd()
9351 
    oprot.trans.flush()
9352 
 
9353 
  def process_getAllFkItems(self, seqid, iprot, oprot):
9354 
    args = getAllFkItems_args()
9355 
    args.read(iprot)
9356 
    iprot.readMessageEnd()
9357 
    result = getAllFkItems_result()
9358 
    result.success = self._handler.getAllFkItems()
9359 
    oprot.writeMessageBegin("getAllFkItems", TMessageType.REPLY, seqid)
9360 
    result.write(oprot)
9361 
    oprot.writeMessageEnd()
9362 
    oprot.trans.flush()
9363 
 
10140 vikram.rag 9364 
  def process_getFlipkartItemBySkyAtFlipkart(self, seqid, iprot, oprot):
9365 
    args = getFlipkartItemBySkyAtFlipkart_args()
9366 
    args.read(iprot)
9367 
    iprot.readMessageEnd()
9368 
    result = getFlipkartItemBySkyAtFlipkart_result()
9369 
    result.success = self._handler.getFlipkartItemBySkyAtFlipkart(args.sku)
9370 
    oprot.writeMessageBegin("getFlipkartItemBySkyAtFlipkart", TMessageType.REPLY, seqid)
9371 
    result.write(oprot)
9372 
    oprot.writeMessageEnd()
9373 
    oprot.trans.flush()
10097 kshitij.so 9374 
 
11015 kshitij.so 9375 
  def process_getMarketplaceHistory(self, seqid, iprot, oprot):
9376 
    args = getMarketplaceHistory_args()
9377 
    args.read(iprot)
9378 
    iprot.readMessageEnd()
9379 
    result = getMarketplaceHistory_result()
9380 
    result.success = self._handler.getMarketplaceHistory(args.source, args.offset, args.itemId)
9381 
    oprot.writeMessageBegin("getMarketplaceHistory", TMessageType.REPLY, seqid)
9382 
    result.write(oprot)
9383 
    oprot.writeMessageEnd()
9384 
    oprot.trans.flush()
9385 
 
10909 vikram.rag 9386 
  def process_getAllFbbListedItems(self, seqid, iprot, oprot):
9387 
    args = getAllFbbListedItems_args()
9388 
    args.read(iprot)
9389 
    iprot.readMessageEnd()
9390 
    result = getAllFbbListedItems_result()
9391 
    result.success = self._handler.getAllFbbListedItems()
9392 
    oprot.writeMessageBegin("getAllFbbListedItems", TMessageType.REPLY, seqid)
9393 
    result.write(oprot)
9394 
    oprot.writeMessageEnd()
9395 
    oprot.trans.flush()
10140 vikram.rag 9396 
 
10924 vikram.rag 9397 
  def process_getAllFbbPricingItems(self, seqid, iprot, oprot):
9398 
    args = getAllFbbPricingItems_args()
9399 
    args.read(iprot)
9400 
    iprot.readMessageEnd()
9401 
    result = getAllFbbPricingItems_result()
9402 
    result.success = self._handler.getAllFbbPricingItems()
9403 
    oprot.writeMessageBegin("getAllFbbPricingItems", TMessageType.REPLY, seqid)
9404 
    result.write(oprot)
9405 
    oprot.writeMessageEnd()
9406 
    oprot.trans.flush()
10909 vikram.rag 9407 
 
11015 kshitij.so 9408 
  def process_getCountForMarketplaceHistory(self, seqid, iprot, oprot):
9409 
    args = getCountForMarketplaceHistory_args()
9410 
    args.read(iprot)
9411 
    iprot.readMessageEnd()
9412 
    result = getCountForMarketplaceHistory_result()
9413 
    result.success = self._handler.getCountForMarketplaceHistory(args.source, args.itemId)
9414 
    oprot.writeMessageBegin("getCountForMarketplaceHistory", TMessageType.REPLY, seqid)
9415 
    result.write(oprot)
9416 
    oprot.writeMessageEnd()
9417 
    oprot.trans.flush()
10924 vikram.rag 9418 
 
11015 kshitij.so 9419 
  def process_getMarketplaceHistoryByDate(self, seqid, iprot, oprot):
9420 
    args = getMarketplaceHistoryByDate_args()
9421 
    args.read(iprot)
9422 
    iprot.readMessageEnd()
9423 
    result = getMarketplaceHistoryByDate_result()
9424 
    result.success = self._handler.getMarketplaceHistoryByDate(args.source, args.startDate, args.endDate, args.offset, args.limit, args.itemId)
9425 
    oprot.writeMessageBegin("getMarketplaceHistoryByDate", TMessageType.REPLY, seqid)
9426 
    result.write(oprot)
9427 
    oprot.writeMessageEnd()
9428 
    oprot.trans.flush()
9429 
 
11531 vikram.rag 9430 
  def process_getPrivateDealDetails(self, seqid, iprot, oprot):
9431 
    args = getPrivateDealDetails_args()
9432 
    args.read(iprot)
9433 
    iprot.readMessageEnd()
9434 
    result = getPrivateDealDetails_result()
9435 
    result.success = self._handler.getPrivateDealDetails(args.item_id)
9436 
    oprot.writeMessageBegin("getPrivateDealDetails", TMessageType.REPLY, seqid)
9437 
    result.write(oprot)
9438 
    oprot.writeMessageEnd()
9439 
    oprot.trans.flush()
11015 kshitij.so 9440 
 
11531 vikram.rag 9441 
  def process_getPrivateDealItems(self, seqid, iprot, oprot):
9442 
    args = getPrivateDealItems_args()
9443 
    args.read(iprot)
9444 
    iprot.readMessageEnd()
9445 
    result = getPrivateDealItems_result()
9446 
    result.success = self._handler.getPrivateDealItems(args.offset, args.limit)
9447 
    oprot.writeMessageBegin("getPrivateDealItems", TMessageType.REPLY, seqid)
9448 
    result.write(oprot)
9449 
    oprot.writeMessageEnd()
9450 
    oprot.trans.flush()
9451 
 
11592 amit.gupta 9452 
  def process_getAllActivePrivateDeals(self, seqid, iprot, oprot):
9453 
    args = getAllActivePrivateDeals_args()
9454 
    args.read(iprot)
9455 
    iprot.readMessageEnd()
9456 
    result = getAllActivePrivateDeals_result()
11653 amit.gupta 9457 
    result.success = self._handler.getAllActivePrivateDeals(args.itemIds, args.daysDelta)
11592 amit.gupta 9458 
    oprot.writeMessageBegin("getAllActivePrivateDeals", TMessageType.REPLY, seqid)
9459 
    result.write(oprot)
9460 
    oprot.writeMessageEnd()
9461 
    oprot.trans.flush()
9462 
 
11531 vikram.rag 9463 
  def process_addOrUpdatePrivateDeal(self, seqid, iprot, oprot):
9464 
    args = addOrUpdatePrivateDeal_args()
9465 
    args.read(iprot)
9466 
    iprot.readMessageEnd()
9467 
    result = addOrUpdatePrivateDeal_result()
9468 
    result.success = self._handler.addOrUpdatePrivateDeal(args.privateDeal)
9469 
    oprot.writeMessageBegin("addOrUpdatePrivateDeal", TMessageType.REPLY, seqid)
9470 
    result.write(oprot)
9471 
    oprot.writeMessageEnd()
9472 
    oprot.trans.flush()
9473 
 
11635 vikram.rag 9474 
  def process_getPrivateDealsCatalogIds(self, seqid, iprot, oprot):
9475 
    args = getPrivateDealsCatalogIds_args()
9476 
    args.read(iprot)
9477 
    iprot.readMessageEnd()
9478 
    result = getPrivateDealsCatalogIds_result()
9479 
    try:
9480 
      result.success = self._handler.getPrivateDealsCatalogIds(args.beginIndex, args.totalItems)
9481 
    except CatalogServiceException, cex:
9482 
      result.cex = cex
9483 
    oprot.writeMessageBegin("getPrivateDealsCatalogIds", TMessageType.REPLY, seqid)
9484 
    result.write(oprot)
9485 
    oprot.writeMessageEnd()
9486 
    oprot.trans.flush()
11531 vikram.rag 9487 
 
11645 amit.gupta 9488 
  def process_getPrivateDealsCount(self, seqid, iprot, oprot):
9489 
    args = getPrivateDealsCount_args()
9490 
    args.read(iprot)
9491 
    iprot.readMessageEnd()
9492 
    result = getPrivateDealsCount_result()
9493 
    result.success = self._handler.getPrivateDealsCount()
9494 
    oprot.writeMessageBegin("getPrivateDealsCount", TMessageType.REPLY, seqid)
9495 
    result.write(oprot)
9496 
    oprot.writeMessageEnd()
9497 
    oprot.trans.flush()
11635 vikram.rag 9498 
 
11905 kshitij.so 9499 
  def process_getAmazonOutSyncItems(self, seqid, iprot, oprot):
9500 
    args = getAmazonOutSyncItems_args()
9501 
    args.read(iprot)
9502 
    iprot.readMessageEnd()
9503 
    result = getAmazonOutSyncItems_result()
9504 
    result.success = self._handler.getAmazonOutSyncItems(args.item_id)
9505 
    oprot.writeMessageBegin("getAmazonOutSyncItems", TMessageType.REPLY, seqid)
9506 
    result.write(oprot)
9507 
    oprot.writeMessageEnd()
9508 
    oprot.trans.flush()
11645 amit.gupta 9509 
 
11905 kshitij.so 9510 
  def process_getAllPrivateDealsComparison(self, seqid, iprot, oprot):
9511 
    args = getAllPrivateDealsComparison_args()
9512 
    args.read(iprot)
9513 
    iprot.readMessageEnd()
9514 
    result = getAllPrivateDealsComparison_result()
9515 
    result.success = self._handler.getAllPrivateDealsComparison()
9516 
    oprot.writeMessageBegin("getAllPrivateDealsComparison", TMessageType.REPLY, seqid)
9517 
    result.write(oprot)
9518 
    oprot.writeMessageEnd()
9519 
    oprot.trans.flush()
9520 
 
12133 kshitij.so 9521 
  def process_getAllSnapdealMarketplaceItem(self, seqid, iprot, oprot):
9522 
    args = getAllSnapdealMarketplaceItem_args()
9523 
    args.read(iprot)
9524 
    iprot.readMessageEnd()
9525 
    result = getAllSnapdealMarketplaceItem_result()
9526 
    result.success = self._handler.getAllSnapdealMarketplaceItem()
9527 
    oprot.writeMessageBegin("getAllSnapdealMarketplaceItem", TMessageType.REPLY, seqid)
9528 
    result.write(oprot)
9529 
    oprot.writeMessageEnd()
9530 
    oprot.trans.flush()
11905 kshitij.so 9531 
 
12133 kshitij.so 9532 
  def process_getAllFlipkartMarketplaceItem(self, seqid, iprot, oprot):
9533 
    args = getAllFlipkartMarketplaceItem_args()
9534 
    args.read(iprot)
9535 
    iprot.readMessageEnd()
9536 
    result = getAllFlipkartMarketplaceItem_result()
9537 
    result.success = self._handler.getAllFlipkartMarketplaceItem()
9538 
    oprot.writeMessageBegin("getAllFlipkartMarketplaceItem", TMessageType.REPLY, seqid)
9539 
    result.write(oprot)
9540 
    oprot.writeMessageEnd()
9541 
    oprot.trans.flush()
9542 
 
12243 kshitij.so 9543 
  def process_addCompetitorScraping(self, seqid, iprot, oprot):
9544 
    args = addCompetitorScraping_args()
9545 
    args.read(iprot)
9546 
    iprot.readMessageEnd()
9547 
    result = addCompetitorScraping_result()
9548 
    self._handler.addCompetitorScraping(args.competitorPricingMap)
9549 
    oprot.writeMessageBegin("addCompetitorScraping", TMessageType.REPLY, seqid)
9550 
    result.write(oprot)
9551 
    oprot.writeMessageEnd()
9552 
    oprot.trans.flush()
12133 kshitij.so 9553 
 
12243 kshitij.so 9554 
  def process_getPreviousCompetitorScraping(self, seqid, iprot, oprot):
9555 
    args = getPreviousCompetitorScraping_args()
9556 
    args.read(iprot)
9557 
    iprot.readMessageEnd()
9558 
    result = getPreviousCompetitorScraping_result()
9559 
    result.success = self._handler.getPreviousCompetitorScraping(args.delta)
9560 
    oprot.writeMessageBegin("getPreviousCompetitorScraping", TMessageType.REPLY, seqid)
9561 
    result.write(oprot)
9562 
    oprot.writeMessageEnd()
9563 
    oprot.trans.flush()
9564 
 
12256 kshitij.so 9565 
  def process_getUploadResultById(self, seqid, iprot, oprot):
9566 
    args = getUploadResultById_args()
9567 
    args.read(iprot)
9568 
    iprot.readMessageEnd()
9569 
    result = getUploadResultById_result()
9570 
    result.success = self._handler.getUploadResultById(args.uploadId)
9571 
    oprot.writeMessageBegin("getUploadResultById", TMessageType.REPLY, seqid)
9572 
    result.write(oprot)
9573 
    oprot.writeMessageEnd()
9574 
    oprot.trans.flush()
12243 kshitij.so 9575 
 
12363 kshitij.so 9576 
  def process_addAmazonPromotion(self, seqid, iprot, oprot):
9577 
    args = addAmazonPromotion_args()
9578 
    args.read(iprot)
9579 
    iprot.readMessageEnd()
9580 
    result = addAmazonPromotion_result()
12947 kshitij.so 9581 
    try:
9582 
      result.success = self._handler.addAmazonPromotion(args.amazonPromotions)
9583 
    except CatalogServiceException, cex:
9584 
      result.cex = cex
12363 kshitij.so 9585 
    oprot.writeMessageBegin("addAmazonPromotion", TMessageType.REPLY, seqid)
9586 
    result.write(oprot)
9587 
    oprot.writeMessageEnd()
9588 
    oprot.trans.flush()
12256 kshitij.so 9589 
 
12363 kshitij.so 9590 
  def process_getAmazonPromotion(self, seqid, iprot, oprot):
9591 
    args = getAmazonPromotion_args()
9592 
    args.read(iprot)
9593 
    iprot.readMessageEnd()
9594 
    result = getAmazonPromotion_result()
9595 
    result.success = self._handler.getAmazonPromotion(args.startDate, args.endDate)
9596 
    oprot.writeMessageBegin("getAmazonPromotion", TMessageType.REPLY, seqid)
9597 
    result.write(oprot)
9598 
    oprot.writeMessageEnd()
9599 
    oprot.trans.flush()
9600 
 
9601 
  def process_updateAmazonPromotion(self, seqid, iprot, oprot):
9602 
    args = updateAmazonPromotion_args()
9603 
    args.read(iprot)
9604 
    iprot.readMessageEnd()
9605 
    result = updateAmazonPromotion_result()
9606 
    result.success = self._handler.updateAmazonPromotion(args.amazonPromotions)
9607 
    oprot.writeMessageBegin("updateAmazonPromotion", TMessageType.REPLY, seqid)
9608 
    result.write(oprot)
9609 
    oprot.writeMessageEnd()
9610 
    oprot.trans.flush()
9611 
 
12567 amit.gupta 9612 
  def process_markPartiallyActive(self, seqid, iprot, oprot):
9613 
    args = markPartiallyActive_args()
9614 
    args.read(iprot)
9615 
    iprot.readMessageEnd()
9616 
    result = markPartiallyActive_result()
9617 
    result.success = self._handler.markPartiallyActive(args.itemId, args.categoryId)
9618 
    oprot.writeMessageBegin("markPartiallyActive", TMessageType.REPLY, seqid)
9619 
    result.write(oprot)
9620 
    oprot.writeMessageEnd()
9621 
    oprot.trans.flush()
12363 kshitij.so 9622 
 
12567 amit.gupta 9623 
  def process_updateItemStateVat(self, seqid, iprot, oprot):
9624 
    args = updateItemStateVat_args()
9625 
    args.read(iprot)
9626 
    iprot.readMessageEnd()
9627 
    result = updateItemStateVat_result()
9628 
    result.success = self._handler.updateItemStateVat(args.itemId, args.statevat)
9629 
    oprot.writeMessageBegin("updateItemStateVat", TMessageType.REPLY, seqid)
9630 
    result.write(oprot)
9631 
    oprot.writeMessageEnd()
9632 
    oprot.trans.flush()
9633 
 
12620 amit.gupta 9634 
  def process_getExAffiliateItemInfo(self, seqid, iprot, oprot):
9635 
    args = getExAffiliateItemInfo_args()
9636 
    args.read(iprot)
9637 
    iprot.readMessageEnd()
9638 
    result = getExAffiliateItemInfo_result()
9639 
    result.success = self._handler.getExAffiliateItemInfo()
9640 
    oprot.writeMessageBegin("getExAffiliateItemInfo", TMessageType.REPLY, seqid)
9641 
    result.write(oprot)
9642 
    oprot.writeMessageEnd()
9643 
    oprot.trans.flush()
12567 amit.gupta 9644 
 
12888 kshitij.so 9645 
  def process_getAllItemstoListOnFbg(self, seqid, iprot, oprot):
9646 
    args = getAllItemstoListOnFbg_args()
9647 
    args.read(iprot)
9648 
    iprot.readMessageEnd()
9649 
    result = getAllItemstoListOnFbg_result()
9650 
    result.success = self._handler.getAllItemstoListOnFbg()
9651 
    oprot.writeMessageBegin("getAllItemstoListOnFbg", TMessageType.REPLY, seqid)
9652 
    result.write(oprot)
9653 
    oprot.writeMessageEnd()
9654 
    oprot.trans.flush()
12620 amit.gupta 9655 
 
12892 kshitij.so 9656 
  def process_getAllFbgListedItems(self, seqid, iprot, oprot):
9657 
    args = getAllFbgListedItems_args()
9658 
    args.read(iprot)
9659 
    iprot.readMessageEnd()
9660 
    result = getAllFbgListedItems_result()
9661 
    result.success = self._handler.getAllFbgListedItems()
9662 
    oprot.writeMessageBegin("getAllFbgListedItems", TMessageType.REPLY, seqid)
9663 
    result.write(oprot)
9664 
    oprot.writeMessageEnd()
9665 
    oprot.trans.flush()
12888 kshitij.so 9666 
 
13136 amit.gupta 9667 
  def process_checkServices(self, seqid, iprot, oprot):
9668 
    args = checkServices_args()
9669 
    args.read(iprot)
9670 
    iprot.readMessageEnd()
9671 
    result = checkServices_result()
9672 
    try:
9673 
      result.success = self._handler.checkServices(args.lines)
9674 
    except CatalogServiceException, cex:
9675 
      result.cex = cex
9676 
    oprot.writeMessageBegin("checkServices", TMessageType.REPLY, seqid)
9677 
    result.write(oprot)
9678 
    oprot.writeMessageEnd()
9679 
    oprot.trans.flush()
12892 kshitij.so 9680 
 
13709 manish.sha 9681 
  def process_addHsItem(self, seqid, iprot, oprot):
9682 
    args = addHsItem_args()
9683 
    args.read(iprot)
9684 
    iprot.readMessageEnd()
9685 
    result = addHsItem_result()
9686 
    self._handler.addHsItem(args.hsItems)
9687 
    oprot.writeMessageBegin("addHsItem", TMessageType.REPLY, seqid)
9688 
    result.write(oprot)
9689 
    oprot.writeMessageEnd()
9690 
    oprot.trans.flush()
13136 amit.gupta 9691 
 
13709 manish.sha 9692 
  def process_getHsItem(self, seqid, iprot, oprot):
9693 
    args = getHsItem_args()
9694 
    args.read(iprot)
9695 
    iprot.readMessageEnd()
9696 
    result = getHsItem_result()
9697 
    result.success = self._handler.getHsItem(args.hsItemId)
9698 
    oprot.writeMessageBegin("getHsItem", TMessageType.REPLY, seqid)
9699 
    result.write(oprot)
9700 
    oprot.writeMessageEnd()
9701 
    oprot.trans.flush()
9702 
 
9703 
  def process_updateHsItem(self, seqid, iprot, oprot):
9704 
    args = updateHsItem_args()
9705 
    args.read(iprot)
9706 
    iprot.readMessageEnd()
9707 
    result = updateHsItem_result()
9708 
    self._handler.updateHsItem(args.hsItem)
9709 
    oprot.writeMessageBegin("updateHsItem", TMessageType.REPLY, seqid)
9710 
    result.write(oprot)
9711 
    oprot.writeMessageEnd()
9712 
    oprot.trans.flush()
9713 
 
14182 kshitij.so 9714 
  def process_getPricingForDtr(self, seqid, iprot, oprot):
9715 
    args = getPricingForDtr_args()
9716 
    args.read(iprot)
9717 
    iprot.readMessageEnd()
9718 
    result = getPricingForDtr_result()
9719 
    result.success = self._handler.getPricingForDtr(args.catalogItemId)
9720 
    oprot.writeMessageBegin("getPricingForDtr", TMessageType.REPLY, seqid)
9721 
    result.write(oprot)
9722 
    oprot.writeMessageEnd()
9723 
    oprot.trans.flush()
13709 manish.sha 9724 
 
15702 kshitij.so 9725 
  def process_getAllItemstoListOnFbd(self, seqid, iprot, oprot):
9726 
    args = getAllItemstoListOnFbd_args()
9727 
    args.read(iprot)
9728 
    iprot.readMessageEnd()
9729 
    result = getAllItemstoListOnFbd_result()
9730 
    result.success = self._handler.getAllItemstoListOnFbd()
9731 
    oprot.writeMessageBegin("getAllItemstoListOnFbd", TMessageType.REPLY, seqid)
9732 
    result.write(oprot)
9733 
    oprot.writeMessageEnd()
9734 
    oprot.trans.flush()
14182 kshitij.so 9735 
 
15706 kshitij.so 9736 
  def process_getAllFbdListedItems(self, seqid, iprot, oprot):
9737 
    args = getAllFbdListedItems_args()
9738 
    args.read(iprot)
9739 
    iprot.readMessageEnd()
9740 
    result = getAllFbdListedItems_result()
9741 
    result.success = self._handler.getAllFbdListedItems()
9742 
    oprot.writeMessageBegin("getAllFbdListedItems", TMessageType.REPLY, seqid)
9743 
    result.write(oprot)
9744 
    oprot.writeMessageEnd()
9745 
    oprot.trans.flush()
15702 kshitij.so 9746 
 
18150 kshitij.so 9747 
  def process_getBulkPricingForItems(self, seqid, iprot, oprot):
9748 
    args = getBulkPricingForItems_args()
9749 
    args.read(iprot)
9750 
    iprot.readMessageEnd()
9751 
    result = getBulkPricingForItems_result()
9752 
    result.success = self._handler.getBulkPricingForItems(args.itemIds)
9753 
    oprot.writeMessageBegin("getBulkPricingForItems", TMessageType.REPLY, seqid)
9754 
    result.write(oprot)
9755 
    oprot.writeMessageEnd()
9756 
    oprot.trans.flush()
15706 kshitij.so 9757 
 
18150 kshitij.so 9758 
  def process_addBulkPricingForItem(self, seqid, iprot, oprot):
9759 
    args = addBulkPricingForItem_args()
9760 
    args.read(iprot)
9761 
    iprot.readMessageEnd()
9762 
    result = addBulkPricingForItem_result()
9763 
    result.success = self._handler.addBulkPricingForItem(args.bulkItemPricing)
9764 
    oprot.writeMessageBegin("addBulkPricingForItem", TMessageType.REPLY, seqid)
9765 
    result.write(oprot)
9766 
    oprot.writeMessageEnd()
9767 
    oprot.trans.flush()
9768 
 
9769 
  def process_deleteBulkPricingForItemById(self, seqid, iprot, oprot):
9770 
    args = deleteBulkPricingForItemById_args()
9771 
    args.read(iprot)
9772 
    iprot.readMessageEnd()
9773 
    result = deleteBulkPricingForItemById_result()
9774 
    result.success = self._handler.deleteBulkPricingForItemById(args.id)
9775 
    oprot.writeMessageBegin("deleteBulkPricingForItemById", TMessageType.REPLY, seqid)
9776 
    result.write(oprot)
9777 
    oprot.writeMessageEnd()
9778 
    oprot.trans.flush()
9779 
 
9780 
  def process_deleteBulkPricingForItem(self, seqid, iprot, oprot):
9781 
    args = deleteBulkPricingForItem_args()
9782 
    args.read(iprot)
9783 
    iprot.readMessageEnd()
9784 
    result = deleteBulkPricingForItem_result()
9785 
    result.success = self._handler.deleteBulkPricingForItem(args.item_id)
9786 
    oprot.writeMessageBegin("deleteBulkPricingForItem", TMessageType.REPLY, seqid)
9787 
    result.write(oprot)
9788 
    oprot.writeMessageEnd()
9789 
    oprot.trans.flush()
9790 
 
9791 
  def process_getBulkPricingByItemId(self, seqid, iprot, oprot):
9792 
    args = getBulkPricingByItemId_args()
9793 
    args.read(iprot)
9794 
    iprot.readMessageEnd()
9795 
    result = getBulkPricingByItemId_result()
9796 
    result.success = self._handler.getBulkPricingByItemId(args.item_id)
9797 
    oprot.writeMessageBegin("getBulkPricingByItemId", TMessageType.REPLY, seqid)
9798 
    result.write(oprot)
9799 
    oprot.writeMessageEnd()
9800 
    oprot.trans.flush()
9801 
 
18602 kshitij.so 9802 
  def process_updateBulkPricesOnProduction(self, seqid, iprot, oprot):
9803 
    args = updateBulkPricesOnProduction_args()
9804 
    args.read(iprot)
9805 
    iprot.readMessageEnd()
9806 
    result = updateBulkPricesOnProduction_result()
9807 
    result.success = self._handler.updateBulkPricesOnProduction(args.item_id, args.bulkItemPricingList)
9808 
    oprot.writeMessageBegin("updateBulkPricesOnProduction", TMessageType.REPLY, seqid)
9809 
    result.write(oprot)
9810 
    oprot.writeMessageEnd()
9811 
    oprot.trans.flush()
18150 kshitij.so 9812 
 
18602 kshitij.so 9813 
 
5944 mandeep.dh 9814 
# HELPER FUNCTIONS AND STRUCTURES
9815 
 
9816 
class addItem_args:
9817 
  """
9818 
  Attributes:
9819 
   - item
9820 
  """
9821 
 
9822 
  thrift_spec = (
9823 
    None, # 0
9824 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
9825 
  )
9826 
 
9827 
  def __init__(self, item=None,):
9828 
    self.item = item
9829 
 
9830 
  def read(self, iprot):
9831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9833 
      return
9834 
    iprot.readStructBegin()
9835 
    while True:
9836 
      (fname, ftype, fid) = iprot.readFieldBegin()
9837 
      if ftype == TType.STOP:
9838 
        break
9839 
      if fid == 1:
9840 
        if ftype == TType.STRUCT:
9841 
          self.item = Item()
9842 
          self.item.read(iprot)
9843 
        else:
9844 
          iprot.skip(ftype)
9845 
      else:
9846 
        iprot.skip(ftype)
9847 
      iprot.readFieldEnd()
9848 
    iprot.readStructEnd()
9849 
 
9850 
  def write(self, oprot):
9851 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9852 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9853 
      return
9854 
    oprot.writeStructBegin('addItem_args')
9855 
    if self.item is not None:
9856 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
9857 
      self.item.write(oprot)
9858 
      oprot.writeFieldEnd()
9859 
    oprot.writeFieldStop()
9860 
    oprot.writeStructEnd()
9861 
 
9862 
  def validate(self):
9863 
    return
9864 
 
9865 
 
9866 
  def __repr__(self):
9867 
    L = ['%s=%r' % (key, value)
9868 
      for key, value in self.__dict__.iteritems()]
9869 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9870 
 
9871 
  def __eq__(self, other):
9872 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9873 
 
9874 
  def __ne__(self, other):
9875 
    return not (self == other)
9876 
 
9877 
class addItem_result:
9878 
  """
9879 
  Attributes:
9880 
   - success
9881 
   - cex
9882 
  """
9883 
 
9884 
  thrift_spec = (
9885 
    (0, TType.I64, 'success', None, None, ), # 0
9886 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9887 
  )
9888 
 
9889 
  def __init__(self, success=None, cex=None,):
9890 
    self.success = success
9891 
    self.cex = cex
9892 
 
9893 
  def read(self, iprot):
9894 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9895 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9896 
      return
9897 
    iprot.readStructBegin()
9898 
    while True:
9899 
      (fname, ftype, fid) = iprot.readFieldBegin()
9900 
      if ftype == TType.STOP:
9901 
        break
9902 
      if fid == 0:
9903 
        if ftype == TType.I64:
9904 
          self.success = iprot.readI64();
9905 
        else:
9906 
          iprot.skip(ftype)
9907 
      elif fid == 1:
9908 
        if ftype == TType.STRUCT:
9909 
          self.cex = CatalogServiceException()
9910 
          self.cex.read(iprot)
9911 
        else:
9912 
          iprot.skip(ftype)
9913 
      else:
9914 
        iprot.skip(ftype)
9915 
      iprot.readFieldEnd()
9916 
    iprot.readStructEnd()
9917 
 
9918 
  def write(self, oprot):
9919 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9920 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9921 
      return
9922 
    oprot.writeStructBegin('addItem_result')
9923 
    if self.success is not None:
9924 
      oprot.writeFieldBegin('success', TType.I64, 0)
9925 
      oprot.writeI64(self.success)
9926 
      oprot.writeFieldEnd()
9927 
    if self.cex is not None:
9928 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9929 
      self.cex.write(oprot)
9930 
      oprot.writeFieldEnd()
9931 
    oprot.writeFieldStop()
9932 
    oprot.writeStructEnd()
9933 
 
9934 
  def validate(self):
9935 
    return
9936 
 
9937 
 
9938 
  def __repr__(self):
9939 
    L = ['%s=%r' % (key, value)
9940 
      for key, value in self.__dict__.iteritems()]
9941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9942 
 
9943 
  def __eq__(self, other):
9944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9945 
 
9946 
  def __ne__(self, other):
9947 
    return not (self == other)
9948 
 
9949 
class updateItem_args:
9950 
  """
9951 
  Attributes:
9952 
   - item
9953 
  """
9954 
 
9955 
  thrift_spec = (
9956 
    None, # 0
9957 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
9958 
  )
9959 
 
9960 
  def __init__(self, item=None,):
9961 
    self.item = item
9962 
 
9963 
  def read(self, iprot):
9964 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9965 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9966 
      return
9967 
    iprot.readStructBegin()
9968 
    while True:
9969 
      (fname, ftype, fid) = iprot.readFieldBegin()
9970 
      if ftype == TType.STOP:
9971 
        break
9972 
      if fid == 1:
9973 
        if ftype == TType.STRUCT:
9974 
          self.item = Item()
9975 
          self.item.read(iprot)
9976 
        else:
9977 
          iprot.skip(ftype)
9978 
      else:
9979 
        iprot.skip(ftype)
9980 
      iprot.readFieldEnd()
9981 
    iprot.readStructEnd()
9982 
 
9983 
  def write(self, oprot):
9984 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9985 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9986 
      return
9987 
    oprot.writeStructBegin('updateItem_args')
9988 
    if self.item is not None:
9989 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
9990 
      self.item.write(oprot)
9991 
      oprot.writeFieldEnd()
9992 
    oprot.writeFieldStop()
9993 
    oprot.writeStructEnd()
9994 
 
9995 
  def validate(self):
9996 
    return
9997 
 
9998 
 
9999 
  def __repr__(self):
10000 
    L = ['%s=%r' % (key, value)
10001 
      for key, value in self.__dict__.iteritems()]
10002 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10003 
 
10004 
  def __eq__(self, other):
10005 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10006 
 
10007 
  def __ne__(self, other):
10008 
    return not (self == other)
10009 
 
10010 
class updateItem_result:
10011 
  """
10012 
  Attributes:
10013 
   - success
10014 
   - cex
10015 
  """
10016 
 
10017 
  thrift_spec = (
10018 
    (0, TType.I64, 'success', None, None, ), # 0
10019 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10020 
  )
10021 
 
10022 
  def __init__(self, success=None, cex=None,):
10023 
    self.success = success
10024 
    self.cex = cex
10025 
 
10026 
  def read(self, iprot):
10027 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10028 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10029 
      return
10030 
    iprot.readStructBegin()
10031 
    while True:
10032 
      (fname, ftype, fid) = iprot.readFieldBegin()
10033 
      if ftype == TType.STOP:
10034 
        break
10035 
      if fid == 0:
10036 
        if ftype == TType.I64:
10037 
          self.success = iprot.readI64();
10038 
        else:
10039 
          iprot.skip(ftype)
10040 
      elif fid == 1:
10041 
        if ftype == TType.STRUCT:
10042 
          self.cex = CatalogServiceException()
10043 
          self.cex.read(iprot)
10044 
        else:
10045 
          iprot.skip(ftype)
10046 
      else:
10047 
        iprot.skip(ftype)
10048 
      iprot.readFieldEnd()
10049 
    iprot.readStructEnd()
10050 
 
10051 
  def write(self, oprot):
10052 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10053 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10054 
      return
10055 
    oprot.writeStructBegin('updateItem_result')
10056 
    if self.success is not None:
10057 
      oprot.writeFieldBegin('success', TType.I64, 0)
10058 
      oprot.writeI64(self.success)
10059 
      oprot.writeFieldEnd()
10060 
    if self.cex is not None:
10061 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10062 
      self.cex.write(oprot)
10063 
      oprot.writeFieldEnd()
10064 
    oprot.writeFieldStop()
10065 
    oprot.writeStructEnd()
10066 
 
10067 
  def validate(self):
10068 
    return
10069 
 
10070 
 
10071 
  def __repr__(self):
10072 
    L = ['%s=%r' % (key, value)
10073 
      for key, value in self.__dict__.iteritems()]
10074 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10075 
 
10076 
  def __eq__(self, other):
10077 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10078 
 
10079 
  def __ne__(self, other):
10080 
    return not (self == other)
10081 
 
10082 
class isActive_args:
10083 
  """
10084 
  Attributes:
10085 
   - itemId
10086 
  """
10087 
 
10088 
  thrift_spec = (
10089 
    None, # 0
10090 
    (1, TType.I64, 'itemId', None, None, ), # 1
10091 
  )
10092 
 
10093 
  def __init__(self, itemId=None,):
10094 
    self.itemId = itemId
10095 
 
10096 
  def read(self, iprot):
10097 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10098 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10099 
      return
10100 
    iprot.readStructBegin()
10101 
    while True:
10102 
      (fname, ftype, fid) = iprot.readFieldBegin()
10103 
      if ftype == TType.STOP:
10104 
        break
10105 
      if fid == 1:
10106 
        if ftype == TType.I64:
10107 
          self.itemId = iprot.readI64();
10108 
        else:
10109 
          iprot.skip(ftype)
10110 
      else:
10111 
        iprot.skip(ftype)
10112 
      iprot.readFieldEnd()
10113 
    iprot.readStructEnd()
10114 
 
10115 
  def write(self, oprot):
10116 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10117 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10118 
      return
10119 
    oprot.writeStructBegin('isActive_args')
10120 
    if self.itemId is not None:
10121 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
10122 
      oprot.writeI64(self.itemId)
10123 
      oprot.writeFieldEnd()
10124 
    oprot.writeFieldStop()
10125 
    oprot.writeStructEnd()
10126 
 
10127 
  def validate(self):
10128 
    return
10129 
 
10130 
 
10131 
  def __repr__(self):
10132 
    L = ['%s=%r' % (key, value)
10133 
      for key, value in self.__dict__.iteritems()]
10134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10135 
 
10136 
  def __eq__(self, other):
10137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10138 
 
10139 
  def __ne__(self, other):
10140 
    return not (self == other)
10141 
 
10142 
class isActive_result:
10143 
  """
10144 
  Attributes:
10145 
   - success
10146 
   - isex
10147 
  """
10148 
 
10149 
  thrift_spec = (
10150 
    (0, TType.STRUCT, 'success', (ItemShippingInfo, ItemShippingInfo.thrift_spec), None, ), # 0
10151 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10152 
  )
10153 
 
10154 
  def __init__(self, success=None, isex=None,):
10155 
    self.success = success
10156 
    self.isex = isex
10157 
 
10158 
  def read(self, iprot):
10159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10161 
      return
10162 
    iprot.readStructBegin()
10163 
    while True:
10164 
      (fname, ftype, fid) = iprot.readFieldBegin()
10165 
      if ftype == TType.STOP:
10166 
        break
10167 
      if fid == 0:
10168 
        if ftype == TType.STRUCT:
10169 
          self.success = ItemShippingInfo()
10170 
          self.success.read(iprot)
10171 
        else:
10172 
          iprot.skip(ftype)
10173 
      elif fid == 1:
10174 
        if ftype == TType.STRUCT:
10175 
          self.isex = CatalogServiceException()
10176 
          self.isex.read(iprot)
10177 
        else:
10178 
          iprot.skip(ftype)
10179 
      else:
10180 
        iprot.skip(ftype)
10181 
      iprot.readFieldEnd()
10182 
    iprot.readStructEnd()
10183 
 
10184 
  def write(self, oprot):
10185 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10186 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10187 
      return
10188 
    oprot.writeStructBegin('isActive_result')
10189 
    if self.success is not None:
10190 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10191 
      self.success.write(oprot)
10192 
      oprot.writeFieldEnd()
10193 
    if self.isex is not None:
10194 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
10195 
      self.isex.write(oprot)
10196 
      oprot.writeFieldEnd()
10197 
    oprot.writeFieldStop()
10198 
    oprot.writeStructEnd()
10199 
 
10200 
  def validate(self):
10201 
    return
10202 
 
10203 
 
10204 
  def __repr__(self):
10205 
    L = ['%s=%r' % (key, value)
10206 
      for key, value in self.__dict__.iteritems()]
10207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10208 
 
10209 
  def __eq__(self, other):
10210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10211 
 
10212 
  def __ne__(self, other):
10213 
    return not (self == other)
10214 
 
7438 amit.gupta 10215 
class getItemsStatus_args:
10216 
  """
10217 
  Attributes:
10218 
   - itemIds
10219 
  """
10220 
 
10221 
  thrift_spec = (
10222 
    None, # 0
10223 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
10224 
  )
10225 
 
10226 
  def __init__(self, itemIds=None,):
10227 
    self.itemIds = itemIds
10228 
 
10229 
  def read(self, iprot):
10230 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10231 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10232 
      return
10233 
    iprot.readStructBegin()
10234 
    while True:
10235 
      (fname, ftype, fid) = iprot.readFieldBegin()
10236 
      if ftype == TType.STOP:
10237 
        break
10238 
      if fid == 1:
10239 
        if ftype == TType.LIST:
10240 
          self.itemIds = []
8590 kshitij.so 10241 
          (_etype33, _size30) = iprot.readListBegin()
10242 
          for _i34 in xrange(_size30):
10243 
            _elem35 = iprot.readI64();
10244 
            self.itemIds.append(_elem35)
7438 amit.gupta 10245 
          iprot.readListEnd()
10246 
        else:
10247 
          iprot.skip(ftype)
10248 
      else:
10249 
        iprot.skip(ftype)
10250 
      iprot.readFieldEnd()
10251 
    iprot.readStructEnd()
10252 
 
10253 
  def write(self, oprot):
10254 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10255 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10256 
      return
10257 
    oprot.writeStructBegin('getItemsStatus_args')
10258 
    if self.itemIds is not None:
10259 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
10260 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
8590 kshitij.so 10261 
      for iter36 in self.itemIds:
10262 
        oprot.writeI64(iter36)
7438 amit.gupta 10263 
      oprot.writeListEnd()
10264 
      oprot.writeFieldEnd()
10265 
    oprot.writeFieldStop()
10266 
    oprot.writeStructEnd()
10267 
 
10268 
  def validate(self):
10269 
    return
10270 
 
10271 
 
10272 
  def __repr__(self):
10273 
    L = ['%s=%r' % (key, value)
10274 
      for key, value in self.__dict__.iteritems()]
10275 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10276 
 
10277 
  def __eq__(self, other):
10278 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10279 
 
10280 
  def __ne__(self, other):
10281 
    return not (self == other)
10282 
 
10283 
class getItemsStatus_result:
10284 
  """
10285 
  Attributes:
10286 
   - success
10287 
   - isex
10288 
  """
10289 
 
10290 
  thrift_spec = (
10291 
    (0, TType.MAP, 'success', (TType.I64,None,TType.BOOL,None), None, ), # 0
10292 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10293 
  )
10294 
 
10295 
  def __init__(self, success=None, isex=None,):
10296 
    self.success = success
10297 
    self.isex = isex
10298 
 
10299 
  def read(self, iprot):
10300 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10301 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10302 
      return
10303 
    iprot.readStructBegin()
10304 
    while True:
10305 
      (fname, ftype, fid) = iprot.readFieldBegin()
10306 
      if ftype == TType.STOP:
10307 
        break
10308 
      if fid == 0:
10309 
        if ftype == TType.MAP:
10310 
          self.success = {}
8590 kshitij.so 10311 
          (_ktype38, _vtype39, _size37 ) = iprot.readMapBegin()
10312 
          for _i41 in xrange(_size37):
10313 
            _key42 = iprot.readI64();
10314 
            _val43 = iprot.readBool();
10315 
            self.success[_key42] = _val43
7438 amit.gupta 10316 
          iprot.readMapEnd()
10317 
        else:
10318 
          iprot.skip(ftype)
10319 
      elif fid == 1:
10320 
        if ftype == TType.STRUCT:
10321 
          self.isex = CatalogServiceException()
10322 
          self.isex.read(iprot)
10323 
        else:
10324 
          iprot.skip(ftype)
10325 
      else:
10326 
        iprot.skip(ftype)
10327 
      iprot.readFieldEnd()
10328 
    iprot.readStructEnd()
10329 
 
10330 
  def write(self, oprot):
10331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10333 
      return
10334 
    oprot.writeStructBegin('getItemsStatus_result')
10335 
    if self.success is not None:
10336 
      oprot.writeFieldBegin('success', TType.MAP, 0)
10337 
      oprot.writeMapBegin(TType.I64, TType.BOOL, len(self.success))
8590 kshitij.so 10338 
      for kiter44,viter45 in self.success.items():
10339 
        oprot.writeI64(kiter44)
10340 
        oprot.writeBool(viter45)
7438 amit.gupta 10341 
      oprot.writeMapEnd()
10342 
      oprot.writeFieldEnd()
10343 
    if self.isex is not None:
10344 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
10345 
      self.isex.write(oprot)
10346 
      oprot.writeFieldEnd()
10347 
    oprot.writeFieldStop()
10348 
    oprot.writeStructEnd()
10349 
 
10350 
  def validate(self):
10351 
    return
10352 
 
10353 
 
10354 
  def __repr__(self):
10355 
    L = ['%s=%r' % (key, value)
10356 
      for key, value in self.__dict__.iteritems()]
10357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10358 
 
10359 
  def __eq__(self, other):
10360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10361 
 
10362 
  def __ne__(self, other):
10363 
    return not (self == other)
10364 
 
5944 mandeep.dh 10365 
class getItemStatusDescription_args:
10366 
  """
10367 
  Attributes:
10368 
   - itemId
10369 
  """
10370 
 
10371 
  thrift_spec = (
10372 
    None, # 0
10373 
    (1, TType.I64, 'itemId', None, None, ), # 1
10374 
  )
10375 
 
10376 
  def __init__(self, itemId=None,):
10377 
    self.itemId = itemId
10378 
 
10379 
  def read(self, iprot):
10380 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10381 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10382 
      return
10383 
    iprot.readStructBegin()
10384 
    while True:
10385 
      (fname, ftype, fid) = iprot.readFieldBegin()
10386 
      if ftype == TType.STOP:
10387 
        break
10388 
      if fid == 1:
10389 
        if ftype == TType.I64:
10390 
          self.itemId = iprot.readI64();
10391 
        else:
10392 
          iprot.skip(ftype)
10393 
      else:
10394 
        iprot.skip(ftype)
10395 
      iprot.readFieldEnd()
10396 
    iprot.readStructEnd()
10397 
 
10398 
  def write(self, oprot):
10399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10401 
      return
10402 
    oprot.writeStructBegin('getItemStatusDescription_args')
10403 
    if self.itemId is not None:
10404 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
10405 
      oprot.writeI64(self.itemId)
10406 
      oprot.writeFieldEnd()
10407 
    oprot.writeFieldStop()
10408 
    oprot.writeStructEnd()
10409 
 
10410 
  def validate(self):
10411 
    return
10412 
 
10413 
 
10414 
  def __repr__(self):
10415 
    L = ['%s=%r' % (key, value)
10416 
      for key, value in self.__dict__.iteritems()]
10417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10418 
 
10419 
  def __eq__(self, other):
10420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10421 
 
10422 
  def __ne__(self, other):
10423 
    return not (self == other)
10424 
 
10425 
class getItemStatusDescription_result:
10426 
  """
10427 
  Attributes:
10428 
   - success
10429 
   - isex
10430 
  """
10431 
 
10432 
  thrift_spec = (
10433 
    (0, TType.STRING, 'success', None, None, ), # 0
10434 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10435 
  )
10436 
 
10437 
  def __init__(self, success=None, isex=None,):
10438 
    self.success = success
10439 
    self.isex = isex
10440 
 
10441 
  def read(self, iprot):
10442 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10443 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10444 
      return
10445 
    iprot.readStructBegin()
10446 
    while True:
10447 
      (fname, ftype, fid) = iprot.readFieldBegin()
10448 
      if ftype == TType.STOP:
10449 
        break
10450 
      if fid == 0:
10451 
        if ftype == TType.STRING:
10452 
          self.success = iprot.readString();
10453 
        else:
10454 
          iprot.skip(ftype)
10455 
      elif fid == 1:
10456 
        if ftype == TType.STRUCT:
10457 
          self.isex = CatalogServiceException()
10458 
          self.isex.read(iprot)
10459 
        else:
10460 
          iprot.skip(ftype)
10461 
      else:
10462 
        iprot.skip(ftype)
10463 
      iprot.readFieldEnd()
10464 
    iprot.readStructEnd()
10465 
 
10466 
  def write(self, oprot):
10467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10469 
      return
10470 
    oprot.writeStructBegin('getItemStatusDescription_result')
10471 
    if self.success is not None:
10472 
      oprot.writeFieldBegin('success', TType.STRING, 0)
10473 
      oprot.writeString(self.success)
10474 
      oprot.writeFieldEnd()
10475 
    if self.isex is not None:
10476 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
10477 
      self.isex.write(oprot)
10478 
      oprot.writeFieldEnd()
10479 
    oprot.writeFieldStop()
10480 
    oprot.writeStructEnd()
10481 
 
10482 
  def validate(self):
10483 
    return
10484 
 
10485 
 
10486 
  def __repr__(self):
10487 
    L = ['%s=%r' % (key, value)
10488 
      for key, value in self.__dict__.iteritems()]
10489 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10490 
 
10491 
  def __eq__(self, other):
10492 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10493 
 
10494 
  def __ne__(self, other):
10495 
    return not (self == other)
10496 
 
10497 
class startItemOn_args:
10498 
  """
10499 
  Attributes:
10500 
   - item_id
10501 
   - timestamp
10502 
  """
10503 
 
10504 
  thrift_spec = (
10505 
    None, # 0
10506 
    (1, TType.I64, 'item_id', None, None, ), # 1
10507 
    (2, TType.I64, 'timestamp', None, None, ), # 2
10508 
  )
10509 
 
10510 
  def __init__(self, item_id=None, timestamp=None,):
10511 
    self.item_id = item_id
10512 
    self.timestamp = timestamp
10513 
 
10514 
  def read(self, iprot):
10515 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10516 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10517 
      return
10518 
    iprot.readStructBegin()
10519 
    while True:
10520 
      (fname, ftype, fid) = iprot.readFieldBegin()
10521 
      if ftype == TType.STOP:
10522 
        break
10523 
      if fid == 1:
10524 
        if ftype == TType.I64:
10525 
          self.item_id = iprot.readI64();
10526 
        else:
10527 
          iprot.skip(ftype)
10528 
      elif fid == 2:
10529 
        if ftype == TType.I64:
10530 
          self.timestamp = iprot.readI64();
10531 
        else:
10532 
          iprot.skip(ftype)
10533 
      else:
10534 
        iprot.skip(ftype)
10535 
      iprot.readFieldEnd()
10536 
    iprot.readStructEnd()
10537 
 
10538 
  def write(self, oprot):
10539 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10540 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10541 
      return
10542 
    oprot.writeStructBegin('startItemOn_args')
10543 
    if self.item_id is not None:
10544 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
10545 
      oprot.writeI64(self.item_id)
10546 
      oprot.writeFieldEnd()
10547 
    if self.timestamp is not None:
10548 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
10549 
      oprot.writeI64(self.timestamp)
10550 
      oprot.writeFieldEnd()
10551 
    oprot.writeFieldStop()
10552 
    oprot.writeStructEnd()
10553 
 
10554 
  def validate(self):
10555 
    return
10556 
 
10557 
 
10558 
  def __repr__(self):
10559 
    L = ['%s=%r' % (key, value)
10560 
      for key, value in self.__dict__.iteritems()]
10561 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10562 
 
10563 
  def __eq__(self, other):
10564 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10565 
 
10566 
  def __ne__(self, other):
10567 
    return not (self == other)
10568 
 
10569 
class startItemOn_result:
10570 
  """
10571 
  Attributes:
10572 
   - cex
10573 
  """
10574 
 
10575 
  thrift_spec = (
10576 
    None, # 0
10577 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10578 
  )
10579 
 
10580 
  def __init__(self, cex=None,):
10581 
    self.cex = cex
10582 
 
10583 
  def read(self, iprot):
10584 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10585 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10586 
      return
10587 
    iprot.readStructBegin()
10588 
    while True:
10589 
      (fname, ftype, fid) = iprot.readFieldBegin()
10590 
      if ftype == TType.STOP:
10591 
        break
10592 
      if fid == 1:
10593 
        if ftype == TType.STRUCT:
10594 
          self.cex = CatalogServiceException()
10595 
          self.cex.read(iprot)
10596 
        else:
10597 
          iprot.skip(ftype)
10598 
      else:
10599 
        iprot.skip(ftype)
10600 
      iprot.readFieldEnd()
10601 
    iprot.readStructEnd()
10602 
 
10603 
  def write(self, oprot):
10604 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10605 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10606 
      return
10607 
    oprot.writeStructBegin('startItemOn_result')
10608 
    if self.cex is not None:
10609 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10610 
      self.cex.write(oprot)
10611 
      oprot.writeFieldEnd()
10612 
    oprot.writeFieldStop()
10613 
    oprot.writeStructEnd()
10614 
 
10615 
  def validate(self):
10616 
    return
10617 
 
10618 
 
10619 
  def __repr__(self):
10620 
    L = ['%s=%r' % (key, value)
10621 
      for key, value in self.__dict__.iteritems()]
10622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10623 
 
10624 
  def __eq__(self, other):
10625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10626 
 
10627 
  def __ne__(self, other):
10628 
    return not (self == other)
10629 
 
10630 
class retireItemOn_args:
10631 
  """
10632 
  Attributes:
10633 
   - item_id
10634 
   - timestamp
10635 
  """
10636 
 
10637 
  thrift_spec = (
10638 
    None, # 0
10639 
    (1, TType.I64, 'item_id', None, None, ), # 1
10640 
    (2, TType.I64, 'timestamp', None, None, ), # 2
10641 
  )
10642 
 
10643 
  def __init__(self, item_id=None, timestamp=None,):
10644 
    self.item_id = item_id
10645 
    self.timestamp = timestamp
10646 
 
10647 
  def read(self, iprot):
10648 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10649 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10650 
      return
10651 
    iprot.readStructBegin()
10652 
    while True:
10653 
      (fname, ftype, fid) = iprot.readFieldBegin()
10654 
      if ftype == TType.STOP:
10655 
        break
10656 
      if fid == 1:
10657 
        if ftype == TType.I64:
10658 
          self.item_id = iprot.readI64();
10659 
        else:
10660 
          iprot.skip(ftype)
10661 
      elif fid == 2:
10662 
        if ftype == TType.I64:
10663 
          self.timestamp = iprot.readI64();
10664 
        else:
10665 
          iprot.skip(ftype)
10666 
      else:
10667 
        iprot.skip(ftype)
10668 
      iprot.readFieldEnd()
10669 
    iprot.readStructEnd()
10670 
 
10671 
  def write(self, oprot):
10672 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10673 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10674 
      return
10675 
    oprot.writeStructBegin('retireItemOn_args')
10676 
    if self.item_id is not None:
10677 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
10678 
      oprot.writeI64(self.item_id)
10679 
      oprot.writeFieldEnd()
10680 
    if self.timestamp is not None:
10681 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
10682 
      oprot.writeI64(self.timestamp)
10683 
      oprot.writeFieldEnd()
10684 
    oprot.writeFieldStop()
10685 
    oprot.writeStructEnd()
10686 
 
10687 
  def validate(self):
10688 
    return
10689 
 
10690 
 
10691 
  def __repr__(self):
10692 
    L = ['%s=%r' % (key, value)
10693 
      for key, value in self.__dict__.iteritems()]
10694 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10695 
 
10696 
  def __eq__(self, other):
10697 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10698 
 
10699 
  def __ne__(self, other):
10700 
    return not (self == other)
10701 
 
10702 
class retireItemOn_result:
10703 
  """
10704 
  Attributes:
10705 
   - cex
10706 
  """
10707 
 
10708 
  thrift_spec = (
10709 
    None, # 0
10710 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10711 
  )
10712 
 
10713 
  def __init__(self, cex=None,):
10714 
    self.cex = cex
10715 
 
10716 
  def read(self, iprot):
10717 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10718 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10719 
      return
10720 
    iprot.readStructBegin()
10721 
    while True:
10722 
      (fname, ftype, fid) = iprot.readFieldBegin()
10723 
      if ftype == TType.STOP:
10724 
        break
10725 
      if fid == 1:
10726 
        if ftype == TType.STRUCT:
10727 
          self.cex = CatalogServiceException()
10728 
          self.cex.read(iprot)
10729 
        else:
10730 
          iprot.skip(ftype)
10731 
      else:
10732 
        iprot.skip(ftype)
10733 
      iprot.readFieldEnd()
10734 
    iprot.readStructEnd()
10735 
 
10736 
  def write(self, oprot):
10737 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10738 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10739 
      return
10740 
    oprot.writeStructBegin('retireItemOn_result')
10741 
    if self.cex is not None:
10742 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10743 
      self.cex.write(oprot)
10744 
      oprot.writeFieldEnd()
10745 
    oprot.writeFieldStop()
10746 
    oprot.writeStructEnd()
10747 
 
10748 
  def validate(self):
10749 
    return
10750 
 
10751 
 
10752 
  def __repr__(self):
10753 
    L = ['%s=%r' % (key, value)
10754 
      for key, value in self.__dict__.iteritems()]
10755 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10756 
 
10757 
  def __eq__(self, other):
10758 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10759 
 
10760 
  def __ne__(self, other):
10761 
    return not (self == other)
10762 
 
10763 
class changeItemStatus_args:
10764 
  """
10765 
  Attributes:
10766 
   - item_id
10767 
   - timestamp
10768 
   - newstatus
10769 
  """
10770 
 
10771 
  thrift_spec = (
10772 
    None, # 0
10773 
    (1, TType.I64, 'item_id', None, None, ), # 1
10774 
    (2, TType.I64, 'timestamp', None, None, ), # 2
10775 
    (3, TType.I32, 'newstatus', None, None, ), # 3
10776 
  )
10777 
 
10778 
  def __init__(self, item_id=None, timestamp=None, newstatus=None,):
10779 
    self.item_id = item_id
10780 
    self.timestamp = timestamp
10781 
    self.newstatus = newstatus
10782 
 
10783 
  def read(self, iprot):
10784 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10785 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10786 
      return
10787 
    iprot.readStructBegin()
10788 
    while True:
10789 
      (fname, ftype, fid) = iprot.readFieldBegin()
10790 
      if ftype == TType.STOP:
10791 
        break
10792 
      if fid == 1:
10793 
        if ftype == TType.I64:
10794 
          self.item_id = iprot.readI64();
10795 
        else:
10796 
          iprot.skip(ftype)
10797 
      elif fid == 2:
10798 
        if ftype == TType.I64:
10799 
          self.timestamp = iprot.readI64();
10800 
        else:
10801 
          iprot.skip(ftype)
10802 
      elif fid == 3:
10803 
        if ftype == TType.I32:
10804 
          self.newstatus = iprot.readI32();
10805 
        else:
10806 
          iprot.skip(ftype)
10807 
      else:
10808 
        iprot.skip(ftype)
10809 
      iprot.readFieldEnd()
10810 
    iprot.readStructEnd()
10811 
 
10812 
  def write(self, oprot):
10813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10815 
      return
10816 
    oprot.writeStructBegin('changeItemStatus_args')
10817 
    if self.item_id is not None:
10818 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
10819 
      oprot.writeI64(self.item_id)
10820 
      oprot.writeFieldEnd()
10821 
    if self.timestamp is not None:
10822 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
10823 
      oprot.writeI64(self.timestamp)
10824 
      oprot.writeFieldEnd()
10825 
    if self.newstatus is not None:
10826 
      oprot.writeFieldBegin('newstatus', TType.I32, 3)
10827 
      oprot.writeI32(self.newstatus)
10828 
      oprot.writeFieldEnd()
10829 
    oprot.writeFieldStop()
10830 
    oprot.writeStructEnd()
10831 
 
10832 
  def validate(self):
10833 
    return
10834 
 
10835 
 
10836 
  def __repr__(self):
10837 
    L = ['%s=%r' % (key, value)
10838 
      for key, value in self.__dict__.iteritems()]
10839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10840 
 
10841 
  def __eq__(self, other):
10842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10843 
 
10844 
  def __ne__(self, other):
10845 
    return not (self == other)
10846 
 
10847 
class changeItemStatus_result:
10848 
  """
10849 
  Attributes:
10850 
   - cex
10851 
  """
10852 
 
10853 
  thrift_spec = (
10854 
    None, # 0
10855 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10856 
  )
10857 
 
10858 
  def __init__(self, cex=None,):
10859 
    self.cex = cex
10860 
 
10861 
  def read(self, iprot):
10862 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10863 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10864 
      return
10865 
    iprot.readStructBegin()
10866 
    while True:
10867 
      (fname, ftype, fid) = iprot.readFieldBegin()
10868 
      if ftype == TType.STOP:
10869 
        break
10870 
      if fid == 1:
10871 
        if ftype == TType.STRUCT:
10872 
          self.cex = CatalogServiceException()
10873 
          self.cex.read(iprot)
10874 
        else:
10875 
          iprot.skip(ftype)
10876 
      else:
10877 
        iprot.skip(ftype)
10878 
      iprot.readFieldEnd()
10879 
    iprot.readStructEnd()
10880 
 
10881 
  def write(self, oprot):
10882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10884 
      return
10885 
    oprot.writeStructBegin('changeItemStatus_result')
10886 
    if self.cex is not None:
10887 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10888 
      self.cex.write(oprot)
10889 
      oprot.writeFieldEnd()
10890 
    oprot.writeFieldStop()
10891 
    oprot.writeStructEnd()
10892 
 
10893 
  def validate(self):
10894 
    return
10895 
 
10896 
 
10897 
  def __repr__(self):
10898 
    L = ['%s=%r' % (key, value)
10899 
      for key, value in self.__dict__.iteritems()]
10900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10901 
 
10902 
  def __eq__(self, other):
10903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10904 
 
10905 
  def __ne__(self, other):
10906 
    return not (self == other)
10907 
 
10908 
class getItem_args:
10909 
  """
10910 
  Attributes:
10911 
   - item_id
10912 
  """
10913 
 
10914 
  thrift_spec = (
10915 
    None, # 0
10916 
    (1, TType.I64, 'item_id', None, None, ), # 1
10917 
  )
10918 
 
10919 
  def __init__(self, item_id=None,):
10920 
    self.item_id = item_id
10921 
 
10922 
  def read(self, iprot):
10923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10925 
      return
10926 
    iprot.readStructBegin()
10927 
    while True:
10928 
      (fname, ftype, fid) = iprot.readFieldBegin()
10929 
      if ftype == TType.STOP:
10930 
        break
10931 
      if fid == 1:
10932 
        if ftype == TType.I64:
10933 
          self.item_id = iprot.readI64();
10934 
        else:
10935 
          iprot.skip(ftype)
10936 
      else:
10937 
        iprot.skip(ftype)
10938 
      iprot.readFieldEnd()
10939 
    iprot.readStructEnd()
10940 
 
10941 
  def write(self, oprot):
10942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10944 
      return
10945 
    oprot.writeStructBegin('getItem_args')
10946 
    if self.item_id is not None:
10947 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
10948 
      oprot.writeI64(self.item_id)
10949 
      oprot.writeFieldEnd()
10950 
    oprot.writeFieldStop()
10951 
    oprot.writeStructEnd()
10952 
 
10953 
  def validate(self):
10954 
    return
10955 
 
10956 
 
10957 
  def __repr__(self):
10958 
    L = ['%s=%r' % (key, value)
10959 
      for key, value in self.__dict__.iteritems()]
10960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10961 
 
10962 
  def __eq__(self, other):
10963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10964 
 
10965 
  def __ne__(self, other):
10966 
    return not (self == other)
10967 
 
10968 
class getItem_result:
10969 
  """
10970 
  Attributes:
10971 
   - success
10972 
   - cex
10973 
  """
10974 
 
10975 
  thrift_spec = (
10976 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
10977 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10978 
  )
10979 
 
10980 
  def __init__(self, success=None, cex=None,):
10981 
    self.success = success
10982 
    self.cex = cex
10983 
 
10984 
  def read(self, iprot):
10985 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10986 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10987 
      return
10988 
    iprot.readStructBegin()
10989 
    while True:
10990 
      (fname, ftype, fid) = iprot.readFieldBegin()
10991 
      if ftype == TType.STOP:
10992 
        break
10993 
      if fid == 0:
10994 
        if ftype == TType.STRUCT:
10995 
          self.success = Item()
10996 
          self.success.read(iprot)
10997 
        else:
10998 
          iprot.skip(ftype)
10999 
      elif fid == 1:
11000 
        if ftype == TType.STRUCT:
11001 
          self.cex = CatalogServiceException()
11002 
          self.cex.read(iprot)
11003 
        else:
11004 
          iprot.skip(ftype)
11005 
      else:
11006 
        iprot.skip(ftype)
11007 
      iprot.readFieldEnd()
11008 
    iprot.readStructEnd()
11009 
 
11010 
  def write(self, oprot):
11011 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11012 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11013 
      return
11014 
    oprot.writeStructBegin('getItem_result')
11015 
    if self.success is not None:
11016 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11017 
      self.success.write(oprot)
11018 
      oprot.writeFieldEnd()
11019 
    if self.cex is not None:
11020 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11021 
      self.cex.write(oprot)
11022 
      oprot.writeFieldEnd()
11023 
    oprot.writeFieldStop()
11024 
    oprot.writeStructEnd()
11025 
 
11026 
  def validate(self):
11027 
    return
11028 
 
11029 
 
11030 
  def __repr__(self):
11031 
    L = ['%s=%r' % (key, value)
11032 
      for key, value in self.__dict__.iteritems()]
11033 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11034 
 
11035 
  def __eq__(self, other):
11036 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11037 
 
11038 
  def __ne__(self, other):
11039 
    return not (self == other)
11040 
 
13493 amit.gupta 11041 
class getItems_args:
11042 
  """
11043 
  Attributes:
11044 
   - item_ids
11045 
  """
11046 
 
11047 
  thrift_spec = (
11048 
    None, # 0
11049 
    (1, TType.LIST, 'item_ids', (TType.I64,None), None, ), # 1
11050 
  )
11051 
 
11052 
  def __init__(self, item_ids=None,):
11053 
    self.item_ids = item_ids
11054 
 
11055 
  def read(self, iprot):
11056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11058 
      return
11059 
    iprot.readStructBegin()
11060 
    while True:
11061 
      (fname, ftype, fid) = iprot.readFieldBegin()
11062 
      if ftype == TType.STOP:
11063 
        break
11064 
      if fid == 1:
11065 
        if ftype == TType.LIST:
11066 
          self.item_ids = []
11067 
          (_etype49, _size46) = iprot.readListBegin()
11068 
          for _i50 in xrange(_size46):
11069 
            _elem51 = iprot.readI64();
11070 
            self.item_ids.append(_elem51)
11071 
          iprot.readListEnd()
11072 
        else:
11073 
          iprot.skip(ftype)
11074 
      else:
11075 
        iprot.skip(ftype)
11076 
      iprot.readFieldEnd()
11077 
    iprot.readStructEnd()
11078 
 
11079 
  def write(self, oprot):
11080 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11081 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11082 
      return
11083 
    oprot.writeStructBegin('getItems_args')
11084 
    if self.item_ids is not None:
11085 
      oprot.writeFieldBegin('item_ids', TType.LIST, 1)
11086 
      oprot.writeListBegin(TType.I64, len(self.item_ids))
11087 
      for iter52 in self.item_ids:
11088 
        oprot.writeI64(iter52)
11089 
      oprot.writeListEnd()
11090 
      oprot.writeFieldEnd()
11091 
    oprot.writeFieldStop()
11092 
    oprot.writeStructEnd()
11093 
 
11094 
  def validate(self):
11095 
    return
11096 
 
11097 
 
11098 
  def __repr__(self):
11099 
    L = ['%s=%r' % (key, value)
11100 
      for key, value in self.__dict__.iteritems()]
11101 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11102 
 
11103 
  def __eq__(self, other):
11104 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11105 
 
11106 
  def __ne__(self, other):
11107 
    return not (self == other)
11108 
 
11109 
class getItems_result:
11110 
  """
11111 
  Attributes:
11112 
   - success
11113 
   - cex
11114 
  """
11115 
 
11116 
  thrift_spec = (
11117 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11118 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11119 
  )
11120 
 
11121 
  def __init__(self, success=None, cex=None,):
11122 
    self.success = success
11123 
    self.cex = cex
11124 
 
11125 
  def read(self, iprot):
11126 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11127 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11128 
      return
11129 
    iprot.readStructBegin()
11130 
    while True:
11131 
      (fname, ftype, fid) = iprot.readFieldBegin()
11132 
      if ftype == TType.STOP:
11133 
        break
11134 
      if fid == 0:
11135 
        if ftype == TType.MAP:
11136 
          self.success = {}
11137 
          (_ktype54, _vtype55, _size53 ) = iprot.readMapBegin()
11138 
          for _i57 in xrange(_size53):
11139 
            _key58 = iprot.readI64();
11140 
            _val59 = Item()
11141 
            _val59.read(iprot)
11142 
            self.success[_key58] = _val59
11143 
          iprot.readMapEnd()
11144 
        else:
11145 
          iprot.skip(ftype)
11146 
      elif fid == 1:
11147 
        if ftype == TType.STRUCT:
11148 
          self.cex = CatalogServiceException()
11149 
          self.cex.read(iprot)
11150 
        else:
11151 
          iprot.skip(ftype)
11152 
      else:
11153 
        iprot.skip(ftype)
11154 
      iprot.readFieldEnd()
11155 
    iprot.readStructEnd()
11156 
 
11157 
  def write(self, oprot):
11158 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11159 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11160 
      return
11161 
    oprot.writeStructBegin('getItems_result')
11162 
    if self.success is not None:
11163 
      oprot.writeFieldBegin('success', TType.MAP, 0)
11164 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.success))
11165 
      for kiter60,viter61 in self.success.items():
11166 
        oprot.writeI64(kiter60)
11167 
        viter61.write(oprot)
11168 
      oprot.writeMapEnd()
11169 
      oprot.writeFieldEnd()
11170 
    if self.cex is not None:
11171 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11172 
      self.cex.write(oprot)
11173 
      oprot.writeFieldEnd()
11174 
    oprot.writeFieldStop()
11175 
    oprot.writeStructEnd()
11176 
 
11177 
  def validate(self):
11178 
    return
11179 
 
11180 
 
11181 
  def __repr__(self):
11182 
    L = ['%s=%r' % (key, value)
11183 
      for key, value in self.__dict__.iteritems()]
11184 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11185 
 
11186 
  def __eq__(self, other):
11187 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11188 
 
11189 
  def __ne__(self, other):
11190 
    return not (self == other)
11191 
 
5944 mandeep.dh 11192 
class getItemsByCatalogId_args:
11193 
  """
11194 
  Attributes:
11195 
   - catalog_item_id
11196 
  """
11197 
 
11198 
  thrift_spec = (
11199 
    None, # 0
11200 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
11201 
  )
11202 
 
11203 
  def __init__(self, catalog_item_id=None,):
11204 
    self.catalog_item_id = catalog_item_id
11205 
 
11206 
  def read(self, iprot):
11207 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11208 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11209 
      return
11210 
    iprot.readStructBegin()
11211 
    while True:
11212 
      (fname, ftype, fid) = iprot.readFieldBegin()
11213 
      if ftype == TType.STOP:
11214 
        break
11215 
      if fid == 1:
11216 
        if ftype == TType.I64:
11217 
          self.catalog_item_id = iprot.readI64();
11218 
        else:
11219 
          iprot.skip(ftype)
11220 
      else:
11221 
        iprot.skip(ftype)
11222 
      iprot.readFieldEnd()
11223 
    iprot.readStructEnd()
11224 
 
11225 
  def write(self, oprot):
11226 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11227 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11228 
      return
11229 
    oprot.writeStructBegin('getItemsByCatalogId_args')
11230 
    if self.catalog_item_id is not None:
11231 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
11232 
      oprot.writeI64(self.catalog_item_id)
11233 
      oprot.writeFieldEnd()
11234 
    oprot.writeFieldStop()
11235 
    oprot.writeStructEnd()
11236 
 
11237 
  def validate(self):
11238 
    return
11239 
 
11240 
 
11241 
  def __repr__(self):
11242 
    L = ['%s=%r' % (key, value)
11243 
      for key, value in self.__dict__.iteritems()]
11244 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11245 
 
11246 
  def __eq__(self, other):
11247 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11248 
 
11249 
  def __ne__(self, other):
11250 
    return not (self == other)
11251 
 
11252 
class getItemsByCatalogId_result:
11253 
  """
11254 
  Attributes:
11255 
   - success
11256 
   - cex
11257 
  """
11258 
 
11259 
  thrift_spec = (
11260 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11261 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11262 
  )
11263 
 
11264 
  def __init__(self, success=None, cex=None,):
11265 
    self.success = success
11266 
    self.cex = cex
11267 
 
11268 
  def read(self, iprot):
11269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11271 
      return
11272 
    iprot.readStructBegin()
11273 
    while True:
11274 
      (fname, ftype, fid) = iprot.readFieldBegin()
11275 
      if ftype == TType.STOP:
11276 
        break
11277 
      if fid == 0:
11278 
        if ftype == TType.LIST:
11279 
          self.success = []
13493 amit.gupta 11280 
          (_etype65, _size62) = iprot.readListBegin()
11281 
          for _i66 in xrange(_size62):
11282 
            _elem67 = Item()
11283 
            _elem67.read(iprot)
11284 
            self.success.append(_elem67)
5944 mandeep.dh 11285 
          iprot.readListEnd()
11286 
        else:
11287 
          iprot.skip(ftype)
11288 
      elif fid == 1:
11289 
        if ftype == TType.STRUCT:
11290 
          self.cex = CatalogServiceException()
11291 
          self.cex.read(iprot)
11292 
        else:
11293 
          iprot.skip(ftype)
11294 
      else:
11295 
        iprot.skip(ftype)
11296 
      iprot.readFieldEnd()
11297 
    iprot.readStructEnd()
11298 
 
11299 
  def write(self, oprot):
11300 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11301 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11302 
      return
11303 
    oprot.writeStructBegin('getItemsByCatalogId_result')
11304 
    if self.success is not None:
11305 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11306 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 11307 
      for iter68 in self.success:
11308 
        iter68.write(oprot)
5944 mandeep.dh 11309 
      oprot.writeListEnd()
11310 
      oprot.writeFieldEnd()
11311 
    if self.cex is not None:
11312 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11313 
      self.cex.write(oprot)
11314 
      oprot.writeFieldEnd()
11315 
    oprot.writeFieldStop()
11316 
    oprot.writeStructEnd()
11317 
 
11318 
  def validate(self):
11319 
    return
11320 
 
11321 
 
11322 
  def __repr__(self):
11323 
    L = ['%s=%r' % (key, value)
11324 
      for key, value in self.__dict__.iteritems()]
11325 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11326 
 
11327 
  def __eq__(self, other):
11328 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11329 
 
11330 
  def __ne__(self, other):
11331 
    return not (self == other)
11332 
 
11333 
class getValidItemsByCatalogId_args:
11334 
  """
11335 
  Attributes:
11336 
   - catalog_item_id
11337 
  """
11338 
 
11339 
  thrift_spec = (
11340 
    None, # 0
11341 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
11342 
  )
11343 
 
11344 
  def __init__(self, catalog_item_id=None,):
11345 
    self.catalog_item_id = catalog_item_id
11346 
 
11347 
  def read(self, iprot):
11348 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11349 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11350 
      return
11351 
    iprot.readStructBegin()
11352 
    while True:
11353 
      (fname, ftype, fid) = iprot.readFieldBegin()
11354 
      if ftype == TType.STOP:
11355 
        break
11356 
      if fid == 1:
11357 
        if ftype == TType.I64:
11358 
          self.catalog_item_id = iprot.readI64();
11359 
        else:
11360 
          iprot.skip(ftype)
11361 
      else:
11362 
        iprot.skip(ftype)
11363 
      iprot.readFieldEnd()
11364 
    iprot.readStructEnd()
11365 
 
11366 
  def write(self, oprot):
11367 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11368 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11369 
      return
11370 
    oprot.writeStructBegin('getValidItemsByCatalogId_args')
11371 
    if self.catalog_item_id is not None:
11372 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
11373 
      oprot.writeI64(self.catalog_item_id)
11374 
      oprot.writeFieldEnd()
11375 
    oprot.writeFieldStop()
11376 
    oprot.writeStructEnd()
11377 
 
11378 
  def validate(self):
11379 
    return
11380 
 
11381 
 
11382 
  def __repr__(self):
11383 
    L = ['%s=%r' % (key, value)
11384 
      for key, value in self.__dict__.iteritems()]
11385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11386 
 
11387 
  def __eq__(self, other):
11388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11389 
 
11390 
  def __ne__(self, other):
11391 
    return not (self == other)
11392 
 
11393 
class getValidItemsByCatalogId_result:
11394 
  """
11395 
  Attributes:
11396 
   - success
11397 
   - cex
11398 
  """
11399 
 
11400 
  thrift_spec = (
11401 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11402 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11403 
  )
11404 
 
11405 
  def __init__(self, success=None, cex=None,):
11406 
    self.success = success
11407 
    self.cex = cex
11408 
 
11409 
  def read(self, iprot):
11410 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11411 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11412 
      return
11413 
    iprot.readStructBegin()
11414 
    while True:
11415 
      (fname, ftype, fid) = iprot.readFieldBegin()
11416 
      if ftype == TType.STOP:
11417 
        break
11418 
      if fid == 0:
11419 
        if ftype == TType.LIST:
11420 
          self.success = []
13493 amit.gupta 11421 
          (_etype72, _size69) = iprot.readListBegin()
11422 
          for _i73 in xrange(_size69):
11423 
            _elem74 = Item()
11424 
            _elem74.read(iprot)
11425 
            self.success.append(_elem74)
5944 mandeep.dh 11426 
          iprot.readListEnd()
11427 
        else:
11428 
          iprot.skip(ftype)
11429 
      elif fid == 1:
11430 
        if ftype == TType.STRUCT:
11431 
          self.cex = CatalogServiceException()
11432 
          self.cex.read(iprot)
11433 
        else:
11434 
          iprot.skip(ftype)
11435 
      else:
11436 
        iprot.skip(ftype)
11437 
      iprot.readFieldEnd()
11438 
    iprot.readStructEnd()
11439 
 
11440 
  def write(self, oprot):
11441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11443 
      return
11444 
    oprot.writeStructBegin('getValidItemsByCatalogId_result')
11445 
    if self.success is not None:
11446 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11447 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 11448 
      for iter75 in self.success:
11449 
        iter75.write(oprot)
5944 mandeep.dh 11450 
      oprot.writeListEnd()
11451 
      oprot.writeFieldEnd()
11452 
    if self.cex is not None:
11453 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11454 
      self.cex.write(oprot)
11455 
      oprot.writeFieldEnd()
11456 
    oprot.writeFieldStop()
11457 
    oprot.writeStructEnd()
11458 
 
11459 
  def validate(self):
11460 
    return
11461 
 
11462 
 
11463 
  def __repr__(self):
11464 
    L = ['%s=%r' % (key, value)
11465 
      for key, value in self.__dict__.iteritems()]
11466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11467 
 
11468 
  def __eq__(self, other):
11469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11470 
 
11471 
  def __ne__(self, other):
11472 
    return not (self == other)
11473 
 
11474 
class getAllItems_args:
11475 
  """
11476 
  Attributes:
11477 
   - isActive
11478 
  """
11479 
 
11480 
  thrift_spec = (
11481 
    None, # 0
11482 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
11483 
  )
11484 
 
11485 
  def __init__(self, isActive=None,):
11486 
    self.isActive = isActive
11487 
 
11488 
  def read(self, iprot):
11489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11491 
      return
11492 
    iprot.readStructBegin()
11493 
    while True:
11494 
      (fname, ftype, fid) = iprot.readFieldBegin()
11495 
      if ftype == TType.STOP:
11496 
        break
11497 
      if fid == 1:
11498 
        if ftype == TType.BOOL:
11499 
          self.isActive = iprot.readBool();
11500 
        else:
11501 
          iprot.skip(ftype)
11502 
      else:
11503 
        iprot.skip(ftype)
11504 
      iprot.readFieldEnd()
11505 
    iprot.readStructEnd()
11506 
 
11507 
  def write(self, oprot):
11508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11510 
      return
11511 
    oprot.writeStructBegin('getAllItems_args')
11512 
    if self.isActive is not None:
11513 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
11514 
      oprot.writeBool(self.isActive)
11515 
      oprot.writeFieldEnd()
11516 
    oprot.writeFieldStop()
11517 
    oprot.writeStructEnd()
11518 
 
11519 
  def validate(self):
11520 
    return
11521 
 
11522 
 
11523 
  def __repr__(self):
11524 
    L = ['%s=%r' % (key, value)
11525 
      for key, value in self.__dict__.iteritems()]
11526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11527 
 
11528 
  def __eq__(self, other):
11529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11530 
 
11531 
  def __ne__(self, other):
11532 
    return not (self == other)
11533 
 
11534 
class getAllItems_result:
11535 
  """
11536 
  Attributes:
11537 
   - success
11538 
   - cex
11539 
  """
11540 
 
11541 
  thrift_spec = (
11542 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11543 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11544 
  )
11545 
 
11546 
  def __init__(self, success=None, cex=None,):
11547 
    self.success = success
11548 
    self.cex = cex
11549 
 
11550 
  def read(self, iprot):
11551 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11552 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11553 
      return
11554 
    iprot.readStructBegin()
11555 
    while True:
11556 
      (fname, ftype, fid) = iprot.readFieldBegin()
11557 
      if ftype == TType.STOP:
11558 
        break
11559 
      if fid == 0:
11560 
        if ftype == TType.LIST:
11561 
          self.success = []
13493 amit.gupta 11562 
          (_etype79, _size76) = iprot.readListBegin()
11563 
          for _i80 in xrange(_size76):
11564 
            _elem81 = Item()
11565 
            _elem81.read(iprot)
11566 
            self.success.append(_elem81)
5944 mandeep.dh 11567 
          iprot.readListEnd()
11568 
        else:
11569 
          iprot.skip(ftype)
11570 
      elif fid == 1:
11571 
        if ftype == TType.STRUCT:
11572 
          self.cex = CatalogServiceException()
11573 
          self.cex.read(iprot)
11574 
        else:
11575 
          iprot.skip(ftype)
11576 
      else:
11577 
        iprot.skip(ftype)
11578 
      iprot.readFieldEnd()
11579 
    iprot.readStructEnd()
11580 
 
11581 
  def write(self, oprot):
11582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11584 
      return
11585 
    oprot.writeStructBegin('getAllItems_result')
11586 
    if self.success is not None:
11587 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11588 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 11589 
      for iter82 in self.success:
11590 
        iter82.write(oprot)
5944 mandeep.dh 11591 
      oprot.writeListEnd()
11592 
      oprot.writeFieldEnd()
11593 
    if self.cex is not None:
11594 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11595 
      self.cex.write(oprot)
11596 
      oprot.writeFieldEnd()
11597 
    oprot.writeFieldStop()
11598 
    oprot.writeStructEnd()
11599 
 
11600 
  def validate(self):
11601 
    return
11602 
 
11603 
 
11604 
  def __repr__(self):
11605 
    L = ['%s=%r' % (key, value)
11606 
      for key, value in self.__dict__.iteritems()]
11607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11608 
 
11609 
  def __eq__(self, other):
11610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11611 
 
11612 
  def __ne__(self, other):
11613 
    return not (self == other)
11614 
 
11615 
class getAllItemsByStatus_args:
11616 
  """
11617 
  Attributes:
11618 
   - itemStatus
11619 
  """
11620 
 
11621 
  thrift_spec = (
11622 
    None, # 0
11623 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
11624 
  )
11625 
 
11626 
  def __init__(self, itemStatus=None,):
11627 
    self.itemStatus = itemStatus
11628 
 
11629 
  def read(self, iprot):
11630 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11631 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11632 
      return
11633 
    iprot.readStructBegin()
11634 
    while True:
11635 
      (fname, ftype, fid) = iprot.readFieldBegin()
11636 
      if ftype == TType.STOP:
11637 
        break
11638 
      if fid == 1:
11639 
        if ftype == TType.I32:
11640 
          self.itemStatus = iprot.readI32();
11641 
        else:
11642 
          iprot.skip(ftype)
11643 
      else:
11644 
        iprot.skip(ftype)
11645 
      iprot.readFieldEnd()
11646 
    iprot.readStructEnd()
11647 
 
11648 
  def write(self, oprot):
11649 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11650 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11651 
      return
11652 
    oprot.writeStructBegin('getAllItemsByStatus_args')
11653 
    if self.itemStatus is not None:
11654 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
11655 
      oprot.writeI32(self.itemStatus)
11656 
      oprot.writeFieldEnd()
11657 
    oprot.writeFieldStop()
11658 
    oprot.writeStructEnd()
11659 
 
11660 
  def validate(self):
11661 
    return
11662 
 
11663 
 
11664 
  def __repr__(self):
11665 
    L = ['%s=%r' % (key, value)
11666 
      for key, value in self.__dict__.iteritems()]
11667 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11668 
 
11669 
  def __eq__(self, other):
11670 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11671 
 
11672 
  def __ne__(self, other):
11673 
    return not (self == other)
11674 
 
11675 
class getAllItemsByStatus_result:
11676 
  """
11677 
  Attributes:
11678 
   - success
11679 
   - cex
11680 
  """
11681 
 
11682 
  thrift_spec = (
11683 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11684 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11685 
  )
11686 
 
11687 
  def __init__(self, success=None, cex=None,):
11688 
    self.success = success
11689 
    self.cex = cex
11690 
 
11691 
  def read(self, iprot):
11692 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11693 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11694 
      return
11695 
    iprot.readStructBegin()
11696 
    while True:
11697 
      (fname, ftype, fid) = iprot.readFieldBegin()
11698 
      if ftype == TType.STOP:
11699 
        break
11700 
      if fid == 0:
11701 
        if ftype == TType.LIST:
11702 
          self.success = []
13493 amit.gupta 11703 
          (_etype86, _size83) = iprot.readListBegin()
11704 
          for _i87 in xrange(_size83):
11705 
            _elem88 = Item()
11706 
            _elem88.read(iprot)
11707 
            self.success.append(_elem88)
5944 mandeep.dh 11708 
          iprot.readListEnd()
11709 
        else:
11710 
          iprot.skip(ftype)
11711 
      elif fid == 1:
11712 
        if ftype == TType.STRUCT:
11713 
          self.cex = CatalogServiceException()
11714 
          self.cex.read(iprot)
11715 
        else:
11716 
          iprot.skip(ftype)
11717 
      else:
11718 
        iprot.skip(ftype)
11719 
      iprot.readFieldEnd()
11720 
    iprot.readStructEnd()
11721 
 
11722 
  def write(self, oprot):
11723 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11724 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11725 
      return
11726 
    oprot.writeStructBegin('getAllItemsByStatus_result')
11727 
    if self.success is not None:
11728 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11729 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 11730 
      for iter89 in self.success:
11731 
        iter89.write(oprot)
5944 mandeep.dh 11732 
      oprot.writeListEnd()
11733 
      oprot.writeFieldEnd()
11734 
    if self.cex is not None:
11735 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11736 
      self.cex.write(oprot)
11737 
      oprot.writeFieldEnd()
11738 
    oprot.writeFieldStop()
11739 
    oprot.writeStructEnd()
11740 
 
11741 
  def validate(self):
11742 
    return
11743 
 
11744 
 
11745 
  def __repr__(self):
11746 
    L = ['%s=%r' % (key, value)
11747 
      for key, value in self.__dict__.iteritems()]
11748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11749 
 
11750 
  def __eq__(self, other):
11751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11752 
 
11753 
  def __ne__(self, other):
11754 
    return not (self == other)
11755 
 
11756 
class markItemAsContentComplete_args:
11757 
  """
11758 
  Attributes:
11759 
   - entityId
11760 
   - category
11761 
   - brand
11762 
   - modelName
11763 
   - modelNumber
9253 rajveer 11764 
   - isAndroid
5944 mandeep.dh 11765 
  """
11766 
 
11767 
  thrift_spec = (
11768 
    None, # 0
11769 
    (1, TType.I64, 'entityId', None, None, ), # 1
11770 
    (2, TType.I64, 'category', None, None, ), # 2
11771 
    (3, TType.STRING, 'brand', None, None, ), # 3
11772 
    (4, TType.STRING, 'modelName', None, None, ), # 4
11773 
    (5, TType.STRING, 'modelNumber', None, None, ), # 5
9253 rajveer 11774 
    (6, TType.BOOL, 'isAndroid', None, None, ), # 6
5944 mandeep.dh 11775 
  )
11776 
 
9253 rajveer 11777 
  def __init__(self, entityId=None, category=None, brand=None, modelName=None, modelNumber=None, isAndroid=None,):
5944 mandeep.dh 11778 
    self.entityId = entityId
11779 
    self.category = category
11780 
    self.brand = brand
11781 
    self.modelName = modelName
11782 
    self.modelNumber = modelNumber
9253 rajveer 11783 
    self.isAndroid = isAndroid
5944 mandeep.dh 11784 
 
11785 
  def read(self, iprot):
11786 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11787 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11788 
      return
11789 
    iprot.readStructBegin()
11790 
    while True:
11791 
      (fname, ftype, fid) = iprot.readFieldBegin()
11792 
      if ftype == TType.STOP:
11793 
        break
11794 
      if fid == 1:
11795 
        if ftype == TType.I64:
11796 
          self.entityId = iprot.readI64();
11797 
        else:
11798 
          iprot.skip(ftype)
11799 
      elif fid == 2:
11800 
        if ftype == TType.I64:
11801 
          self.category = iprot.readI64();
11802 
        else:
11803 
          iprot.skip(ftype)
11804 
      elif fid == 3:
11805 
        if ftype == TType.STRING:
11806 
          self.brand = iprot.readString();
11807 
        else:
11808 
          iprot.skip(ftype)
11809 
      elif fid == 4:
11810 
        if ftype == TType.STRING:
11811 
          self.modelName = iprot.readString();
11812 
        else:
11813 
          iprot.skip(ftype)
11814 
      elif fid == 5:
11815 
        if ftype == TType.STRING:
11816 
          self.modelNumber = iprot.readString();
11817 
        else:
11818 
          iprot.skip(ftype)
9253 rajveer 11819 
      elif fid == 6:
11820 
        if ftype == TType.BOOL:
11821 
          self.isAndroid = iprot.readBool();
11822 
        else:
11823 
          iprot.skip(ftype)
5944 mandeep.dh 11824 
      else:
11825 
        iprot.skip(ftype)
11826 
      iprot.readFieldEnd()
11827 
    iprot.readStructEnd()
11828 
 
11829 
  def write(self, oprot):
11830 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11831 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11832 
      return
11833 
    oprot.writeStructBegin('markItemAsContentComplete_args')
11834 
    if self.entityId is not None:
11835 
      oprot.writeFieldBegin('entityId', TType.I64, 1)
11836 
      oprot.writeI64(self.entityId)
11837 
      oprot.writeFieldEnd()
11838 
    if self.category is not None:
11839 
      oprot.writeFieldBegin('category', TType.I64, 2)
11840 
      oprot.writeI64(self.category)
11841 
      oprot.writeFieldEnd()
11842 
    if self.brand is not None:
11843 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
11844 
      oprot.writeString(self.brand)
11845 
      oprot.writeFieldEnd()
11846 
    if self.modelName is not None:
11847 
      oprot.writeFieldBegin('modelName', TType.STRING, 4)
11848 
      oprot.writeString(self.modelName)
11849 
      oprot.writeFieldEnd()
11850 
    if self.modelNumber is not None:
11851 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 5)
11852 
      oprot.writeString(self.modelNumber)
11853 
      oprot.writeFieldEnd()
9253 rajveer 11854 
    if self.isAndroid is not None:
11855 
      oprot.writeFieldBegin('isAndroid', TType.BOOL, 6)
11856 
      oprot.writeBool(self.isAndroid)
11857 
      oprot.writeFieldEnd()
5944 mandeep.dh 11858 
    oprot.writeFieldStop()
11859 
    oprot.writeStructEnd()
11860 
 
11861 
  def validate(self):
11862 
    return
11863 
 
11864 
 
11865 
  def __repr__(self):
11866 
    L = ['%s=%r' % (key, value)
11867 
      for key, value in self.__dict__.iteritems()]
11868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11869 
 
11870 
  def __eq__(self, other):
11871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11872 
 
11873 
  def __ne__(self, other):
11874 
    return not (self == other)
11875 
 
11876 
class markItemAsContentComplete_result:
11877 
  """
11878 
  Attributes:
11879 
   - success
11880 
   - cex
11881 
  """
11882 
 
11883 
  thrift_spec = (
11884 
    (0, TType.BOOL, 'success', None, None, ), # 0
11885 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11886 
  )
11887 
 
11888 
  def __init__(self, success=None, cex=None,):
11889 
    self.success = success
11890 
    self.cex = cex
11891 
 
11892 
  def read(self, iprot):
11893 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11894 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11895 
      return
11896 
    iprot.readStructBegin()
11897 
    while True:
11898 
      (fname, ftype, fid) = iprot.readFieldBegin()
11899 
      if ftype == TType.STOP:
11900 
        break
11901 
      if fid == 0:
11902 
        if ftype == TType.BOOL:
11903 
          self.success = iprot.readBool();
11904 
        else:
11905 
          iprot.skip(ftype)
11906 
      elif fid == 1:
11907 
        if ftype == TType.STRUCT:
11908 
          self.cex = CatalogServiceException()
11909 
          self.cex.read(iprot)
11910 
        else:
11911 
          iprot.skip(ftype)
11912 
      else:
11913 
        iprot.skip(ftype)
11914 
      iprot.readFieldEnd()
11915 
    iprot.readStructEnd()
11916 
 
11917 
  def write(self, oprot):
11918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11920 
      return
11921 
    oprot.writeStructBegin('markItemAsContentComplete_result')
11922 
    if self.success is not None:
11923 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11924 
      oprot.writeBool(self.success)
11925 
      oprot.writeFieldEnd()
11926 
    if self.cex is not None:
11927 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11928 
      self.cex.write(oprot)
11929 
      oprot.writeFieldEnd()
11930 
    oprot.writeFieldStop()
11931 
    oprot.writeStructEnd()
11932 
 
11933 
  def validate(self):
11934 
    return
11935 
 
11936 
 
11937 
  def __repr__(self):
11938 
    L = ['%s=%r' % (key, value)
11939 
      for key, value in self.__dict__.iteritems()]
11940 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11941 
 
11942 
  def __eq__(self, other):
11943 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11944 
 
11945 
  def __ne__(self, other):
11946 
    return not (self == other)
11947 
 
12567 amit.gupta 11948 
class getVatRates_args:
11949 
  """
11950 
  Attributes:
11951 
   - itemId
11952 
   - categoryId
11953 
  """
11954 
 
11955 
  thrift_spec = (
11956 
    None, # 0
11957 
    (1, TType.I64, 'itemId', None, None, ), # 1
11958 
    (2, TType.I64, 'categoryId', None, None, ), # 2
11959 
  )
11960 
 
11961 
  def __init__(self, itemId=None, categoryId=None,):
11962 
    self.itemId = itemId
11963 
    self.categoryId = categoryId
11964 
 
11965 
  def read(self, iprot):
11966 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11967 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11968 
      return
11969 
    iprot.readStructBegin()
11970 
    while True:
11971 
      (fname, ftype, fid) = iprot.readFieldBegin()
11972 
      if ftype == TType.STOP:
11973 
        break
11974 
      if fid == 1:
11975 
        if ftype == TType.I64:
11976 
          self.itemId = iprot.readI64();
11977 
        else:
11978 
          iprot.skip(ftype)
11979 
      elif fid == 2:
11980 
        if ftype == TType.I64:
11981 
          self.categoryId = iprot.readI64();
11982 
        else:
11983 
          iprot.skip(ftype)
11984 
      else:
11985 
        iprot.skip(ftype)
11986 
      iprot.readFieldEnd()
11987 
    iprot.readStructEnd()
11988 
 
11989 
  def write(self, oprot):
11990 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11991 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11992 
      return
11993 
    oprot.writeStructBegin('getVatRates_args')
11994 
    if self.itemId is not None:
11995 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11996 
      oprot.writeI64(self.itemId)
11997 
      oprot.writeFieldEnd()
11998 
    if self.categoryId is not None:
11999 
      oprot.writeFieldBegin('categoryId', TType.I64, 2)
12000 
      oprot.writeI64(self.categoryId)
12001 
      oprot.writeFieldEnd()
12002 
    oprot.writeFieldStop()
12003 
    oprot.writeStructEnd()
12004 
 
12005 
  def validate(self):
12006 
    return
12007 
 
12008 
 
12009 
  def __repr__(self):
12010 
    L = ['%s=%r' % (key, value)
12011 
      for key, value in self.__dict__.iteritems()]
12012 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12013 
 
12014 
  def __eq__(self, other):
12015 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12016 
 
12017 
  def __ne__(self, other):
12018 
    return not (self == other)
12019 
 
12020 
class getVatRates_result:
12021 
  """
12022 
  Attributes:
12023 
   - success
12024 
   - cex
12025 
  """
12026 
 
12027 
  thrift_spec = (
12028 
    (0, TType.MAP, 'success', (TType.I64,None,TType.DOUBLE,None), None, ), # 0
12029 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12030 
  )
12031 
 
12032 
  def __init__(self, success=None, cex=None,):
12033 
    self.success = success
12034 
    self.cex = cex
12035 
 
12036 
  def read(self, iprot):
12037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12039 
      return
12040 
    iprot.readStructBegin()
12041 
    while True:
12042 
      (fname, ftype, fid) = iprot.readFieldBegin()
12043 
      if ftype == TType.STOP:
12044 
        break
12045 
      if fid == 0:
12046 
        if ftype == TType.MAP:
12047 
          self.success = {}
13493 amit.gupta 12048 
          (_ktype91, _vtype92, _size90 ) = iprot.readMapBegin()
12049 
          for _i94 in xrange(_size90):
12050 
            _key95 = iprot.readI64();
12051 
            _val96 = iprot.readDouble();
12052 
            self.success[_key95] = _val96
12567 amit.gupta 12053 
          iprot.readMapEnd()
12054 
        else:
12055 
          iprot.skip(ftype)
12056 
      elif fid == 1:
12057 
        if ftype == TType.STRUCT:
12058 
          self.cex = CatalogServiceException()
12059 
          self.cex.read(iprot)
12060 
        else:
12061 
          iprot.skip(ftype)
12062 
      else:
12063 
        iprot.skip(ftype)
12064 
      iprot.readFieldEnd()
12065 
    iprot.readStructEnd()
12066 
 
12067 
  def write(self, oprot):
12068 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12069 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12070 
      return
12071 
    oprot.writeStructBegin('getVatRates_result')
12072 
    if self.success is not None:
12073 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12074 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.success))
13493 amit.gupta 12075 
      for kiter97,viter98 in self.success.items():
12076 
        oprot.writeI64(kiter97)
12077 
        oprot.writeDouble(viter98)
12567 amit.gupta 12078 
      oprot.writeMapEnd()
12079 
      oprot.writeFieldEnd()
12080 
    if self.cex is not None:
12081 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
12082 
      self.cex.write(oprot)
12083 
      oprot.writeFieldEnd()
12084 
    oprot.writeFieldStop()
12085 
    oprot.writeStructEnd()
12086 
 
12087 
  def validate(self):
12088 
    return
12089 
 
12090 
 
12091 
  def __repr__(self):
12092 
    L = ['%s=%r' % (key, value)
12093 
      for key, value in self.__dict__.iteritems()]
12094 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12095 
 
12096 
  def __eq__(self, other):
12097 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12098 
 
12099 
  def __ne__(self, other):
12100 
    return not (self == other)
12101 
 
5944 mandeep.dh 12102 
class getAllItemsInRange_args:
12103 
  """
12104 
  Attributes:
12105 
   - offset
12106 
   - limit
12107 
  """
12108 
 
12109 
  thrift_spec = (
12110 
    None, # 0
12111 
    (1, TType.I64, 'offset', None, None, ), # 1
12112 
    (2, TType.I64, 'limit', None, None, ), # 2
12113 
  )
12114 
 
12115 
  def __init__(self, offset=None, limit=None,):
12116 
    self.offset = offset
12117 
    self.limit = limit
12118 
 
12119 
  def read(self, iprot):
12120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12122 
      return
12123 
    iprot.readStructBegin()
12124 
    while True:
12125 
      (fname, ftype, fid) = iprot.readFieldBegin()
12126 
      if ftype == TType.STOP:
12127 
        break
12128 
      if fid == 1:
12129 
        if ftype == TType.I64:
12130 
          self.offset = iprot.readI64();
12131 
        else:
12132 
          iprot.skip(ftype)
12133 
      elif fid == 2:
12134 
        if ftype == TType.I64:
12135 
          self.limit = iprot.readI64();
12136 
        else:
12137 
          iprot.skip(ftype)
12138 
      else:
12139 
        iprot.skip(ftype)
12140 
      iprot.readFieldEnd()
12141 
    iprot.readStructEnd()
12142 
 
12143 
  def write(self, oprot):
12144 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12145 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12146 
      return
12147 
    oprot.writeStructBegin('getAllItemsInRange_args')
12148 
    if self.offset is not None:
12149 
      oprot.writeFieldBegin('offset', TType.I64, 1)
12150 
      oprot.writeI64(self.offset)
12151 
      oprot.writeFieldEnd()
12152 
    if self.limit is not None:
12153 
      oprot.writeFieldBegin('limit', TType.I64, 2)
12154 
      oprot.writeI64(self.limit)
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 getAllItemsInRange_result:
12175 
  """
12176 
  Attributes:
12177 
   - success
12178 
   - cex
12179 
  """
12180 
 
12181 
  thrift_spec = (
12182 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12183 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12184 
  )
12185 
 
12186 
  def __init__(self, success=None, cex=None,):
12187 
    self.success = success
12188 
    self.cex = cex
12189 
 
12190 
  def read(self, iprot):
12191 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12192 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12193 
      return
12194 
    iprot.readStructBegin()
12195 
    while True:
12196 
      (fname, ftype, fid) = iprot.readFieldBegin()
12197 
      if ftype == TType.STOP:
12198 
        break
12199 
      if fid == 0:
12200 
        if ftype == TType.LIST:
12201 
          self.success = []
13493 amit.gupta 12202 
          (_etype102, _size99) = iprot.readListBegin()
12203 
          for _i103 in xrange(_size99):
12204 
            _elem104 = Item()
12205 
            _elem104.read(iprot)
12206 
            self.success.append(_elem104)
5944 mandeep.dh 12207 
          iprot.readListEnd()
12208 
        else:
12209 
          iprot.skip(ftype)
12210 
      elif fid == 1:
12211 
        if ftype == TType.STRUCT:
12212 
          self.cex = CatalogServiceException()
12213 
          self.cex.read(iprot)
12214 
        else:
12215 
          iprot.skip(ftype)
12216 
      else:
12217 
        iprot.skip(ftype)
12218 
      iprot.readFieldEnd()
12219 
    iprot.readStructEnd()
12220 
 
12221 
  def write(self, oprot):
12222 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12223 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12224 
      return
12225 
    oprot.writeStructBegin('getAllItemsInRange_result')
12226 
    if self.success is not None:
12227 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12228 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 12229 
      for iter105 in self.success:
12230 
        iter105.write(oprot)
5944 mandeep.dh 12231 
      oprot.writeListEnd()
12232 
      oprot.writeFieldEnd()
12233 
    if self.cex is not None:
12234 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
12235 
      self.cex.write(oprot)
12236 
      oprot.writeFieldEnd()
12237 
    oprot.writeFieldStop()
12238 
    oprot.writeStructEnd()
12239 
 
12240 
  def validate(self):
12241 
    return
12242 
 
12243 
 
12244 
  def __repr__(self):
12245 
    L = ['%s=%r' % (key, value)
12246 
      for key, value in self.__dict__.iteritems()]
12247 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12248 
 
12249 
  def __eq__(self, other):
12250 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12251 
 
12252 
  def __ne__(self, other):
12253 
    return not (self == other)
12254 
 
12255 
class getAllItemsByStatusInRange_args:
12256 
  """
12257 
  Attributes:
12258 
   - itemStatus
12259 
   - offset
12260 
   - limit
12261 
  """
12262 
 
12263 
  thrift_spec = (
12264 
    None, # 0
12265 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
12266 
    (2, TType.I64, 'offset', None, None, ), # 2
12267 
    (3, TType.I64, 'limit', None, None, ), # 3
12268 
  )
12269 
 
12270 
  def __init__(self, itemStatus=None, offset=None, limit=None,):
12271 
    self.itemStatus = itemStatus
12272 
    self.offset = offset
12273 
    self.limit = limit
12274 
 
12275 
  def read(self, iprot):
12276 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12277 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12278 
      return
12279 
    iprot.readStructBegin()
12280 
    while True:
12281 
      (fname, ftype, fid) = iprot.readFieldBegin()
12282 
      if ftype == TType.STOP:
12283 
        break
12284 
      if fid == 1:
12285 
        if ftype == TType.I32:
12286 
          self.itemStatus = iprot.readI32();
12287 
        else:
12288 
          iprot.skip(ftype)
12289 
      elif fid == 2:
12290 
        if ftype == TType.I64:
12291 
          self.offset = iprot.readI64();
12292 
        else:
12293 
          iprot.skip(ftype)
12294 
      elif fid == 3:
12295 
        if ftype == TType.I64:
12296 
          self.limit = iprot.readI64();
12297 
        else:
12298 
          iprot.skip(ftype)
12299 
      else:
12300 
        iprot.skip(ftype)
12301 
      iprot.readFieldEnd()
12302 
    iprot.readStructEnd()
12303 
 
12304 
  def write(self, oprot):
12305 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12306 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12307 
      return
12308 
    oprot.writeStructBegin('getAllItemsByStatusInRange_args')
12309 
    if self.itemStatus is not None:
12310 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
12311 
      oprot.writeI32(self.itemStatus)
12312 
      oprot.writeFieldEnd()
12313 
    if self.offset is not None:
12314 
      oprot.writeFieldBegin('offset', TType.I64, 2)
12315 
      oprot.writeI64(self.offset)
12316 
      oprot.writeFieldEnd()
12317 
    if self.limit is not None:
12318 
      oprot.writeFieldBegin('limit', TType.I64, 3)
12319 
      oprot.writeI64(self.limit)
12320 
      oprot.writeFieldEnd()
12321 
    oprot.writeFieldStop()
12322 
    oprot.writeStructEnd()
12323 
 
12324 
  def validate(self):
12325 
    return
12326 
 
12327 
 
12328 
  def __repr__(self):
12329 
    L = ['%s=%r' % (key, value)
12330 
      for key, value in self.__dict__.iteritems()]
12331 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12332 
 
12333 
  def __eq__(self, other):
12334 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12335 
 
12336 
  def __ne__(self, other):
12337 
    return not (self == other)
12338 
 
12339 
class getAllItemsByStatusInRange_result:
12340 
  """
12341 
  Attributes:
12342 
   - success
12343 
   - cex
12344 
  """
12345 
 
12346 
  thrift_spec = (
12347 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12348 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12349 
  )
12350 
 
12351 
  def __init__(self, success=None, cex=None,):
12352 
    self.success = success
12353 
    self.cex = cex
12354 
 
12355 
  def read(self, iprot):
12356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12358 
      return
12359 
    iprot.readStructBegin()
12360 
    while True:
12361 
      (fname, ftype, fid) = iprot.readFieldBegin()
12362 
      if ftype == TType.STOP:
12363 
        break
12364 
      if fid == 0:
12365 
        if ftype == TType.LIST:
12366 
          self.success = []
13493 amit.gupta 12367 
          (_etype109, _size106) = iprot.readListBegin()
12368 
          for _i110 in xrange(_size106):
12369 
            _elem111 = Item()
12370 
            _elem111.read(iprot)
12371 
            self.success.append(_elem111)
5944 mandeep.dh 12372 
          iprot.readListEnd()
12373 
        else:
12374 
          iprot.skip(ftype)
12375 
      elif fid == 1:
12376 
        if ftype == TType.STRUCT:
12377 
          self.cex = CatalogServiceException()
12378 
          self.cex.read(iprot)
12379 
        else:
12380 
          iprot.skip(ftype)
12381 
      else:
12382 
        iprot.skip(ftype)
12383 
      iprot.readFieldEnd()
12384 
    iprot.readStructEnd()
12385 
 
12386 
  def write(self, oprot):
12387 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12388 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12389 
      return
12390 
    oprot.writeStructBegin('getAllItemsByStatusInRange_result')
12391 
    if self.success is not None:
12392 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12393 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 12394 
      for iter112 in self.success:
12395 
        iter112.write(oprot)
5944 mandeep.dh 12396 
      oprot.writeListEnd()
12397 
      oprot.writeFieldEnd()
12398 
    if self.cex is not None:
12399 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
12400 
      self.cex.write(oprot)
12401 
      oprot.writeFieldEnd()
12402 
    oprot.writeFieldStop()
12403 
    oprot.writeStructEnd()
12404 
 
12405 
  def validate(self):
12406 
    return
12407 
 
12408 
 
12409 
  def __repr__(self):
12410 
    L = ['%s=%r' % (key, value)
12411 
      for key, value in self.__dict__.iteritems()]
12412 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12413 
 
12414 
  def __eq__(self, other):
12415 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12416 
 
12417 
  def __ne__(self, other):
12418 
    return not (self == other)
12419 
 
12420 
class getItemCountByStatus_args:
12421 
  """
12422 
  Attributes:
12423 
   - useStatus
12424 
   - itemStatus
12425 
  """
12426 
 
12427 
  thrift_spec = (
12428 
    None, # 0
12429 
    (1, TType.BOOL, 'useStatus', None, None, ), # 1
12430 
    (2, TType.I32, 'itemStatus', None, None, ), # 2
12431 
  )
12432 
 
12433 
  def __init__(self, useStatus=None, itemStatus=None,):
12434 
    self.useStatus = useStatus
12435 
    self.itemStatus = itemStatus
12436 
 
12437 
  def read(self, iprot):
12438 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12439 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12440 
      return
12441 
    iprot.readStructBegin()
12442 
    while True:
12443 
      (fname, ftype, fid) = iprot.readFieldBegin()
12444 
      if ftype == TType.STOP:
12445 
        break
12446 
      if fid == 1:
12447 
        if ftype == TType.BOOL:
12448 
          self.useStatus = iprot.readBool();
12449 
        else:
12450 
          iprot.skip(ftype)
12451 
      elif fid == 2:
12452 
        if ftype == TType.I32:
12453 
          self.itemStatus = iprot.readI32();
12454 
        else:
12455 
          iprot.skip(ftype)
12456 
      else:
12457 
        iprot.skip(ftype)
12458 
      iprot.readFieldEnd()
12459 
    iprot.readStructEnd()
12460 
 
12461 
  def write(self, oprot):
12462 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12463 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12464 
      return
12465 
    oprot.writeStructBegin('getItemCountByStatus_args')
12466 
    if self.useStatus is not None:
12467 
      oprot.writeFieldBegin('useStatus', TType.BOOL, 1)
12468 
      oprot.writeBool(self.useStatus)
12469 
      oprot.writeFieldEnd()
12470 
    if self.itemStatus is not None:
12471 
      oprot.writeFieldBegin('itemStatus', TType.I32, 2)
12472 
      oprot.writeI32(self.itemStatus)
12473 
      oprot.writeFieldEnd()
12474 
    oprot.writeFieldStop()
12475 
    oprot.writeStructEnd()
12476 
 
12477 
  def validate(self):
12478 
    return
12479 
 
12480 
 
12481 
  def __repr__(self):
12482 
    L = ['%s=%r' % (key, value)
12483 
      for key, value in self.__dict__.iteritems()]
12484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12485 
 
12486 
  def __eq__(self, other):
12487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12488 
 
12489 
  def __ne__(self, other):
12490 
    return not (self == other)
12491 
 
12492 
class getItemCountByStatus_result:
12493 
  """
12494 
  Attributes:
12495 
   - success
12496 
  """
12497 
 
12498 
  thrift_spec = (
12499 
    (0, TType.I32, 'success', None, None, ), # 0
12500 
  )
12501 
 
12502 
  def __init__(self, success=None,):
12503 
    self.success = success
12504 
 
12505 
  def read(self, iprot):
12506 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12507 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12508 
      return
12509 
    iprot.readStructBegin()
12510 
    while True:
12511 
      (fname, ftype, fid) = iprot.readFieldBegin()
12512 
      if ftype == TType.STOP:
12513 
        break
12514 
      if fid == 0:
12515 
        if ftype == TType.I32:
12516 
          self.success = iprot.readI32();
12517 
        else:
12518 
          iprot.skip(ftype)
12519 
      else:
12520 
        iprot.skip(ftype)
12521 
      iprot.readFieldEnd()
12522 
    iprot.readStructEnd()
12523 
 
12524 
  def write(self, oprot):
12525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12527 
      return
12528 
    oprot.writeStructBegin('getItemCountByStatus_result')
12529 
    if self.success is not None:
12530 
      oprot.writeFieldBegin('success', TType.I32, 0)
12531 
      oprot.writeI32(self.success)
12532 
      oprot.writeFieldEnd()
12533 
    oprot.writeFieldStop()
12534 
    oprot.writeStructEnd()
12535 
 
12536 
  def validate(self):
12537 
    return
12538 
 
12539 
 
12540 
  def __repr__(self):
12541 
    L = ['%s=%r' % (key, value)
12542 
      for key, value in self.__dict__.iteritems()]
12543 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12544 
 
12545 
  def __eq__(self, other):
12546 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12547 
 
12548 
  def __ne__(self, other):
12549 
    return not (self == other)
12550 
 
12551 
class getBestSellers_args:
12552 
 
12553 
  thrift_spec = (
12554 
  )
12555 
 
12556 
  def read(self, iprot):
12557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12559 
      return
12560 
    iprot.readStructBegin()
12561 
    while True:
12562 
      (fname, ftype, fid) = iprot.readFieldBegin()
12563 
      if ftype == TType.STOP:
12564 
        break
12565 
      else:
12566 
        iprot.skip(ftype)
12567 
      iprot.readFieldEnd()
12568 
    iprot.readStructEnd()
12569 
 
12570 
  def write(self, oprot):
12571 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12572 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12573 
      return
12574 
    oprot.writeStructBegin('getBestSellers_args')
12575 
    oprot.writeFieldStop()
12576 
    oprot.writeStructEnd()
12577 
 
12578 
  def validate(self):
12579 
    return
12580 
 
12581 
 
12582 
  def __repr__(self):
12583 
    L = ['%s=%r' % (key, value)
12584 
      for key, value in self.__dict__.iteritems()]
12585 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12586 
 
12587 
  def __eq__(self, other):
12588 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12589 
 
12590 
  def __ne__(self, other):
12591 
    return not (self == other)
12592 
 
12593 
class getBestSellers_result:
12594 
  """
12595 
  Attributes:
12596 
   - success
12597 
   - isex
12598 
  """
12599 
 
12600 
  thrift_spec = (
12601 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12602 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12603 
  )
12604 
 
12605 
  def __init__(self, success=None, isex=None,):
12606 
    self.success = success
12607 
    self.isex = isex
12608 
 
12609 
  def read(self, iprot):
12610 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12611 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12612 
      return
12613 
    iprot.readStructBegin()
12614 
    while True:
12615 
      (fname, ftype, fid) = iprot.readFieldBegin()
12616 
      if ftype == TType.STOP:
12617 
        break
12618 
      if fid == 0:
12619 
        if ftype == TType.LIST:
12620 
          self.success = []
13493 amit.gupta 12621 
          (_etype116, _size113) = iprot.readListBegin()
12622 
          for _i117 in xrange(_size113):
12623 
            _elem118 = Item()
12624 
            _elem118.read(iprot)
12625 
            self.success.append(_elem118)
5944 mandeep.dh 12626 
          iprot.readListEnd()
12627 
        else:
12628 
          iprot.skip(ftype)
12629 
      elif fid == 1:
12630 
        if ftype == TType.STRUCT:
12631 
          self.isex = CatalogServiceException()
12632 
          self.isex.read(iprot)
12633 
        else:
12634 
          iprot.skip(ftype)
12635 
      else:
12636 
        iprot.skip(ftype)
12637 
      iprot.readFieldEnd()
12638 
    iprot.readStructEnd()
12639 
 
12640 
  def write(self, oprot):
12641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12643 
      return
12644 
    oprot.writeStructBegin('getBestSellers_result')
12645 
    if self.success is not None:
12646 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12647 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 12648 
      for iter119 in self.success:
12649 
        iter119.write(oprot)
5944 mandeep.dh 12650 
      oprot.writeListEnd()
12651 
      oprot.writeFieldEnd()
12652 
    if self.isex is not None:
12653 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
12654 
      self.isex.write(oprot)
12655 
      oprot.writeFieldEnd()
12656 
    oprot.writeFieldStop()
12657 
    oprot.writeStructEnd()
12658 
 
12659 
  def validate(self):
12660 
    return
12661 
 
12662 
 
12663 
  def __repr__(self):
12664 
    L = ['%s=%r' % (key, value)
12665 
      for key, value in self.__dict__.iteritems()]
12666 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12667 
 
12668 
  def __eq__(self, other):
12669 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12670 
 
12671 
  def __ne__(self, other):
12672 
    return not (self == other)
12673 
 
12674 
class getBestSellersCatalogIds_args:
12675 
  """
12676 
  Attributes:
12677 
   - beginIndex
12678 
   - totalItems
12679 
   - brand
12680 
   - category
12681 
  """
12682 
 
12683 
  thrift_spec = (
12684 
    None, # 0
12685 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
12686 
    (2, TType.I64, 'totalItems', None, None, ), # 2
12687 
    (3, TType.STRING, 'brand', None, None, ), # 3
12688 
    (4, TType.I64, 'category', None, None, ), # 4
12689 
  )
12690 
 
12691 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
12692 
    self.beginIndex = beginIndex
12693 
    self.totalItems = totalItems
12694 
    self.brand = brand
12695 
    self.category = category
12696 
 
12697 
  def read(self, iprot):
12698 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12699 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12700 
      return
12701 
    iprot.readStructBegin()
12702 
    while True:
12703 
      (fname, ftype, fid) = iprot.readFieldBegin()
12704 
      if ftype == TType.STOP:
12705 
        break
12706 
      if fid == 1:
12707 
        if ftype == TType.I64:
12708 
          self.beginIndex = iprot.readI64();
12709 
        else:
12710 
          iprot.skip(ftype)
12711 
      elif fid == 2:
12712 
        if ftype == TType.I64:
12713 
          self.totalItems = iprot.readI64();
12714 
        else:
12715 
          iprot.skip(ftype)
12716 
      elif fid == 3:
12717 
        if ftype == TType.STRING:
12718 
          self.brand = iprot.readString();
12719 
        else:
12720 
          iprot.skip(ftype)
12721 
      elif fid == 4:
12722 
        if ftype == TType.I64:
12723 
          self.category = iprot.readI64();
12724 
        else:
12725 
          iprot.skip(ftype)
12726 
      else:
12727 
        iprot.skip(ftype)
12728 
      iprot.readFieldEnd()
12729 
    iprot.readStructEnd()
12730 
 
12731 
  def write(self, oprot):
12732 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12733 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12734 
      return
12735 
    oprot.writeStructBegin('getBestSellersCatalogIds_args')
12736 
    if self.beginIndex is not None:
12737 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
12738 
      oprot.writeI64(self.beginIndex)
12739 
      oprot.writeFieldEnd()
12740 
    if self.totalItems is not None:
12741 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
12742 
      oprot.writeI64(self.totalItems)
12743 
      oprot.writeFieldEnd()
12744 
    if self.brand is not None:
12745 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
12746 
      oprot.writeString(self.brand)
12747 
      oprot.writeFieldEnd()
12748 
    if self.category is not None:
12749 
      oprot.writeFieldBegin('category', TType.I64, 4)
12750 
      oprot.writeI64(self.category)
12751 
      oprot.writeFieldEnd()
12752 
    oprot.writeFieldStop()
12753 
    oprot.writeStructEnd()
12754 
 
12755 
  def validate(self):
12756 
    return
12757 
 
12758 
 
12759 
  def __repr__(self):
12760 
    L = ['%s=%r' % (key, value)
12761 
      for key, value in self.__dict__.iteritems()]
12762 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12763 
 
12764 
  def __eq__(self, other):
12765 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12766 
 
12767 
  def __ne__(self, other):
12768 
    return not (self == other)
12769 
 
12770 
class getBestSellersCatalogIds_result:
12771 
  """
12772 
  Attributes:
12773 
   - success
12774 
   - cex
12775 
  """
12776 
 
12777 
  thrift_spec = (
12778 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12779 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12780 
  )
12781 
 
12782 
  def __init__(self, success=None, cex=None,):
12783 
    self.success = success
12784 
    self.cex = cex
12785 
 
12786 
  def read(self, iprot):
12787 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12788 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12789 
      return
12790 
    iprot.readStructBegin()
12791 
    while True:
12792 
      (fname, ftype, fid) = iprot.readFieldBegin()
12793 
      if ftype == TType.STOP:
12794 
        break
12795 
      if fid == 0:
12796 
        if ftype == TType.LIST:
12797 
          self.success = []
13493 amit.gupta 12798 
          (_etype123, _size120) = iprot.readListBegin()
12799 
          for _i124 in xrange(_size120):
12800 
            _elem125 = iprot.readI64();
12801 
            self.success.append(_elem125)
5944 mandeep.dh 12802 
          iprot.readListEnd()
12803 
        else:
12804 
          iprot.skip(ftype)
12805 
      elif fid == 1:
12806 
        if ftype == TType.STRUCT:
12807 
          self.cex = CatalogServiceException()
12808 
          self.cex.read(iprot)
12809 
        else:
12810 
          iprot.skip(ftype)
12811 
      else:
12812 
        iprot.skip(ftype)
12813 
      iprot.readFieldEnd()
12814 
    iprot.readStructEnd()
12815 
 
12816 
  def write(self, oprot):
12817 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12818 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12819 
      return
12820 
    oprot.writeStructBegin('getBestSellersCatalogIds_result')
12821 
    if self.success is not None:
12822 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12823 
      oprot.writeListBegin(TType.I64, len(self.success))
13493 amit.gupta 12824 
      for iter126 in self.success:
12825 
        oprot.writeI64(iter126)
5944 mandeep.dh 12826 
      oprot.writeListEnd()
12827 
      oprot.writeFieldEnd()
12828 
    if self.cex is not None:
12829 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
12830 
      self.cex.write(oprot)
12831 
      oprot.writeFieldEnd()
12832 
    oprot.writeFieldStop()
12833 
    oprot.writeStructEnd()
12834 
 
12835 
  def validate(self):
12836 
    return
12837 
 
12838 
 
12839 
  def __repr__(self):
12840 
    L = ['%s=%r' % (key, value)
12841 
      for key, value in self.__dict__.iteritems()]
12842 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12843 
 
12844 
  def __eq__(self, other):
12845 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12846 
 
12847 
  def __ne__(self, other):
12848 
    return not (self == other)
12849 
 
12850 
class getBestSellersCount_args:
12851 
 
12852 
  thrift_spec = (
12853 
  )
12854 
 
12855 
  def read(self, iprot):
12856 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12857 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12858 
      return
12859 
    iprot.readStructBegin()
12860 
    while True:
12861 
      (fname, ftype, fid) = iprot.readFieldBegin()
12862 
      if ftype == TType.STOP:
12863 
        break
12864 
      else:
12865 
        iprot.skip(ftype)
12866 
      iprot.readFieldEnd()
12867 
    iprot.readStructEnd()
12868 
 
12869 
  def write(self, oprot):
12870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12872 
      return
12873 
    oprot.writeStructBegin('getBestSellersCount_args')
12874 
    oprot.writeFieldStop()
12875 
    oprot.writeStructEnd()
12876 
 
12877 
  def validate(self):
12878 
    return
12879 
 
12880 
 
12881 
  def __repr__(self):
12882 
    L = ['%s=%r' % (key, value)
12883 
      for key, value in self.__dict__.iteritems()]
12884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12885 
 
12886 
  def __eq__(self, other):
12887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12888 
 
12889 
  def __ne__(self, other):
12890 
    return not (self == other)
12891 
 
12892 
class getBestSellersCount_result:
12893 
  """
12894 
  Attributes:
12895 
   - success
12896 
   - cex
12897 
  """
12898 
 
12899 
  thrift_spec = (
12900 
    (0, TType.I64, 'success', None, None, ), # 0
12901 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12902 
  )
12903 
 
12904 
  def __init__(self, success=None, cex=None,):
12905 
    self.success = success
12906 
    self.cex = cex
12907 
 
12908 
  def read(self, iprot):
12909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12911 
      return
12912 
    iprot.readStructBegin()
12913 
    while True:
12914 
      (fname, ftype, fid) = iprot.readFieldBegin()
12915 
      if ftype == TType.STOP:
12916 
        break
12917 
      if fid == 0:
12918 
        if ftype == TType.I64:
12919 
          self.success = iprot.readI64();
12920 
        else:
12921 
          iprot.skip(ftype)
12922 
      elif fid == 1:
12923 
        if ftype == TType.STRUCT:
12924 
          self.cex = CatalogServiceException()
12925 
          self.cex.read(iprot)
12926 
        else:
12927 
          iprot.skip(ftype)
12928 
      else:
12929 
        iprot.skip(ftype)
12930 
      iprot.readFieldEnd()
12931 
    iprot.readStructEnd()
12932 
 
12933 
  def write(self, oprot):
12934 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12935 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12936 
      return
12937 
    oprot.writeStructBegin('getBestSellersCount_result')
12938 
    if self.success is not None:
12939 
      oprot.writeFieldBegin('success', TType.I64, 0)
12940 
      oprot.writeI64(self.success)
12941 
      oprot.writeFieldEnd()
12942 
    if self.cex is not None:
12943 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
12944 
      self.cex.write(oprot)
12945 
      oprot.writeFieldEnd()
12946 
    oprot.writeFieldStop()
12947 
    oprot.writeStructEnd()
12948 
 
12949 
  def validate(self):
12950 
    return
12951 
 
12952 
 
12953 
  def __repr__(self):
12954 
    L = ['%s=%r' % (key, value)
12955 
      for key, value in self.__dict__.iteritems()]
12956 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12957 
 
12958 
  def __eq__(self, other):
12959 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12960 
 
12961 
  def __ne__(self, other):
12962 
    return not (self == other)
12963 
 
12964 
class getBestDeals_args:
12965 
 
12966 
  thrift_spec = (
12967 
  )
12968 
 
12969 
  def read(self, iprot):
12970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12972 
      return
12973 
    iprot.readStructBegin()
12974 
    while True:
12975 
      (fname, ftype, fid) = iprot.readFieldBegin()
12976 
      if ftype == TType.STOP:
12977 
        break
12978 
      else:
12979 
        iprot.skip(ftype)
12980 
      iprot.readFieldEnd()
12981 
    iprot.readStructEnd()
12982 
 
12983 
  def write(self, oprot):
12984 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12985 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12986 
      return
12987 
    oprot.writeStructBegin('getBestDeals_args')
12988 
    oprot.writeFieldStop()
12989 
    oprot.writeStructEnd()
12990 
 
12991 
  def validate(self):
12992 
    return
12993 
 
12994 
 
12995 
  def __repr__(self):
12996 
    L = ['%s=%r' % (key, value)
12997 
      for key, value in self.__dict__.iteritems()]
12998 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12999 
 
13000 
  def __eq__(self, other):
13001 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13002 
 
13003 
  def __ne__(self, other):
13004 
    return not (self == other)
13005 
 
13006 
class getBestDeals_result:
13007 
  """
13008 
  Attributes:
13009 
   - success
13010 
   - isex
13011 
  """
13012 
 
13013 
  thrift_spec = (
13014 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
13015 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13016 
  )
13017 
 
13018 
  def __init__(self, success=None, isex=None,):
13019 
    self.success = success
13020 
    self.isex = isex
13021 
 
13022 
  def read(self, iprot):
13023 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13024 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13025 
      return
13026 
    iprot.readStructBegin()
13027 
    while True:
13028 
      (fname, ftype, fid) = iprot.readFieldBegin()
13029 
      if ftype == TType.STOP:
13030 
        break
13031 
      if fid == 0:
13032 
        if ftype == TType.LIST:
13033 
          self.success = []
13493 amit.gupta 13034 
          (_etype130, _size127) = iprot.readListBegin()
13035 
          for _i131 in xrange(_size127):
13036 
            _elem132 = Item()
13037 
            _elem132.read(iprot)
13038 
            self.success.append(_elem132)
5944 mandeep.dh 13039 
          iprot.readListEnd()
13040 
        else:
13041 
          iprot.skip(ftype)
13042 
      elif fid == 1:
13043 
        if ftype == TType.STRUCT:
13044 
          self.isex = CatalogServiceException()
13045 
          self.isex.read(iprot)
13046 
        else:
13047 
          iprot.skip(ftype)
13048 
      else:
13049 
        iprot.skip(ftype)
13050 
      iprot.readFieldEnd()
13051 
    iprot.readStructEnd()
13052 
 
13053 
  def write(self, oprot):
13054 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13055 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13056 
      return
13057 
    oprot.writeStructBegin('getBestDeals_result')
13058 
    if self.success is not None:
13059 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13060 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 13061 
      for iter133 in self.success:
13062 
        iter133.write(oprot)
5944 mandeep.dh 13063 
      oprot.writeListEnd()
13064 
      oprot.writeFieldEnd()
13065 
    if self.isex is not None:
13066 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
13067 
      self.isex.write(oprot)
13068 
      oprot.writeFieldEnd()
13069 
    oprot.writeFieldStop()
13070 
    oprot.writeStructEnd()
13071 
 
13072 
  def validate(self):
13073 
    return
13074 
 
13075 
 
13076 
  def __repr__(self):
13077 
    L = ['%s=%r' % (key, value)
13078 
      for key, value in self.__dict__.iteritems()]
13079 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13080 
 
13081 
  def __eq__(self, other):
13082 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13083 
 
13084 
  def __ne__(self, other):
13085 
    return not (self == other)
13086 
 
13087 
class getBestDealsCatalogIds_args:
13088 
  """
13089 
  Attributes:
13090 
   - beginIndex
13091 
   - totalItems
13092 
   - brand
13093 
   - category
13094 
  """
13095 
 
13096 
  thrift_spec = (
13097 
    None, # 0
13098 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
13099 
    (2, TType.I64, 'totalItems', None, None, ), # 2
13100 
    (3, TType.STRING, 'brand', None, None, ), # 3
13101 
    (4, TType.I64, 'category', None, None, ), # 4
13102 
  )
13103 
 
13104 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
13105 
    self.beginIndex = beginIndex
13106 
    self.totalItems = totalItems
13107 
    self.brand = brand
13108 
    self.category = category
13109 
 
13110 
  def read(self, iprot):
13111 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13112 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13113 
      return
13114 
    iprot.readStructBegin()
13115 
    while True:
13116 
      (fname, ftype, fid) = iprot.readFieldBegin()
13117 
      if ftype == TType.STOP:
13118 
        break
13119 
      if fid == 1:
13120 
        if ftype == TType.I64:
13121 
          self.beginIndex = iprot.readI64();
13122 
        else:
13123 
          iprot.skip(ftype)
13124 
      elif fid == 2:
13125 
        if ftype == TType.I64:
13126 
          self.totalItems = iprot.readI64();
13127 
        else:
13128 
          iprot.skip(ftype)
13129 
      elif fid == 3:
13130 
        if ftype == TType.STRING:
13131 
          self.brand = iprot.readString();
13132 
        else:
13133 
          iprot.skip(ftype)
13134 
      elif fid == 4:
13135 
        if ftype == TType.I64:
13136 
          self.category = iprot.readI64();
13137 
        else:
13138 
          iprot.skip(ftype)
13139 
      else:
13140 
        iprot.skip(ftype)
13141 
      iprot.readFieldEnd()
13142 
    iprot.readStructEnd()
13143 
 
13144 
  def write(self, oprot):
13145 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13146 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13147 
      return
13148 
    oprot.writeStructBegin('getBestDealsCatalogIds_args')
13149 
    if self.beginIndex is not None:
13150 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
13151 
      oprot.writeI64(self.beginIndex)
13152 
      oprot.writeFieldEnd()
13153 
    if self.totalItems is not None:
13154 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
13155 
      oprot.writeI64(self.totalItems)
13156 
      oprot.writeFieldEnd()
13157 
    if self.brand is not None:
13158 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
13159 
      oprot.writeString(self.brand)
13160 
      oprot.writeFieldEnd()
13161 
    if self.category is not None:
13162 
      oprot.writeFieldBegin('category', TType.I64, 4)
13163 
      oprot.writeI64(self.category)
13164 
      oprot.writeFieldEnd()
13165 
    oprot.writeFieldStop()
13166 
    oprot.writeStructEnd()
13167 
 
13168 
  def validate(self):
13169 
    return
13170 
 
13171 
 
13172 
  def __repr__(self):
13173 
    L = ['%s=%r' % (key, value)
13174 
      for key, value in self.__dict__.iteritems()]
13175 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13176 
 
13177 
  def __eq__(self, other):
13178 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13179 
 
13180 
  def __ne__(self, other):
13181 
    return not (self == other)
13182 
 
13183 
class getBestDealsCatalogIds_result:
13184 
  """
13185 
  Attributes:
13186 
   - success
13187 
   - cex
13188 
  """
13189 
 
13190 
  thrift_spec = (
13191 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
13192 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13193 
  )
13194 
 
13195 
  def __init__(self, success=None, cex=None,):
13196 
    self.success = success
13197 
    self.cex = cex
13198 
 
13199 
  def read(self, iprot):
13200 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13201 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13202 
      return
13203 
    iprot.readStructBegin()
13204 
    while True:
13205 
      (fname, ftype, fid) = iprot.readFieldBegin()
13206 
      if ftype == TType.STOP:
13207 
        break
13208 
      if fid == 0:
13209 
        if ftype == TType.LIST:
13210 
          self.success = []
13493 amit.gupta 13211 
          (_etype137, _size134) = iprot.readListBegin()
13212 
          for _i138 in xrange(_size134):
13213 
            _elem139 = iprot.readI64();
13214 
            self.success.append(_elem139)
5944 mandeep.dh 13215 
          iprot.readListEnd()
13216 
        else:
13217 
          iprot.skip(ftype)
13218 
      elif fid == 1:
13219 
        if ftype == TType.STRUCT:
13220 
          self.cex = CatalogServiceException()
13221 
          self.cex.read(iprot)
13222 
        else:
13223 
          iprot.skip(ftype)
13224 
      else:
13225 
        iprot.skip(ftype)
13226 
      iprot.readFieldEnd()
13227 
    iprot.readStructEnd()
13228 
 
13229 
  def write(self, oprot):
13230 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13231 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13232 
      return
13233 
    oprot.writeStructBegin('getBestDealsCatalogIds_result')
13234 
    if self.success is not None:
13235 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13236 
      oprot.writeListBegin(TType.I64, len(self.success))
13493 amit.gupta 13237 
      for iter140 in self.success:
13238 
        oprot.writeI64(iter140)
5944 mandeep.dh 13239 
      oprot.writeListEnd()
13240 
      oprot.writeFieldEnd()
13241 
    if self.cex is not None:
13242 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13243 
      self.cex.write(oprot)
13244 
      oprot.writeFieldEnd()
13245 
    oprot.writeFieldStop()
13246 
    oprot.writeStructEnd()
13247 
 
13248 
  def validate(self):
13249 
    return
13250 
 
13251 
 
13252 
  def __repr__(self):
13253 
    L = ['%s=%r' % (key, value)
13254 
      for key, value in self.__dict__.iteritems()]
13255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13256 
 
13257 
  def __eq__(self, other):
13258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13259 
 
13260 
  def __ne__(self, other):
13261 
    return not (self == other)
13262 
 
13263 
class getBestDealsCount_args:
13264 
 
13265 
  thrift_spec = (
13266 
  )
13267 
 
13268 
  def read(self, iprot):
13269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13271 
      return
13272 
    iprot.readStructBegin()
13273 
    while True:
13274 
      (fname, ftype, fid) = iprot.readFieldBegin()
13275 
      if ftype == TType.STOP:
13276 
        break
13277 
      else:
13278 
        iprot.skip(ftype)
13279 
      iprot.readFieldEnd()
13280 
    iprot.readStructEnd()
13281 
 
13282 
  def write(self, oprot):
13283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13285 
      return
13286 
    oprot.writeStructBegin('getBestDealsCount_args')
13287 
    oprot.writeFieldStop()
13288 
    oprot.writeStructEnd()
13289 
 
13290 
  def validate(self):
13291 
    return
13292 
 
13293 
 
13294 
  def __repr__(self):
13295 
    L = ['%s=%r' % (key, value)
13296 
      for key, value in self.__dict__.iteritems()]
13297 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13298 
 
13299 
  def __eq__(self, other):
13300 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13301 
 
13302 
  def __ne__(self, other):
13303 
    return not (self == other)
13304 
 
13305 
class getBestDealsCount_result:
13306 
  """
13307 
  Attributes:
13308 
   - success
13309 
   - cex
13310 
  """
13311 
 
13312 
  thrift_spec = (
13313 
    (0, TType.I64, 'success', None, None, ), # 0
13314 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13315 
  )
13316 
 
13317 
  def __init__(self, success=None, cex=None,):
13318 
    self.success = success
13319 
    self.cex = cex
13320 
 
13321 
  def read(self, iprot):
13322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13324 
      return
13325 
    iprot.readStructBegin()
13326 
    while True:
13327 
      (fname, ftype, fid) = iprot.readFieldBegin()
13328 
      if ftype == TType.STOP:
13329 
        break
13330 
      if fid == 0:
13331 
        if ftype == TType.I64:
13332 
          self.success = iprot.readI64();
13333 
        else:
13334 
          iprot.skip(ftype)
13335 
      elif fid == 1:
13336 
        if ftype == TType.STRUCT:
13337 
          self.cex = CatalogServiceException()
13338 
          self.cex.read(iprot)
13339 
        else:
13340 
          iprot.skip(ftype)
13341 
      else:
13342 
        iprot.skip(ftype)
13343 
      iprot.readFieldEnd()
13344 
    iprot.readStructEnd()
13345 
 
13346 
  def write(self, oprot):
13347 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13348 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13349 
      return
13350 
    oprot.writeStructBegin('getBestDealsCount_result')
13351 
    if self.success is not None:
13352 
      oprot.writeFieldBegin('success', TType.I64, 0)
13353 
      oprot.writeI64(self.success)
13354 
      oprot.writeFieldEnd()
13355 
    if self.cex is not None:
13356 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13357 
      self.cex.write(oprot)
13358 
      oprot.writeFieldEnd()
13359 
    oprot.writeFieldStop()
13360 
    oprot.writeStructEnd()
13361 
 
13362 
  def validate(self):
13363 
    return
13364 
 
13365 
 
13366 
  def __repr__(self):
13367 
    L = ['%s=%r' % (key, value)
13368 
      for key, value in self.__dict__.iteritems()]
13369 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13370 
 
13371 
  def __eq__(self, other):
13372 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13373 
 
13374 
  def __ne__(self, other):
13375 
    return not (self == other)
13376 
 
13377 
class getComingSoon_args:
13378 
 
13379 
  thrift_spec = (
13380 
  )
13381 
 
13382 
  def read(self, iprot):
13383 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13384 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13385 
      return
13386 
    iprot.readStructBegin()
13387 
    while True:
13388 
      (fname, ftype, fid) = iprot.readFieldBegin()
13389 
      if ftype == TType.STOP:
13390 
        break
13391 
      else:
13392 
        iprot.skip(ftype)
13393 
      iprot.readFieldEnd()
13394 
    iprot.readStructEnd()
13395 
 
13396 
  def write(self, oprot):
13397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13399 
      return
13400 
    oprot.writeStructBegin('getComingSoon_args')
13401 
    oprot.writeFieldStop()
13402 
    oprot.writeStructEnd()
13403 
 
13404 
  def validate(self):
13405 
    return
13406 
 
13407 
 
13408 
  def __repr__(self):
13409 
    L = ['%s=%r' % (key, value)
13410 
      for key, value in self.__dict__.iteritems()]
13411 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13412 
 
13413 
  def __eq__(self, other):
13414 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13415 
 
13416 
  def __ne__(self, other):
13417 
    return not (self == other)
13418 
 
13419 
class getComingSoon_result:
13420 
  """
13421 
  Attributes:
13422 
   - success
13423 
   - isex
13424 
  """
13425 
 
13426 
  thrift_spec = (
13427 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
13428 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13429 
  )
13430 
 
13431 
  def __init__(self, success=None, isex=None,):
13432 
    self.success = success
13433 
    self.isex = isex
13434 
 
13435 
  def read(self, iprot):
13436 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13437 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13438 
      return
13439 
    iprot.readStructBegin()
13440 
    while True:
13441 
      (fname, ftype, fid) = iprot.readFieldBegin()
13442 
      if ftype == TType.STOP:
13443 
        break
13444 
      if fid == 0:
13445 
        if ftype == TType.LIST:
13446 
          self.success = []
13493 amit.gupta 13447 
          (_etype144, _size141) = iprot.readListBegin()
13448 
          for _i145 in xrange(_size141):
13449 
            _elem146 = Item()
13450 
            _elem146.read(iprot)
13451 
            self.success.append(_elem146)
5944 mandeep.dh 13452 
          iprot.readListEnd()
13453 
        else:
13454 
          iprot.skip(ftype)
13455 
      elif fid == 1:
13456 
        if ftype == TType.STRUCT:
13457 
          self.isex = CatalogServiceException()
13458 
          self.isex.read(iprot)
13459 
        else:
13460 
          iprot.skip(ftype)
13461 
      else:
13462 
        iprot.skip(ftype)
13463 
      iprot.readFieldEnd()
13464 
    iprot.readStructEnd()
13465 
 
13466 
  def write(self, oprot):
13467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13469 
      return
13470 
    oprot.writeStructBegin('getComingSoon_result')
13471 
    if self.success is not None:
13472 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13473 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 13474 
      for iter147 in self.success:
13475 
        iter147.write(oprot)
5944 mandeep.dh 13476 
      oprot.writeListEnd()
13477 
      oprot.writeFieldEnd()
13478 
    if self.isex is not None:
13479 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
13480 
      self.isex.write(oprot)
13481 
      oprot.writeFieldEnd()
13482 
    oprot.writeFieldStop()
13483 
    oprot.writeStructEnd()
13484 
 
13485 
  def validate(self):
13486 
    return
13487 
 
13488 
 
13489 
  def __repr__(self):
13490 
    L = ['%s=%r' % (key, value)
13491 
      for key, value in self.__dict__.iteritems()]
13492 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13493 
 
13494 
  def __eq__(self, other):
13495 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13496 
 
13497 
  def __ne__(self, other):
13498 
    return not (self == other)
13499 
 
13500 
class getComingSoonCatalogIds_args:
13501 
  """
13502 
  Attributes:
13503 
   - beginIndex
13504 
   - totalItems
13505 
   - brand
13506 
   - category
13507 
  """
13508 
 
13509 
  thrift_spec = (
13510 
    None, # 0
13511 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
13512 
    (2, TType.I64, 'totalItems', None, None, ), # 2
13513 
    (3, TType.STRING, 'brand', None, None, ), # 3
13514 
    (4, TType.I64, 'category', None, None, ), # 4
13515 
  )
13516 
 
13517 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
13518 
    self.beginIndex = beginIndex
13519 
    self.totalItems = totalItems
13520 
    self.brand = brand
13521 
    self.category = category
13522 
 
13523 
  def read(self, iprot):
13524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13526 
      return
13527 
    iprot.readStructBegin()
13528 
    while True:
13529 
      (fname, ftype, fid) = iprot.readFieldBegin()
13530 
      if ftype == TType.STOP:
13531 
        break
13532 
      if fid == 1:
13533 
        if ftype == TType.I64:
13534 
          self.beginIndex = iprot.readI64();
13535 
        else:
13536 
          iprot.skip(ftype)
13537 
      elif fid == 2:
13538 
        if ftype == TType.I64:
13539 
          self.totalItems = iprot.readI64();
13540 
        else:
13541 
          iprot.skip(ftype)
13542 
      elif fid == 3:
13543 
        if ftype == TType.STRING:
13544 
          self.brand = iprot.readString();
13545 
        else:
13546 
          iprot.skip(ftype)
13547 
      elif fid == 4:
13548 
        if ftype == TType.I64:
13549 
          self.category = iprot.readI64();
13550 
        else:
13551 
          iprot.skip(ftype)
13552 
      else:
13553 
        iprot.skip(ftype)
13554 
      iprot.readFieldEnd()
13555 
    iprot.readStructEnd()
13556 
 
13557 
  def write(self, oprot):
13558 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13559 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13560 
      return
13561 
    oprot.writeStructBegin('getComingSoonCatalogIds_args')
13562 
    if self.beginIndex is not None:
13563 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
13564 
      oprot.writeI64(self.beginIndex)
13565 
      oprot.writeFieldEnd()
13566 
    if self.totalItems is not None:
13567 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
13568 
      oprot.writeI64(self.totalItems)
13569 
      oprot.writeFieldEnd()
13570 
    if self.brand is not None:
13571 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
13572 
      oprot.writeString(self.brand)
13573 
      oprot.writeFieldEnd()
13574 
    if self.category is not None:
13575 
      oprot.writeFieldBegin('category', TType.I64, 4)
13576 
      oprot.writeI64(self.category)
13577 
      oprot.writeFieldEnd()
13578 
    oprot.writeFieldStop()
13579 
    oprot.writeStructEnd()
13580 
 
13581 
  def validate(self):
13582 
    return
13583 
 
13584 
 
13585 
  def __repr__(self):
13586 
    L = ['%s=%r' % (key, value)
13587 
      for key, value in self.__dict__.iteritems()]
13588 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13589 
 
13590 
  def __eq__(self, other):
13591 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13592 
 
13593 
  def __ne__(self, other):
13594 
    return not (self == other)
13595 
 
13596 
class getComingSoonCatalogIds_result:
13597 
  """
13598 
  Attributes:
13599 
   - success
13600 
   - cex
13601 
  """
13602 
 
13603 
  thrift_spec = (
13604 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
13605 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13606 
  )
13607 
 
13608 
  def __init__(self, success=None, cex=None,):
13609 
    self.success = success
13610 
    self.cex = cex
13611 
 
13612 
  def read(self, iprot):
13613 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13614 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13615 
      return
13616 
    iprot.readStructBegin()
13617 
    while True:
13618 
      (fname, ftype, fid) = iprot.readFieldBegin()
13619 
      if ftype == TType.STOP:
13620 
        break
13621 
      if fid == 0:
13622 
        if ftype == TType.LIST:
13623 
          self.success = []
13493 amit.gupta 13624 
          (_etype151, _size148) = iprot.readListBegin()
13625 
          for _i152 in xrange(_size148):
13626 
            _elem153 = iprot.readI64();
13627 
            self.success.append(_elem153)
5944 mandeep.dh 13628 
          iprot.readListEnd()
13629 
        else:
13630 
          iprot.skip(ftype)
13631 
      elif fid == 1:
13632 
        if ftype == TType.STRUCT:
13633 
          self.cex = CatalogServiceException()
13634 
          self.cex.read(iprot)
13635 
        else:
13636 
          iprot.skip(ftype)
13637 
      else:
13638 
        iprot.skip(ftype)
13639 
      iprot.readFieldEnd()
13640 
    iprot.readStructEnd()
13641 
 
13642 
  def write(self, oprot):
13643 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13644 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13645 
      return
13646 
    oprot.writeStructBegin('getComingSoonCatalogIds_result')
13647 
    if self.success is not None:
13648 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13649 
      oprot.writeListBegin(TType.I64, len(self.success))
13493 amit.gupta 13650 
      for iter154 in self.success:
13651 
        oprot.writeI64(iter154)
5944 mandeep.dh 13652 
      oprot.writeListEnd()
13653 
      oprot.writeFieldEnd()
13654 
    if self.cex is not None:
13655 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13656 
      self.cex.write(oprot)
13657 
      oprot.writeFieldEnd()
13658 
    oprot.writeFieldStop()
13659 
    oprot.writeStructEnd()
13660 
 
13661 
  def validate(self):
13662 
    return
13663 
 
13664 
 
13665 
  def __repr__(self):
13666 
    L = ['%s=%r' % (key, value)
13667 
      for key, value in self.__dict__.iteritems()]
13668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13669 
 
13670 
  def __eq__(self, other):
13671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13672 
 
13673 
  def __ne__(self, other):
13674 
    return not (self == other)
13675 
 
13676 
class getComingSoonCount_args:
13677 
 
13678 
  thrift_spec = (
13679 
  )
13680 
 
13681 
  def read(self, iprot):
13682 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13683 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13684 
      return
13685 
    iprot.readStructBegin()
13686 
    while True:
13687 
      (fname, ftype, fid) = iprot.readFieldBegin()
13688 
      if ftype == TType.STOP:
13689 
        break
13690 
      else:
13691 
        iprot.skip(ftype)
13692 
      iprot.readFieldEnd()
13693 
    iprot.readStructEnd()
13694 
 
13695 
  def write(self, oprot):
13696 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13697 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13698 
      return
13699 
    oprot.writeStructBegin('getComingSoonCount_args')
13700 
    oprot.writeFieldStop()
13701 
    oprot.writeStructEnd()
13702 
 
13703 
  def validate(self):
13704 
    return
13705 
 
13706 
 
13707 
  def __repr__(self):
13708 
    L = ['%s=%r' % (key, value)
13709 
      for key, value in self.__dict__.iteritems()]
13710 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13711 
 
13712 
  def __eq__(self, other):
13713 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13714 
 
13715 
  def __ne__(self, other):
13716 
    return not (self == other)
13717 
 
13718 
class getComingSoonCount_result:
13719 
  """
13720 
  Attributes:
13721 
   - success
13722 
   - cex
13723 
  """
13724 
 
13725 
  thrift_spec = (
13726 
    (0, TType.I64, 'success', None, None, ), # 0
13727 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13728 
  )
13729 
 
13730 
  def __init__(self, success=None, cex=None,):
13731 
    self.success = success
13732 
    self.cex = cex
13733 
 
13734 
  def read(self, iprot):
13735 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13736 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13737 
      return
13738 
    iprot.readStructBegin()
13739 
    while True:
13740 
      (fname, ftype, fid) = iprot.readFieldBegin()
13741 
      if ftype == TType.STOP:
13742 
        break
13743 
      if fid == 0:
13744 
        if ftype == TType.I64:
13745 
          self.success = iprot.readI64();
13746 
        else:
13747 
          iprot.skip(ftype)
13748 
      elif fid == 1:
13749 
        if ftype == TType.STRUCT:
13750 
          self.cex = CatalogServiceException()
13751 
          self.cex.read(iprot)
13752 
        else:
13753 
          iprot.skip(ftype)
13754 
      else:
13755 
        iprot.skip(ftype)
13756 
      iprot.readFieldEnd()
13757 
    iprot.readStructEnd()
13758 
 
13759 
  def write(self, oprot):
13760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13762 
      return
13763 
    oprot.writeStructBegin('getComingSoonCount_result')
13764 
    if self.success is not None:
13765 
      oprot.writeFieldBegin('success', TType.I64, 0)
13766 
      oprot.writeI64(self.success)
13767 
      oprot.writeFieldEnd()
13768 
    if self.cex is not None:
13769 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13770 
      self.cex.write(oprot)
13771 
      oprot.writeFieldEnd()
13772 
    oprot.writeFieldStop()
13773 
    oprot.writeStructEnd()
13774 
 
13775 
  def validate(self):
13776 
    return
13777 
 
13778 
 
13779 
  def __repr__(self):
13780 
    L = ['%s=%r' % (key, value)
13781 
      for key, value in self.__dict__.iteritems()]
13782 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13783 
 
13784 
  def __eq__(self, other):
13785 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13786 
 
13787 
  def __ne__(self, other):
13788 
    return not (self == other)
13789 
 
13790 
class getLatestArrivals_args:
13791 
 
13792 
  thrift_spec = (
13793 
  )
13794 
 
13795 
  def read(self, iprot):
13796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13798 
      return
13799 
    iprot.readStructBegin()
13800 
    while True:
13801 
      (fname, ftype, fid) = iprot.readFieldBegin()
13802 
      if ftype == TType.STOP:
13803 
        break
13804 
      else:
13805 
        iprot.skip(ftype)
13806 
      iprot.readFieldEnd()
13807 
    iprot.readStructEnd()
13808 
 
13809 
  def write(self, oprot):
13810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13812 
      return
13813 
    oprot.writeStructBegin('getLatestArrivals_args')
13814 
    oprot.writeFieldStop()
13815 
    oprot.writeStructEnd()
13816 
 
13817 
  def validate(self):
13818 
    return
13819 
 
13820 
 
13821 
  def __repr__(self):
13822 
    L = ['%s=%r' % (key, value)
13823 
      for key, value in self.__dict__.iteritems()]
13824 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13825 
 
13826 
  def __eq__(self, other):
13827 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13828 
 
13829 
  def __ne__(self, other):
13830 
    return not (self == other)
13831 
 
13832 
class getLatestArrivals_result:
13833 
  """
13834 
  Attributes:
13835 
   - success
13836 
   - isex
13837 
  """
13838 
 
13839 
  thrift_spec = (
13840 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
13841 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13842 
  )
13843 
 
13844 
  def __init__(self, success=None, isex=None,):
13845 
    self.success = success
13846 
    self.isex = isex
13847 
 
13848 
  def read(self, iprot):
13849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13851 
      return
13852 
    iprot.readStructBegin()
13853 
    while True:
13854 
      (fname, ftype, fid) = iprot.readFieldBegin()
13855 
      if ftype == TType.STOP:
13856 
        break
13857 
      if fid == 0:
13858 
        if ftype == TType.LIST:
13859 
          self.success = []
13493 amit.gupta 13860 
          (_etype158, _size155) = iprot.readListBegin()
13861 
          for _i159 in xrange(_size155):
13862 
            _elem160 = Item()
13863 
            _elem160.read(iprot)
13864 
            self.success.append(_elem160)
5944 mandeep.dh 13865 
          iprot.readListEnd()
13866 
        else:
13867 
          iprot.skip(ftype)
13868 
      elif fid == 1:
13869 
        if ftype == TType.STRUCT:
13870 
          self.isex = CatalogServiceException()
13871 
          self.isex.read(iprot)
13872 
        else:
13873 
          iprot.skip(ftype)
13874 
      else:
13875 
        iprot.skip(ftype)
13876 
      iprot.readFieldEnd()
13877 
    iprot.readStructEnd()
13878 
 
13879 
  def write(self, oprot):
13880 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13881 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13882 
      return
13883 
    oprot.writeStructBegin('getLatestArrivals_result')
13884 
    if self.success is not None:
13885 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13886 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 13887 
      for iter161 in self.success:
13888 
        iter161.write(oprot)
5944 mandeep.dh 13889 
      oprot.writeListEnd()
13890 
      oprot.writeFieldEnd()
13891 
    if self.isex is not None:
13892 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
13893 
      self.isex.write(oprot)
13894 
      oprot.writeFieldEnd()
13895 
    oprot.writeFieldStop()
13896 
    oprot.writeStructEnd()
13897 
 
13898 
  def validate(self):
13899 
    return
13900 
 
13901 
 
13902 
  def __repr__(self):
13903 
    L = ['%s=%r' % (key, value)
13904 
      for key, value in self.__dict__.iteritems()]
13905 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13906 
 
13907 
  def __eq__(self, other):
13908 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13909 
 
13910 
  def __ne__(self, other):
13911 
    return not (self == other)
13912 
 
13913 
class getLatestArrivalsCatalogIds_args:
13914 
  """
13915 
  Attributes:
13916 
   - beginIndex
13917 
   - totalItems
13918 
   - brand
13919 
   - categories
13920 
  """
13921 
 
13922 
  thrift_spec = (
13923 
    None, # 0
13924 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
13925 
    (2, TType.I64, 'totalItems', None, None, ), # 2
13926 
    (3, TType.STRING, 'brand', None, None, ), # 3
13927 
    (4, TType.LIST, 'categories', (TType.I64,None), None, ), # 4
13928 
  )
13929 
 
13930 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, categories=None,):
13931 
    self.beginIndex = beginIndex
13932 
    self.totalItems = totalItems
13933 
    self.brand = brand
13934 
    self.categories = categories
13935 
 
13936 
  def read(self, iprot):
13937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13939 
      return
13940 
    iprot.readStructBegin()
13941 
    while True:
13942 
      (fname, ftype, fid) = iprot.readFieldBegin()
13943 
      if ftype == TType.STOP:
13944 
        break
13945 
      if fid == 1:
13946 
        if ftype == TType.I64:
13947 
          self.beginIndex = iprot.readI64();
13948 
        else:
13949 
          iprot.skip(ftype)
13950 
      elif fid == 2:
13951 
        if ftype == TType.I64:
13952 
          self.totalItems = iprot.readI64();
13953 
        else:
13954 
          iprot.skip(ftype)
13955 
      elif fid == 3:
13956 
        if ftype == TType.STRING:
13957 
          self.brand = iprot.readString();
13958 
        else:
13959 
          iprot.skip(ftype)
13960 
      elif fid == 4:
13961 
        if ftype == TType.LIST:
13962 
          self.categories = []
13493 amit.gupta 13963 
          (_etype165, _size162) = iprot.readListBegin()
13964 
          for _i166 in xrange(_size162):
13965 
            _elem167 = iprot.readI64();
13966 
            self.categories.append(_elem167)
5944 mandeep.dh 13967 
          iprot.readListEnd()
13968 
        else:
13969 
          iprot.skip(ftype)
13970 
      else:
13971 
        iprot.skip(ftype)
13972 
      iprot.readFieldEnd()
13973 
    iprot.readStructEnd()
13974 
 
13975 
  def write(self, oprot):
13976 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13977 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13978 
      return
13979 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_args')
13980 
    if self.beginIndex is not None:
13981 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
13982 
      oprot.writeI64(self.beginIndex)
13983 
      oprot.writeFieldEnd()
13984 
    if self.totalItems is not None:
13985 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
13986 
      oprot.writeI64(self.totalItems)
13987 
      oprot.writeFieldEnd()
13988 
    if self.brand is not None:
13989 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
13990 
      oprot.writeString(self.brand)
13991 
      oprot.writeFieldEnd()
13992 
    if self.categories is not None:
13993 
      oprot.writeFieldBegin('categories', TType.LIST, 4)
13994 
      oprot.writeListBegin(TType.I64, len(self.categories))
13493 amit.gupta 13995 
      for iter168 in self.categories:
13996 
        oprot.writeI64(iter168)
5944 mandeep.dh 13997 
      oprot.writeListEnd()
13998 
      oprot.writeFieldEnd()
13999 
    oprot.writeFieldStop()
14000 
    oprot.writeStructEnd()
14001 
 
14002 
  def validate(self):
14003 
    return
14004 
 
14005 
 
14006 
  def __repr__(self):
14007 
    L = ['%s=%r' % (key, value)
14008 
      for key, value in self.__dict__.iteritems()]
14009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14010 
 
14011 
  def __eq__(self, other):
14012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14013 
 
14014 
  def __ne__(self, other):
14015 
    return not (self == other)
14016 
 
14017 
class getLatestArrivalsCatalogIds_result:
14018 
  """
14019 
  Attributes:
14020 
   - success
14021 
   - cex
14022 
  """
14023 
 
14024 
  thrift_spec = (
14025 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
14026 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14027 
  )
14028 
 
14029 
  def __init__(self, success=None, cex=None,):
14030 
    self.success = success
14031 
    self.cex = cex
14032 
 
14033 
  def read(self, iprot):
14034 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14035 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14036 
      return
14037 
    iprot.readStructBegin()
14038 
    while True:
14039 
      (fname, ftype, fid) = iprot.readFieldBegin()
14040 
      if ftype == TType.STOP:
14041 
        break
14042 
      if fid == 0:
14043 
        if ftype == TType.LIST:
14044 
          self.success = []
13493 amit.gupta 14045 
          (_etype172, _size169) = iprot.readListBegin()
14046 
          for _i173 in xrange(_size169):
14047 
            _elem174 = iprot.readI64();
14048 
            self.success.append(_elem174)
5944 mandeep.dh 14049 
          iprot.readListEnd()
14050 
        else:
14051 
          iprot.skip(ftype)
14052 
      elif fid == 1:
14053 
        if ftype == TType.STRUCT:
14054 
          self.cex = CatalogServiceException()
14055 
          self.cex.read(iprot)
14056 
        else:
14057 
          iprot.skip(ftype)
14058 
      else:
14059 
        iprot.skip(ftype)
14060 
      iprot.readFieldEnd()
14061 
    iprot.readStructEnd()
14062 
 
14063 
  def write(self, oprot):
14064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14066 
      return
14067 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_result')
14068 
    if self.success is not None:
14069 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14070 
      oprot.writeListBegin(TType.I64, len(self.success))
13493 amit.gupta 14071 
      for iter175 in self.success:
14072 
        oprot.writeI64(iter175)
5944 mandeep.dh 14073 
      oprot.writeListEnd()
14074 
      oprot.writeFieldEnd()
14075 
    if self.cex is not None:
14076 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14077 
      self.cex.write(oprot)
14078 
      oprot.writeFieldEnd()
14079 
    oprot.writeFieldStop()
14080 
    oprot.writeStructEnd()
14081 
 
14082 
  def validate(self):
14083 
    return
14084 
 
14085 
 
14086 
  def __repr__(self):
14087 
    L = ['%s=%r' % (key, value)
14088 
      for key, value in self.__dict__.iteritems()]
14089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14090 
 
14091 
  def __eq__(self, other):
14092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14093 
 
14094 
  def __ne__(self, other):
14095 
    return not (self == other)
14096 
 
14097 
class getLatestArrivalsCount_args:
14098 
 
14099 
  thrift_spec = (
14100 
  )
14101 
 
14102 
  def read(self, iprot):
14103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14105 
      return
14106 
    iprot.readStructBegin()
14107 
    while True:
14108 
      (fname, ftype, fid) = iprot.readFieldBegin()
14109 
      if ftype == TType.STOP:
14110 
        break
14111 
      else:
14112 
        iprot.skip(ftype)
14113 
      iprot.readFieldEnd()
14114 
    iprot.readStructEnd()
14115 
 
14116 
  def write(self, oprot):
14117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14119 
      return
14120 
    oprot.writeStructBegin('getLatestArrivalsCount_args')
14121 
    oprot.writeFieldStop()
14122 
    oprot.writeStructEnd()
14123 
 
14124 
  def validate(self):
14125 
    return
14126 
 
14127 
 
14128 
  def __repr__(self):
14129 
    L = ['%s=%r' % (key, value)
14130 
      for key, value in self.__dict__.iteritems()]
14131 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14132 
 
14133 
  def __eq__(self, other):
14134 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14135 
 
14136 
  def __ne__(self, other):
14137 
    return not (self == other)
14138 
 
14139 
class getLatestArrivalsCount_result:
14140 
  """
14141 
  Attributes:
14142 
   - success
14143 
   - cex
14144 
  """
14145 
 
14146 
  thrift_spec = (
14147 
    (0, TType.I64, 'success', None, None, ), # 0
14148 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14149 
  )
14150 
 
14151 
  def __init__(self, success=None, cex=None,):
14152 
    self.success = success
14153 
    self.cex = cex
14154 
 
14155 
  def read(self, iprot):
14156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14158 
      return
14159 
    iprot.readStructBegin()
14160 
    while True:
14161 
      (fname, ftype, fid) = iprot.readFieldBegin()
14162 
      if ftype == TType.STOP:
14163 
        break
14164 
      if fid == 0:
14165 
        if ftype == TType.I64:
14166 
          self.success = iprot.readI64();
14167 
        else:
14168 
          iprot.skip(ftype)
14169 
      elif fid == 1:
14170 
        if ftype == TType.STRUCT:
14171 
          self.cex = CatalogServiceException()
14172 
          self.cex.read(iprot)
14173 
        else:
14174 
          iprot.skip(ftype)
14175 
      else:
14176 
        iprot.skip(ftype)
14177 
      iprot.readFieldEnd()
14178 
    iprot.readStructEnd()
14179 
 
14180 
  def write(self, oprot):
14181 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14182 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14183 
      return
14184 
    oprot.writeStructBegin('getLatestArrivalsCount_result')
14185 
    if self.success is not None:
14186 
      oprot.writeFieldBegin('success', TType.I64, 0)
14187 
      oprot.writeI64(self.success)
14188 
      oprot.writeFieldEnd()
14189 
    if self.cex is not None:
14190 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14191 
      self.cex.write(oprot)
14192 
      oprot.writeFieldEnd()
14193 
    oprot.writeFieldStop()
14194 
    oprot.writeStructEnd()
14195 
 
14196 
  def validate(self):
14197 
    return
14198 
 
14199 
 
14200 
  def __repr__(self):
14201 
    L = ['%s=%r' % (key, value)
14202 
      for key, value in self.__dict__.iteritems()]
14203 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14204 
 
14205 
  def __eq__(self, other):
14206 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14207 
 
14208 
  def __ne__(self, other):
14209 
    return not (self == other)
14210 
 
14211 
class generateNewEntityID_args:
14212 
 
14213 
  thrift_spec = (
14214 
  )
14215 
 
14216 
  def read(self, iprot):
14217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14219 
      return
14220 
    iprot.readStructBegin()
14221 
    while True:
14222 
      (fname, ftype, fid) = iprot.readFieldBegin()
14223 
      if ftype == TType.STOP:
14224 
        break
14225 
      else:
14226 
        iprot.skip(ftype)
14227 
      iprot.readFieldEnd()
14228 
    iprot.readStructEnd()
14229 
 
14230 
  def write(self, oprot):
14231 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14232 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14233 
      return
14234 
    oprot.writeStructBegin('generateNewEntityID_args')
14235 
    oprot.writeFieldStop()
14236 
    oprot.writeStructEnd()
14237 
 
14238 
  def validate(self):
14239 
    return
14240 
 
14241 
 
14242 
  def __repr__(self):
14243 
    L = ['%s=%r' % (key, value)
14244 
      for key, value in self.__dict__.iteritems()]
14245 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14246 
 
14247 
  def __eq__(self, other):
14248 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14249 
 
14250 
  def __ne__(self, other):
14251 
    return not (self == other)
14252 
 
14253 
class generateNewEntityID_result:
14254 
  """
14255 
  Attributes:
14256 
   - success
14257 
  """
14258 
 
14259 
  thrift_spec = (
14260 
    (0, TType.I64, 'success', None, None, ), # 0
14261 
  )
14262 
 
14263 
  def __init__(self, success=None,):
14264 
    self.success = success
14265 
 
14266 
  def read(self, iprot):
14267 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14268 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14269 
      return
14270 
    iprot.readStructBegin()
14271 
    while True:
14272 
      (fname, ftype, fid) = iprot.readFieldBegin()
14273 
      if ftype == TType.STOP:
14274 
        break
14275 
      if fid == 0:
14276 
        if ftype == TType.I64:
14277 
          self.success = iprot.readI64();
14278 
        else:
14279 
          iprot.skip(ftype)
14280 
      else:
14281 
        iprot.skip(ftype)
14282 
      iprot.readFieldEnd()
14283 
    iprot.readStructEnd()
14284 
 
14285 
  def write(self, oprot):
14286 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14287 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14288 
      return
14289 
    oprot.writeStructBegin('generateNewEntityID_result')
14290 
    if self.success is not None:
14291 
      oprot.writeFieldBegin('success', TType.I64, 0)
14292 
      oprot.writeI64(self.success)
14293 
      oprot.writeFieldEnd()
14294 
    oprot.writeFieldStop()
14295 
    oprot.writeStructEnd()
14296 
 
14297 
  def validate(self):
14298 
    return
14299 
 
14300 
 
14301 
  def __repr__(self):
14302 
    L = ['%s=%r' % (key, value)
14303 
      for key, value in self.__dict__.iteritems()]
14304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14305 
 
14306 
  def __eq__(self, other):
14307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14308 
 
14309 
  def __ne__(self, other):
14310 
    return not (self == other)
14311 
 
14312 
class addCategory_args:
14313 
  """
14314 
  Attributes:
14315 
   - category
14316 
  """
14317 
 
14318 
  thrift_spec = (
14319 
    None, # 0
14320 
    (1, TType.STRUCT, 'category', (Category, Category.thrift_spec), None, ), # 1
14321 
  )
14322 
 
14323 
  def __init__(self, category=None,):
14324 
    self.category = category
14325 
 
14326 
  def read(self, iprot):
14327 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14328 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14329 
      return
14330 
    iprot.readStructBegin()
14331 
    while True:
14332 
      (fname, ftype, fid) = iprot.readFieldBegin()
14333 
      if ftype == TType.STOP:
14334 
        break
14335 
      if fid == 1:
14336 
        if ftype == TType.STRUCT:
14337 
          self.category = Category()
14338 
          self.category.read(iprot)
14339 
        else:
14340 
          iprot.skip(ftype)
14341 
      else:
14342 
        iprot.skip(ftype)
14343 
      iprot.readFieldEnd()
14344 
    iprot.readStructEnd()
14345 
 
14346 
  def write(self, oprot):
14347 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14348 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14349 
      return
14350 
    oprot.writeStructBegin('addCategory_args')
14351 
    if self.category is not None:
14352 
      oprot.writeFieldBegin('category', TType.STRUCT, 1)
14353 
      self.category.write(oprot)
14354 
      oprot.writeFieldEnd()
14355 
    oprot.writeFieldStop()
14356 
    oprot.writeStructEnd()
14357 
 
14358 
  def validate(self):
14359 
    return
14360 
 
14361 
 
14362 
  def __repr__(self):
14363 
    L = ['%s=%r' % (key, value)
14364 
      for key, value in self.__dict__.iteritems()]
14365 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14366 
 
14367 
  def __eq__(self, other):
14368 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14369 
 
14370 
  def __ne__(self, other):
14371 
    return not (self == other)
14372 
 
14373 
class addCategory_result:
14374 
  """
14375 
  Attributes:
14376 
   - success
14377 
  """
14378 
 
14379 
  thrift_spec = (
14380 
    (0, TType.BOOL, 'success', None, None, ), # 0
14381 
  )
14382 
 
14383 
  def __init__(self, success=None,):
14384 
    self.success = success
14385 
 
14386 
  def read(self, iprot):
14387 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14388 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14389 
      return
14390 
    iprot.readStructBegin()
14391 
    while True:
14392 
      (fname, ftype, fid) = iprot.readFieldBegin()
14393 
      if ftype == TType.STOP:
14394 
        break
14395 
      if fid == 0:
14396 
        if ftype == TType.BOOL:
14397 
          self.success = iprot.readBool();
14398 
        else:
14399 
          iprot.skip(ftype)
14400 
      else:
14401 
        iprot.skip(ftype)
14402 
      iprot.readFieldEnd()
14403 
    iprot.readStructEnd()
14404 
 
14405 
  def write(self, oprot):
14406 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14407 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14408 
      return
14409 
    oprot.writeStructBegin('addCategory_result')
14410 
    if self.success is not None:
14411 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14412 
      oprot.writeBool(self.success)
14413 
      oprot.writeFieldEnd()
14414 
    oprot.writeFieldStop()
14415 
    oprot.writeStructEnd()
14416 
 
14417 
  def validate(self):
14418 
    return
14419 
 
14420 
 
14421 
  def __repr__(self):
14422 
    L = ['%s=%r' % (key, value)
14423 
      for key, value in self.__dict__.iteritems()]
14424 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14425 
 
14426 
  def __eq__(self, other):
14427 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14428 
 
14429 
  def __ne__(self, other):
14430 
    return not (self == other)
14431 
 
14432 
class getCategory_args:
14433 
  """
14434 
  Attributes:
14435 
   - id
14436 
  """
14437 
 
14438 
  thrift_spec = (
14439 
    None, # 0
14440 
    (1, TType.I64, 'id', None, None, ), # 1
14441 
  )
14442 
 
14443 
  def __init__(self, id=None,):
14444 
    self.id = id
14445 
 
14446 
  def read(self, iprot):
14447 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14448 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14449 
      return
14450 
    iprot.readStructBegin()
14451 
    while True:
14452 
      (fname, ftype, fid) = iprot.readFieldBegin()
14453 
      if ftype == TType.STOP:
14454 
        break
14455 
      if fid == 1:
14456 
        if ftype == TType.I64:
14457 
          self.id = iprot.readI64();
14458 
        else:
14459 
          iprot.skip(ftype)
14460 
      else:
14461 
        iprot.skip(ftype)
14462 
      iprot.readFieldEnd()
14463 
    iprot.readStructEnd()
14464 
 
14465 
  def write(self, oprot):
14466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14468 
      return
14469 
    oprot.writeStructBegin('getCategory_args')
14470 
    if self.id is not None:
14471 
      oprot.writeFieldBegin('id', TType.I64, 1)
14472 
      oprot.writeI64(self.id)
14473 
      oprot.writeFieldEnd()
14474 
    oprot.writeFieldStop()
14475 
    oprot.writeStructEnd()
14476 
 
14477 
  def validate(self):
14478 
    return
14479 
 
14480 
 
14481 
  def __repr__(self):
14482 
    L = ['%s=%r' % (key, value)
14483 
      for key, value in self.__dict__.iteritems()]
14484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14485 
 
14486 
  def __eq__(self, other):
14487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14488 
 
14489 
  def __ne__(self, other):
14490 
    return not (self == other)
14491 
 
14492 
class getCategory_result:
14493 
  """
14494 
  Attributes:
14495 
   - success
14496 
  """
14497 
 
14498 
  thrift_spec = (
14499 
    (0, TType.STRUCT, 'success', (Category, Category.thrift_spec), None, ), # 0
14500 
  )
14501 
 
14502 
  def __init__(self, success=None,):
14503 
    self.success = success
14504 
 
14505 
  def read(self, iprot):
14506 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14507 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14508 
      return
14509 
    iprot.readStructBegin()
14510 
    while True:
14511 
      (fname, ftype, fid) = iprot.readFieldBegin()
14512 
      if ftype == TType.STOP:
14513 
        break
14514 
      if fid == 0:
14515 
        if ftype == TType.STRUCT:
14516 
          self.success = Category()
14517 
          self.success.read(iprot)
14518 
        else:
14519 
          iprot.skip(ftype)
14520 
      else:
14521 
        iprot.skip(ftype)
14522 
      iprot.readFieldEnd()
14523 
    iprot.readStructEnd()
14524 
 
14525 
  def write(self, oprot):
14526 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14527 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14528 
      return
14529 
    oprot.writeStructBegin('getCategory_result')
14530 
    if self.success is not None:
14531 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14532 
      self.success.write(oprot)
14533 
      oprot.writeFieldEnd()
14534 
    oprot.writeFieldStop()
14535 
    oprot.writeStructEnd()
14536 
 
14537 
  def validate(self):
14538 
    return
14539 
 
14540 
 
14541 
  def __repr__(self):
14542 
    L = ['%s=%r' % (key, value)
14543 
      for key, value in self.__dict__.iteritems()]
14544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14545 
 
14546 
  def __eq__(self, other):
14547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14548 
 
14549 
  def __ne__(self, other):
14550 
    return not (self == other)
14551 
 
14552 
class getAllCategories_args:
14553 
 
14554 
  thrift_spec = (
14555 
  )
14556 
 
14557 
  def read(self, iprot):
14558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14560 
      return
14561 
    iprot.readStructBegin()
14562 
    while True:
14563 
      (fname, ftype, fid) = iprot.readFieldBegin()
14564 
      if ftype == TType.STOP:
14565 
        break
14566 
      else:
14567 
        iprot.skip(ftype)
14568 
      iprot.readFieldEnd()
14569 
    iprot.readStructEnd()
14570 
 
14571 
  def write(self, oprot):
14572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14574 
      return
14575 
    oprot.writeStructBegin('getAllCategories_args')
14576 
    oprot.writeFieldStop()
14577 
    oprot.writeStructEnd()
14578 
 
14579 
  def validate(self):
14580 
    return
14581 
 
14582 
 
14583 
  def __repr__(self):
14584 
    L = ['%s=%r' % (key, value)
14585 
      for key, value in self.__dict__.iteritems()]
14586 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14587 
 
14588 
  def __eq__(self, other):
14589 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14590 
 
14591 
  def __ne__(self, other):
14592 
    return not (self == other)
14593 
 
14594 
class getAllCategories_result:
14595 
  """
14596 
  Attributes:
14597 
   - success
14598 
  """
14599 
 
14600 
  thrift_spec = (
14601 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
14602 
  )
14603 
 
14604 
  def __init__(self, success=None,):
14605 
    self.success = success
14606 
 
14607 
  def read(self, iprot):
14608 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14609 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14610 
      return
14611 
    iprot.readStructBegin()
14612 
    while True:
14613 
      (fname, ftype, fid) = iprot.readFieldBegin()
14614 
      if ftype == TType.STOP:
14615 
        break
14616 
      if fid == 0:
14617 
        if ftype == TType.LIST:
14618 
          self.success = []
13493 amit.gupta 14619 
          (_etype179, _size176) = iprot.readListBegin()
14620 
          for _i180 in xrange(_size176):
14621 
            _elem181 = Category()
14622 
            _elem181.read(iprot)
14623 
            self.success.append(_elem181)
5944 mandeep.dh 14624 
          iprot.readListEnd()
14625 
        else:
14626 
          iprot.skip(ftype)
14627 
      else:
14628 
        iprot.skip(ftype)
14629 
      iprot.readFieldEnd()
14630 
    iprot.readStructEnd()
14631 
 
14632 
  def write(self, oprot):
14633 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14634 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14635 
      return
14636 
    oprot.writeStructBegin('getAllCategories_result')
14637 
    if self.success is not None:
14638 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14639 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 14640 
      for iter182 in self.success:
14641 
        iter182.write(oprot)
5944 mandeep.dh 14642 
      oprot.writeListEnd()
14643 
      oprot.writeFieldEnd()
14644 
    oprot.writeFieldStop()
14645 
    oprot.writeStructEnd()
14646 
 
14647 
  def validate(self):
14648 
    return
14649 
 
14650 
 
14651 
  def __repr__(self):
14652 
    L = ['%s=%r' % (key, value)
14653 
      for key, value in self.__dict__.iteritems()]
14654 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14655 
 
14656 
  def __eq__(self, other):
14657 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14658 
 
14659 
  def __ne__(self, other):
14660 
    return not (self == other)
14661 
 
14662 
class getAllSimilarItems_args:
14663 
  """
14664 
  Attributes:
14665 
   - itemId
14666 
  """
14667 
 
14668 
  thrift_spec = (
14669 
    None, # 0
14670 
    (1, TType.I64, 'itemId', None, None, ), # 1
14671 
  )
14672 
 
14673 
  def __init__(self, itemId=None,):
14674 
    self.itemId = itemId
14675 
 
14676 
  def read(self, iprot):
14677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14679 
      return
14680 
    iprot.readStructBegin()
14681 
    while True:
14682 
      (fname, ftype, fid) = iprot.readFieldBegin()
14683 
      if ftype == TType.STOP:
14684 
        break
14685 
      if fid == 1:
14686 
        if ftype == TType.I64:
14687 
          self.itemId = iprot.readI64();
14688 
        else:
14689 
          iprot.skip(ftype)
14690 
      else:
14691 
        iprot.skip(ftype)
14692 
      iprot.readFieldEnd()
14693 
    iprot.readStructEnd()
14694 
 
14695 
  def write(self, oprot):
14696 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14697 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14698 
      return
14699 
    oprot.writeStructBegin('getAllSimilarItems_args')
14700 
    if self.itemId is not None:
14701 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14702 
      oprot.writeI64(self.itemId)
14703 
      oprot.writeFieldEnd()
14704 
    oprot.writeFieldStop()
14705 
    oprot.writeStructEnd()
14706 
 
14707 
  def validate(self):
14708 
    return
14709 
 
14710 
 
14711 
  def __repr__(self):
14712 
    L = ['%s=%r' % (key, value)
14713 
      for key, value in self.__dict__.iteritems()]
14714 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14715 
 
14716 
  def __eq__(self, other):
14717 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14718 
 
14719 
  def __ne__(self, other):
14720 
    return not (self == other)
14721 
 
14722 
class getAllSimilarItems_result:
14723 
  """
14724 
  Attributes:
14725 
   - success
14726 
  """
14727 
 
14728 
  thrift_spec = (
14729 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
14730 
  )
14731 
 
14732 
  def __init__(self, success=None,):
14733 
    self.success = success
14734 
 
14735 
  def read(self, iprot):
14736 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14737 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14738 
      return
14739 
    iprot.readStructBegin()
14740 
    while True:
14741 
      (fname, ftype, fid) = iprot.readFieldBegin()
14742 
      if ftype == TType.STOP:
14743 
        break
14744 
      if fid == 0:
14745 
        if ftype == TType.LIST:
14746 
          self.success = []
13493 amit.gupta 14747 
          (_etype186, _size183) = iprot.readListBegin()
14748 
          for _i187 in xrange(_size183):
14749 
            _elem188 = Item()
14750 
            _elem188.read(iprot)
14751 
            self.success.append(_elem188)
5944 mandeep.dh 14752 
          iprot.readListEnd()
14753 
        else:
14754 
          iprot.skip(ftype)
14755 
      else:
14756 
        iprot.skip(ftype)
14757 
      iprot.readFieldEnd()
14758 
    iprot.readStructEnd()
14759 
 
14760 
  def write(self, oprot):
14761 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14762 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14763 
      return
14764 
    oprot.writeStructBegin('getAllSimilarItems_result')
14765 
    if self.success is not None:
14766 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14767 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 14768 
      for iter189 in self.success:
14769 
        iter189.write(oprot)
5944 mandeep.dh 14770 
      oprot.writeListEnd()
14771 
      oprot.writeFieldEnd()
14772 
    oprot.writeFieldStop()
14773 
    oprot.writeStructEnd()
14774 
 
14775 
  def validate(self):
14776 
    return
14777 
 
14778 
 
14779 
  def __repr__(self):
14780 
    L = ['%s=%r' % (key, value)
14781 
      for key, value in self.__dict__.iteritems()]
14782 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14783 
 
14784 
  def __eq__(self, other):
14785 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14786 
 
14787 
  def __ne__(self, other):
14788 
    return not (self == other)
14789 
 
14790 
class addSimilarItem_args:
14791 
  """
14792 
  Attributes:
14793 
   - itemId
14794 
   - catalogItemId
14795 
  """
14796 
 
14797 
  thrift_spec = (
14798 
    None, # 0
14799 
    (1, TType.I64, 'itemId', None, None, ), # 1
14800 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
14801 
  )
14802 
 
14803 
  def __init__(self, itemId=None, catalogItemId=None,):
14804 
    self.itemId = itemId
14805 
    self.catalogItemId = catalogItemId
14806 
 
14807 
  def read(self, iprot):
14808 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14809 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14810 
      return
14811 
    iprot.readStructBegin()
14812 
    while True:
14813 
      (fname, ftype, fid) = iprot.readFieldBegin()
14814 
      if ftype == TType.STOP:
14815 
        break
14816 
      if fid == 1:
14817 
        if ftype == TType.I64:
14818 
          self.itemId = iprot.readI64();
14819 
        else:
14820 
          iprot.skip(ftype)
14821 
      elif fid == 2:
14822 
        if ftype == TType.I64:
14823 
          self.catalogItemId = iprot.readI64();
14824 
        else:
14825 
          iprot.skip(ftype)
14826 
      else:
14827 
        iprot.skip(ftype)
14828 
      iprot.readFieldEnd()
14829 
    iprot.readStructEnd()
14830 
 
14831 
  def write(self, oprot):
14832 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14833 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14834 
      return
14835 
    oprot.writeStructBegin('addSimilarItem_args')
14836 
    if self.itemId is not None:
14837 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14838 
      oprot.writeI64(self.itemId)
14839 
      oprot.writeFieldEnd()
14840 
    if self.catalogItemId is not None:
14841 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
14842 
      oprot.writeI64(self.catalogItemId)
14843 
      oprot.writeFieldEnd()
14844 
    oprot.writeFieldStop()
14845 
    oprot.writeStructEnd()
14846 
 
14847 
  def validate(self):
14848 
    return
14849 
 
14850 
 
14851 
  def __repr__(self):
14852 
    L = ['%s=%r' % (key, value)
14853 
      for key, value in self.__dict__.iteritems()]
14854 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14855 
 
14856 
  def __eq__(self, other):
14857 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14858 
 
14859 
  def __ne__(self, other):
14860 
    return not (self == other)
14861 
 
14862 
class addSimilarItem_result:
14863 
  """
14864 
  Attributes:
14865 
   - success
14866 
   - cex
14867 
  """
14868 
 
14869 
  thrift_spec = (
14870 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
14871 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14872 
  )
14873 
 
14874 
  def __init__(self, success=None, cex=None,):
14875 
    self.success = success
14876 
    self.cex = cex
14877 
 
14878 
  def read(self, iprot):
14879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14881 
      return
14882 
    iprot.readStructBegin()
14883 
    while True:
14884 
      (fname, ftype, fid) = iprot.readFieldBegin()
14885 
      if ftype == TType.STOP:
14886 
        break
14887 
      if fid == 0:
14888 
        if ftype == TType.STRUCT:
14889 
          self.success = Item()
14890 
          self.success.read(iprot)
14891 
        else:
14892 
          iprot.skip(ftype)
14893 
      elif fid == 1:
14894 
        if ftype == TType.STRUCT:
14895 
          self.cex = CatalogServiceException()
14896 
          self.cex.read(iprot)
14897 
        else:
14898 
          iprot.skip(ftype)
14899 
      else:
14900 
        iprot.skip(ftype)
14901 
      iprot.readFieldEnd()
14902 
    iprot.readStructEnd()
14903 
 
14904 
  def write(self, oprot):
14905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14907 
      return
14908 
    oprot.writeStructBegin('addSimilarItem_result')
14909 
    if self.success is not None:
14910 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14911 
      self.success.write(oprot)
14912 
      oprot.writeFieldEnd()
14913 
    if self.cex is not None:
14914 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14915 
      self.cex.write(oprot)
14916 
      oprot.writeFieldEnd()
14917 
    oprot.writeFieldStop()
14918 
    oprot.writeStructEnd()
14919 
 
14920 
  def validate(self):
14921 
    return
14922 
 
14923 
 
14924 
  def __repr__(self):
14925 
    L = ['%s=%r' % (key, value)
14926 
      for key, value in self.__dict__.iteritems()]
14927 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14928 
 
14929 
  def __eq__(self, other):
14930 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14931 
 
14932 
  def __ne__(self, other):
14933 
    return not (self == other)
14934 
 
6512 kshitij.so 14935 
class addTag_args:
14936 
  """
14937 
  Attributes:
14938 
   - displayName
14939 
   - itemId
14940 
  """
14941 
 
14942 
  thrift_spec = (
14943 
    None, # 0
14944 
    (1, TType.STRING, 'displayName', None, None, ), # 1
14945 
    (2, TType.I64, 'itemId', None, None, ), # 2
14946 
  )
14947 
 
14948 
  def __init__(self, displayName=None, itemId=None,):
14949 
    self.displayName = displayName
14950 
    self.itemId = itemId
14951 
 
14952 
  def read(self, iprot):
14953 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14954 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14955 
      return
14956 
    iprot.readStructBegin()
14957 
    while True:
14958 
      (fname, ftype, fid) = iprot.readFieldBegin()
14959 
      if ftype == TType.STOP:
14960 
        break
14961 
      if fid == 1:
14962 
        if ftype == TType.STRING:
14963 
          self.displayName = iprot.readString();
14964 
        else:
14965 
          iprot.skip(ftype)
14966 
      elif fid == 2:
14967 
        if ftype == TType.I64:
14968 
          self.itemId = iprot.readI64();
14969 
        else:
14970 
          iprot.skip(ftype)
14971 
      else:
14972 
        iprot.skip(ftype)
14973 
      iprot.readFieldEnd()
14974 
    iprot.readStructEnd()
14975 
 
14976 
  def write(self, oprot):
14977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14979 
      return
14980 
    oprot.writeStructBegin('addTag_args')
14981 
    if self.displayName is not None:
14982 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
14983 
      oprot.writeString(self.displayName)
14984 
      oprot.writeFieldEnd()
14985 
    if self.itemId is not None:
14986 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
14987 
      oprot.writeI64(self.itemId)
14988 
      oprot.writeFieldEnd()
14989 
    oprot.writeFieldStop()
14990 
    oprot.writeStructEnd()
14991 
 
14992 
  def validate(self):
14993 
    return
14994 
 
14995 
 
14996 
  def __repr__(self):
14997 
    L = ['%s=%r' % (key, value)
14998 
      for key, value in self.__dict__.iteritems()]
14999 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15000 
 
15001 
  def __eq__(self, other):
15002 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15003 
 
15004 
  def __ne__(self, other):
15005 
    return not (self == other)
15006 
 
15007 
class addTag_result:
15008 
  """
15009 
  Attributes:
15010 
   - success
15011 
  """
15012 
 
15013 
  thrift_spec = (
15014 
    (0, TType.BOOL, 'success', None, None, ), # 0
15015 
  )
15016 
 
15017 
  def __init__(self, success=None,):
15018 
    self.success = success
15019 
 
15020 
  def read(self, iprot):
15021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15023 
      return
15024 
    iprot.readStructBegin()
15025 
    while True:
15026 
      (fname, ftype, fid) = iprot.readFieldBegin()
15027 
      if ftype == TType.STOP:
15028 
        break
15029 
      if fid == 0:
15030 
        if ftype == TType.BOOL:
15031 
          self.success = iprot.readBool();
15032 
        else:
15033 
          iprot.skip(ftype)
15034 
      else:
15035 
        iprot.skip(ftype)
15036 
      iprot.readFieldEnd()
15037 
    iprot.readStructEnd()
15038 
 
15039 
  def write(self, oprot):
15040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15042 
      return
15043 
    oprot.writeStructBegin('addTag_result')
15044 
    if self.success is not None:
15045 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15046 
      oprot.writeBool(self.success)
15047 
      oprot.writeFieldEnd()
15048 
    oprot.writeFieldStop()
15049 
    oprot.writeStructEnd()
15050 
 
15051 
  def validate(self):
15052 
    return
15053 
 
15054 
 
15055 
  def __repr__(self):
15056 
    L = ['%s=%r' % (key, value)
15057 
      for key, value in self.__dict__.iteritems()]
15058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15059 
 
15060 
  def __eq__(self, other):
15061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15062 
 
15063 
  def __ne__(self, other):
15064 
    return not (self == other)
15065 
 
15066 
class deleteEntityTag_args:
15067 
  """
15068 
  Attributes:
15069 
   - displayName
15070 
   - itemId
15071 
  """
15072 
 
15073 
  thrift_spec = (
15074 
    None, # 0
15075 
    (1, TType.STRING, 'displayName', None, None, ), # 1
15076 
    (2, TType.I64, 'itemId', None, None, ), # 2
15077 
  )
15078 
 
15079 
  def __init__(self, displayName=None, itemId=None,):
15080 
    self.displayName = displayName
15081 
    self.itemId = itemId
15082 
 
15083 
  def read(self, iprot):
15084 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15085 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15086 
      return
15087 
    iprot.readStructBegin()
15088 
    while True:
15089 
      (fname, ftype, fid) = iprot.readFieldBegin()
15090 
      if ftype == TType.STOP:
15091 
        break
15092 
      if fid == 1:
15093 
        if ftype == TType.STRING:
15094 
          self.displayName = iprot.readString();
15095 
        else:
15096 
          iprot.skip(ftype)
15097 
      elif fid == 2:
15098 
        if ftype == TType.I64:
15099 
          self.itemId = iprot.readI64();
15100 
        else:
15101 
          iprot.skip(ftype)
15102 
      else:
15103 
        iprot.skip(ftype)
15104 
      iprot.readFieldEnd()
15105 
    iprot.readStructEnd()
15106 
 
15107 
  def write(self, oprot):
15108 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15109 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15110 
      return
15111 
    oprot.writeStructBegin('deleteEntityTag_args')
15112 
    if self.displayName is not None:
15113 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
15114 
      oprot.writeString(self.displayName)
15115 
      oprot.writeFieldEnd()
15116 
    if self.itemId is not None:
15117 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
15118 
      oprot.writeI64(self.itemId)
15119 
      oprot.writeFieldEnd()
15120 
    oprot.writeFieldStop()
15121 
    oprot.writeStructEnd()
15122 
 
15123 
  def validate(self):
15124 
    return
15125 
 
15126 
 
15127 
  def __repr__(self):
15128 
    L = ['%s=%r' % (key, value)
15129 
      for key, value in self.__dict__.iteritems()]
15130 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15131 
 
15132 
  def __eq__(self, other):
15133 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15134 
 
15135 
  def __ne__(self, other):
15136 
    return not (self == other)
15137 
 
15138 
class deleteEntityTag_result:
15139 
  """
15140 
  Attributes:
15141 
   - success
15142 
  """
15143 
 
15144 
  thrift_spec = (
15145 
    (0, TType.BOOL, 'success', None, None, ), # 0
15146 
  )
15147 
 
15148 
  def __init__(self, success=None,):
15149 
    self.success = success
15150 
 
15151 
  def read(self, iprot):
15152 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15153 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15154 
      return
15155 
    iprot.readStructBegin()
15156 
    while True:
15157 
      (fname, ftype, fid) = iprot.readFieldBegin()
15158 
      if ftype == TType.STOP:
15159 
        break
15160 
      if fid == 0:
15161 
        if ftype == TType.BOOL:
15162 
          self.success = iprot.readBool();
15163 
        else:
15164 
          iprot.skip(ftype)
15165 
      else:
15166 
        iprot.skip(ftype)
15167 
      iprot.readFieldEnd()
15168 
    iprot.readStructEnd()
15169 
 
15170 
  def write(self, oprot):
15171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15173 
      return
15174 
    oprot.writeStructBegin('deleteEntityTag_result')
15175 
    if self.success is not None:
15176 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15177 
      oprot.writeBool(self.success)
15178 
      oprot.writeFieldEnd()
15179 
    oprot.writeFieldStop()
15180 
    oprot.writeStructEnd()
15181 
 
15182 
  def validate(self):
15183 
    return
15184 
 
15185 
 
15186 
  def __repr__(self):
15187 
    L = ['%s=%r' % (key, value)
15188 
      for key, value in self.__dict__.iteritems()]
15189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15190 
 
15191 
  def __eq__(self, other):
15192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15193 
 
15194 
  def __ne__(self, other):
15195 
    return not (self == other)
15196 
 
15197 
class deleteTag_args:
15198 
  """
15199 
  Attributes:
15200 
   - displayName
15201 
  """
15202 
 
15203 
  thrift_spec = (
15204 
    None, # 0
15205 
    (1, TType.STRING, 'displayName', None, None, ), # 1
15206 
  )
15207 
 
15208 
  def __init__(self, displayName=None,):
15209 
    self.displayName = displayName
15210 
 
15211 
  def read(self, iprot):
15212 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15213 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15214 
      return
15215 
    iprot.readStructBegin()
15216 
    while True:
15217 
      (fname, ftype, fid) = iprot.readFieldBegin()
15218 
      if ftype == TType.STOP:
15219 
        break
15220 
      if fid == 1:
15221 
        if ftype == TType.STRING:
15222 
          self.displayName = iprot.readString();
15223 
        else:
15224 
          iprot.skip(ftype)
15225 
      else:
15226 
        iprot.skip(ftype)
15227 
      iprot.readFieldEnd()
15228 
    iprot.readStructEnd()
15229 
 
15230 
  def write(self, oprot):
15231 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15232 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15233 
      return
15234 
    oprot.writeStructBegin('deleteTag_args')
15235 
    if self.displayName is not None:
15236 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
15237 
      oprot.writeString(self.displayName)
15238 
      oprot.writeFieldEnd()
15239 
    oprot.writeFieldStop()
15240 
    oprot.writeStructEnd()
15241 
 
15242 
  def validate(self):
15243 
    return
15244 
 
15245 
 
15246 
  def __repr__(self):
15247 
    L = ['%s=%r' % (key, value)
15248 
      for key, value in self.__dict__.iteritems()]
15249 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15250 
 
15251 
  def __eq__(self, other):
15252 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15253 
 
15254 
  def __ne__(self, other):
15255 
    return not (self == other)
15256 
 
15257 
class deleteTag_result:
15258 
  """
15259 
  Attributes:
15260 
   - success
15261 
  """
15262 
 
15263 
  thrift_spec = (
15264 
    (0, TType.BOOL, 'success', None, None, ), # 0
15265 
  )
15266 
 
15267 
  def __init__(self, success=None,):
15268 
    self.success = success
15269 
 
15270 
  def read(self, iprot):
15271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15273 
      return
15274 
    iprot.readStructBegin()
15275 
    while True:
15276 
      (fname, ftype, fid) = iprot.readFieldBegin()
15277 
      if ftype == TType.STOP:
15278 
        break
15279 
      if fid == 0:
15280 
        if ftype == TType.BOOL:
15281 
          self.success = iprot.readBool();
15282 
        else:
15283 
          iprot.skip(ftype)
15284 
      else:
15285 
        iprot.skip(ftype)
15286 
      iprot.readFieldEnd()
15287 
    iprot.readStructEnd()
15288 
 
15289 
  def write(self, oprot):
15290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15292 
      return
15293 
    oprot.writeStructBegin('deleteTag_result')
15294 
    if self.success is not None:
15295 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15296 
      oprot.writeBool(self.success)
15297 
      oprot.writeFieldEnd()
15298 
    oprot.writeFieldStop()
15299 
    oprot.writeStructEnd()
15300 
 
15301 
  def validate(self):
15302 
    return
15303 
 
15304 
 
15305 
  def __repr__(self):
15306 
    L = ['%s=%r' % (key, value)
15307 
      for key, value in self.__dict__.iteritems()]
15308 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15309 
 
15310 
  def __eq__(self, other):
15311 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15312 
 
15313 
  def __ne__(self, other):
15314 
    return not (self == other)
15315 
 
15316 
class getAllTags_args:
15317 
 
15318 
  thrift_spec = (
15319 
  )
15320 
 
15321 
  def read(self, iprot):
15322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15324 
      return
15325 
    iprot.readStructBegin()
15326 
    while True:
15327 
      (fname, ftype, fid) = iprot.readFieldBegin()
15328 
      if ftype == TType.STOP:
15329 
        break
15330 
      else:
15331 
        iprot.skip(ftype)
15332 
      iprot.readFieldEnd()
15333 
    iprot.readStructEnd()
15334 
 
15335 
  def write(self, oprot):
15336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15338 
      return
15339 
    oprot.writeStructBegin('getAllTags_args')
15340 
    oprot.writeFieldStop()
15341 
    oprot.writeStructEnd()
15342 
 
15343 
  def validate(self):
15344 
    return
15345 
 
15346 
 
15347 
  def __repr__(self):
15348 
    L = ['%s=%r' % (key, value)
15349 
      for key, value in self.__dict__.iteritems()]
15350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15351 
 
15352 
  def __eq__(self, other):
15353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15354 
 
15355 
  def __ne__(self, other):
15356 
    return not (self == other)
15357 
 
15358 
class getAllTags_result:
15359 
  """
15360 
  Attributes:
15361 
   - success
15362 
  """
15363 
 
15364 
  thrift_spec = (
15365 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
15366 
  )
15367 
 
15368 
  def __init__(self, success=None,):
15369 
    self.success = success
15370 
 
15371 
  def read(self, iprot):
15372 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15373 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15374 
      return
15375 
    iprot.readStructBegin()
15376 
    while True:
15377 
      (fname, ftype, fid) = iprot.readFieldBegin()
15378 
      if ftype == TType.STOP:
15379 
        break
15380 
      if fid == 0:
15381 
        if ftype == TType.LIST:
15382 
          self.success = []
13493 amit.gupta 15383 
          (_etype193, _size190) = iprot.readListBegin()
15384 
          for _i194 in xrange(_size190):
15385 
            _elem195 = iprot.readString();
15386 
            self.success.append(_elem195)
6512 kshitij.so 15387 
          iprot.readListEnd()
15388 
        else:
15389 
          iprot.skip(ftype)
15390 
      else:
15391 
        iprot.skip(ftype)
15392 
      iprot.readFieldEnd()
15393 
    iprot.readStructEnd()
15394 
 
15395 
  def write(self, oprot):
15396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15398 
      return
15399 
    oprot.writeStructBegin('getAllTags_result')
15400 
    if self.success is not None:
15401 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15402 
      oprot.writeListBegin(TType.STRING, len(self.success))
13493 amit.gupta 15403 
      for iter196 in self.success:
15404 
        oprot.writeString(iter196)
6512 kshitij.so 15405 
      oprot.writeListEnd()
15406 
      oprot.writeFieldEnd()
15407 
    oprot.writeFieldStop()
15408 
    oprot.writeStructEnd()
15409 
 
15410 
  def validate(self):
15411 
    return
15412 
 
15413 
 
15414 
  def __repr__(self):
15415 
    L = ['%s=%r' % (key, value)
15416 
      for key, value in self.__dict__.iteritems()]
15417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15418 
 
15419 
  def __eq__(self, other):
15420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15421 
 
15422 
  def __ne__(self, other):
15423 
    return not (self == other)
15424 
 
15425 
class getAllEntitiesByTagName_args:
15426 
  """
15427 
  Attributes:
15428 
   - displayName
15429 
  """
15430 
 
15431 
  thrift_spec = (
15432 
    None, # 0
15433 
    (1, TType.STRING, 'displayName', None, None, ), # 1
15434 
  )
15435 
 
15436 
  def __init__(self, displayName=None,):
15437 
    self.displayName = displayName
15438 
 
15439 
  def read(self, iprot):
15440 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15441 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15442 
      return
15443 
    iprot.readStructBegin()
15444 
    while True:
15445 
      (fname, ftype, fid) = iprot.readFieldBegin()
15446 
      if ftype == TType.STOP:
15447 
        break
15448 
      if fid == 1:
15449 
        if ftype == TType.STRING:
15450 
          self.displayName = iprot.readString();
15451 
        else:
15452 
          iprot.skip(ftype)
15453 
      else:
15454 
        iprot.skip(ftype)
15455 
      iprot.readFieldEnd()
15456 
    iprot.readStructEnd()
15457 
 
15458 
  def write(self, oprot):
15459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15461 
      return
15462 
    oprot.writeStructBegin('getAllEntitiesByTagName_args')
15463 
    if self.displayName is not None:
15464 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
15465 
      oprot.writeString(self.displayName)
15466 
      oprot.writeFieldEnd()
15467 
    oprot.writeFieldStop()
15468 
    oprot.writeStructEnd()
15469 
 
15470 
  def validate(self):
15471 
    return
15472 
 
15473 
 
15474 
  def __repr__(self):
15475 
    L = ['%s=%r' % (key, value)
15476 
      for key, value in self.__dict__.iteritems()]
15477 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15478 
 
15479 
  def __eq__(self, other):
15480 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15481 
 
15482 
  def __ne__(self, other):
15483 
    return not (self == other)
15484 
 
15485 
class getAllEntitiesByTagName_result:
15486 
  """
15487 
  Attributes:
15488 
   - success
15489 
  """
15490 
 
15491 
  thrift_spec = (
15492 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
15493 
  )
15494 
 
15495 
  def __init__(self, success=None,):
15496 
    self.success = success
15497 
 
15498 
  def read(self, iprot):
15499 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15500 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15501 
      return
15502 
    iprot.readStructBegin()
15503 
    while True:
15504 
      (fname, ftype, fid) = iprot.readFieldBegin()
15505 
      if ftype == TType.STOP:
15506 
        break
15507 
      if fid == 0:
15508 
        if ftype == TType.LIST:
15509 
          self.success = []
13493 amit.gupta 15510 
          (_etype200, _size197) = iprot.readListBegin()
15511 
          for _i201 in xrange(_size197):
15512 
            _elem202 = iprot.readI64();
15513 
            self.success.append(_elem202)
6512 kshitij.so 15514 
          iprot.readListEnd()
15515 
        else:
15516 
          iprot.skip(ftype)
15517 
      else:
15518 
        iprot.skip(ftype)
15519 
      iprot.readFieldEnd()
15520 
    iprot.readStructEnd()
15521 
 
15522 
  def write(self, oprot):
15523 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15524 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15525 
      return
15526 
    oprot.writeStructBegin('getAllEntitiesByTagName_result')
15527 
    if self.success is not None:
15528 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15529 
      oprot.writeListBegin(TType.I64, len(self.success))
13493 amit.gupta 15530 
      for iter203 in self.success:
15531 
        oprot.writeI64(iter203)
6512 kshitij.so 15532 
      oprot.writeListEnd()
15533 
      oprot.writeFieldEnd()
15534 
    oprot.writeFieldStop()
15535 
    oprot.writeStructEnd()
15536 
 
15537 
  def validate(self):
15538 
    return
15539 
 
15540 
 
15541 
  def __repr__(self):
15542 
    L = ['%s=%r' % (key, value)
15543 
      for key, value in self.__dict__.iteritems()]
15544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15545 
 
15546 
  def __eq__(self, other):
15547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15548 
 
15549 
  def __ne__(self, other):
15550 
    return not (self == other)
15551 
 
6845 amit.gupta 15552 
class getAllEntityTags_args:
15553 
 
15554 
  thrift_spec = (
15555 
  )
15556 
 
15557 
  def read(self, iprot):
15558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15560 
      return
15561 
    iprot.readStructBegin()
15562 
    while True:
15563 
      (fname, ftype, fid) = iprot.readFieldBegin()
15564 
      if ftype == TType.STOP:
15565 
        break
15566 
      else:
15567 
        iprot.skip(ftype)
15568 
      iprot.readFieldEnd()
15569 
    iprot.readStructEnd()
15570 
 
15571 
  def write(self, oprot):
15572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15574 
      return
15575 
    oprot.writeStructBegin('getAllEntityTags_args')
15576 
    oprot.writeFieldStop()
15577 
    oprot.writeStructEnd()
15578 
 
15579 
  def validate(self):
15580 
    return
15581 
 
15582 
 
15583 
  def __repr__(self):
15584 
    L = ['%s=%r' % (key, value)
15585 
      for key, value in self.__dict__.iteritems()]
15586 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15587 
 
15588 
  def __eq__(self, other):
15589 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15590 
 
15591 
  def __ne__(self, other):
15592 
    return not (self == other)
15593 
 
15594 
class getAllEntityTags_result:
15595 
  """
15596 
  Attributes:
15597 
   - success
15598 
  """
15599 
 
15600 
  thrift_spec = (
15601 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRING,None)), None, ), # 0
15602 
  )
15603 
 
15604 
  def __init__(self, success=None,):
15605 
    self.success = success
15606 
 
15607 
  def read(self, iprot):
15608 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15609 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15610 
      return
15611 
    iprot.readStructBegin()
15612 
    while True:
15613 
      (fname, ftype, fid) = iprot.readFieldBegin()
15614 
      if ftype == TType.STOP:
15615 
        break
15616 
      if fid == 0:
15617 
        if ftype == TType.MAP:
15618 
          self.success = {}
13493 amit.gupta 15619 
          (_ktype205, _vtype206, _size204 ) = iprot.readMapBegin()
15620 
          for _i208 in xrange(_size204):
15621 
            _key209 = iprot.readI64();
15622 
            _val210 = []
15623 
            (_etype214, _size211) = iprot.readListBegin()
15624 
            for _i215 in xrange(_size211):
15625 
              _elem216 = iprot.readString();
15626 
              _val210.append(_elem216)
6845 amit.gupta 15627 
            iprot.readListEnd()
13493 amit.gupta 15628 
            self.success[_key209] = _val210
6845 amit.gupta 15629 
          iprot.readMapEnd()
15630 
        else:
15631 
          iprot.skip(ftype)
15632 
      else:
15633 
        iprot.skip(ftype)
15634 
      iprot.readFieldEnd()
15635 
    iprot.readStructEnd()
15636 
 
15637 
  def write(self, oprot):
15638 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15639 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15640 
      return
15641 
    oprot.writeStructBegin('getAllEntityTags_result')
15642 
    if self.success is not None:
15643 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15644 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
13493 amit.gupta 15645 
      for kiter217,viter218 in self.success.items():
15646 
        oprot.writeI64(kiter217)
15647 
        oprot.writeListBegin(TType.STRING, len(viter218))
15648 
        for iter219 in viter218:
15649 
          oprot.writeString(iter219)
6845 amit.gupta 15650 
        oprot.writeListEnd()
15651 
      oprot.writeMapEnd()
15652 
      oprot.writeFieldEnd()
15653 
    oprot.writeFieldStop()
15654 
    oprot.writeStructEnd()
15655 
 
15656 
  def validate(self):
15657 
    return
15658 
 
15659 
 
15660 
  def __repr__(self):
15661 
    L = ['%s=%r' % (key, value)
15662 
      for key, value in self.__dict__.iteritems()]
15663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15664 
 
15665 
  def __eq__(self, other):
15666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15667 
 
15668 
  def __ne__(self, other):
15669 
    return not (self == other)
15670 
 
6850 kshitij.so 15671 
class addBanner_args:
15672 
  """
15673 
  Attributes:
8590 kshitij.so 15674 
   - bannerCongregate
6850 kshitij.so 15675 
  """
15676 
 
15677 
  thrift_spec = (
15678 
    None, # 0
8590 kshitij.so 15679 
    (1, TType.STRUCT, 'bannerCongregate', (BannerCongregate, BannerCongregate.thrift_spec), None, ), # 1
6850 kshitij.so 15680 
  )
15681 
 
8590 kshitij.so 15682 
  def __init__(self, bannerCongregate=None,):
15683 
    self.bannerCongregate = bannerCongregate
6850 kshitij.so 15684 
 
15685 
  def read(self, iprot):
15686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15688 
      return
15689 
    iprot.readStructBegin()
15690 
    while True:
15691 
      (fname, ftype, fid) = iprot.readFieldBegin()
15692 
      if ftype == TType.STOP:
15693 
        break
15694 
      if fid == 1:
8579 kshitij.so 15695 
        if ftype == TType.STRUCT:
8590 kshitij.so 15696 
          self.bannerCongregate = BannerCongregate()
15697 
          self.bannerCongregate.read(iprot)
6850 kshitij.so 15698 
        else:
15699 
          iprot.skip(ftype)
8579 kshitij.so 15700 
      else:
15701 
        iprot.skip(ftype)
15702 
      iprot.readFieldEnd()
15703 
    iprot.readStructEnd()
15704 
 
15705 
  def write(self, oprot):
15706 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15707 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15708 
      return
15709 
    oprot.writeStructBegin('addBanner_args')
8590 kshitij.so 15710 
    if self.bannerCongregate is not None:
15711 
      oprot.writeFieldBegin('bannerCongregate', TType.STRUCT, 1)
15712 
      self.bannerCongregate.write(oprot)
8579 kshitij.so 15713 
      oprot.writeFieldEnd()
15714 
    oprot.writeFieldStop()
15715 
    oprot.writeStructEnd()
15716 
 
15717 
  def validate(self):
15718 
    return
15719 
 
15720 
 
15721 
  def __repr__(self):
15722 
    L = ['%s=%r' % (key, value)
15723 
      for key, value in self.__dict__.iteritems()]
15724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15725 
 
15726 
  def __eq__(self, other):
15727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15728 
 
15729 
  def __ne__(self, other):
15730 
    return not (self == other)
15731 
 
15732 
class addBanner_result:
10097 kshitij.so 15733 
  """
15734 
  Attributes:
15735 
   - success
15736 
  """
8579 kshitij.so 15737 
 
15738 
  thrift_spec = (
10097 kshitij.so 15739 
    (0, TType.BOOL, 'success', None, None, ), # 0
8579 kshitij.so 15740 
  )
15741 
 
10097 kshitij.so 15742 
  def __init__(self, success=None,):
15743 
    self.success = success
15744 
 
8579 kshitij.so 15745 
  def read(self, iprot):
15746 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15747 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15748 
      return
15749 
    iprot.readStructBegin()
15750 
    while True:
15751 
      (fname, ftype, fid) = iprot.readFieldBegin()
15752 
      if ftype == TType.STOP:
15753 
        break
10097 kshitij.so 15754 
      if fid == 0:
15755 
        if ftype == TType.BOOL:
15756 
          self.success = iprot.readBool();
15757 
        else:
15758 
          iprot.skip(ftype)
8579 kshitij.so 15759 
      else:
15760 
        iprot.skip(ftype)
15761 
      iprot.readFieldEnd()
15762 
    iprot.readStructEnd()
15763 
 
15764 
  def write(self, oprot):
15765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15767 
      return
15768 
    oprot.writeStructBegin('addBanner_result')
10097 kshitij.so 15769 
    if self.success is not None:
15770 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15771 
      oprot.writeBool(self.success)
15772 
      oprot.writeFieldEnd()
8579 kshitij.so 15773 
    oprot.writeFieldStop()
15774 
    oprot.writeStructEnd()
15775 
 
15776 
  def validate(self):
15777 
    return
15778 
 
15779 
 
15780 
  def __repr__(self):
15781 
    L = ['%s=%r' % (key, value)
15782 
      for key, value in self.__dict__.iteritems()]
15783 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15784 
 
15785 
  def __eq__(self, other):
15786 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15787 
 
15788 
  def __ne__(self, other):
15789 
    return not (self == other)
15790 
 
15791 
class updateBanner_args:
15792 
  """
15793 
  Attributes:
15794 
   - banner
15795 
  """
15796 
 
15797 
  thrift_spec = (
15798 
    None, # 0
15799 
    (1, TType.STRUCT, 'banner', (Banner, Banner.thrift_spec), None, ), # 1
15800 
  )
15801 
 
15802 
  def __init__(self, banner=None,):
15803 
    self.banner = banner
15804 
 
15805 
  def read(self, iprot):
15806 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15807 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15808 
      return
15809 
    iprot.readStructBegin()
15810 
    while True:
15811 
      (fname, ftype, fid) = iprot.readFieldBegin()
15812 
      if ftype == TType.STOP:
15813 
        break
15814 
      if fid == 1:
15815 
        if ftype == TType.STRUCT:
15816 
          self.banner = Banner()
15817 
          self.banner.read(iprot)
6850 kshitij.so 15818 
        else:
15819 
          iprot.skip(ftype)
15820 
      else:
15821 
        iprot.skip(ftype)
15822 
      iprot.readFieldEnd()
15823 
    iprot.readStructEnd()
15824 
 
15825 
  def write(self, oprot):
15826 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15827 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15828 
      return
8579 kshitij.so 15829 
    oprot.writeStructBegin('updateBanner_args')
15830 
    if self.banner is not None:
15831 
      oprot.writeFieldBegin('banner', TType.STRUCT, 1)
15832 
      self.banner.write(oprot)
6850 kshitij.so 15833 
      oprot.writeFieldEnd()
15834 
    oprot.writeFieldStop()
15835 
    oprot.writeStructEnd()
15836 
 
15837 
  def validate(self):
15838 
    return
15839 
 
15840 
 
15841 
  def __repr__(self):
15842 
    L = ['%s=%r' % (key, value)
15843 
      for key, value in self.__dict__.iteritems()]
15844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15845 
 
15846 
  def __eq__(self, other):
15847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15848 
 
15849 
  def __ne__(self, other):
15850 
    return not (self == other)
15851 
 
8579 kshitij.so 15852 
class updateBanner_result:
6850 kshitij.so 15853 
  """
15854 
  Attributes:
15855 
   - success
15856 
  """
15857 
 
15858 
  thrift_spec = (
15859 
    (0, TType.BOOL, 'success', None, None, ), # 0
15860 
  )
15861 
 
15862 
  def __init__(self, success=None,):
15863 
    self.success = success
15864 
 
15865 
  def read(self, iprot):
15866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15868 
      return
15869 
    iprot.readStructBegin()
15870 
    while True:
15871 
      (fname, ftype, fid) = iprot.readFieldBegin()
15872 
      if ftype == TType.STOP:
15873 
        break
15874 
      if fid == 0:
15875 
        if ftype == TType.BOOL:
15876 
          self.success = iprot.readBool();
15877 
        else:
15878 
          iprot.skip(ftype)
15879 
      else:
15880 
        iprot.skip(ftype)
15881 
      iprot.readFieldEnd()
15882 
    iprot.readStructEnd()
15883 
 
15884 
  def write(self, oprot):
15885 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15886 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15887 
      return
8579 kshitij.so 15888 
    oprot.writeStructBegin('updateBanner_result')
6850 kshitij.so 15889 
    if self.success is not None:
15890 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15891 
      oprot.writeBool(self.success)
15892 
      oprot.writeFieldEnd()
15893 
    oprot.writeFieldStop()
15894 
    oprot.writeStructEnd()
15895 
 
15896 
  def validate(self):
15897 
    return
15898 
 
15899 
 
15900 
  def __repr__(self):
15901 
    L = ['%s=%r' % (key, value)
15902 
      for key, value in self.__dict__.iteritems()]
15903 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15904 
 
15905 
  def __eq__(self, other):
15906 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15907 
 
15908 
  def __ne__(self, other):
15909 
    return not (self == other)
15910 
 
15911 
class getAllBanners_args:
15912 
 
15913 
  thrift_spec = (
15914 
  )
15915 
 
15916 
  def read(self, iprot):
15917 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15918 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15919 
      return
15920 
    iprot.readStructBegin()
15921 
    while True:
15922 
      (fname, ftype, fid) = iprot.readFieldBegin()
15923 
      if ftype == TType.STOP:
15924 
        break
15925 
      else:
15926 
        iprot.skip(ftype)
15927 
      iprot.readFieldEnd()
15928 
    iprot.readStructEnd()
15929 
 
15930 
  def write(self, oprot):
15931 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15932 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15933 
      return
15934 
    oprot.writeStructBegin('getAllBanners_args')
15935 
    oprot.writeFieldStop()
15936 
    oprot.writeStructEnd()
15937 
 
15938 
  def validate(self):
15939 
    return
15940 
 
15941 
 
15942 
  def __repr__(self):
15943 
    L = ['%s=%r' % (key, value)
15944 
      for key, value in self.__dict__.iteritems()]
15945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15946 
 
15947 
  def __eq__(self, other):
15948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15949 
 
15950 
  def __ne__(self, other):
15951 
    return not (self == other)
15952 
 
15953 
class getAllBanners_result:
15954 
  """
15955 
  Attributes:
15956 
   - success
15957 
  """
15958 
 
15959 
  thrift_spec = (
8579 kshitij.so 15960 
    (0, TType.LIST, 'success', (TType.STRUCT,(Banner, Banner.thrift_spec)), None, ), # 0
6850 kshitij.so 15961 
  )
15962 
 
15963 
  def __init__(self, success=None,):
15964 
    self.success = success
15965 
 
15966 
  def read(self, iprot):
15967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15969 
      return
15970 
    iprot.readStructBegin()
15971 
    while True:
15972 
      (fname, ftype, fid) = iprot.readFieldBegin()
15973 
      if ftype == TType.STOP:
15974 
        break
15975 
      if fid == 0:
15976 
        if ftype == TType.LIST:
15977 
          self.success = []
13493 amit.gupta 15978 
          (_etype223, _size220) = iprot.readListBegin()
15979 
          for _i224 in xrange(_size220):
15980 
            _elem225 = Banner()
15981 
            _elem225.read(iprot)
15982 
            self.success.append(_elem225)
6850 kshitij.so 15983 
          iprot.readListEnd()
15984 
        else:
15985 
          iprot.skip(ftype)
15986 
      else:
15987 
        iprot.skip(ftype)
15988 
      iprot.readFieldEnd()
15989 
    iprot.readStructEnd()
15990 
 
15991 
  def write(self, oprot):
15992 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15993 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15994 
      return
15995 
    oprot.writeStructBegin('getAllBanners_result')
15996 
    if self.success is not None:
15997 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8579 kshitij.so 15998 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 15999 
      for iter226 in self.success:
16000 
        iter226.write(oprot)
6850 kshitij.so 16001 
      oprot.writeListEnd()
16002 
      oprot.writeFieldEnd()
16003 
    oprot.writeFieldStop()
16004 
    oprot.writeStructEnd()
16005 
 
16006 
  def validate(self):
16007 
    return
16008 
 
16009 
 
16010 
  def __repr__(self):
16011 
    L = ['%s=%r' % (key, value)
16012 
      for key, value in self.__dict__.iteritems()]
16013 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16014 
 
16015 
  def __eq__(self, other):
16016 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16017 
 
16018 
  def __ne__(self, other):
16019 
    return not (self == other)
16020 
 
16021 
class deleteBanner_args:
16022 
  """
16023 
  Attributes:
16024 
   - bannerName
9155 kshitij.so 16025 
   - bannerType
6850 kshitij.so 16026 
  """
16027 
 
16028 
  thrift_spec = (
16029 
    None, # 0
16030 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 16031 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6850 kshitij.so 16032 
  )
16033 
 
9155 kshitij.so 16034 
  def __init__(self, bannerName=None, bannerType=None,):
6850 kshitij.so 16035 
    self.bannerName = bannerName
9155 kshitij.so 16036 
    self.bannerType = bannerType
6850 kshitij.so 16037 
 
16038 
  def read(self, iprot):
16039 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16040 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16041 
      return
16042 
    iprot.readStructBegin()
16043 
    while True:
16044 
      (fname, ftype, fid) = iprot.readFieldBegin()
16045 
      if ftype == TType.STOP:
16046 
        break
16047 
      if fid == 1:
16048 
        if ftype == TType.STRING:
16049 
          self.bannerName = iprot.readString();
16050 
        else:
16051 
          iprot.skip(ftype)
9155 kshitij.so 16052 
      elif fid == 2:
16053 
        if ftype == TType.I32:
16054 
          self.bannerType = iprot.readI32();
16055 
        else:
16056 
          iprot.skip(ftype)
6850 kshitij.so 16057 
      else:
16058 
        iprot.skip(ftype)
16059 
      iprot.readFieldEnd()
16060 
    iprot.readStructEnd()
16061 
 
16062 
  def write(self, oprot):
16063 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16064 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16065 
      return
16066 
    oprot.writeStructBegin('deleteBanner_args')
16067 
    if self.bannerName is not None:
16068 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
16069 
      oprot.writeString(self.bannerName)
16070 
      oprot.writeFieldEnd()
9155 kshitij.so 16071 
    if self.bannerType is not None:
16072 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
16073 
      oprot.writeI32(self.bannerType)
16074 
      oprot.writeFieldEnd()
6850 kshitij.so 16075 
    oprot.writeFieldStop()
16076 
    oprot.writeStructEnd()
16077 
 
16078 
  def validate(self):
16079 
    return
16080 
 
16081 
 
16082 
  def __repr__(self):
16083 
    L = ['%s=%r' % (key, value)
16084 
      for key, value in self.__dict__.iteritems()]
16085 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16086 
 
16087 
  def __eq__(self, other):
16088 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16089 
 
16090 
  def __ne__(self, other):
16091 
    return not (self == other)
16092 
 
16093 
class deleteBanner_result:
16094 
  """
16095 
  Attributes:
16096 
   - success
16097 
  """
16098 
 
16099 
  thrift_spec = (
16100 
    (0, TType.BOOL, 'success', None, None, ), # 0
16101 
  )
16102 
 
16103 
  def __init__(self, success=None,):
16104 
    self.success = success
16105 
 
16106 
  def read(self, iprot):
16107 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16108 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16109 
      return
16110 
    iprot.readStructBegin()
16111 
    while True:
16112 
      (fname, ftype, fid) = iprot.readFieldBegin()
16113 
      if ftype == TType.STOP:
16114 
        break
16115 
      if fid == 0:
16116 
        if ftype == TType.BOOL:
16117 
          self.success = iprot.readBool();
16118 
        else:
16119 
          iprot.skip(ftype)
16120 
      else:
16121 
        iprot.skip(ftype)
16122 
      iprot.readFieldEnd()
16123 
    iprot.readStructEnd()
16124 
 
16125 
  def write(self, oprot):
16126 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16127 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16128 
      return
16129 
    oprot.writeStructBegin('deleteBanner_result')
16130 
    if self.success is not None:
16131 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16132 
      oprot.writeBool(self.success)
16133 
      oprot.writeFieldEnd()
16134 
    oprot.writeFieldStop()
16135 
    oprot.writeStructEnd()
16136 
 
16137 
  def validate(self):
16138 
    return
16139 
 
16140 
 
16141 
  def __repr__(self):
16142 
    L = ['%s=%r' % (key, value)
16143 
      for key, value in self.__dict__.iteritems()]
16144 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16145 
 
16146 
  def __eq__(self, other):
16147 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16148 
 
16149 
  def __ne__(self, other):
16150 
    return not (self == other)
16151 
 
16152 
class getBannerDetails_args:
16153 
  """
16154 
  Attributes:
16155 
   - bannerName
9155 kshitij.so 16156 
   - bannerType
6850 kshitij.so 16157 
  """
16158 
 
16159 
  thrift_spec = (
16160 
    None, # 0
16161 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 16162 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6850 kshitij.so 16163 
  )
16164 
 
9155 kshitij.so 16165 
  def __init__(self, bannerName=None, bannerType=None,):
6850 kshitij.so 16166 
    self.bannerName = bannerName
9155 kshitij.so 16167 
    self.bannerType = bannerType
6850 kshitij.so 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.STRING:
16180 
          self.bannerName = iprot.readString();
16181 
        else:
16182 
          iprot.skip(ftype)
9155 kshitij.so 16183 
      elif fid == 2:
16184 
        if ftype == TType.I32:
16185 
          self.bannerType = iprot.readI32();
16186 
        else:
16187 
          iprot.skip(ftype)
6850 kshitij.so 16188 
      else:
16189 
        iprot.skip(ftype)
16190 
      iprot.readFieldEnd()
16191 
    iprot.readStructEnd()
16192 
 
16193 
  def write(self, oprot):
16194 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16195 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16196 
      return
16197 
    oprot.writeStructBegin('getBannerDetails_args')
16198 
    if self.bannerName is not None:
16199 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
16200 
      oprot.writeString(self.bannerName)
16201 
      oprot.writeFieldEnd()
9155 kshitij.so 16202 
    if self.bannerType is not None:
16203 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
16204 
      oprot.writeI32(self.bannerType)
16205 
      oprot.writeFieldEnd()
6850 kshitij.so 16206 
    oprot.writeFieldStop()
16207 
    oprot.writeStructEnd()
16208 
 
16209 
  def validate(self):
16210 
    return
16211 
 
16212 
 
16213 
  def __repr__(self):
16214 
    L = ['%s=%r' % (key, value)
16215 
      for key, value in self.__dict__.iteritems()]
16216 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16217 
 
16218 
  def __eq__(self, other):
16219 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16220 
 
16221 
  def __ne__(self, other):
16222 
    return not (self == other)
16223 
 
16224 
class getBannerDetails_result:
16225 
  """
16226 
  Attributes:
16227 
   - success
16228 
  """
16229 
 
16230 
  thrift_spec = (
16231 
    (0, TType.STRUCT, 'success', (Banner, Banner.thrift_spec), None, ), # 0
16232 
  )
16233 
 
16234 
  def __init__(self, success=None,):
16235 
    self.success = success
16236 
 
16237 
  def read(self, iprot):
16238 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16239 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16240 
      return
16241 
    iprot.readStructBegin()
16242 
    while True:
16243 
      (fname, ftype, fid) = iprot.readFieldBegin()
16244 
      if ftype == TType.STOP:
16245 
        break
16246 
      if fid == 0:
16247 
        if ftype == TType.STRUCT:
16248 
          self.success = Banner()
16249 
          self.success.read(iprot)
16250 
        else:
16251 
          iprot.skip(ftype)
16252 
      else:
16253 
        iprot.skip(ftype)
16254 
      iprot.readFieldEnd()
16255 
    iprot.readStructEnd()
16256 
 
16257 
  def write(self, oprot):
16258 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16259 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16260 
      return
16261 
    oprot.writeStructBegin('getBannerDetails_result')
16262 
    if self.success is not None:
16263 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16264 
      self.success.write(oprot)
16265 
      oprot.writeFieldEnd()
16266 
    oprot.writeFieldStop()
16267 
    oprot.writeStructEnd()
16268 
 
16269 
  def validate(self):
16270 
    return
16271 
 
16272 
 
16273 
  def __repr__(self):
16274 
    L = ['%s=%r' % (key, value)
16275 
      for key, value in self.__dict__.iteritems()]
16276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16277 
 
16278 
  def __eq__(self, other):
16279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16280 
 
16281 
  def __ne__(self, other):
16282 
    return not (self == other)
16283 
 
16284 
class getActiveBanners_args:
16285 
 
16286 
  thrift_spec = (
16287 
  )
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 
      else:
16299 
        iprot.skip(ftype)
16300 
      iprot.readFieldEnd()
16301 
    iprot.readStructEnd()
16302 
 
16303 
  def write(self, oprot):
16304 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16305 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16306 
      return
16307 
    oprot.writeStructBegin('getActiveBanners_args')
16308 
    oprot.writeFieldStop()
16309 
    oprot.writeStructEnd()
16310 
 
16311 
  def validate(self):
16312 
    return
16313 
 
16314 
 
16315 
  def __repr__(self):
16316 
    L = ['%s=%r' % (key, value)
16317 
      for key, value in self.__dict__.iteritems()]
16318 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16319 
 
16320 
  def __eq__(self, other):
16321 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16322 
 
16323 
  def __ne__(self, other):
16324 
    return not (self == other)
16325 
 
16326 
class getActiveBanners_result:
16327 
  """
16328 
  Attributes:
16329 
   - success
16330 
  """
16331 
 
16332 
  thrift_spec = (
8579 kshitij.so 16333 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
6850 kshitij.so 16334 
  )
16335 
 
16336 
  def __init__(self, success=None,):
16337 
    self.success = success
16338 
 
16339 
  def read(self, iprot):
16340 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16341 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16342 
      return
16343 
    iprot.readStructBegin()
16344 
    while True:
16345 
      (fname, ftype, fid) = iprot.readFieldBegin()
16346 
      if ftype == TType.STOP:
16347 
        break
16348 
      if fid == 0:
8579 kshitij.so 16349 
        if ftype == TType.MAP:
16350 
          self.success = {}
13493 amit.gupta 16351 
          (_ktype228, _vtype229, _size227 ) = iprot.readMapBegin()
16352 
          for _i231 in xrange(_size227):
16353 
            _key232 = iprot.readString();
16354 
            _val233 = []
16355 
            (_etype237, _size234) = iprot.readListBegin()
16356 
            for _i238 in xrange(_size234):
16357 
              _elem239 = Banner()
16358 
              _elem239.read(iprot)
16359 
              _val233.append(_elem239)
8579 kshitij.so 16360 
            iprot.readListEnd()
13493 amit.gupta 16361 
            self.success[_key232] = _val233
8579 kshitij.so 16362 
          iprot.readMapEnd()
6850 kshitij.so 16363 
        else:
16364 
          iprot.skip(ftype)
16365 
      else:
16366 
        iprot.skip(ftype)
16367 
      iprot.readFieldEnd()
16368 
    iprot.readStructEnd()
16369 
 
16370 
  def write(self, oprot):
16371 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16372 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16373 
      return
16374 
    oprot.writeStructBegin('getActiveBanners_result')
16375 
    if self.success is not None:
8579 kshitij.so 16376 
      oprot.writeFieldBegin('success', TType.MAP, 0)
16377 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
13493 amit.gupta 16378 
      for kiter240,viter241 in self.success.items():
16379 
        oprot.writeString(kiter240)
16380 
        oprot.writeListBegin(TType.STRUCT, len(viter241))
16381 
        for iter242 in viter241:
16382 
          iter242.write(oprot)
8579 kshitij.so 16383 
        oprot.writeListEnd()
16384 
      oprot.writeMapEnd()
6850 kshitij.so 16385 
      oprot.writeFieldEnd()
16386 
    oprot.writeFieldStop()
16387 
    oprot.writeStructEnd()
16388 
 
16389 
  def validate(self):
16390 
    return
16391 
 
16392 
 
16393 
  def __repr__(self):
16394 
    L = ['%s=%r' % (key, value)
16395 
      for key, value in self.__dict__.iteritems()]
16396 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16397 
 
16398 
  def __eq__(self, other):
16399 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16400 
 
16401 
  def __ne__(self, other):
16402 
    return not (self == other)
16403 
 
6849 kshitij.so 16404 
class addBannerMap_args:
16405 
  """
16406 
  Attributes:
8579 kshitij.so 16407 
   - bannerMaps
6849 kshitij.so 16408 
  """
16409 
 
16410 
  thrift_spec = (
16411 
    None, # 0
8579 kshitij.so 16412 
    (1, TType.LIST, 'bannerMaps', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 1
6849 kshitij.so 16413 
  )
16414 
 
8579 kshitij.so 16415 
  def __init__(self, bannerMaps=None,):
16416 
    self.bannerMaps = bannerMaps
6849 kshitij.so 16417 
 
16418 
  def read(self, iprot):
16419 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16420 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16421 
      return
16422 
    iprot.readStructBegin()
16423 
    while True:
16424 
      (fname, ftype, fid) = iprot.readFieldBegin()
16425 
      if ftype == TType.STOP:
16426 
        break
16427 
      if fid == 1:
8579 kshitij.so 16428 
        if ftype == TType.LIST:
16429 
          self.bannerMaps = []
13493 amit.gupta 16430 
          (_etype246, _size243) = iprot.readListBegin()
16431 
          for _i247 in xrange(_size243):
16432 
            _elem248 = BannerMap()
16433 
            _elem248.read(iprot)
16434 
            self.bannerMaps.append(_elem248)
8579 kshitij.so 16435 
          iprot.readListEnd()
6849 kshitij.so 16436 
        else:
16437 
          iprot.skip(ftype)
8579 kshitij.so 16438 
      else:
16439 
        iprot.skip(ftype)
16440 
      iprot.readFieldEnd()
16441 
    iprot.readStructEnd()
16442 
 
16443 
  def write(self, oprot):
16444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16446 
      return
16447 
    oprot.writeStructBegin('addBannerMap_args')
16448 
    if self.bannerMaps is not None:
16449 
      oprot.writeFieldBegin('bannerMaps', TType.LIST, 1)
16450 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerMaps))
13493 amit.gupta 16451 
      for iter249 in self.bannerMaps:
16452 
        iter249.write(oprot)
8579 kshitij.so 16453 
      oprot.writeListEnd()
16454 
      oprot.writeFieldEnd()
16455 
    oprot.writeFieldStop()
16456 
    oprot.writeStructEnd()
16457 
 
16458 
  def validate(self):
16459 
    return
16460 
 
16461 
 
16462 
  def __repr__(self):
16463 
    L = ['%s=%r' % (key, value)
16464 
      for key, value in self.__dict__.iteritems()]
16465 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16466 
 
16467 
  def __eq__(self, other):
16468 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16469 
 
16470 
  def __ne__(self, other):
16471 
    return not (self == other)
16472 
 
16473 
class addBannerMap_result:
16474 
  """
16475 
  Attributes:
16476 
   - success
16477 
  """
16478 
 
16479 
  thrift_spec = (
16480 
    (0, TType.BOOL, 'success', None, None, ), # 0
16481 
  )
16482 
 
16483 
  def __init__(self, success=None,):
16484 
    self.success = success
16485 
 
16486 
  def read(self, iprot):
16487 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16488 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16489 
      return
16490 
    iprot.readStructBegin()
16491 
    while True:
16492 
      (fname, ftype, fid) = iprot.readFieldBegin()
16493 
      if ftype == TType.STOP:
16494 
        break
16495 
      if fid == 0:
16496 
        if ftype == TType.BOOL:
16497 
          self.success = iprot.readBool();
6849 kshitij.so 16498 
        else:
16499 
          iprot.skip(ftype)
8579 kshitij.so 16500 
      else:
16501 
        iprot.skip(ftype)
16502 
      iprot.readFieldEnd()
16503 
    iprot.readStructEnd()
16504 
 
16505 
  def write(self, oprot):
16506 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16507 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16508 
      return
16509 
    oprot.writeStructBegin('addBannerMap_result')
16510 
    if self.success is not None:
16511 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16512 
      oprot.writeBool(self.success)
16513 
      oprot.writeFieldEnd()
16514 
    oprot.writeFieldStop()
16515 
    oprot.writeStructEnd()
16516 
 
16517 
  def validate(self):
16518 
    return
16519 
 
16520 
 
16521 
  def __repr__(self):
16522 
    L = ['%s=%r' % (key, value)
16523 
      for key, value in self.__dict__.iteritems()]
16524 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16525 
 
16526 
  def __eq__(self, other):
16527 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16528 
 
16529 
  def __ne__(self, other):
16530 
    return not (self == other)
16531 
 
16532 
class updateBannerMap_args:
16533 
  """
16534 
  Attributes:
16535 
   - bannerMap
16536 
  """
16537 
 
16538 
  thrift_spec = (
16539 
    None, # 0
16540 
    (1, TType.STRUCT, 'bannerMap', (BannerMap, BannerMap.thrift_spec), None, ), # 1
16541 
  )
16542 
 
16543 
  def __init__(self, bannerMap=None,):
16544 
    self.bannerMap = bannerMap
16545 
 
16546 
  def read(self, iprot):
16547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16549 
      return
16550 
    iprot.readStructBegin()
16551 
    while True:
16552 
      (fname, ftype, fid) = iprot.readFieldBegin()
16553 
      if ftype == TType.STOP:
16554 
        break
16555 
      if fid == 1:
16556 
        if ftype == TType.STRUCT:
16557 
          self.bannerMap = BannerMap()
16558 
          self.bannerMap.read(iprot)
6849 kshitij.so 16559 
        else:
16560 
          iprot.skip(ftype)
16561 
      else:
16562 
        iprot.skip(ftype)
16563 
      iprot.readFieldEnd()
16564 
    iprot.readStructEnd()
16565 
 
16566 
  def write(self, oprot):
16567 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16568 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16569 
      return
8579 kshitij.so 16570 
    oprot.writeStructBegin('updateBannerMap_args')
16571 
    if self.bannerMap is not None:
16572 
      oprot.writeFieldBegin('bannerMap', TType.STRUCT, 1)
16573 
      self.bannerMap.write(oprot)
6849 kshitij.so 16574 
      oprot.writeFieldEnd()
16575 
    oprot.writeFieldStop()
16576 
    oprot.writeStructEnd()
16577 
 
16578 
  def validate(self):
16579 
    return
16580 
 
16581 
 
16582 
  def __repr__(self):
16583 
    L = ['%s=%r' % (key, value)
16584 
      for key, value in self.__dict__.iteritems()]
16585 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16586 
 
16587 
  def __eq__(self, other):
16588 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16589 
 
16590 
  def __ne__(self, other):
16591 
    return not (self == other)
16592 
 
8579 kshitij.so 16593 
class updateBannerMap_result:
6849 kshitij.so 16594 
  """
16595 
  Attributes:
16596 
   - success
16597 
  """
16598 
 
16599 
  thrift_spec = (
16600 
    (0, TType.BOOL, 'success', None, None, ), # 0
16601 
  )
16602 
 
16603 
  def __init__(self, success=None,):
16604 
    self.success = success
16605 
 
16606 
  def read(self, iprot):
16607 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16608 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16609 
      return
16610 
    iprot.readStructBegin()
16611 
    while True:
16612 
      (fname, ftype, fid) = iprot.readFieldBegin()
16613 
      if ftype == TType.STOP:
16614 
        break
16615 
      if fid == 0:
16616 
        if ftype == TType.BOOL:
16617 
          self.success = iprot.readBool();
16618 
        else:
16619 
          iprot.skip(ftype)
16620 
      else:
16621 
        iprot.skip(ftype)
16622 
      iprot.readFieldEnd()
16623 
    iprot.readStructEnd()
16624 
 
16625 
  def write(self, oprot):
16626 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16627 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16628 
      return
8579 kshitij.so 16629 
    oprot.writeStructBegin('updateBannerMap_result')
6849 kshitij.so 16630 
    if self.success is not None:
16631 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16632 
      oprot.writeBool(self.success)
16633 
      oprot.writeFieldEnd()
16634 
    oprot.writeFieldStop()
16635 
    oprot.writeStructEnd()
16636 
 
16637 
  def validate(self):
16638 
    return
16639 
 
16640 
 
16641 
  def __repr__(self):
16642 
    L = ['%s=%r' % (key, value)
16643 
      for key, value in self.__dict__.iteritems()]
16644 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16645 
 
16646 
  def __eq__(self, other):
16647 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16648 
 
16649 
  def __ne__(self, other):
16650 
    return not (self == other)
16651 
 
16652 
class deleteBannerMap_args:
16653 
  """
16654 
  Attributes:
16655 
   - bannerName
16656 
  """
16657 
 
16658 
  thrift_spec = (
16659 
    None, # 0
16660 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
16661 
  )
16662 
 
16663 
  def __init__(self, bannerName=None,):
16664 
    self.bannerName = bannerName
16665 
 
16666 
  def read(self, iprot):
16667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16669 
      return
16670 
    iprot.readStructBegin()
16671 
    while True:
16672 
      (fname, ftype, fid) = iprot.readFieldBegin()
16673 
      if ftype == TType.STOP:
16674 
        break
16675 
      if fid == 1:
16676 
        if ftype == TType.STRING:
16677 
          self.bannerName = iprot.readString();
16678 
        else:
16679 
          iprot.skip(ftype)
16680 
      else:
16681 
        iprot.skip(ftype)
16682 
      iprot.readFieldEnd()
16683 
    iprot.readStructEnd()
16684 
 
16685 
  def write(self, oprot):
16686 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16687 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16688 
      return
16689 
    oprot.writeStructBegin('deleteBannerMap_args')
16690 
    if self.bannerName is not None:
16691 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
16692 
      oprot.writeString(self.bannerName)
16693 
      oprot.writeFieldEnd()
16694 
    oprot.writeFieldStop()
16695 
    oprot.writeStructEnd()
16696 
 
16697 
  def validate(self):
16698 
    return
16699 
 
16700 
 
16701 
  def __repr__(self):
16702 
    L = ['%s=%r' % (key, value)
16703 
      for key, value in self.__dict__.iteritems()]
16704 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16705 
 
16706 
  def __eq__(self, other):
16707 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16708 
 
16709 
  def __ne__(self, other):
16710 
    return not (self == other)
16711 
 
16712 
class deleteBannerMap_result:
16713 
  """
16714 
  Attributes:
16715 
   - success
16716 
  """
16717 
 
16718 
  thrift_spec = (
16719 
    (0, TType.BOOL, 'success', None, None, ), # 0
16720 
  )
16721 
 
16722 
  def __init__(self, success=None,):
16723 
    self.success = success
16724 
 
16725 
  def read(self, iprot):
16726 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16727 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16728 
      return
16729 
    iprot.readStructBegin()
16730 
    while True:
16731 
      (fname, ftype, fid) = iprot.readFieldBegin()
16732 
      if ftype == TType.STOP:
16733 
        break
16734 
      if fid == 0:
16735 
        if ftype == TType.BOOL:
16736 
          self.success = iprot.readBool();
16737 
        else:
16738 
          iprot.skip(ftype)
16739 
      else:
16740 
        iprot.skip(ftype)
16741 
      iprot.readFieldEnd()
16742 
    iprot.readStructEnd()
16743 
 
16744 
  def write(self, oprot):
16745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16747 
      return
16748 
    oprot.writeStructBegin('deleteBannerMap_result')
16749 
    if self.success is not None:
16750 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16751 
      oprot.writeBool(self.success)
16752 
      oprot.writeFieldEnd()
16753 
    oprot.writeFieldStop()
16754 
    oprot.writeStructEnd()
16755 
 
16756 
  def validate(self):
16757 
    return
16758 
 
16759 
 
16760 
  def __repr__(self):
16761 
    L = ['%s=%r' % (key, value)
16762 
      for key, value in self.__dict__.iteritems()]
16763 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16764 
 
16765 
  def __eq__(self, other):
16766 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16767 
 
16768 
  def __ne__(self, other):
16769 
    return not (self == other)
16770 
 
16771 
class getBannerMapDetails_args:
16772 
  """
16773 
  Attributes:
16774 
   - bannerName
9155 kshitij.so 16775 
   - bannerType
6849 kshitij.so 16776 
  """
16777 
 
16778 
  thrift_spec = (
16779 
    None, # 0
16780 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 16781 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6849 kshitij.so 16782 
  )
16783 
 
9155 kshitij.so 16784 
  def __init__(self, bannerName=None, bannerType=None,):
6849 kshitij.so 16785 
    self.bannerName = bannerName
9155 kshitij.so 16786 
    self.bannerType = bannerType
6849 kshitij.so 16787 
 
16788 
  def read(self, iprot):
16789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16791 
      return
16792 
    iprot.readStructBegin()
16793 
    while True:
16794 
      (fname, ftype, fid) = iprot.readFieldBegin()
16795 
      if ftype == TType.STOP:
16796 
        break
16797 
      if fid == 1:
16798 
        if ftype == TType.STRING:
16799 
          self.bannerName = iprot.readString();
16800 
        else:
16801 
          iprot.skip(ftype)
9155 kshitij.so 16802 
      elif fid == 2:
16803 
        if ftype == TType.I32:
16804 
          self.bannerType = iprot.readI32();
16805 
        else:
16806 
          iprot.skip(ftype)
6849 kshitij.so 16807 
      else:
16808 
        iprot.skip(ftype)
16809 
      iprot.readFieldEnd()
16810 
    iprot.readStructEnd()
16811 
 
16812 
  def write(self, oprot):
16813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16815 
      return
16816 
    oprot.writeStructBegin('getBannerMapDetails_args')
16817 
    if self.bannerName is not None:
16818 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
16819 
      oprot.writeString(self.bannerName)
16820 
      oprot.writeFieldEnd()
9155 kshitij.so 16821 
    if self.bannerType is not None:
16822 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
16823 
      oprot.writeI32(self.bannerType)
16824 
      oprot.writeFieldEnd()
6849 kshitij.so 16825 
    oprot.writeFieldStop()
16826 
    oprot.writeStructEnd()
16827 
 
16828 
  def validate(self):
16829 
    return
16830 
 
16831 
 
16832 
  def __repr__(self):
16833 
    L = ['%s=%r' % (key, value)
16834 
      for key, value in self.__dict__.iteritems()]
16835 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16836 
 
16837 
  def __eq__(self, other):
16838 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16839 
 
16840 
  def __ne__(self, other):
16841 
    return not (self == other)
16842 
 
16843 
class getBannerMapDetails_result:
16844 
  """
16845 
  Attributes:
16846 
   - success
16847 
  """
16848 
 
16849 
  thrift_spec = (
16850 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 0
16851 
  )
16852 
 
16853 
  def __init__(self, success=None,):
16854 
    self.success = success
16855 
 
16856 
  def read(self, iprot):
16857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16859 
      return
16860 
    iprot.readStructBegin()
16861 
    while True:
16862 
      (fname, ftype, fid) = iprot.readFieldBegin()
16863 
      if ftype == TType.STOP:
16864 
        break
16865 
      if fid == 0:
16866 
        if ftype == TType.LIST:
16867 
          self.success = []
13493 amit.gupta 16868 
          (_etype253, _size250) = iprot.readListBegin()
16869 
          for _i254 in xrange(_size250):
16870 
            _elem255 = BannerMap()
16871 
            _elem255.read(iprot)
16872 
            self.success.append(_elem255)
6849 kshitij.so 16873 
          iprot.readListEnd()
16874 
        else:
16875 
          iprot.skip(ftype)
16876 
      else:
16877 
        iprot.skip(ftype)
16878 
      iprot.readFieldEnd()
16879 
    iprot.readStructEnd()
16880 
 
16881 
  def write(self, oprot):
16882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16884 
      return
16885 
    oprot.writeStructBegin('getBannerMapDetails_result')
16886 
    if self.success is not None:
16887 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16888 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 16889 
      for iter256 in self.success:
16890 
        iter256.write(oprot)
6849 kshitij.so 16891 
      oprot.writeListEnd()
16892 
      oprot.writeFieldEnd()
16893 
    oprot.writeFieldStop()
16894 
    oprot.writeStructEnd()
16895 
 
16896 
  def validate(self):
16897 
    return
16898 
 
16899 
 
16900 
  def __repr__(self):
16901 
    L = ['%s=%r' % (key, value)
16902 
      for key, value in self.__dict__.iteritems()]
16903 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16904 
 
16905 
  def __eq__(self, other):
16906 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16907 
 
16908 
  def __ne__(self, other):
16909 
    return not (self == other)
16910 
 
8579 kshitij.so 16911 
class addBannerUri_args:
16912 
  """
16913 
  Attributes:
16914 
   - bannerUriMappings
16915 
  """
16916 
 
16917 
  thrift_spec = (
16918 
    None, # 0
16919 
    (1, TType.LIST, 'bannerUriMappings', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 1
16920 
  )
16921 
 
16922 
  def __init__(self, bannerUriMappings=None,):
16923 
    self.bannerUriMappings = bannerUriMappings
16924 
 
16925 
  def read(self, iprot):
16926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16928 
      return
16929 
    iprot.readStructBegin()
16930 
    while True:
16931 
      (fname, ftype, fid) = iprot.readFieldBegin()
16932 
      if ftype == TType.STOP:
16933 
        break
16934 
      if fid == 1:
16935 
        if ftype == TType.LIST:
16936 
          self.bannerUriMappings = []
13493 amit.gupta 16937 
          (_etype260, _size257) = iprot.readListBegin()
16938 
          for _i261 in xrange(_size257):
16939 
            _elem262 = BannerUriMapping()
16940 
            _elem262.read(iprot)
16941 
            self.bannerUriMappings.append(_elem262)
8579 kshitij.so 16942 
          iprot.readListEnd()
16943 
        else:
16944 
          iprot.skip(ftype)
16945 
      else:
16946 
        iprot.skip(ftype)
16947 
      iprot.readFieldEnd()
16948 
    iprot.readStructEnd()
16949 
 
16950 
  def write(self, oprot):
16951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16953 
      return
16954 
    oprot.writeStructBegin('addBannerUri_args')
16955 
    if self.bannerUriMappings is not None:
16956 
      oprot.writeFieldBegin('bannerUriMappings', TType.LIST, 1)
16957 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerUriMappings))
13493 amit.gupta 16958 
      for iter263 in self.bannerUriMappings:
16959 
        iter263.write(oprot)
8579 kshitij.so 16960 
      oprot.writeListEnd()
16961 
      oprot.writeFieldEnd()
16962 
    oprot.writeFieldStop()
16963 
    oprot.writeStructEnd()
16964 
 
16965 
  def validate(self):
16966 
    return
16967 
 
16968 
 
16969 
  def __repr__(self):
16970 
    L = ['%s=%r' % (key, value)
16971 
      for key, value in self.__dict__.iteritems()]
16972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16973 
 
16974 
  def __eq__(self, other):
16975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16976 
 
16977 
  def __ne__(self, other):
16978 
    return not (self == other)
16979 
 
16980 
class addBannerUri_result:
16981 
 
16982 
  thrift_spec = (
16983 
  )
16984 
 
16985 
  def read(self, iprot):
16986 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16987 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16988 
      return
16989 
    iprot.readStructBegin()
16990 
    while True:
16991 
      (fname, ftype, fid) = iprot.readFieldBegin()
16992 
      if ftype == TType.STOP:
16993 
        break
16994 
      else:
16995 
        iprot.skip(ftype)
16996 
      iprot.readFieldEnd()
16997 
    iprot.readStructEnd()
16998 
 
16999 
  def write(self, oprot):
17000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17002 
      return
17003 
    oprot.writeStructBegin('addBannerUri_result')
17004 
    oprot.writeFieldStop()
17005 
    oprot.writeStructEnd()
17006 
 
17007 
  def validate(self):
17008 
    return
17009 
 
17010 
 
17011 
  def __repr__(self):
17012 
    L = ['%s=%r' % (key, value)
17013 
      for key, value in self.__dict__.iteritems()]
17014 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17015 
 
17016 
  def __eq__(self, other):
17017 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17018 
 
17019 
  def __ne__(self, other):
17020 
    return not (self == other)
17021 
 
17022 
class getUriMapping_args:
17023 
  """
17024 
  Attributes:
17025 
   - bannerName
9155 kshitij.so 17026 
   - bannerType
8579 kshitij.so 17027 
  """
17028 
 
17029 
  thrift_spec = (
17030 
    None, # 0
17031 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 17032 
    (2, TType.I32, 'bannerType', None, None, ), # 2
8579 kshitij.so 17033 
  )
17034 
 
9155 kshitij.so 17035 
  def __init__(self, bannerName=None, bannerType=None,):
8579 kshitij.so 17036 
    self.bannerName = bannerName
9155 kshitij.so 17037 
    self.bannerType = bannerType
8579 kshitij.so 17038 
 
17039 
  def read(self, iprot):
17040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17042 
      return
17043 
    iprot.readStructBegin()
17044 
    while True:
17045 
      (fname, ftype, fid) = iprot.readFieldBegin()
17046 
      if ftype == TType.STOP:
17047 
        break
17048 
      if fid == 1:
17049 
        if ftype == TType.STRING:
17050 
          self.bannerName = iprot.readString();
17051 
        else:
17052 
          iprot.skip(ftype)
9155 kshitij.so 17053 
      elif fid == 2:
17054 
        if ftype == TType.I32:
17055 
          self.bannerType = iprot.readI32();
17056 
        else:
17057 
          iprot.skip(ftype)
8579 kshitij.so 17058 
      else:
17059 
        iprot.skip(ftype)
17060 
      iprot.readFieldEnd()
17061 
    iprot.readStructEnd()
17062 
 
17063 
  def write(self, oprot):
17064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17066 
      return
17067 
    oprot.writeStructBegin('getUriMapping_args')
17068 
    if self.bannerName is not None:
17069 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
17070 
      oprot.writeString(self.bannerName)
17071 
      oprot.writeFieldEnd()
9155 kshitij.so 17072 
    if self.bannerType is not None:
17073 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
17074 
      oprot.writeI32(self.bannerType)
17075 
      oprot.writeFieldEnd()
8579 kshitij.so 17076 
    oprot.writeFieldStop()
17077 
    oprot.writeStructEnd()
17078 
 
17079 
  def validate(self):
17080 
    return
17081 
 
17082 
 
17083 
  def __repr__(self):
17084 
    L = ['%s=%r' % (key, value)
17085 
      for key, value in self.__dict__.iteritems()]
17086 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17087 
 
17088 
  def __eq__(self, other):
17089 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17090 
 
17091 
  def __ne__(self, other):
17092 
    return not (self == other)
17093 
 
17094 
class getUriMapping_result:
17095 
  """
17096 
  Attributes:
17097 
   - success
17098 
  """
17099 
 
17100 
  thrift_spec = (
17101 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 0
17102 
  )
17103 
 
17104 
  def __init__(self, success=None,):
17105 
    self.success = success
17106 
 
17107 
  def read(self, iprot):
17108 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17109 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17110 
      return
17111 
    iprot.readStructBegin()
17112 
    while True:
17113 
      (fname, ftype, fid) = iprot.readFieldBegin()
17114 
      if ftype == TType.STOP:
17115 
        break
17116 
      if fid == 0:
17117 
        if ftype == TType.LIST:
17118 
          self.success = []
13493 amit.gupta 17119 
          (_etype267, _size264) = iprot.readListBegin()
17120 
          for _i268 in xrange(_size264):
17121 
            _elem269 = BannerUriMapping()
17122 
            _elem269.read(iprot)
17123 
            self.success.append(_elem269)
8579 kshitij.so 17124 
          iprot.readListEnd()
17125 
        else:
17126 
          iprot.skip(ftype)
17127 
      else:
17128 
        iprot.skip(ftype)
17129 
      iprot.readFieldEnd()
17130 
    iprot.readStructEnd()
17131 
 
17132 
  def write(self, oprot):
17133 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17134 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17135 
      return
17136 
    oprot.writeStructBegin('getUriMapping_result')
17137 
    if self.success is not None:
17138 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17139 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 17140 
      for iter270 in self.success:
17141 
        iter270.write(oprot)
8579 kshitij.so 17142 
      oprot.writeListEnd()
17143 
      oprot.writeFieldEnd()
17144 
    oprot.writeFieldStop()
17145 
    oprot.writeStructEnd()
17146 
 
17147 
  def validate(self):
17148 
    return
17149 
 
17150 
 
17151 
  def __repr__(self):
17152 
    L = ['%s=%r' % (key, value)
17153 
      for key, value in self.__dict__.iteritems()]
17154 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17155 
 
17156 
  def __eq__(self, other):
17157 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17158 
 
17159 
  def __ne__(self, other):
17160 
    return not (self == other)
17161 
 
17162 
class addCampaign_args:
17163 
  """
17164 
  Attributes:
17165 
   - campaign
17166 
  """
17167 
 
17168 
  thrift_spec = (
17169 
    None, # 0
17170 
    (1, TType.STRUCT, 'campaign', (Campaign, Campaign.thrift_spec), None, ), # 1
17171 
  )
17172 
 
17173 
  def __init__(self, campaign=None,):
17174 
    self.campaign = campaign
17175 
 
17176 
  def read(self, iprot):
17177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17179 
      return
17180 
    iprot.readStructBegin()
17181 
    while True:
17182 
      (fname, ftype, fid) = iprot.readFieldBegin()
17183 
      if ftype == TType.STOP:
17184 
        break
17185 
      if fid == 1:
17186 
        if ftype == TType.STRUCT:
17187 
          self.campaign = Campaign()
17188 
          self.campaign.read(iprot)
17189 
        else:
17190 
          iprot.skip(ftype)
17191 
      else:
17192 
        iprot.skip(ftype)
17193 
      iprot.readFieldEnd()
17194 
    iprot.readStructEnd()
17195 
 
17196 
  def write(self, oprot):
17197 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17198 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17199 
      return
17200 
    oprot.writeStructBegin('addCampaign_args')
17201 
    if self.campaign is not None:
17202 
      oprot.writeFieldBegin('campaign', TType.STRUCT, 1)
17203 
      self.campaign.write(oprot)
17204 
      oprot.writeFieldEnd()
17205 
    oprot.writeFieldStop()
17206 
    oprot.writeStructEnd()
17207 
 
17208 
  def validate(self):
17209 
    return
17210 
 
17211 
 
17212 
  def __repr__(self):
17213 
    L = ['%s=%r' % (key, value)
17214 
      for key, value in self.__dict__.iteritems()]
17215 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17216 
 
17217 
  def __eq__(self, other):
17218 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17219 
 
17220 
  def __ne__(self, other):
17221 
    return not (self == other)
17222 
 
17223 
class addCampaign_result:
17224 
 
17225 
  thrift_spec = (
17226 
  )
17227 
 
17228 
  def read(self, iprot):
17229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17231 
      return
17232 
    iprot.readStructBegin()
17233 
    while True:
17234 
      (fname, ftype, fid) = iprot.readFieldBegin()
17235 
      if ftype == TType.STOP:
17236 
        break
17237 
      else:
17238 
        iprot.skip(ftype)
17239 
      iprot.readFieldEnd()
17240 
    iprot.readStructEnd()
17241 
 
17242 
  def write(self, oprot):
17243 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17244 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17245 
      return
17246 
    oprot.writeStructBegin('addCampaign_result')
17247 
    oprot.writeFieldStop()
17248 
    oprot.writeStructEnd()
17249 
 
17250 
  def validate(self):
17251 
    return
17252 
 
17253 
 
17254 
  def __repr__(self):
17255 
    L = ['%s=%r' % (key, value)
17256 
      for key, value in self.__dict__.iteritems()]
17257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17258 
 
17259 
  def __eq__(self, other):
17260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17261 
 
17262 
  def __ne__(self, other):
17263 
    return not (self == other)
17264 
 
17265 
class getCampaigns_args:
17266 
  """
17267 
  Attributes:
17268 
   - campaignName
17269 
  """
17270 
 
17271 
  thrift_spec = (
17272 
    None, # 0
17273 
    (1, TType.STRING, 'campaignName', None, None, ), # 1
17274 
  )
17275 
 
17276 
  def __init__(self, campaignName=None,):
17277 
    self.campaignName = campaignName
17278 
 
17279 
  def read(self, iprot):
17280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17282 
      return
17283 
    iprot.readStructBegin()
17284 
    while True:
17285 
      (fname, ftype, fid) = iprot.readFieldBegin()
17286 
      if ftype == TType.STOP:
17287 
        break
17288 
      if fid == 1:
17289 
        if ftype == TType.STRING:
17290 
          self.campaignName = iprot.readString();
17291 
        else:
17292 
          iprot.skip(ftype)
17293 
      else:
17294 
        iprot.skip(ftype)
17295 
      iprot.readFieldEnd()
17296 
    iprot.readStructEnd()
17297 
 
17298 
  def write(self, oprot):
17299 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17300 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17301 
      return
17302 
    oprot.writeStructBegin('getCampaigns_args')
17303 
    if self.campaignName is not None:
17304 
      oprot.writeFieldBegin('campaignName', TType.STRING, 1)
17305 
      oprot.writeString(self.campaignName)
17306 
      oprot.writeFieldEnd()
17307 
    oprot.writeFieldStop()
17308 
    oprot.writeStructEnd()
17309 
 
17310 
  def validate(self):
17311 
    return
17312 
 
17313 
 
17314 
  def __repr__(self):
17315 
    L = ['%s=%r' % (key, value)
17316 
      for key, value in self.__dict__.iteritems()]
17317 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17318 
 
17319 
  def __eq__(self, other):
17320 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17321 
 
17322 
  def __ne__(self, other):
17323 
    return not (self == other)
17324 
 
17325 
class getCampaigns_result:
17326 
  """
17327 
  Attributes:
17328 
   - success
17329 
  """
17330 
 
17331 
  thrift_spec = (
17332 
    (0, TType.LIST, 'success', (TType.STRUCT,(Campaign, Campaign.thrift_spec)), None, ), # 0
17333 
  )
17334 
 
17335 
  def __init__(self, success=None,):
17336 
    self.success = success
17337 
 
17338 
  def read(self, iprot):
17339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17341 
      return
17342 
    iprot.readStructBegin()
17343 
    while True:
17344 
      (fname, ftype, fid) = iprot.readFieldBegin()
17345 
      if ftype == TType.STOP:
17346 
        break
17347 
      if fid == 0:
17348 
        if ftype == TType.LIST:
17349 
          self.success = []
13493 amit.gupta 17350 
          (_etype274, _size271) = iprot.readListBegin()
17351 
          for _i275 in xrange(_size271):
17352 
            _elem276 = Campaign()
17353 
            _elem276.read(iprot)
17354 
            self.success.append(_elem276)
8579 kshitij.so 17355 
          iprot.readListEnd()
17356 
        else:
17357 
          iprot.skip(ftype)
17358 
      else:
17359 
        iprot.skip(ftype)
17360 
      iprot.readFieldEnd()
17361 
    iprot.readStructEnd()
17362 
 
17363 
  def write(self, oprot):
17364 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17365 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17366 
      return
17367 
    oprot.writeStructBegin('getCampaigns_result')
17368 
    if self.success is not None:
17369 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17370 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 17371 
      for iter277 in self.success:
17372 
        iter277.write(oprot)
8579 kshitij.so 17373 
      oprot.writeListEnd()
17374 
      oprot.writeFieldEnd()
17375 
    oprot.writeFieldStop()
17376 
    oprot.writeStructEnd()
17377 
 
17378 
  def validate(self):
17379 
    return
17380 
 
17381 
 
17382 
  def __repr__(self):
17383 
    L = ['%s=%r' % (key, value)
17384 
      for key, value in self.__dict__.iteritems()]
17385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17386 
 
17387 
  def __eq__(self, other):
17388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17389 
 
17390 
  def __ne__(self, other):
17391 
    return not (self == other)
17392 
 
17393 
class deleteCampaign_args:
17394 
  """
17395 
  Attributes:
17396 
   - campaignId
17397 
  """
17398 
 
17399 
  thrift_spec = (
17400 
    None, # 0
17401 
    (1, TType.I64, 'campaignId', None, None, ), # 1
17402 
  )
17403 
 
17404 
  def __init__(self, campaignId=None,):
17405 
    self.campaignId = campaignId
17406 
 
17407 
  def read(self, iprot):
17408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17410 
      return
17411 
    iprot.readStructBegin()
17412 
    while True:
17413 
      (fname, ftype, fid) = iprot.readFieldBegin()
17414 
      if ftype == TType.STOP:
17415 
        break
17416 
      if fid == 1:
17417 
        if ftype == TType.I64:
17418 
          self.campaignId = iprot.readI64();
17419 
        else:
17420 
          iprot.skip(ftype)
17421 
      else:
17422 
        iprot.skip(ftype)
17423 
      iprot.readFieldEnd()
17424 
    iprot.readStructEnd()
17425 
 
17426 
  def write(self, oprot):
17427 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17428 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17429 
      return
17430 
    oprot.writeStructBegin('deleteCampaign_args')
17431 
    if self.campaignId is not None:
17432 
      oprot.writeFieldBegin('campaignId', TType.I64, 1)
17433 
      oprot.writeI64(self.campaignId)
17434 
      oprot.writeFieldEnd()
17435 
    oprot.writeFieldStop()
17436 
    oprot.writeStructEnd()
17437 
 
17438 
  def validate(self):
17439 
    return
17440 
 
17441 
 
17442 
  def __repr__(self):
17443 
    L = ['%s=%r' % (key, value)
17444 
      for key, value in self.__dict__.iteritems()]
17445 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17446 
 
17447 
  def __eq__(self, other):
17448 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17449 
 
17450 
  def __ne__(self, other):
17451 
    return not (self == other)
17452 
 
17453 
class deleteCampaign_result:
17454 
 
17455 
  thrift_spec = (
17456 
  )
17457 
 
17458 
  def read(self, iprot):
17459 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17460 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17461 
      return
17462 
    iprot.readStructBegin()
17463 
    while True:
17464 
      (fname, ftype, fid) = iprot.readFieldBegin()
17465 
      if ftype == TType.STOP:
17466 
        break
17467 
      else:
17468 
        iprot.skip(ftype)
17469 
      iprot.readFieldEnd()
17470 
    iprot.readStructEnd()
17471 
 
17472 
  def write(self, oprot):
17473 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17474 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17475 
      return
17476 
    oprot.writeStructBegin('deleteCampaign_result')
17477 
    oprot.writeFieldStop()
17478 
    oprot.writeStructEnd()
17479 
 
17480 
  def validate(self):
17481 
    return
17482 
 
17483 
 
17484 
  def __repr__(self):
17485 
    L = ['%s=%r' % (key, value)
17486 
      for key, value in self.__dict__.iteritems()]
17487 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17488 
 
17489 
  def __eq__(self, other):
17490 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17491 
 
17492 
  def __ne__(self, other):
17493 
    return not (self == other)
17494 
 
17495 
class getAllCampaigns_args:
17496 
 
17497 
  thrift_spec = (
17498 
  )
17499 
 
17500 
  def read(self, iprot):
17501 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17502 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17503 
      return
17504 
    iprot.readStructBegin()
17505 
    while True:
17506 
      (fname, ftype, fid) = iprot.readFieldBegin()
17507 
      if ftype == TType.STOP:
17508 
        break
17509 
      else:
17510 
        iprot.skip(ftype)
17511 
      iprot.readFieldEnd()
17512 
    iprot.readStructEnd()
17513 
 
17514 
  def write(self, oprot):
17515 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17516 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17517 
      return
17518 
    oprot.writeStructBegin('getAllCampaigns_args')
17519 
    oprot.writeFieldStop()
17520 
    oprot.writeStructEnd()
17521 
 
17522 
  def validate(self):
17523 
    return
17524 
 
17525 
 
17526 
  def __repr__(self):
17527 
    L = ['%s=%r' % (key, value)
17528 
      for key, value in self.__dict__.iteritems()]
17529 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17530 
 
17531 
  def __eq__(self, other):
17532 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17533 
 
17534 
  def __ne__(self, other):
17535 
    return not (self == other)
17536 
 
17537 
class getAllCampaigns_result:
17538 
  """
17539 
  Attributes:
17540 
   - success
17541 
  """
17542 
 
17543 
  thrift_spec = (
17544 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
17545 
  )
17546 
 
17547 
  def __init__(self, success=None,):
17548 
    self.success = success
17549 
 
17550 
  def read(self, iprot):
17551 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17552 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17553 
      return
17554 
    iprot.readStructBegin()
17555 
    while True:
17556 
      (fname, ftype, fid) = iprot.readFieldBegin()
17557 
      if ftype == TType.STOP:
17558 
        break
17559 
      if fid == 0:
17560 
        if ftype == TType.LIST:
17561 
          self.success = []
13493 amit.gupta 17562 
          (_etype281, _size278) = iprot.readListBegin()
17563 
          for _i282 in xrange(_size278):
17564 
            _elem283 = iprot.readString();
17565 
            self.success.append(_elem283)
8579 kshitij.so 17566 
          iprot.readListEnd()
17567 
        else:
17568 
          iprot.skip(ftype)
17569 
      else:
17570 
        iprot.skip(ftype)
17571 
      iprot.readFieldEnd()
17572 
    iprot.readStructEnd()
17573 
 
17574 
  def write(self, oprot):
17575 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17576 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17577 
      return
17578 
    oprot.writeStructBegin('getAllCampaigns_result')
17579 
    if self.success is not None:
17580 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17581 
      oprot.writeListBegin(TType.STRING, len(self.success))
13493 amit.gupta 17582 
      for iter284 in self.success:
17583 
        oprot.writeString(iter284)
8579 kshitij.so 17584 
      oprot.writeListEnd()
17585 
      oprot.writeFieldEnd()
17586 
    oprot.writeFieldStop()
17587 
    oprot.writeStructEnd()
17588 
 
17589 
  def validate(self):
17590 
    return
17591 
 
17592 
 
17593 
  def __repr__(self):
17594 
    L = ['%s=%r' % (key, value)
17595 
      for key, value in self.__dict__.iteritems()]
17596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17597 
 
17598 
  def __eq__(self, other):
17599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17600 
 
17601 
  def __ne__(self, other):
17602 
    return not (self == other)
17603 
 
9155 kshitij.so 17604 
class getActiveBannersForMobileSite_args:
17605 
 
17606 
  thrift_spec = (
17607 
  )
17608 
 
17609 
  def read(self, iprot):
17610 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17611 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17612 
      return
17613 
    iprot.readStructBegin()
17614 
    while True:
17615 
      (fname, ftype, fid) = iprot.readFieldBegin()
17616 
      if ftype == TType.STOP:
17617 
        break
17618 
      else:
17619 
        iprot.skip(ftype)
17620 
      iprot.readFieldEnd()
17621 
    iprot.readStructEnd()
17622 
 
17623 
  def write(self, oprot):
17624 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17625 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17626 
      return
17627 
    oprot.writeStructBegin('getActiveBannersForMobileSite_args')
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 getActiveBannersForMobileSite_result:
17647 
  """
17648 
  Attributes:
17649 
   - success
17650 
  """
17651 
 
17652 
  thrift_spec = (
17653 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
17654 
  )
17655 
 
17656 
  def __init__(self, success=None,):
17657 
    self.success = success
17658 
 
17659 
  def read(self, iprot):
17660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17662 
      return
17663 
    iprot.readStructBegin()
17664 
    while True:
17665 
      (fname, ftype, fid) = iprot.readFieldBegin()
17666 
      if ftype == TType.STOP:
17667 
        break
17668 
      if fid == 0:
17669 
        if ftype == TType.MAP:
17670 
          self.success = {}
13493 amit.gupta 17671 
          (_ktype286, _vtype287, _size285 ) = iprot.readMapBegin()
17672 
          for _i289 in xrange(_size285):
17673 
            _key290 = iprot.readString();
17674 
            _val291 = []
17675 
            (_etype295, _size292) = iprot.readListBegin()
17676 
            for _i296 in xrange(_size292):
17677 
              _elem297 = Banner()
17678 
              _elem297.read(iprot)
17679 
              _val291.append(_elem297)
9155 kshitij.so 17680 
            iprot.readListEnd()
13493 amit.gupta 17681 
            self.success[_key290] = _val291
9155 kshitij.so 17682 
          iprot.readMapEnd()
17683 
        else:
17684 
          iprot.skip(ftype)
17685 
      else:
17686 
        iprot.skip(ftype)
17687 
      iprot.readFieldEnd()
17688 
    iprot.readStructEnd()
17689 
 
17690 
  def write(self, oprot):
17691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17693 
      return
17694 
    oprot.writeStructBegin('getActiveBannersForMobileSite_result')
17695 
    if self.success is not None:
17696 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17697 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
13493 amit.gupta 17698 
      for kiter298,viter299 in self.success.items():
17699 
        oprot.writeString(kiter298)
17700 
        oprot.writeListBegin(TType.STRUCT, len(viter299))
17701 
        for iter300 in viter299:
17702 
          iter300.write(oprot)
9155 kshitij.so 17703 
        oprot.writeListEnd()
17704 
      oprot.writeMapEnd()
17705 
      oprot.writeFieldEnd()
17706 
    oprot.writeFieldStop()
17707 
    oprot.writeStructEnd()
17708 
 
17709 
  def validate(self):
17710 
    return
17711 
 
17712 
 
17713 
  def __repr__(self):
17714 
    L = ['%s=%r' % (key, value)
17715 
      for key, value in self.__dict__.iteritems()]
17716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17717 
 
17718 
  def __eq__(self, other):
17719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17720 
 
17721 
  def __ne__(self, other):
17722 
    return not (self == other)
17723 
 
5944 mandeep.dh 17724 
class deleteSimilarItem_args:
17725 
  """
17726 
  Attributes:
17727 
   - itemId
17728 
   - catalogItemId
17729 
  """
17730 
 
17731 
  thrift_spec = (
17732 
    None, # 0
17733 
    (1, TType.I64, 'itemId', None, None, ), # 1
17734 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
17735 
  )
17736 
 
17737 
  def __init__(self, itemId=None, catalogItemId=None,):
17738 
    self.itemId = itemId
17739 
    self.catalogItemId = catalogItemId
17740 
 
17741 
  def read(self, iprot):
17742 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17743 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17744 
      return
17745 
    iprot.readStructBegin()
17746 
    while True:
17747 
      (fname, ftype, fid) = iprot.readFieldBegin()
17748 
      if ftype == TType.STOP:
17749 
        break
17750 
      if fid == 1:
17751 
        if ftype == TType.I64:
17752 
          self.itemId = iprot.readI64();
17753 
        else:
17754 
          iprot.skip(ftype)
17755 
      elif fid == 2:
17756 
        if ftype == TType.I64:
17757 
          self.catalogItemId = iprot.readI64();
17758 
        else:
17759 
          iprot.skip(ftype)
17760 
      else:
17761 
        iprot.skip(ftype)
17762 
      iprot.readFieldEnd()
17763 
    iprot.readStructEnd()
17764 
 
17765 
  def write(self, oprot):
17766 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17767 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17768 
      return
17769 
    oprot.writeStructBegin('deleteSimilarItem_args')
17770 
    if self.itemId is not None:
17771 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17772 
      oprot.writeI64(self.itemId)
17773 
      oprot.writeFieldEnd()
17774 
    if self.catalogItemId is not None:
17775 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
17776 
      oprot.writeI64(self.catalogItemId)
17777 
      oprot.writeFieldEnd()
17778 
    oprot.writeFieldStop()
17779 
    oprot.writeStructEnd()
17780 
 
17781 
  def validate(self):
17782 
    return
17783 
 
17784 
 
17785 
  def __repr__(self):
17786 
    L = ['%s=%r' % (key, value)
17787 
      for key, value in self.__dict__.iteritems()]
17788 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17789 
 
17790 
  def __eq__(self, other):
17791 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17792 
 
17793 
  def __ne__(self, other):
17794 
    return not (self == other)
17795 
 
17796 
class deleteSimilarItem_result:
17797 
  """
17798 
  Attributes:
17799 
   - success
17800 
   - cex
17801 
  """
17802 
 
17803 
  thrift_spec = (
17804 
    (0, TType.BOOL, 'success', None, None, ), # 0
17805 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17806 
  )
17807 
 
17808 
  def __init__(self, success=None, cex=None,):
17809 
    self.success = success
17810 
    self.cex = cex
17811 
 
17812 
  def read(self, iprot):
17813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17815 
      return
17816 
    iprot.readStructBegin()
17817 
    while True:
17818 
      (fname, ftype, fid) = iprot.readFieldBegin()
17819 
      if ftype == TType.STOP:
17820 
        break
17821 
      if fid == 0:
17822 
        if ftype == TType.BOOL:
17823 
          self.success = iprot.readBool();
17824 
        else:
17825 
          iprot.skip(ftype)
17826 
      elif fid == 1:
17827 
        if ftype == TType.STRUCT:
17828 
          self.cex = CatalogServiceException()
17829 
          self.cex.read(iprot)
17830 
        else:
17831 
          iprot.skip(ftype)
17832 
      else:
17833 
        iprot.skip(ftype)
17834 
      iprot.readFieldEnd()
17835 
    iprot.readStructEnd()
17836 
 
17837 
  def write(self, oprot):
17838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17840 
      return
17841 
    oprot.writeStructBegin('deleteSimilarItem_result')
17842 
    if self.success is not None:
17843 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17844 
      oprot.writeBool(self.success)
17845 
      oprot.writeFieldEnd()
17846 
    if self.cex is not None:
17847 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17848 
      self.cex.write(oprot)
17849 
      oprot.writeFieldEnd()
17850 
    oprot.writeFieldStop()
17851 
    oprot.writeStructEnd()
17852 
 
17853 
  def validate(self):
17854 
    return
17855 
 
17856 
 
17857 
  def __repr__(self):
17858 
    L = ['%s=%r' % (key, value)
17859 
      for key, value in self.__dict__.iteritems()]
17860 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17861 
 
17862 
  def __eq__(self, other):
17863 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17864 
 
17865 
  def __ne__(self, other):
17866 
    return not (self == other)
17867 
 
17868 
class checkSimilarItem_args:
17869 
  """
17870 
  Attributes:
17871 
   - brand
17872 
   - modelNumber
17873 
   - modelName
17874 
   - color
17875 
  """
17876 
 
17877 
  thrift_spec = (
17878 
    None, # 0
17879 
    (1, TType.STRING, 'brand', None, None, ), # 1
17880 
    (2, TType.STRING, 'modelNumber', None, None, ), # 2
17881 
    (3, TType.STRING, 'modelName', None, None, ), # 3
17882 
    (4, TType.STRING, 'color', None, None, ), # 4
17883 
  )
17884 
 
17885 
  def __init__(self, brand=None, modelNumber=None, modelName=None, color=None,):
17886 
    self.brand = brand
17887 
    self.modelNumber = modelNumber
17888 
    self.modelName = modelName
17889 
    self.color = color
17890 
 
17891 
  def read(self, iprot):
17892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17894 
      return
17895 
    iprot.readStructBegin()
17896 
    while True:
17897 
      (fname, ftype, fid) = iprot.readFieldBegin()
17898 
      if ftype == TType.STOP:
17899 
        break
17900 
      if fid == 1:
17901 
        if ftype == TType.STRING:
17902 
          self.brand = iprot.readString();
17903 
        else:
17904 
          iprot.skip(ftype)
17905 
      elif fid == 2:
17906 
        if ftype == TType.STRING:
17907 
          self.modelNumber = iprot.readString();
17908 
        else:
17909 
          iprot.skip(ftype)
17910 
      elif fid == 3:
17911 
        if ftype == TType.STRING:
17912 
          self.modelName = iprot.readString();
17913 
        else:
17914 
          iprot.skip(ftype)
17915 
      elif fid == 4:
17916 
        if ftype == TType.STRING:
17917 
          self.color = iprot.readString();
17918 
        else:
17919 
          iprot.skip(ftype)
17920 
      else:
17921 
        iprot.skip(ftype)
17922 
      iprot.readFieldEnd()
17923 
    iprot.readStructEnd()
17924 
 
17925 
  def write(self, oprot):
17926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17928 
      return
17929 
    oprot.writeStructBegin('checkSimilarItem_args')
17930 
    if self.brand is not None:
17931 
      oprot.writeFieldBegin('brand', TType.STRING, 1)
17932 
      oprot.writeString(self.brand)
17933 
      oprot.writeFieldEnd()
17934 
    if self.modelNumber is not None:
17935 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 2)
17936 
      oprot.writeString(self.modelNumber)
17937 
      oprot.writeFieldEnd()
17938 
    if self.modelName is not None:
17939 
      oprot.writeFieldBegin('modelName', TType.STRING, 3)
17940 
      oprot.writeString(self.modelName)
17941 
      oprot.writeFieldEnd()
17942 
    if self.color is not None:
17943 
      oprot.writeFieldBegin('color', TType.STRING, 4)
17944 
      oprot.writeString(self.color)
17945 
      oprot.writeFieldEnd()
17946 
    oprot.writeFieldStop()
17947 
    oprot.writeStructEnd()
17948 
 
17949 
  def validate(self):
17950 
    return
17951 
 
17952 
 
17953 
  def __repr__(self):
17954 
    L = ['%s=%r' % (key, value)
17955 
      for key, value in self.__dict__.iteritems()]
17956 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17957 
 
17958 
  def __eq__(self, other):
17959 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17960 
 
17961 
  def __ne__(self, other):
17962 
    return not (self == other)
17963 
 
17964 
class checkSimilarItem_result:
17965 
  """
17966 
  Attributes:
17967 
   - success
17968 
  """
17969 
 
17970 
  thrift_spec = (
17971 
    (0, TType.I64, 'success', None, None, ), # 0
17972 
  )
17973 
 
17974 
  def __init__(self, success=None,):
17975 
    self.success = success
17976 
 
17977 
  def read(self, iprot):
17978 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17979 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17980 
      return
17981 
    iprot.readStructBegin()
17982 
    while True:
17983 
      (fname, ftype, fid) = iprot.readFieldBegin()
17984 
      if ftype == TType.STOP:
17985 
        break
17986 
      if fid == 0:
17987 
        if ftype == TType.I64:
17988 
          self.success = iprot.readI64();
17989 
        else:
17990 
          iprot.skip(ftype)
17991 
      else:
17992 
        iprot.skip(ftype)
17993 
      iprot.readFieldEnd()
17994 
    iprot.readStructEnd()
17995 
 
17996 
  def write(self, oprot):
17997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17999 
      return
18000 
    oprot.writeStructBegin('checkSimilarItem_result')
18001 
    if self.success is not None:
18002 
      oprot.writeFieldBegin('success', TType.I64, 0)
18003 
      oprot.writeI64(self.success)
18004 
      oprot.writeFieldEnd()
18005 
    oprot.writeFieldStop()
18006 
    oprot.writeStructEnd()
18007 
 
18008 
  def validate(self):
18009 
    return
18010 
 
18011 
 
18012 
  def __repr__(self):
18013 
    L = ['%s=%r' % (key, value)
18014 
      for key, value in self.__dict__.iteritems()]
18015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18016 
 
18017 
  def __eq__(self, other):
18018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18019 
 
18020 
  def __ne__(self, other):
18021 
    return not (self == other)
18022 
 
18023 
class validateRiskyStatus_args:
18024 
  """
18025 
  Attributes:
18026 
   - itemId
18027 
  """
18028 
 
18029 
  thrift_spec = (
18030 
    None, # 0
18031 
    (1, TType.I64, 'itemId', None, None, ), # 1
18032 
  )
18033 
 
18034 
  def __init__(self, itemId=None,):
18035 
    self.itemId = itemId
18036 
 
18037 
  def read(self, iprot):
18038 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18039 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18040 
      return
18041 
    iprot.readStructBegin()
18042 
    while True:
18043 
      (fname, ftype, fid) = iprot.readFieldBegin()
18044 
      if ftype == TType.STOP:
18045 
        break
18046 
      if fid == 1:
18047 
        if ftype == TType.I64:
18048 
          self.itemId = iprot.readI64();
18049 
        else:
18050 
          iprot.skip(ftype)
18051 
      else:
18052 
        iprot.skip(ftype)
18053 
      iprot.readFieldEnd()
18054 
    iprot.readStructEnd()
18055 
 
18056 
  def write(self, oprot):
18057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18059 
      return
18060 
    oprot.writeStructBegin('validateRiskyStatus_args')
18061 
    if self.itemId is not None:
18062 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18063 
      oprot.writeI64(self.itemId)
18064 
      oprot.writeFieldEnd()
18065 
    oprot.writeFieldStop()
18066 
    oprot.writeStructEnd()
18067 
 
18068 
  def validate(self):
18069 
    return
18070 
 
18071 
 
18072 
  def __repr__(self):
18073 
    L = ['%s=%r' % (key, value)
18074 
      for key, value in self.__dict__.iteritems()]
18075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18076 
 
18077 
  def __eq__(self, other):
18078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18079 
 
18080 
  def __ne__(self, other):
18081 
    return not (self == other)
18082 
 
18083 
class validateRiskyStatus_result:
18084 
 
18085 
  thrift_spec = (
18086 
  )
18087 
 
18088 
  def read(self, iprot):
18089 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18090 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18091 
      return
18092 
    iprot.readStructBegin()
18093 
    while True:
18094 
      (fname, ftype, fid) = iprot.readFieldBegin()
18095 
      if ftype == TType.STOP:
18096 
        break
18097 
      else:
18098 
        iprot.skip(ftype)
18099 
      iprot.readFieldEnd()
18100 
    iprot.readStructEnd()
18101 
 
18102 
  def write(self, oprot):
18103 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18104 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18105 
      return
18106 
    oprot.writeStructBegin('validateRiskyStatus_result')
18107 
    oprot.writeFieldStop()
18108 
    oprot.writeStructEnd()
18109 
 
18110 
  def validate(self):
18111 
    return
18112 
 
18113 
 
18114 
  def __repr__(self):
18115 
    L = ['%s=%r' % (key, value)
18116 
      for key, value in self.__dict__.iteritems()]
18117 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18118 
 
18119 
  def __eq__(self, other):
18120 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18121 
 
18122 
  def __ne__(self, other):
18123 
    return not (self == other)
18124 
 
18125 
class changeItemRiskyFlag_args:
18126 
  """
18127 
  Attributes:
18128 
   - itemId
18129 
   - risky
18130 
  """
18131 
 
18132 
  thrift_spec = (
18133 
    None, # 0
18134 
    (1, TType.I64, 'itemId', None, None, ), # 1
18135 
    (2, TType.BOOL, 'risky', None, None, ), # 2
18136 
  )
18137 
 
18138 
  def __init__(self, itemId=None, risky=None,):
18139 
    self.itemId = itemId
18140 
    self.risky = risky
18141 
 
18142 
  def read(self, iprot):
18143 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18144 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18145 
      return
18146 
    iprot.readStructBegin()
18147 
    while True:
18148 
      (fname, ftype, fid) = iprot.readFieldBegin()
18149 
      if ftype == TType.STOP:
18150 
        break
18151 
      if fid == 1:
18152 
        if ftype == TType.I64:
18153 
          self.itemId = iprot.readI64();
18154 
        else:
18155 
          iprot.skip(ftype)
18156 
      elif fid == 2:
18157 
        if ftype == TType.BOOL:
18158 
          self.risky = iprot.readBool();
18159 
        else:
18160 
          iprot.skip(ftype)
18161 
      else:
18162 
        iprot.skip(ftype)
18163 
      iprot.readFieldEnd()
18164 
    iprot.readStructEnd()
18165 
 
18166 
  def write(self, oprot):
18167 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18168 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18169 
      return
18170 
    oprot.writeStructBegin('changeItemRiskyFlag_args')
18171 
    if self.itemId is not None:
18172 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18173 
      oprot.writeI64(self.itemId)
18174 
      oprot.writeFieldEnd()
18175 
    if self.risky is not None:
18176 
      oprot.writeFieldBegin('risky', TType.BOOL, 2)
18177 
      oprot.writeBool(self.risky)
18178 
      oprot.writeFieldEnd()
18179 
    oprot.writeFieldStop()
18180 
    oprot.writeStructEnd()
18181 
 
18182 
  def validate(self):
18183 
    return
18184 
 
18185 
 
18186 
  def __repr__(self):
18187 
    L = ['%s=%r' % (key, value)
18188 
      for key, value in self.__dict__.iteritems()]
18189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18190 
 
18191 
  def __eq__(self, other):
18192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18193 
 
18194 
  def __ne__(self, other):
18195 
    return not (self == other)
18196 
 
18197 
class changeItemRiskyFlag_result:
18198 
 
18199 
  thrift_spec = (
18200 
  )
18201 
 
18202 
  def read(self, iprot):
18203 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18204 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18205 
      return
18206 
    iprot.readStructBegin()
18207 
    while True:
18208 
      (fname, ftype, fid) = iprot.readFieldBegin()
18209 
      if ftype == TType.STOP:
18210 
        break
18211 
      else:
18212 
        iprot.skip(ftype)
18213 
      iprot.readFieldEnd()
18214 
    iprot.readStructEnd()
18215 
 
18216 
  def write(self, oprot):
18217 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18218 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18219 
      return
18220 
    oprot.writeStructBegin('changeItemRiskyFlag_result')
18221 
    oprot.writeFieldStop()
18222 
    oprot.writeStructEnd()
18223 
 
18224 
  def validate(self):
18225 
    return
18226 
 
18227 
 
18228 
  def __repr__(self):
18229 
    L = ['%s=%r' % (key, value)
18230 
      for key, value in self.__dict__.iteritems()]
18231 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18232 
 
18233 
  def __eq__(self, other):
18234 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18235 
 
18236 
  def __ne__(self, other):
18237 
    return not (self == other)
18238 
 
18239 
class getItemsByRiskyFlag_args:
18240 
 
18241 
  thrift_spec = (
18242 
  )
18243 
 
18244 
  def read(self, iprot):
18245 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18246 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18247 
      return
18248 
    iprot.readStructBegin()
18249 
    while True:
18250 
      (fname, ftype, fid) = iprot.readFieldBegin()
18251 
      if ftype == TType.STOP:
18252 
        break
18253 
      else:
18254 
        iprot.skip(ftype)
18255 
      iprot.readFieldEnd()
18256 
    iprot.readStructEnd()
18257 
 
18258 
  def write(self, oprot):
18259 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18260 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18261 
      return
18262 
    oprot.writeStructBegin('getItemsByRiskyFlag_args')
18263 
    oprot.writeFieldStop()
18264 
    oprot.writeStructEnd()
18265 
 
18266 
  def validate(self):
18267 
    return
18268 
 
18269 
 
18270 
  def __repr__(self):
18271 
    L = ['%s=%r' % (key, value)
18272 
      for key, value in self.__dict__.iteritems()]
18273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18274 
 
18275 
  def __eq__(self, other):
18276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18277 
 
18278 
  def __ne__(self, other):
18279 
    return not (self == other)
18280 
 
18281 
class getItemsByRiskyFlag_result:
18282 
  """
18283 
  Attributes:
18284 
   - success
18285 
  """
18286 
 
18287 
  thrift_spec = (
18288 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
18289 
  )
18290 
 
18291 
  def __init__(self, success=None,):
18292 
    self.success = success
18293 
 
18294 
  def read(self, iprot):
18295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18297 
      return
18298 
    iprot.readStructBegin()
18299 
    while True:
18300 
      (fname, ftype, fid) = iprot.readFieldBegin()
18301 
      if ftype == TType.STOP:
18302 
        break
18303 
      if fid == 0:
18304 
        if ftype == TType.LIST:
18305 
          self.success = []
13493 amit.gupta 18306 
          (_etype304, _size301) = iprot.readListBegin()
18307 
          for _i305 in xrange(_size301):
18308 
            _elem306 = Item()
18309 
            _elem306.read(iprot)
18310 
            self.success.append(_elem306)
5944 mandeep.dh 18311 
          iprot.readListEnd()
18312 
        else:
18313 
          iprot.skip(ftype)
18314 
      else:
18315 
        iprot.skip(ftype)
18316 
      iprot.readFieldEnd()
18317 
    iprot.readStructEnd()
18318 
 
18319 
  def write(self, oprot):
18320 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18321 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18322 
      return
18323 
    oprot.writeStructBegin('getItemsByRiskyFlag_result')
18324 
    if self.success is not None:
18325 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18326 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 18327 
      for iter307 in self.success:
18328 
        iter307.write(oprot)
5944 mandeep.dh 18329 
      oprot.writeListEnd()
18330 
      oprot.writeFieldEnd()
18331 
    oprot.writeFieldStop()
18332 
    oprot.writeStructEnd()
18333 
 
18334 
  def validate(self):
18335 
    return
18336 
 
18337 
 
18338 
  def __repr__(self):
18339 
    L = ['%s=%r' % (key, value)
18340 
      for key, value in self.__dict__.iteritems()]
18341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18342 
 
18343 
  def __eq__(self, other):
18344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18345 
 
18346 
  def __ne__(self, other):
18347 
    return not (self == other)
18348 
 
18349 
class getItemsForMasterSheet_args:
18350 
  """
18351 
  Attributes:
18352 
   - category
18353 
   - brand
18354 
  """
18355 
 
18356 
  thrift_spec = (
18357 
    None, # 0
18358 
    (1, TType.STRING, 'category', None, None, ), # 1
18359 
    (2, TType.STRING, 'brand', None, None, ), # 2
18360 
  )
18361 
 
18362 
  def __init__(self, category=None, brand=None,):
18363 
    self.category = category
18364 
    self.brand = brand
18365 
 
18366 
  def read(self, iprot):
18367 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18368 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18369 
      return
18370 
    iprot.readStructBegin()
18371 
    while True:
18372 
      (fname, ftype, fid) = iprot.readFieldBegin()
18373 
      if ftype == TType.STOP:
18374 
        break
18375 
      if fid == 1:
18376 
        if ftype == TType.STRING:
18377 
          self.category = iprot.readString();
18378 
        else:
18379 
          iprot.skip(ftype)
18380 
      elif fid == 2:
18381 
        if ftype == TType.STRING:
18382 
          self.brand = iprot.readString();
18383 
        else:
18384 
          iprot.skip(ftype)
18385 
      else:
18386 
        iprot.skip(ftype)
18387 
      iprot.readFieldEnd()
18388 
    iprot.readStructEnd()
18389 
 
18390 
  def write(self, oprot):
18391 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18392 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18393 
      return
18394 
    oprot.writeStructBegin('getItemsForMasterSheet_args')
18395 
    if self.category is not None:
18396 
      oprot.writeFieldBegin('category', TType.STRING, 1)
18397 
      oprot.writeString(self.category)
18398 
      oprot.writeFieldEnd()
18399 
    if self.brand is not None:
18400 
      oprot.writeFieldBegin('brand', TType.STRING, 2)
18401 
      oprot.writeString(self.brand)
18402 
      oprot.writeFieldEnd()
18403 
    oprot.writeFieldStop()
18404 
    oprot.writeStructEnd()
18405 
 
18406 
  def validate(self):
18407 
    return
18408 
 
18409 
 
18410 
  def __repr__(self):
18411 
    L = ['%s=%r' % (key, value)
18412 
      for key, value in self.__dict__.iteritems()]
18413 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18414 
 
18415 
  def __eq__(self, other):
18416 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18417 
 
18418 
  def __ne__(self, other):
18419 
    return not (self == other)
18420 
 
18421 
class getItemsForMasterSheet_result:
18422 
  """
18423 
  Attributes:
18424 
   - success
18425 
  """
18426 
 
18427 
  thrift_spec = (
18428 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
18429 
  )
18430 
 
18431 
  def __init__(self, success=None,):
18432 
    self.success = success
18433 
 
18434 
  def read(self, iprot):
18435 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18436 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18437 
      return
18438 
    iprot.readStructBegin()
18439 
    while True:
18440 
      (fname, ftype, fid) = iprot.readFieldBegin()
18441 
      if ftype == TType.STOP:
18442 
        break
18443 
      if fid == 0:
18444 
        if ftype == TType.LIST:
18445 
          self.success = []
13493 amit.gupta 18446 
          (_etype311, _size308) = iprot.readListBegin()
18447 
          for _i312 in xrange(_size308):
18448 
            _elem313 = Item()
18449 
            _elem313.read(iprot)
18450 
            self.success.append(_elem313)
5944 mandeep.dh 18451 
          iprot.readListEnd()
18452 
        else:
18453 
          iprot.skip(ftype)
18454 
      else:
18455 
        iprot.skip(ftype)
18456 
      iprot.readFieldEnd()
18457 
    iprot.readStructEnd()
18458 
 
18459 
  def write(self, oprot):
18460 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18461 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18462 
      return
18463 
    oprot.writeStructBegin('getItemsForMasterSheet_result')
18464 
    if self.success is not None:
18465 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18466 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 18467 
      for iter314 in self.success:
18468 
        iter314.write(oprot)
5944 mandeep.dh 18469 
      oprot.writeListEnd()
18470 
      oprot.writeFieldEnd()
18471 
    oprot.writeFieldStop()
18472 
    oprot.writeStructEnd()
18473 
 
18474 
  def validate(self):
18475 
    return
18476 
 
18477 
 
18478 
  def __repr__(self):
18479 
    L = ['%s=%r' % (key, value)
18480 
      for key, value in self.__dict__.iteritems()]
18481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18482 
 
18483 
  def __eq__(self, other):
18484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18485 
 
18486 
  def __ne__(self, other):
18487 
    return not (self == other)
18488 
 
18489 
class getSimilarItemsCatalogIds_args:
18490 
  """
18491 
  Attributes:
18492 
   - beginIndex
18493 
   - totalItems
18494 
   - itemId
18495 
  """
18496 
 
18497 
  thrift_spec = (
18498 
    None, # 0
18499 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
18500 
    (2, TType.I64, 'totalItems', None, None, ), # 2
18501 
    (3, TType.I64, 'itemId', None, None, ), # 3
18502 
  )
18503 
 
18504 
  def __init__(self, beginIndex=None, totalItems=None, itemId=None,):
18505 
    self.beginIndex = beginIndex
18506 
    self.totalItems = totalItems
18507 
    self.itemId = itemId
18508 
 
18509 
  def read(self, iprot):
18510 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18511 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18512 
      return
18513 
    iprot.readStructBegin()
18514 
    while True:
18515 
      (fname, ftype, fid) = iprot.readFieldBegin()
18516 
      if ftype == TType.STOP:
18517 
        break
18518 
      if fid == 1:
18519 
        if ftype == TType.I64:
18520 
          self.beginIndex = iprot.readI64();
18521 
        else:
18522 
          iprot.skip(ftype)
18523 
      elif fid == 2:
18524 
        if ftype == TType.I64:
18525 
          self.totalItems = iprot.readI64();
18526 
        else:
18527 
          iprot.skip(ftype)
18528 
      elif fid == 3:
18529 
        if ftype == TType.I64:
18530 
          self.itemId = iprot.readI64();
18531 
        else:
18532 
          iprot.skip(ftype)
18533 
      else:
18534 
        iprot.skip(ftype)
18535 
      iprot.readFieldEnd()
18536 
    iprot.readStructEnd()
18537 
 
18538 
  def write(self, oprot):
18539 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18540 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18541 
      return
18542 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_args')
18543 
    if self.beginIndex is not None:
18544 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
18545 
      oprot.writeI64(self.beginIndex)
18546 
      oprot.writeFieldEnd()
18547 
    if self.totalItems is not None:
18548 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
18549 
      oprot.writeI64(self.totalItems)
18550 
      oprot.writeFieldEnd()
18551 
    if self.itemId is not None:
18552 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
18553 
      oprot.writeI64(self.itemId)
18554 
      oprot.writeFieldEnd()
18555 
    oprot.writeFieldStop()
18556 
    oprot.writeStructEnd()
18557 
 
18558 
  def validate(self):
18559 
    return
18560 
 
18561 
 
18562 
  def __repr__(self):
18563 
    L = ['%s=%r' % (key, value)
18564 
      for key, value in self.__dict__.iteritems()]
18565 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18566 
 
18567 
  def __eq__(self, other):
18568 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18569 
 
18570 
  def __ne__(self, other):
18571 
    return not (self == other)
18572 
 
18573 
class getSimilarItemsCatalogIds_result:
18574 
  """
18575 
  Attributes:
18576 
   - success
18577 
  """
18578 
 
18579 
  thrift_spec = (
18580 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
18581 
  )
18582 
 
18583 
  def __init__(self, success=None,):
18584 
    self.success = success
18585 
 
18586 
  def read(self, iprot):
18587 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18588 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18589 
      return
18590 
    iprot.readStructBegin()
18591 
    while True:
18592 
      (fname, ftype, fid) = iprot.readFieldBegin()
18593 
      if ftype == TType.STOP:
18594 
        break
18595 
      if fid == 0:
18596 
        if ftype == TType.LIST:
18597 
          self.success = []
13493 amit.gupta 18598 
          (_etype318, _size315) = iprot.readListBegin()
18599 
          for _i319 in xrange(_size315):
18600 
            _elem320 = iprot.readI64();
18601 
            self.success.append(_elem320)
5944 mandeep.dh 18602 
          iprot.readListEnd()
18603 
        else:
18604 
          iprot.skip(ftype)
18605 
      else:
18606 
        iprot.skip(ftype)
18607 
      iprot.readFieldEnd()
18608 
    iprot.readStructEnd()
18609 
 
18610 
  def write(self, oprot):
18611 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18612 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18613 
      return
18614 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_result')
18615 
    if self.success is not None:
18616 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18617 
      oprot.writeListBegin(TType.I64, len(self.success))
13493 amit.gupta 18618 
      for iter321 in self.success:
18619 
        oprot.writeI64(iter321)
5944 mandeep.dh 18620 
      oprot.writeListEnd()
18621 
      oprot.writeFieldEnd()
18622 
    oprot.writeFieldStop()
18623 
    oprot.writeStructEnd()
18624 
 
18625 
  def validate(self):
18626 
    return
18627 
 
18628 
 
18629 
  def __repr__(self):
18630 
    L = ['%s=%r' % (key, value)
18631 
      for key, value in self.__dict__.iteritems()]
18632 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18633 
 
18634 
  def __eq__(self, other):
18635 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18636 
 
18637 
  def __ne__(self, other):
18638 
    return not (self == other)
18639 
 
18640 
class addProductNotification_args:
18641 
  """
18642 
  Attributes:
18643 
   - itemId
18644 
   - email
18645 
  """
18646 
 
18647 
  thrift_spec = None
18648 
  def __init__(self, itemId=None, email=None,):
18649 
    self.itemId = itemId
18650 
    self.email = email
18651 
 
18652 
  def read(self, iprot):
18653 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18654 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18655 
      return
18656 
    iprot.readStructBegin()
18657 
    while True:
18658 
      (fname, ftype, fid) = iprot.readFieldBegin()
18659 
      if ftype == TType.STOP:
18660 
        break
18661 
      if fid == -1:
18662 
        if ftype == TType.I64:
18663 
          self.itemId = iprot.readI64();
18664 
        else:
18665 
          iprot.skip(ftype)
18666 
      elif fid == -2:
18667 
        if ftype == TType.STRING:
18668 
          self.email = iprot.readString();
18669 
        else:
18670 
          iprot.skip(ftype)
18671 
      else:
18672 
        iprot.skip(ftype)
18673 
      iprot.readFieldEnd()
18674 
    iprot.readStructEnd()
18675 
 
18676 
  def write(self, oprot):
18677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18679 
      return
18680 
    oprot.writeStructBegin('addProductNotification_args')
18681 
    if self.email is not None:
18682 
      oprot.writeFieldBegin('email', TType.STRING, -2)
18683 
      oprot.writeString(self.email)
18684 
      oprot.writeFieldEnd()
18685 
    if self.itemId is not None:
18686 
      oprot.writeFieldBegin('itemId', TType.I64, -1)
18687 
      oprot.writeI64(self.itemId)
18688 
      oprot.writeFieldEnd()
18689 
    oprot.writeFieldStop()
18690 
    oprot.writeStructEnd()
18691 
 
18692 
  def validate(self):
18693 
    return
18694 
 
18695 
 
18696 
  def __repr__(self):
18697 
    L = ['%s=%r' % (key, value)
18698 
      for key, value in self.__dict__.iteritems()]
18699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18700 
 
18701 
  def __eq__(self, other):
18702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18703 
 
18704 
  def __ne__(self, other):
18705 
    return not (self == other)
18706 
 
18707 
class addProductNotification_result:
18708 
  """
18709 
  Attributes:
18710 
   - success
18711 
  """
18712 
 
18713 
  thrift_spec = (
18714 
    (0, TType.BOOL, 'success', None, None, ), # 0
18715 
  )
18716 
 
18717 
  def __init__(self, success=None,):
18718 
    self.success = success
18719 
 
18720 
  def read(self, iprot):
18721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18723 
      return
18724 
    iprot.readStructBegin()
18725 
    while True:
18726 
      (fname, ftype, fid) = iprot.readFieldBegin()
18727 
      if ftype == TType.STOP:
18728 
        break
18729 
      if fid == 0:
18730 
        if ftype == TType.BOOL:
18731 
          self.success = iprot.readBool();
18732 
        else:
18733 
          iprot.skip(ftype)
18734 
      else:
18735 
        iprot.skip(ftype)
18736 
      iprot.readFieldEnd()
18737 
    iprot.readStructEnd()
18738 
 
18739 
  def write(self, oprot):
18740 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18741 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18742 
      return
18743 
    oprot.writeStructBegin('addProductNotification_result')
18744 
    if self.success is not None:
18745 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18746 
      oprot.writeBool(self.success)
18747 
      oprot.writeFieldEnd()
18748 
    oprot.writeFieldStop()
18749 
    oprot.writeStructEnd()
18750 
 
18751 
  def validate(self):
18752 
    return
18753 
 
18754 
 
18755 
  def __repr__(self):
18756 
    L = ['%s=%r' % (key, value)
18757 
      for key, value in self.__dict__.iteritems()]
18758 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18759 
 
18760 
  def __eq__(self, other):
18761 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18762 
 
18763 
  def __ne__(self, other):
18764 
    return not (self == other)
18765 
 
18766 
class sendProductNotifications_args:
18767 
 
18768 
  thrift_spec = (
18769 
  )
18770 
 
18771 
  def read(self, iprot):
18772 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18773 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18774 
      return
18775 
    iprot.readStructBegin()
18776 
    while True:
18777 
      (fname, ftype, fid) = iprot.readFieldBegin()
18778 
      if ftype == TType.STOP:
18779 
        break
18780 
      else:
18781 
        iprot.skip(ftype)
18782 
      iprot.readFieldEnd()
18783 
    iprot.readStructEnd()
18784 
 
18785 
  def write(self, oprot):
18786 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18787 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18788 
      return
18789 
    oprot.writeStructBegin('sendProductNotifications_args')
18790 
    oprot.writeFieldStop()
18791 
    oprot.writeStructEnd()
18792 
 
18793 
  def validate(self):
18794 
    return
18795 
 
18796 
 
18797 
  def __repr__(self):
18798 
    L = ['%s=%r' % (key, value)
18799 
      for key, value in self.__dict__.iteritems()]
18800 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18801 
 
18802 
  def __eq__(self, other):
18803 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18804 
 
18805 
  def __ne__(self, other):
18806 
    return not (self == other)
18807 
 
18808 
class sendProductNotifications_result:
18809 
  """
18810 
  Attributes:
18811 
   - success
18812 
  """
18813 
 
18814 
  thrift_spec = (
18815 
    (0, TType.BOOL, 'success', None, None, ), # 0
18816 
  )
18817 
 
18818 
  def __init__(self, success=None,):
18819 
    self.success = success
18820 
 
18821 
  def read(self, iprot):
18822 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18823 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18824 
      return
18825 
    iprot.readStructBegin()
18826 
    while True:
18827 
      (fname, ftype, fid) = iprot.readFieldBegin()
18828 
      if ftype == TType.STOP:
18829 
        break
18830 
      if fid == 0:
18831 
        if ftype == TType.BOOL:
18832 
          self.success = iprot.readBool();
18833 
        else:
18834 
          iprot.skip(ftype)
18835 
      else:
18836 
        iprot.skip(ftype)
18837 
      iprot.readFieldEnd()
18838 
    iprot.readStructEnd()
18839 
 
18840 
  def write(self, oprot):
18841 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18842 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18843 
      return
18844 
    oprot.writeStructBegin('sendProductNotifications_result')
18845 
    if self.success is not None:
18846 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18847 
      oprot.writeBool(self.success)
18848 
      oprot.writeFieldEnd()
18849 
    oprot.writeFieldStop()
18850 
    oprot.writeStructEnd()
18851 
 
18852 
  def validate(self):
18853 
    return
18854 
 
18855 
 
18856 
  def __repr__(self):
18857 
    L = ['%s=%r' % (key, value)
18858 
      for key, value in self.__dict__.iteritems()]
18859 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18860 
 
18861 
  def __eq__(self, other):
18862 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18863 
 
18864 
  def __ne__(self, other):
18865 
    return not (self == other)
18866 
 
18867 
class getAllBrandsByCategory_args:
18868 
  """
18869 
  Attributes:
18870 
   - categoryId
18871 
  """
18872 
 
18873 
  thrift_spec = (
18874 
    None, # 0
18875 
    (1, TType.I64, 'categoryId', None, None, ), # 1
18876 
  )
18877 
 
18878 
  def __init__(self, categoryId=None,):
18879 
    self.categoryId = categoryId
18880 
 
18881 
  def read(self, iprot):
18882 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18883 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18884 
      return
18885 
    iprot.readStructBegin()
18886 
    while True:
18887 
      (fname, ftype, fid) = iprot.readFieldBegin()
18888 
      if ftype == TType.STOP:
18889 
        break
18890 
      if fid == 1:
18891 
        if ftype == TType.I64:
18892 
          self.categoryId = iprot.readI64();
18893 
        else:
18894 
          iprot.skip(ftype)
18895 
      else:
18896 
        iprot.skip(ftype)
18897 
      iprot.readFieldEnd()
18898 
    iprot.readStructEnd()
18899 
 
18900 
  def write(self, oprot):
18901 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18902 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18903 
      return
18904 
    oprot.writeStructBegin('getAllBrandsByCategory_args')
18905 
    if self.categoryId is not None:
18906 
      oprot.writeFieldBegin('categoryId', TType.I64, 1)
18907 
      oprot.writeI64(self.categoryId)
18908 
      oprot.writeFieldEnd()
18909 
    oprot.writeFieldStop()
18910 
    oprot.writeStructEnd()
18911 
 
18912 
  def validate(self):
18913 
    return
18914 
 
18915 
 
18916 
  def __repr__(self):
18917 
    L = ['%s=%r' % (key, value)
18918 
      for key, value in self.__dict__.iteritems()]
18919 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18920 
 
18921 
  def __eq__(self, other):
18922 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18923 
 
18924 
  def __ne__(self, other):
18925 
    return not (self == other)
18926 
 
18927 
class getAllBrandsByCategory_result:
18928 
  """
18929 
  Attributes:
18930 
   - success
18931 
  """
18932 
 
18933 
  thrift_spec = (
18934 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
18935 
  )
18936 
 
18937 
  def __init__(self, success=None,):
18938 
    self.success = success
18939 
 
18940 
  def read(self, iprot):
18941 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18942 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18943 
      return
18944 
    iprot.readStructBegin()
18945 
    while True:
18946 
      (fname, ftype, fid) = iprot.readFieldBegin()
18947 
      if ftype == TType.STOP:
18948 
        break
18949 
      if fid == 0:
18950 
        if ftype == TType.LIST:
18951 
          self.success = []
13493 amit.gupta 18952 
          (_etype325, _size322) = iprot.readListBegin()
18953 
          for _i326 in xrange(_size322):
18954 
            _elem327 = iprot.readString();
18955 
            self.success.append(_elem327)
5944 mandeep.dh 18956 
          iprot.readListEnd()
18957 
        else:
18958 
          iprot.skip(ftype)
18959 
      else:
18960 
        iprot.skip(ftype)
18961 
      iprot.readFieldEnd()
18962 
    iprot.readStructEnd()
18963 
 
18964 
  def write(self, oprot):
18965 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18966 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18967 
      return
18968 
    oprot.writeStructBegin('getAllBrandsByCategory_result')
18969 
    if self.success is not None:
18970 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18971 
      oprot.writeListBegin(TType.STRING, len(self.success))
13493 amit.gupta 18972 
      for iter328 in self.success:
18973 
        oprot.writeString(iter328)
5944 mandeep.dh 18974 
      oprot.writeListEnd()
18975 
      oprot.writeFieldEnd()
18976 
    oprot.writeFieldStop()
18977 
    oprot.writeStructEnd()
18978 
 
18979 
  def validate(self):
18980 
    return
18981 
 
18982 
 
18983 
  def __repr__(self):
18984 
    L = ['%s=%r' % (key, value)
18985 
      for key, value in self.__dict__.iteritems()]
18986 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18987 
 
18988 
  def __eq__(self, other):
18989 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18990 
 
18991 
  def __ne__(self, other):
18992 
    return not (self == other)
18993 
 
18994 
class getAllBrands_args:
18995 
 
18996 
  thrift_spec = (
18997 
  )
18998 
 
18999 
  def read(self, iprot):
19000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19002 
      return
19003 
    iprot.readStructBegin()
19004 
    while True:
19005 
      (fname, ftype, fid) = iprot.readFieldBegin()
19006 
      if ftype == TType.STOP:
19007 
        break
19008 
      else:
19009 
        iprot.skip(ftype)
19010 
      iprot.readFieldEnd()
19011 
    iprot.readStructEnd()
19012 
 
19013 
  def write(self, oprot):
19014 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19015 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19016 
      return
19017 
    oprot.writeStructBegin('getAllBrands_args')
19018 
    oprot.writeFieldStop()
19019 
    oprot.writeStructEnd()
19020 
 
19021 
  def validate(self):
19022 
    return
19023 
 
19024 
 
19025 
  def __repr__(self):
19026 
    L = ['%s=%r' % (key, value)
19027 
      for key, value in self.__dict__.iteritems()]
19028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19029 
 
19030 
  def __eq__(self, other):
19031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19032 
 
19033 
  def __ne__(self, other):
19034 
    return not (self == other)
19035 
 
19036 
class getAllBrands_result:
19037 
  """
19038 
  Attributes:
19039 
   - success
19040 
  """
19041 
 
19042 
  thrift_spec = (
19043 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
19044 
  )
19045 
 
19046 
  def __init__(self, success=None,):
19047 
    self.success = success
19048 
 
19049 
  def read(self, iprot):
19050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19052 
      return
19053 
    iprot.readStructBegin()
19054 
    while True:
19055 
      (fname, ftype, fid) = iprot.readFieldBegin()
19056 
      if ftype == TType.STOP:
19057 
        break
19058 
      if fid == 0:
19059 
        if ftype == TType.LIST:
19060 
          self.success = []
13493 amit.gupta 19061 
          (_etype332, _size329) = iprot.readListBegin()
19062 
          for _i333 in xrange(_size329):
19063 
            _elem334 = iprot.readString();
19064 
            self.success.append(_elem334)
5944 mandeep.dh 19065 
          iprot.readListEnd()
19066 
        else:
19067 
          iprot.skip(ftype)
19068 
      else:
19069 
        iprot.skip(ftype)
19070 
      iprot.readFieldEnd()
19071 
    iprot.readStructEnd()
19072 
 
19073 
  def write(self, oprot):
19074 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19075 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19076 
      return
19077 
    oprot.writeStructBegin('getAllBrands_result')
19078 
    if self.success is not None:
19079 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19080 
      oprot.writeListBegin(TType.STRING, len(self.success))
13493 amit.gupta 19081 
      for iter335 in self.success:
19082 
        oprot.writeString(iter335)
5944 mandeep.dh 19083 
      oprot.writeListEnd()
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 getAllSources_args:
19104 
 
19105 
  thrift_spec = (
19106 
  )
19107 
 
19108 
  def read(self, iprot):
19109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19111 
      return
19112 
    iprot.readStructBegin()
19113 
    while True:
19114 
      (fname, ftype, fid) = iprot.readFieldBegin()
19115 
      if ftype == TType.STOP:
19116 
        break
19117 
      else:
19118 
        iprot.skip(ftype)
19119 
      iprot.readFieldEnd()
19120 
    iprot.readStructEnd()
19121 
 
19122 
  def write(self, oprot):
19123 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19124 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19125 
      return
19126 
    oprot.writeStructBegin('getAllSources_args')
19127 
    oprot.writeFieldStop()
19128 
    oprot.writeStructEnd()
19129 
 
19130 
  def validate(self):
19131 
    return
19132 
 
19133 
 
19134 
  def __repr__(self):
19135 
    L = ['%s=%r' % (key, value)
19136 
      for key, value in self.__dict__.iteritems()]
19137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19138 
 
19139 
  def __eq__(self, other):
19140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19141 
 
19142 
  def __ne__(self, other):
19143 
    return not (self == other)
19144 
 
19145 
class getAllSources_result:
19146 
  """
19147 
  Attributes:
19148 
   - success
19149 
  """
19150 
 
19151 
  thrift_spec = (
19152 
    (0, TType.LIST, 'success', (TType.STRUCT,(Source, Source.thrift_spec)), None, ), # 0
19153 
  )
19154 
 
19155 
  def __init__(self, success=None,):
19156 
    self.success = success
19157 
 
19158 
  def read(self, iprot):
19159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19161 
      return
19162 
    iprot.readStructBegin()
19163 
    while True:
19164 
      (fname, ftype, fid) = iprot.readFieldBegin()
19165 
      if ftype == TType.STOP:
19166 
        break
19167 
      if fid == 0:
19168 
        if ftype == TType.LIST:
19169 
          self.success = []
13493 amit.gupta 19170 
          (_etype339, _size336) = iprot.readListBegin()
19171 
          for _i340 in xrange(_size336):
19172 
            _elem341 = Source()
19173 
            _elem341.read(iprot)
19174 
            self.success.append(_elem341)
5944 mandeep.dh 19175 
          iprot.readListEnd()
19176 
        else:
19177 
          iprot.skip(ftype)
19178 
      else:
19179 
        iprot.skip(ftype)
19180 
      iprot.readFieldEnd()
19181 
    iprot.readStructEnd()
19182 
 
19183 
  def write(self, oprot):
19184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19186 
      return
19187 
    oprot.writeStructBegin('getAllSources_result')
19188 
    if self.success is not None:
19189 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19190 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 19191 
      for iter342 in self.success:
19192 
        iter342.write(oprot)
5944 mandeep.dh 19193 
      oprot.writeListEnd()
19194 
      oprot.writeFieldEnd()
19195 
    oprot.writeFieldStop()
19196 
    oprot.writeStructEnd()
19197 
 
19198 
  def validate(self):
19199 
    return
19200 
 
19201 
 
19202 
  def __repr__(self):
19203 
    L = ['%s=%r' % (key, value)
19204 
      for key, value in self.__dict__.iteritems()]
19205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19206 
 
19207 
  def __eq__(self, other):
19208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19209 
 
19210 
  def __ne__(self, other):
19211 
    return not (self == other)
19212 
 
19213 
class getItemPricingBySource_args:
19214 
  """
19215 
  Attributes:
19216 
   - itemId
19217 
   - sourceId
19218 
  """
19219 
 
19220 
  thrift_spec = (
19221 
    None, # 0
19222 
    (1, TType.I64, 'itemId', None, None, ), # 1
19223 
    (2, TType.I64, 'sourceId', None, None, ), # 2
19224 
  )
19225 
 
19226 
  def __init__(self, itemId=None, sourceId=None,):
19227 
    self.itemId = itemId
19228 
    self.sourceId = sourceId
19229 
 
19230 
  def read(self, iprot):
19231 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19232 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19233 
      return
19234 
    iprot.readStructBegin()
19235 
    while True:
19236 
      (fname, ftype, fid) = iprot.readFieldBegin()
19237 
      if ftype == TType.STOP:
19238 
        break
19239 
      if fid == 1:
19240 
        if ftype == TType.I64:
19241 
          self.itemId = iprot.readI64();
19242 
        else:
19243 
          iprot.skip(ftype)
19244 
      elif fid == 2:
19245 
        if ftype == TType.I64:
19246 
          self.sourceId = iprot.readI64();
19247 
        else:
19248 
          iprot.skip(ftype)
19249 
      else:
19250 
        iprot.skip(ftype)
19251 
      iprot.readFieldEnd()
19252 
    iprot.readStructEnd()
19253 
 
19254 
  def write(self, oprot):
19255 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19256 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19257 
      return
19258 
    oprot.writeStructBegin('getItemPricingBySource_args')
19259 
    if self.itemId is not None:
19260 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19261 
      oprot.writeI64(self.itemId)
19262 
      oprot.writeFieldEnd()
19263 
    if self.sourceId is not None:
19264 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
19265 
      oprot.writeI64(self.sourceId)
19266 
      oprot.writeFieldEnd()
19267 
    oprot.writeFieldStop()
19268 
    oprot.writeStructEnd()
19269 
 
19270 
  def validate(self):
19271 
    return
19272 
 
19273 
 
19274 
  def __repr__(self):
19275 
    L = ['%s=%r' % (key, value)
19276 
      for key, value in self.__dict__.iteritems()]
19277 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19278 
 
19279 
  def __eq__(self, other):
19280 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19281 
 
19282 
  def __ne__(self, other):
19283 
    return not (self == other)
19284 
 
19285 
class getItemPricingBySource_result:
19286 
  """
19287 
  Attributes:
19288 
   - success
19289 
   - cex
19290 
  """
19291 
 
19292 
  thrift_spec = (
19293 
    (0, TType.STRUCT, 'success', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 0
19294 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
19295 
  )
19296 
 
19297 
  def __init__(self, success=None, cex=None,):
19298 
    self.success = success
19299 
    self.cex = cex
19300 
 
19301 
  def read(self, iprot):
19302 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19303 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19304 
      return
19305 
    iprot.readStructBegin()
19306 
    while True:
19307 
      (fname, ftype, fid) = iprot.readFieldBegin()
19308 
      if ftype == TType.STOP:
19309 
        break
19310 
      if fid == 0:
19311 
        if ftype == TType.STRUCT:
19312 
          self.success = SourceItemPricing()
19313 
          self.success.read(iprot)
19314 
        else:
19315 
          iprot.skip(ftype)
19316 
      elif fid == 1:
19317 
        if ftype == TType.STRUCT:
19318 
          self.cex = CatalogServiceException()
19319 
          self.cex.read(iprot)
19320 
        else:
19321 
          iprot.skip(ftype)
19322 
      else:
19323 
        iprot.skip(ftype)
19324 
      iprot.readFieldEnd()
19325 
    iprot.readStructEnd()
19326 
 
19327 
  def write(self, oprot):
19328 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19329 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19330 
      return
19331 
    oprot.writeStructBegin('getItemPricingBySource_result')
19332 
    if self.success is not None:
19333 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19334 
      self.success.write(oprot)
19335 
      oprot.writeFieldEnd()
19336 
    if self.cex is not None:
19337 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
19338 
      self.cex.write(oprot)
19339 
      oprot.writeFieldEnd()
19340 
    oprot.writeFieldStop()
19341 
    oprot.writeStructEnd()
19342 
 
19343 
  def validate(self):
19344 
    return
19345 
 
19346 
 
19347 
  def __repr__(self):
19348 
    L = ['%s=%r' % (key, value)
19349 
      for key, value in self.__dict__.iteritems()]
19350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19351 
 
19352 
  def __eq__(self, other):
19353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19354 
 
19355 
  def __ne__(self, other):
19356 
    return not (self == other)
19357 
 
19358 
class addSourceItemPricing_args:
19359 
  """
19360 
  Attributes:
19361 
   - sourceItemPricing
19362 
  """
19363 
 
19364 
  thrift_spec = (
19365 
    None, # 0
19366 
    (1, TType.STRUCT, 'sourceItemPricing', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 1
19367 
  )
19368 
 
19369 
  def __init__(self, sourceItemPricing=None,):
19370 
    self.sourceItemPricing = sourceItemPricing
19371 
 
19372 
  def read(self, iprot):
19373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19375 
      return
19376 
    iprot.readStructBegin()
19377 
    while True:
19378 
      (fname, ftype, fid) = iprot.readFieldBegin()
19379 
      if ftype == TType.STOP:
19380 
        break
19381 
      if fid == 1:
19382 
        if ftype == TType.STRUCT:
19383 
          self.sourceItemPricing = SourceItemPricing()
19384 
          self.sourceItemPricing.read(iprot)
19385 
        else:
19386 
          iprot.skip(ftype)
19387 
      else:
19388 
        iprot.skip(ftype)
19389 
      iprot.readFieldEnd()
19390 
    iprot.readStructEnd()
19391 
 
19392 
  def write(self, oprot):
19393 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19394 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19395 
      return
19396 
    oprot.writeStructBegin('addSourceItemPricing_args')
19397 
    if self.sourceItemPricing is not None:
19398 
      oprot.writeFieldBegin('sourceItemPricing', TType.STRUCT, 1)
19399 
      self.sourceItemPricing.write(oprot)
19400 
      oprot.writeFieldEnd()
19401 
    oprot.writeFieldStop()
19402 
    oprot.writeStructEnd()
19403 
 
19404 
  def validate(self):
19405 
    return
19406 
 
19407 
 
19408 
  def __repr__(self):
19409 
    L = ['%s=%r' % (key, value)
19410 
      for key, value in self.__dict__.iteritems()]
19411 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19412 
 
19413 
  def __eq__(self, other):
19414 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19415 
 
19416 
  def __ne__(self, other):
19417 
    return not (self == other)
19418 
 
19419 
class addSourceItemPricing_result:
19420 
  """
19421 
  Attributes:
19422 
   - cex
19423 
  """
19424 
 
19425 
  thrift_spec = (
19426 
    None, # 0
19427 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
19428 
  )
19429 
 
19430 
  def __init__(self, cex=None,):
19431 
    self.cex = cex
19432 
 
19433 
  def read(self, iprot):
19434 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19435 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19436 
      return
19437 
    iprot.readStructBegin()
19438 
    while True:
19439 
      (fname, ftype, fid) = iprot.readFieldBegin()
19440 
      if ftype == TType.STOP:
19441 
        break
19442 
      if fid == 1:
19443 
        if ftype == TType.STRUCT:
19444 
          self.cex = CatalogServiceException()
19445 
          self.cex.read(iprot)
19446 
        else:
19447 
          iprot.skip(ftype)
19448 
      else:
19449 
        iprot.skip(ftype)
19450 
      iprot.readFieldEnd()
19451 
    iprot.readStructEnd()
19452 
 
19453 
  def write(self, oprot):
19454 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19455 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19456 
      return
19457 
    oprot.writeStructBegin('addSourceItemPricing_result')
19458 
    if self.cex is not None:
19459 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
19460 
      self.cex.write(oprot)
19461 
      oprot.writeFieldEnd()
19462 
    oprot.writeFieldStop()
19463 
    oprot.writeStructEnd()
19464 
 
19465 
  def validate(self):
19466 
    return
19467 
 
19468 
 
19469 
  def __repr__(self):
19470 
    L = ['%s=%r' % (key, value)
19471 
      for key, value in self.__dict__.iteritems()]
19472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19473 
 
19474 
  def __eq__(self, other):
19475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19476 
 
19477 
  def __ne__(self, other):
19478 
    return not (self == other)
19479 
 
19480 
class getAllSourcePricing_args:
19481 
  """
19482 
  Attributes:
19483 
   - itemId
19484 
  """
19485 
 
19486 
  thrift_spec = (
19487 
    None, # 0
19488 
    (1, TType.I64, 'itemId', None, None, ), # 1
19489 
  )
19490 
 
19491 
  def __init__(self, itemId=None,):
19492 
    self.itemId = itemId
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 == 1:
19504 
        if ftype == TType.I64:
19505 
          self.itemId = iprot.readI64();
19506 
        else:
19507 
          iprot.skip(ftype)
19508 
      else:
19509 
        iprot.skip(ftype)
19510 
      iprot.readFieldEnd()
19511 
    iprot.readStructEnd()
19512 
 
19513 
  def write(self, oprot):
19514 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19515 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19516 
      return
19517 
    oprot.writeStructBegin('getAllSourcePricing_args')
19518 
    if self.itemId is not None:
19519 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19520 
      oprot.writeI64(self.itemId)
19521 
      oprot.writeFieldEnd()
19522 
    oprot.writeFieldStop()
19523 
    oprot.writeStructEnd()
19524 
 
19525 
  def validate(self):
19526 
    return
19527 
 
19528 
 
19529 
  def __repr__(self):
19530 
    L = ['%s=%r' % (key, value)
19531 
      for key, value in self.__dict__.iteritems()]
19532 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19533 
 
19534 
  def __eq__(self, other):
19535 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19536 
 
19537 
  def __ne__(self, other):
19538 
    return not (self == other)
19539 
 
19540 
class getAllSourcePricing_result:
19541 
  """
19542 
  Attributes:
19543 
   - success
19544 
   - cex
19545 
  """
19546 
 
19547 
  thrift_spec = (
19548 
    (0, TType.LIST, 'success', (TType.STRUCT,(SourceItemPricing, SourceItemPricing.thrift_spec)), None, ), # 0
19549 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
19550 
  )
19551 
 
19552 
  def __init__(self, success=None, cex=None,):
19553 
    self.success = success
19554 
    self.cex = cex
19555 
 
19556 
  def read(self, iprot):
19557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19559 
      return
19560 
    iprot.readStructBegin()
19561 
    while True:
19562 
      (fname, ftype, fid) = iprot.readFieldBegin()
19563 
      if ftype == TType.STOP:
19564 
        break
19565 
      if fid == 0:
19566 
        if ftype == TType.LIST:
19567 
          self.success = []
13493 amit.gupta 19568 
          (_etype346, _size343) = iprot.readListBegin()
19569 
          for _i347 in xrange(_size343):
19570 
            _elem348 = SourceItemPricing()
19571 
            _elem348.read(iprot)
19572 
            self.success.append(_elem348)
5944 mandeep.dh 19573 
          iprot.readListEnd()
19574 
        else:
19575 
          iprot.skip(ftype)
19576 
      elif fid == 1:
19577 
        if ftype == TType.STRUCT:
19578 
          self.cex = CatalogServiceException()
19579 
          self.cex.read(iprot)
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('getAllSourcePricing_result')
19592 
    if self.success is not None:
19593 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19594 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 19595 
      for iter349 in self.success:
19596 
        iter349.write(oprot)
5944 mandeep.dh 19597 
      oprot.writeListEnd()
19598 
      oprot.writeFieldEnd()
19599 
    if self.cex is not None:
19600 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
19601 
      self.cex.write(oprot)
19602 
      oprot.writeFieldEnd()
19603 
    oprot.writeFieldStop()
19604 
    oprot.writeStructEnd()
19605 
 
19606 
  def validate(self):
19607 
    return
19608 
 
19609 
 
19610 
  def __repr__(self):
19611 
    L = ['%s=%r' % (key, value)
19612 
      for key, value in self.__dict__.iteritems()]
19613 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19614 
 
19615 
  def __eq__(self, other):
19616 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19617 
 
19618 
  def __ne__(self, other):
19619 
    return not (self == other)
19620 
 
19621 
class getItemForSource_args:
19622 
  """
19623 
  Attributes:
19624 
   - item_id
19625 
   - sourceId
19626 
  """
19627 
 
19628 
  thrift_spec = (
19629 
    None, # 0
19630 
    (1, TType.I64, 'item_id', None, None, ), # 1
19631 
    (2, TType.I64, 'sourceId', None, None, ), # 2
19632 
  )
19633 
 
19634 
  def __init__(self, item_id=None, sourceId=None,):
19635 
    self.item_id = item_id
19636 
    self.sourceId = sourceId
19637 
 
19638 
  def read(self, iprot):
19639 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19640 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19641 
      return
19642 
    iprot.readStructBegin()
19643 
    while True:
19644 
      (fname, ftype, fid) = iprot.readFieldBegin()
19645 
      if ftype == TType.STOP:
19646 
        break
19647 
      if fid == 1:
19648 
        if ftype == TType.I64:
19649 
          self.item_id = iprot.readI64();
19650 
        else:
19651 
          iprot.skip(ftype)
19652 
      elif fid == 2:
19653 
        if ftype == TType.I64:
19654 
          self.sourceId = iprot.readI64();
19655 
        else:
19656 
          iprot.skip(ftype)
19657 
      else:
19658 
        iprot.skip(ftype)
19659 
      iprot.readFieldEnd()
19660 
    iprot.readStructEnd()
19661 
 
19662 
  def write(self, oprot):
19663 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19664 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19665 
      return
19666 
    oprot.writeStructBegin('getItemForSource_args')
19667 
    if self.item_id is not None:
19668 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
19669 
      oprot.writeI64(self.item_id)
19670 
      oprot.writeFieldEnd()
19671 
    if self.sourceId is not None:
19672 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
19673 
      oprot.writeI64(self.sourceId)
19674 
      oprot.writeFieldEnd()
19675 
    oprot.writeFieldStop()
19676 
    oprot.writeStructEnd()
19677 
 
19678 
  def validate(self):
19679 
    return
19680 
 
19681 
 
19682 
  def __repr__(self):
19683 
    L = ['%s=%r' % (key, value)
19684 
      for key, value in self.__dict__.iteritems()]
19685 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19686 
 
19687 
  def __eq__(self, other):
19688 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19689 
 
19690 
  def __ne__(self, other):
19691 
    return not (self == other)
19692 
 
19693 
class getItemForSource_result:
19694 
  """
19695 
  Attributes:
19696 
   - success
19697 
   - cex
19698 
  """
19699 
 
19700 
  thrift_spec = (
19701 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
19702 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
19703 
  )
19704 
 
19705 
  def __init__(self, success=None, cex=None,):
19706 
    self.success = success
19707 
    self.cex = cex
19708 
 
19709 
  def read(self, iprot):
19710 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19711 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19712 
      return
19713 
    iprot.readStructBegin()
19714 
    while True:
19715 
      (fname, ftype, fid) = iprot.readFieldBegin()
19716 
      if ftype == TType.STOP:
19717 
        break
19718 
      if fid == 0:
19719 
        if ftype == TType.STRUCT:
19720 
          self.success = Item()
19721 
          self.success.read(iprot)
19722 
        else:
19723 
          iprot.skip(ftype)
19724 
      elif fid == 1:
19725 
        if ftype == TType.STRUCT:
19726 
          self.cex = CatalogServiceException()
19727 
          self.cex.read(iprot)
19728 
        else:
19729 
          iprot.skip(ftype)
19730 
      else:
19731 
        iprot.skip(ftype)
19732 
      iprot.readFieldEnd()
19733 
    iprot.readStructEnd()
19734 
 
19735 
  def write(self, oprot):
19736 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19737 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19738 
      return
19739 
    oprot.writeStructBegin('getItemForSource_result')
19740 
    if self.success is not None:
19741 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19742 
      self.success.write(oprot)
19743 
      oprot.writeFieldEnd()
19744 
    if self.cex is not None:
19745 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
19746 
      self.cex.write(oprot)
19747 
      oprot.writeFieldEnd()
19748 
    oprot.writeFieldStop()
19749 
    oprot.writeStructEnd()
19750 
 
19751 
  def validate(self):
19752 
    return
19753 
 
19754 
 
19755 
  def __repr__(self):
19756 
    L = ['%s=%r' % (key, value)
19757 
      for key, value in self.__dict__.iteritems()]
19758 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19759 
 
19760 
  def __eq__(self, other):
19761 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19762 
 
19763 
  def __ne__(self, other):
19764 
    return not (self == other)
19765 
 
19766 
class searchItemsInRange_args:
19767 
  """
19768 
  Attributes:
19769 
   - searchTerms
19770 
   - offset
19771 
   - limit
19772 
  """
19773 
 
19774 
  thrift_spec = (
19775 
    None, # 0
19776 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
19777 
    (2, TType.I64, 'offset', None, None, ), # 2
19778 
    (3, TType.I64, 'limit', None, None, ), # 3
19779 
  )
19780 
 
19781 
  def __init__(self, searchTerms=None, offset=None, limit=None,):
19782 
    self.searchTerms = searchTerms
19783 
    self.offset = offset
19784 
    self.limit = limit
19785 
 
19786 
  def read(self, iprot):
19787 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19788 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19789 
      return
19790 
    iprot.readStructBegin()
19791 
    while True:
19792 
      (fname, ftype, fid) = iprot.readFieldBegin()
19793 
      if ftype == TType.STOP:
19794 
        break
19795 
      if fid == 1:
19796 
        if ftype == TType.LIST:
19797 
          self.searchTerms = []
13493 amit.gupta 19798 
          (_etype353, _size350) = iprot.readListBegin()
19799 
          for _i354 in xrange(_size350):
19800 
            _elem355 = iprot.readString();
19801 
            self.searchTerms.append(_elem355)
5944 mandeep.dh 19802 
          iprot.readListEnd()
19803 
        else:
19804 
          iprot.skip(ftype)
19805 
      elif fid == 2:
19806 
        if ftype == TType.I64:
19807 
          self.offset = iprot.readI64();
19808 
        else:
19809 
          iprot.skip(ftype)
19810 
      elif fid == 3:
19811 
        if ftype == TType.I64:
19812 
          self.limit = iprot.readI64();
19813 
        else:
19814 
          iprot.skip(ftype)
19815 
      else:
19816 
        iprot.skip(ftype)
19817 
      iprot.readFieldEnd()
19818 
    iprot.readStructEnd()
19819 
 
19820 
  def write(self, oprot):
19821 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19822 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19823 
      return
19824 
    oprot.writeStructBegin('searchItemsInRange_args')
19825 
    if self.searchTerms is not None:
19826 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
19827 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
13493 amit.gupta 19828 
      for iter356 in self.searchTerms:
19829 
        oprot.writeString(iter356)
5944 mandeep.dh 19830 
      oprot.writeListEnd()
19831 
      oprot.writeFieldEnd()
19832 
    if self.offset is not None:
19833 
      oprot.writeFieldBegin('offset', TType.I64, 2)
19834 
      oprot.writeI64(self.offset)
19835 
      oprot.writeFieldEnd()
19836 
    if self.limit is not None:
19837 
      oprot.writeFieldBegin('limit', TType.I64, 3)
19838 
      oprot.writeI64(self.limit)
19839 
      oprot.writeFieldEnd()
19840 
    oprot.writeFieldStop()
19841 
    oprot.writeStructEnd()
19842 
 
19843 
  def validate(self):
19844 
    return
19845 
 
19846 
 
19847 
  def __repr__(self):
19848 
    L = ['%s=%r' % (key, value)
19849 
      for key, value in self.__dict__.iteritems()]
19850 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19851 
 
19852 
  def __eq__(self, other):
19853 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19854 
 
19855 
  def __ne__(self, other):
19856 
    return not (self == other)
19857 
 
19858 
class searchItemsInRange_result:
19859 
  """
19860 
  Attributes:
19861 
   - success
19862 
  """
19863 
 
19864 
  thrift_spec = (
19865 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
19866 
  )
19867 
 
19868 
  def __init__(self, success=None,):
19869 
    self.success = success
19870 
 
19871 
  def read(self, iprot):
19872 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19873 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19874 
      return
19875 
    iprot.readStructBegin()
19876 
    while True:
19877 
      (fname, ftype, fid) = iprot.readFieldBegin()
19878 
      if ftype == TType.STOP:
19879 
        break
19880 
      if fid == 0:
19881 
        if ftype == TType.LIST:
19882 
          self.success = []
13493 amit.gupta 19883 
          (_etype360, _size357) = iprot.readListBegin()
19884 
          for _i361 in xrange(_size357):
19885 
            _elem362 = Item()
19886 
            _elem362.read(iprot)
19887 
            self.success.append(_elem362)
5944 mandeep.dh 19888 
          iprot.readListEnd()
19889 
        else:
19890 
          iprot.skip(ftype)
19891 
      else:
19892 
        iprot.skip(ftype)
19893 
      iprot.readFieldEnd()
19894 
    iprot.readStructEnd()
19895 
 
19896 
  def write(self, oprot):
19897 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19898 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19899 
      return
19900 
    oprot.writeStructBegin('searchItemsInRange_result')
19901 
    if self.success is not None:
19902 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19903 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 19904 
      for iter363 in self.success:
19905 
        iter363.write(oprot)
5944 mandeep.dh 19906 
      oprot.writeListEnd()
19907 
      oprot.writeFieldEnd()
19908 
    oprot.writeFieldStop()
19909 
    oprot.writeStructEnd()
19910 
 
19911 
  def validate(self):
19912 
    return
19913 
 
19914 
 
19915 
  def __repr__(self):
19916 
    L = ['%s=%r' % (key, value)
19917 
      for key, value in self.__dict__.iteritems()]
19918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19919 
 
19920 
  def __eq__(self, other):
19921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19922 
 
19923 
  def __ne__(self, other):
19924 
    return not (self == other)
19925 
 
19926 
class getSearchResultCount_args:
19927 
  """
19928 
  Attributes:
19929 
   - searchTerms
19930 
  """
19931 
 
19932 
  thrift_spec = (
19933 
    None, # 0
19934 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
19935 
  )
19936 
 
19937 
  def __init__(self, searchTerms=None,):
19938 
    self.searchTerms = searchTerms
19939 
 
19940 
  def read(self, iprot):
19941 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19942 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19943 
      return
19944 
    iprot.readStructBegin()
19945 
    while True:
19946 
      (fname, ftype, fid) = iprot.readFieldBegin()
19947 
      if ftype == TType.STOP:
19948 
        break
19949 
      if fid == 1:
19950 
        if ftype == TType.LIST:
19951 
          self.searchTerms = []
13493 amit.gupta 19952 
          (_etype367, _size364) = iprot.readListBegin()
19953 
          for _i368 in xrange(_size364):
19954 
            _elem369 = iprot.readString();
19955 
            self.searchTerms.append(_elem369)
5944 mandeep.dh 19956 
          iprot.readListEnd()
19957 
        else:
19958 
          iprot.skip(ftype)
19959 
      else:
19960 
        iprot.skip(ftype)
19961 
      iprot.readFieldEnd()
19962 
    iprot.readStructEnd()
19963 
 
19964 
  def write(self, oprot):
19965 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19966 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19967 
      return
19968 
    oprot.writeStructBegin('getSearchResultCount_args')
19969 
    if self.searchTerms is not None:
19970 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
19971 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
13493 amit.gupta 19972 
      for iter370 in self.searchTerms:
19973 
        oprot.writeString(iter370)
5944 mandeep.dh 19974 
      oprot.writeListEnd()
19975 
      oprot.writeFieldEnd()
19976 
    oprot.writeFieldStop()
19977 
    oprot.writeStructEnd()
19978 
 
19979 
  def validate(self):
19980 
    return
19981 
 
19982 
 
19983 
  def __repr__(self):
19984 
    L = ['%s=%r' % (key, value)
19985 
      for key, value in self.__dict__.iteritems()]
19986 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19987 
 
19988 
  def __eq__(self, other):
19989 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19990 
 
19991 
  def __ne__(self, other):
19992 
    return not (self == other)
19993 
 
19994 
class getSearchResultCount_result:
19995 
  """
19996 
  Attributes:
19997 
   - success
19998 
  """
19999 
 
20000 
  thrift_spec = (
20001 
    (0, TType.I32, 'success', None, None, ), # 0
20002 
  )
20003 
 
20004 
  def __init__(self, success=None,):
20005 
    self.success = success
20006 
 
20007 
  def read(self, iprot):
20008 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20009 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20010 
      return
20011 
    iprot.readStructBegin()
20012 
    while True:
20013 
      (fname, ftype, fid) = iprot.readFieldBegin()
20014 
      if ftype == TType.STOP:
20015 
        break
20016 
      if fid == 0:
20017 
        if ftype == TType.I32:
20018 
          self.success = iprot.readI32();
20019 
        else:
20020 
          iprot.skip(ftype)
20021 
      else:
20022 
        iprot.skip(ftype)
20023 
      iprot.readFieldEnd()
20024 
    iprot.readStructEnd()
20025 
 
20026 
  def write(self, oprot):
20027 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20028 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20029 
      return
20030 
    oprot.writeStructBegin('getSearchResultCount_result')
20031 
    if self.success is not None:
20032 
      oprot.writeFieldBegin('success', TType.I32, 0)
20033 
      oprot.writeI32(self.success)
20034 
      oprot.writeFieldEnd()
20035 
    oprot.writeFieldStop()
20036 
    oprot.writeStructEnd()
20037 
 
20038 
  def validate(self):
20039 
    return
20040 
 
20041 
 
20042 
  def __repr__(self):
20043 
    L = ['%s=%r' % (key, value)
20044 
      for key, value in self.__dict__.iteritems()]
20045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20046 
 
20047 
  def __eq__(self, other):
20048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20049 
 
20050 
  def __ne__(self, other):
20051 
    return not (self == other)
20052 
 
20053 
class getProductNotifications_args:
20054 
  """
20055 
  Attributes:
20056 
   - startDateTime
20057 
  """
20058 
 
20059 
  thrift_spec = (
20060 
    None, # 0
20061 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
20062 
  )
20063 
 
20064 
  def __init__(self, startDateTime=None,):
20065 
    self.startDateTime = startDateTime
20066 
 
20067 
  def read(self, iprot):
20068 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20069 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20070 
      return
20071 
    iprot.readStructBegin()
20072 
    while True:
20073 
      (fname, ftype, fid) = iprot.readFieldBegin()
20074 
      if ftype == TType.STOP:
20075 
        break
20076 
      if fid == 1:
20077 
        if ftype == TType.I64:
20078 
          self.startDateTime = iprot.readI64();
20079 
        else:
20080 
          iprot.skip(ftype)
20081 
      else:
20082 
        iprot.skip(ftype)
20083 
      iprot.readFieldEnd()
20084 
    iprot.readStructEnd()
20085 
 
20086 
  def write(self, oprot):
20087 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20088 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20089 
      return
20090 
    oprot.writeStructBegin('getProductNotifications_args')
20091 
    if self.startDateTime is not None:
20092 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
20093 
      oprot.writeI64(self.startDateTime)
20094 
      oprot.writeFieldEnd()
20095 
    oprot.writeFieldStop()
20096 
    oprot.writeStructEnd()
20097 
 
20098 
  def validate(self):
20099 
    return
20100 
 
20101 
 
20102 
  def __repr__(self):
20103 
    L = ['%s=%r' % (key, value)
20104 
      for key, value in self.__dict__.iteritems()]
20105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20106 
 
20107 
  def __eq__(self, other):
20108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20109 
 
20110 
  def __ne__(self, other):
20111 
    return not (self == other)
20112 
 
20113 
class getProductNotifications_result:
20114 
  """
20115 
  Attributes:
20116 
   - success
20117 
  """
20118 
 
20119 
  thrift_spec = (
20120 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequest, ProductNotificationRequest.thrift_spec)), None, ), # 0
20121 
  )
20122 
 
20123 
  def __init__(self, success=None,):
20124 
    self.success = success
20125 
 
20126 
  def read(self, iprot):
20127 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20128 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20129 
      return
20130 
    iprot.readStructBegin()
20131 
    while True:
20132 
      (fname, ftype, fid) = iprot.readFieldBegin()
20133 
      if ftype == TType.STOP:
20134 
        break
20135 
      if fid == 0:
20136 
        if ftype == TType.LIST:
20137 
          self.success = []
13493 amit.gupta 20138 
          (_etype374, _size371) = iprot.readListBegin()
20139 
          for _i375 in xrange(_size371):
20140 
            _elem376 = ProductNotificationRequest()
20141 
            _elem376.read(iprot)
20142 
            self.success.append(_elem376)
5944 mandeep.dh 20143 
          iprot.readListEnd()
20144 
        else:
20145 
          iprot.skip(ftype)
20146 
      else:
20147 
        iprot.skip(ftype)
20148 
      iprot.readFieldEnd()
20149 
    iprot.readStructEnd()
20150 
 
20151 
  def write(self, oprot):
20152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20154 
      return
20155 
    oprot.writeStructBegin('getProductNotifications_result')
20156 
    if self.success is not None:
20157 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20158 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 20159 
      for iter377 in self.success:
20160 
        iter377.write(oprot)
5944 mandeep.dh 20161 
      oprot.writeListEnd()
20162 
      oprot.writeFieldEnd()
20163 
    oprot.writeFieldStop()
20164 
    oprot.writeStructEnd()
20165 
 
20166 
  def validate(self):
20167 
    return
20168 
 
20169 
 
20170 
  def __repr__(self):
20171 
    L = ['%s=%r' % (key, value)
20172 
      for key, value in self.__dict__.iteritems()]
20173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20174 
 
20175 
  def __eq__(self, other):
20176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20177 
 
20178 
  def __ne__(self, other):
20179 
    return not (self == other)
20180 
 
20181 
class getProductNotificationRequestCount_args:
20182 
  """
20183 
  Attributes:
20184 
   - startDateTime
7897 amar.kumar 20185 
   - categoryId
5944 mandeep.dh 20186 
  """
20187 
 
20188 
  thrift_spec = (
20189 
    None, # 0
20190 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
7897 amar.kumar 20191 
    (2, TType.I64, 'categoryId', None, None, ), # 2
5944 mandeep.dh 20192 
  )
20193 
 
7897 amar.kumar 20194 
  def __init__(self, startDateTime=None, categoryId=None,):
5944 mandeep.dh 20195 
    self.startDateTime = startDateTime
7897 amar.kumar 20196 
    self.categoryId = categoryId
5944 mandeep.dh 20197 
 
20198 
  def read(self, iprot):
20199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20201 
      return
20202 
    iprot.readStructBegin()
20203 
    while True:
20204 
      (fname, ftype, fid) = iprot.readFieldBegin()
20205 
      if ftype == TType.STOP:
20206 
        break
20207 
      if fid == 1:
20208 
        if ftype == TType.I64:
20209 
          self.startDateTime = iprot.readI64();
20210 
        else:
20211 
          iprot.skip(ftype)
7897 amar.kumar 20212 
      elif fid == 2:
20213 
        if ftype == TType.I64:
20214 
          self.categoryId = iprot.readI64();
20215 
        else:
20216 
          iprot.skip(ftype)
5944 mandeep.dh 20217 
      else:
20218 
        iprot.skip(ftype)
20219 
      iprot.readFieldEnd()
20220 
    iprot.readStructEnd()
20221 
 
20222 
  def write(self, oprot):
20223 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20224 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20225 
      return
20226 
    oprot.writeStructBegin('getProductNotificationRequestCount_args')
20227 
    if self.startDateTime is not None:
20228 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
20229 
      oprot.writeI64(self.startDateTime)
20230 
      oprot.writeFieldEnd()
7897 amar.kumar 20231 
    if self.categoryId is not None:
20232 
      oprot.writeFieldBegin('categoryId', TType.I64, 2)
20233 
      oprot.writeI64(self.categoryId)
20234 
      oprot.writeFieldEnd()
5944 mandeep.dh 20235 
    oprot.writeFieldStop()
20236 
    oprot.writeStructEnd()
20237 
 
20238 
  def validate(self):
20239 
    return
20240 
 
20241 
 
20242 
  def __repr__(self):
20243 
    L = ['%s=%r' % (key, value)
20244 
      for key, value in self.__dict__.iteritems()]
20245 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20246 
 
20247 
  def __eq__(self, other):
20248 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20249 
 
20250 
  def __ne__(self, other):
20251 
    return not (self == other)
20252 
 
20253 
class getProductNotificationRequestCount_result:
20254 
  """
20255 
  Attributes:
20256 
   - success
20257 
  """
20258 
 
20259 
  thrift_spec = (
20260 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequestCount, ProductNotificationRequestCount.thrift_spec)), None, ), # 0
20261 
  )
20262 
 
20263 
  def __init__(self, success=None,):
20264 
    self.success = success
20265 
 
20266 
  def read(self, iprot):
20267 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20268 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20269 
      return
20270 
    iprot.readStructBegin()
20271 
    while True:
20272 
      (fname, ftype, fid) = iprot.readFieldBegin()
20273 
      if ftype == TType.STOP:
20274 
        break
20275 
      if fid == 0:
20276 
        if ftype == TType.LIST:
20277 
          self.success = []
13493 amit.gupta 20278 
          (_etype381, _size378) = iprot.readListBegin()
20279 
          for _i382 in xrange(_size378):
20280 
            _elem383 = ProductNotificationRequestCount()
20281 
            _elem383.read(iprot)
20282 
            self.success.append(_elem383)
5944 mandeep.dh 20283 
          iprot.readListEnd()
20284 
        else:
20285 
          iprot.skip(ftype)
20286 
      else:
20287 
        iprot.skip(ftype)
20288 
      iprot.readFieldEnd()
20289 
    iprot.readStructEnd()
20290 
 
20291 
  def write(self, oprot):
20292 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20293 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20294 
      return
20295 
    oprot.writeStructBegin('getProductNotificationRequestCount_result')
20296 
    if self.success is not None:
20297 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20298 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 20299 
      for iter384 in self.success:
20300 
        iter384.write(oprot)
5944 mandeep.dh 20301 
      oprot.writeListEnd()
20302 
      oprot.writeFieldEnd()
20303 
    oprot.writeFieldStop()
20304 
    oprot.writeStructEnd()
20305 
 
20306 
  def validate(self):
20307 
    return
20308 
 
20309 
 
20310 
  def __repr__(self):
20311 
    L = ['%s=%r' % (key, value)
20312 
      for key, value in self.__dict__.iteritems()]
20313 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20314 
 
20315 
  def __eq__(self, other):
20316 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20317 
 
20318 
  def __ne__(self, other):
20319 
    return not (self == other)
20320 
 
20321 
class addAuthorizationLog_args:
20322 
  """
20323 
  Attributes:
20324 
   - itemId
20325 
   - username
20326 
   - reason
20327 
  """
20328 
 
20329 
  thrift_spec = (
20330 
    None, # 0
20331 
    (1, TType.I64, 'itemId', None, None, ), # 1
20332 
    (2, TType.STRING, 'username', None, None, ), # 2
20333 
    (3, TType.STRING, 'reason', None, None, ), # 3
20334 
  )
20335 
 
20336 
  def __init__(self, itemId=None, username=None, reason=None,):
20337 
    self.itemId = itemId
20338 
    self.username = username
20339 
    self.reason = reason
20340 
 
20341 
  def read(self, iprot):
20342 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20343 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20344 
      return
20345 
    iprot.readStructBegin()
20346 
    while True:
20347 
      (fname, ftype, fid) = iprot.readFieldBegin()
20348 
      if ftype == TType.STOP:
20349 
        break
20350 
      if fid == 1:
20351 
        if ftype == TType.I64:
20352 
          self.itemId = iprot.readI64();
20353 
        else:
20354 
          iprot.skip(ftype)
20355 
      elif fid == 2:
20356 
        if ftype == TType.STRING:
20357 
          self.username = iprot.readString();
20358 
        else:
20359 
          iprot.skip(ftype)
20360 
      elif fid == 3:
20361 
        if ftype == TType.STRING:
20362 
          self.reason = iprot.readString();
20363 
        else:
20364 
          iprot.skip(ftype)
20365 
      else:
20366 
        iprot.skip(ftype)
20367 
      iprot.readFieldEnd()
20368 
    iprot.readStructEnd()
20369 
 
20370 
  def write(self, oprot):
20371 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20372 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20373 
      return
20374 
    oprot.writeStructBegin('addAuthorizationLog_args')
20375 
    if self.itemId is not None:
20376 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20377 
      oprot.writeI64(self.itemId)
20378 
      oprot.writeFieldEnd()
20379 
    if self.username is not None:
20380 
      oprot.writeFieldBegin('username', TType.STRING, 2)
20381 
      oprot.writeString(self.username)
20382 
      oprot.writeFieldEnd()
20383 
    if self.reason is not None:
20384 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
20385 
      oprot.writeString(self.reason)
20386 
      oprot.writeFieldEnd()
20387 
    oprot.writeFieldStop()
20388 
    oprot.writeStructEnd()
20389 
 
20390 
  def validate(self):
20391 
    return
20392 
 
20393 
 
20394 
  def __repr__(self):
20395 
    L = ['%s=%r' % (key, value)
20396 
      for key, value in self.__dict__.iteritems()]
20397 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20398 
 
20399 
  def __eq__(self, other):
20400 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20401 
 
20402 
  def __ne__(self, other):
20403 
    return not (self == other)
20404 
 
20405 
class addAuthorizationLog_result:
20406 
  """
20407 
  Attributes:
20408 
   - success
20409 
   - cex
20410 
  """
20411 
 
20412 
  thrift_spec = (
20413 
    (0, TType.BOOL, 'success', None, None, ), # 0
20414 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
20415 
  )
20416 
 
20417 
  def __init__(self, success=None, cex=None,):
20418 
    self.success = success
20419 
    self.cex = cex
20420 
 
20421 
  def read(self, iprot):
20422 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20423 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20424 
      return
20425 
    iprot.readStructBegin()
20426 
    while True:
20427 
      (fname, ftype, fid) = iprot.readFieldBegin()
20428 
      if ftype == TType.STOP:
20429 
        break
20430 
      if fid == 0:
20431 
        if ftype == TType.BOOL:
20432 
          self.success = iprot.readBool();
20433 
        else:
20434 
          iprot.skip(ftype)
20435 
      elif fid == 1:
20436 
        if ftype == TType.STRUCT:
20437 
          self.cex = CatalogServiceException()
20438 
          self.cex.read(iprot)
20439 
        else:
20440 
          iprot.skip(ftype)
20441 
      else:
20442 
        iprot.skip(ftype)
20443 
      iprot.readFieldEnd()
20444 
    iprot.readStructEnd()
20445 
 
20446 
  def write(self, oprot):
20447 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20448 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20449 
      return
20450 
    oprot.writeStructBegin('addAuthorizationLog_result')
20451 
    if self.success is not None:
20452 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20453 
      oprot.writeBool(self.success)
20454 
      oprot.writeFieldEnd()
20455 
    if self.cex is not None:
20456 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
20457 
      self.cex.write(oprot)
20458 
      oprot.writeFieldEnd()
20459 
    oprot.writeFieldStop()
20460 
    oprot.writeStructEnd()
20461 
 
20462 
  def validate(self):
20463 
    return
20464 
 
20465 
 
20466 
  def __repr__(self):
20467 
    L = ['%s=%r' % (key, value)
20468 
      for key, value in self.__dict__.iteritems()]
20469 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20470 
 
20471 
  def __eq__(self, other):
20472 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20473 
 
20474 
  def __ne__(self, other):
20475 
    return not (self == other)
20476 
 
20477 
class addupdateVoucherForItem_args:
20478 
  """
20479 
  Attributes:
20480 
   - catalog_item_id
20481 
   - voucherType
20482 
   - voucherAmount
20483 
  """
20484 
 
20485 
  thrift_spec = (
20486 
    None, # 0
20487 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
20488 
    (2, TType.I64, 'voucherType', None, None, ), # 2
20489 
    (3, TType.I64, 'voucherAmount', None, None, ), # 3
20490 
  )
20491 
 
20492 
  def __init__(self, catalog_item_id=None, voucherType=None, voucherAmount=None,):
20493 
    self.catalog_item_id = catalog_item_id
20494 
    self.voucherType = voucherType
20495 
    self.voucherAmount = voucherAmount
20496 
 
20497 
  def read(self, iprot):
20498 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20499 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20500 
      return
20501 
    iprot.readStructBegin()
20502 
    while True:
20503 
      (fname, ftype, fid) = iprot.readFieldBegin()
20504 
      if ftype == TType.STOP:
20505 
        break
20506 
      if fid == 1:
20507 
        if ftype == TType.I64:
20508 
          self.catalog_item_id = iprot.readI64();
20509 
        else:
20510 
          iprot.skip(ftype)
20511 
      elif fid == 2:
20512 
        if ftype == TType.I64:
20513 
          self.voucherType = iprot.readI64();
20514 
        else:
20515 
          iprot.skip(ftype)
20516 
      elif fid == 3:
20517 
        if ftype == TType.I64:
20518 
          self.voucherAmount = iprot.readI64();
20519 
        else:
20520 
          iprot.skip(ftype)
20521 
      else:
20522 
        iprot.skip(ftype)
20523 
      iprot.readFieldEnd()
20524 
    iprot.readStructEnd()
20525 
 
20526 
  def write(self, oprot):
20527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20529 
      return
20530 
    oprot.writeStructBegin('addupdateVoucherForItem_args')
20531 
    if self.catalog_item_id is not None:
20532 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
20533 
      oprot.writeI64(self.catalog_item_id)
20534 
      oprot.writeFieldEnd()
20535 
    if self.voucherType is not None:
20536 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
20537 
      oprot.writeI64(self.voucherType)
20538 
      oprot.writeFieldEnd()
20539 
    if self.voucherAmount is not None:
20540 
      oprot.writeFieldBegin('voucherAmount', TType.I64, 3)
20541 
      oprot.writeI64(self.voucherAmount)
20542 
      oprot.writeFieldEnd()
20543 
    oprot.writeFieldStop()
20544 
    oprot.writeStructEnd()
20545 
 
20546 
  def validate(self):
20547 
    return
20548 
 
20549 
 
20550 
  def __repr__(self):
20551 
    L = ['%s=%r' % (key, value)
20552 
      for key, value in self.__dict__.iteritems()]
20553 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20554 
 
20555 
  def __eq__(self, other):
20556 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20557 
 
20558 
  def __ne__(self, other):
20559 
    return not (self == other)
20560 
 
20561 
class addupdateVoucherForItem_result:
20562 
  """
20563 
  Attributes:
20564 
   - success
20565 
   - cex
20566 
  """
20567 
 
20568 
  thrift_spec = (
20569 
    (0, TType.BOOL, 'success', None, None, ), # 0
20570 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
20571 
  )
20572 
 
20573 
  def __init__(self, success=None, cex=None,):
20574 
    self.success = success
20575 
    self.cex = cex
20576 
 
20577 
  def read(self, iprot):
20578 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20579 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20580 
      return
20581 
    iprot.readStructBegin()
20582 
    while True:
20583 
      (fname, ftype, fid) = iprot.readFieldBegin()
20584 
      if ftype == TType.STOP:
20585 
        break
20586 
      if fid == 0:
20587 
        if ftype == TType.BOOL:
20588 
          self.success = iprot.readBool();
20589 
        else:
20590 
          iprot.skip(ftype)
20591 
      elif fid == 1:
20592 
        if ftype == TType.STRUCT:
20593 
          self.cex = CatalogServiceException()
20594 
          self.cex.read(iprot)
20595 
        else:
20596 
          iprot.skip(ftype)
20597 
      else:
20598 
        iprot.skip(ftype)
20599 
      iprot.readFieldEnd()
20600 
    iprot.readStructEnd()
20601 
 
20602 
  def write(self, oprot):
20603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20605 
      return
20606 
    oprot.writeStructBegin('addupdateVoucherForItem_result')
20607 
    if self.success is not None:
20608 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20609 
      oprot.writeBool(self.success)
20610 
      oprot.writeFieldEnd()
20611 
    if self.cex is not None:
20612 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
20613 
      self.cex.write(oprot)
20614 
      oprot.writeFieldEnd()
20615 
    oprot.writeFieldStop()
20616 
    oprot.writeStructEnd()
20617 
 
20618 
  def validate(self):
20619 
    return
20620 
 
20621 
 
20622 
  def __repr__(self):
20623 
    L = ['%s=%r' % (key, value)
20624 
      for key, value in self.__dict__.iteritems()]
20625 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20626 
 
20627 
  def __eq__(self, other):
20628 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20629 
 
20630 
  def __ne__(self, other):
20631 
    return not (self == other)
20632 
 
20633 
class deleteVoucherForItem_args:
20634 
  """
20635 
  Attributes:
20636 
   - catalog_item_id
20637 
   - voucherType
20638 
  """
20639 
 
20640 
  thrift_spec = (
20641 
    None, # 0
20642 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
20643 
    (2, TType.I64, 'voucherType', None, None, ), # 2
20644 
  )
20645 
 
20646 
  def __init__(self, catalog_item_id=None, voucherType=None,):
20647 
    self.catalog_item_id = catalog_item_id
20648 
    self.voucherType = voucherType
20649 
 
20650 
  def read(self, iprot):
20651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20653 
      return
20654 
    iprot.readStructBegin()
20655 
    while True:
20656 
      (fname, ftype, fid) = iprot.readFieldBegin()
20657 
      if ftype == TType.STOP:
20658 
        break
20659 
      if fid == 1:
20660 
        if ftype == TType.I64:
20661 
          self.catalog_item_id = iprot.readI64();
20662 
        else:
20663 
          iprot.skip(ftype)
20664 
      elif fid == 2:
20665 
        if ftype == TType.I64:
20666 
          self.voucherType = iprot.readI64();
20667 
        else:
20668 
          iprot.skip(ftype)
20669 
      else:
20670 
        iprot.skip(ftype)
20671 
      iprot.readFieldEnd()
20672 
    iprot.readStructEnd()
20673 
 
20674 
  def write(self, oprot):
20675 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20676 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20677 
      return
20678 
    oprot.writeStructBegin('deleteVoucherForItem_args')
20679 
    if self.catalog_item_id is not None:
20680 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
20681 
      oprot.writeI64(self.catalog_item_id)
20682 
      oprot.writeFieldEnd()
20683 
    if self.voucherType is not None:
20684 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
20685 
      oprot.writeI64(self.voucherType)
20686 
      oprot.writeFieldEnd()
20687 
    oprot.writeFieldStop()
20688 
    oprot.writeStructEnd()
20689 
 
20690 
  def validate(self):
20691 
    return
20692 
 
20693 
 
20694 
  def __repr__(self):
20695 
    L = ['%s=%r' % (key, value)
20696 
      for key, value in self.__dict__.iteritems()]
20697 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20698 
 
20699 
  def __eq__(self, other):
20700 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20701 
 
20702 
  def __ne__(self, other):
20703 
    return not (self == other)
20704 
 
20705 
class deleteVoucherForItem_result:
20706 
  """
20707 
  Attributes:
20708 
   - success
20709 
   - cex
20710 
  """
20711 
 
20712 
  thrift_spec = (
20713 
    (0, TType.BOOL, 'success', None, None, ), # 0
20714 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
20715 
  )
20716 
 
20717 
  def __init__(self, success=None, cex=None,):
20718 
    self.success = success
20719 
    self.cex = cex
20720 
 
20721 
  def read(self, iprot):
20722 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20723 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20724 
      return
20725 
    iprot.readStructBegin()
20726 
    while True:
20727 
      (fname, ftype, fid) = iprot.readFieldBegin()
20728 
      if ftype == TType.STOP:
20729 
        break
20730 
      if fid == 0:
20731 
        if ftype == TType.BOOL:
20732 
          self.success = iprot.readBool();
20733 
        else:
20734 
          iprot.skip(ftype)
20735 
      elif fid == 1:
20736 
        if ftype == TType.STRUCT:
20737 
          self.cex = CatalogServiceException()
20738 
          self.cex.read(iprot)
20739 
        else:
20740 
          iprot.skip(ftype)
20741 
      else:
20742 
        iprot.skip(ftype)
20743 
      iprot.readFieldEnd()
20744 
    iprot.readStructEnd()
20745 
 
20746 
  def write(self, oprot):
20747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20749 
      return
20750 
    oprot.writeStructBegin('deleteVoucherForItem_result')
20751 
    if self.success is not None:
20752 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20753 
      oprot.writeBool(self.success)
20754 
      oprot.writeFieldEnd()
20755 
    if self.cex is not None:
20756 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
20757 
      self.cex.write(oprot)
20758 
      oprot.writeFieldEnd()
20759 
    oprot.writeFieldStop()
20760 
    oprot.writeStructEnd()
20761 
 
20762 
  def validate(self):
20763 
    return
20764 
 
20765 
 
20766 
  def __repr__(self):
20767 
    L = ['%s=%r' % (key, value)
20768 
      for key, value in self.__dict__.iteritems()]
20769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20770 
 
20771 
  def __eq__(self, other):
20772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20773 
 
20774 
  def __ne__(self, other):
20775 
    return not (self == other)
20776 
 
20777 
class getVoucherAmount_args:
20778 
  """
20779 
  Attributes:
20780 
   - itemId
20781 
   - voucherType
20782 
  """
20783 
 
20784 
  thrift_spec = (
20785 
    None, # 0
20786 
    (1, TType.I64, 'itemId', None, None, ), # 1
20787 
    (2, TType.I64, 'voucherType', None, None, ), # 2
20788 
  )
20789 
 
20790 
  def __init__(self, itemId=None, voucherType=None,):
20791 
    self.itemId = itemId
20792 
    self.voucherType = voucherType
20793 
 
20794 
  def read(self, iprot):
20795 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20796 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20797 
      return
20798 
    iprot.readStructBegin()
20799 
    while True:
20800 
      (fname, ftype, fid) = iprot.readFieldBegin()
20801 
      if ftype == TType.STOP:
20802 
        break
20803 
      if fid == 1:
20804 
        if ftype == TType.I64:
20805 
          self.itemId = iprot.readI64();
20806 
        else:
20807 
          iprot.skip(ftype)
20808 
      elif fid == 2:
20809 
        if ftype == TType.I64:
20810 
          self.voucherType = iprot.readI64();
20811 
        else:
20812 
          iprot.skip(ftype)
20813 
      else:
20814 
        iprot.skip(ftype)
20815 
      iprot.readFieldEnd()
20816 
    iprot.readStructEnd()
20817 
 
20818 
  def write(self, oprot):
20819 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20820 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20821 
      return
20822 
    oprot.writeStructBegin('getVoucherAmount_args')
20823 
    if self.itemId is not None:
20824 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20825 
      oprot.writeI64(self.itemId)
20826 
      oprot.writeFieldEnd()
20827 
    if self.voucherType is not None:
20828 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
20829 
      oprot.writeI64(self.voucherType)
20830 
      oprot.writeFieldEnd()
20831 
    oprot.writeFieldStop()
20832 
    oprot.writeStructEnd()
20833 
 
20834 
  def validate(self):
20835 
    return
20836 
 
20837 
 
20838 
  def __repr__(self):
20839 
    L = ['%s=%r' % (key, value)
20840 
      for key, value in self.__dict__.iteritems()]
20841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20842 
 
20843 
  def __eq__(self, other):
20844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20845 
 
20846 
  def __ne__(self, other):
20847 
    return not (self == other)
20848 
 
20849 
class getVoucherAmount_result:
20850 
  """
20851 
  Attributes:
20852 
   - success
20853 
  """
20854 
 
20855 
  thrift_spec = (
20856 
    (0, TType.I64, 'success', None, None, ), # 0
20857 
  )
20858 
 
20859 
  def __init__(self, success=None,):
20860 
    self.success = success
20861 
 
20862 
  def read(self, iprot):
20863 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20864 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20865 
      return
20866 
    iprot.readStructBegin()
20867 
    while True:
20868 
      (fname, ftype, fid) = iprot.readFieldBegin()
20869 
      if ftype == TType.STOP:
20870 
        break
20871 
      if fid == 0:
20872 
        if ftype == TType.I64:
20873 
          self.success = iprot.readI64();
20874 
        else:
20875 
          iprot.skip(ftype)
20876 
      else:
20877 
        iprot.skip(ftype)
20878 
      iprot.readFieldEnd()
20879 
    iprot.readStructEnd()
20880 
 
20881 
  def write(self, oprot):
20882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20884 
      return
20885 
    oprot.writeStructBegin('getVoucherAmount_result')
20886 
    if self.success is not None:
20887 
      oprot.writeFieldBegin('success', TType.I64, 0)
20888 
      oprot.writeI64(self.success)
20889 
      oprot.writeFieldEnd()
20890 
    oprot.writeFieldStop()
20891 
    oprot.writeStructEnd()
20892 
 
20893 
  def validate(self):
20894 
    return
20895 
 
20896 
 
20897 
  def __repr__(self):
20898 
    L = ['%s=%r' % (key, value)
20899 
      for key, value in self.__dict__.iteritems()]
20900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20901 
 
20902 
  def __eq__(self, other):
20903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20904 
 
20905 
  def __ne__(self, other):
20906 
    return not (self == other)
20907 
 
20908 
class getAllItemVouchers_args:
20909 
  """
20910 
  Attributes:
20911 
   - itemId
20912 
  """
20913 
 
20914 
  thrift_spec = (
20915 
    None, # 0
20916 
    (1, TType.I64, 'itemId', None, None, ), # 1
20917 
  )
20918 
 
20919 
  def __init__(self, itemId=None,):
20920 
    self.itemId = itemId
20921 
 
20922 
  def read(self, iprot):
20923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20925 
      return
20926 
    iprot.readStructBegin()
20927 
    while True:
20928 
      (fname, ftype, fid) = iprot.readFieldBegin()
20929 
      if ftype == TType.STOP:
20930 
        break
20931 
      if fid == 1:
20932 
        if ftype == TType.I64:
20933 
          self.itemId = iprot.readI64();
20934 
        else:
20935 
          iprot.skip(ftype)
20936 
      else:
20937 
        iprot.skip(ftype)
20938 
      iprot.readFieldEnd()
20939 
    iprot.readStructEnd()
20940 
 
20941 
  def write(self, oprot):
20942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20944 
      return
20945 
    oprot.writeStructBegin('getAllItemVouchers_args')
20946 
    if self.itemId is not None:
20947 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20948 
      oprot.writeI64(self.itemId)
20949 
      oprot.writeFieldEnd()
20950 
    oprot.writeFieldStop()
20951 
    oprot.writeStructEnd()
20952 
 
20953 
  def validate(self):
20954 
    return
20955 
 
20956 
 
20957 
  def __repr__(self):
20958 
    L = ['%s=%r' % (key, value)
20959 
      for key, value in self.__dict__.iteritems()]
20960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20961 
 
20962 
  def __eq__(self, other):
20963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20964 
 
20965 
  def __ne__(self, other):
20966 
    return not (self == other)
20967 
 
20968 
class getAllItemVouchers_result:
20969 
  """
20970 
  Attributes:
20971 
   - success
20972 
  """
20973 
 
20974 
  thrift_spec = (
20975 
    (0, TType.LIST, 'success', (TType.STRUCT,(VoucherItemMapping, VoucherItemMapping.thrift_spec)), None, ), # 0
20976 
  )
20977 
 
20978 
  def __init__(self, success=None,):
20979 
    self.success = success
20980 
 
20981 
  def read(self, iprot):
20982 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20983 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20984 
      return
20985 
    iprot.readStructBegin()
20986 
    while True:
20987 
      (fname, ftype, fid) = iprot.readFieldBegin()
20988 
      if ftype == TType.STOP:
20989 
        break
20990 
      if fid == 0:
20991 
        if ftype == TType.LIST:
20992 
          self.success = []
13493 amit.gupta 20993 
          (_etype388, _size385) = iprot.readListBegin()
20994 
          for _i389 in xrange(_size385):
20995 
            _elem390 = VoucherItemMapping()
20996 
            _elem390.read(iprot)
20997 
            self.success.append(_elem390)
5944 mandeep.dh 20998 
          iprot.readListEnd()
20999 
        else:
21000 
          iprot.skip(ftype)
21001 
      else:
21002 
        iprot.skip(ftype)
21003 
      iprot.readFieldEnd()
21004 
    iprot.readStructEnd()
21005 
 
21006 
  def write(self, oprot):
21007 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21008 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21009 
      return
21010 
    oprot.writeStructBegin('getAllItemVouchers_result')
21011 
    if self.success is not None:
21012 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21013 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 21014 
      for iter391 in self.success:
21015 
        iter391.write(oprot)
5944 mandeep.dh 21016 
      oprot.writeListEnd()
21017 
      oprot.writeFieldEnd()
21018 
    oprot.writeFieldStop()
21019 
    oprot.writeStructEnd()
21020 
 
21021 
  def validate(self):
21022 
    return
21023 
 
21024 
 
21025 
  def __repr__(self):
21026 
    L = ['%s=%r' % (key, value)
21027 
      for key, value in self.__dict__.iteritems()]
21028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21029 
 
21030 
  def __eq__(self, other):
21031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21032 
 
21033 
  def __ne__(self, other):
21034 
    return not (self == other)
21035 
 
21036 
class isValidCatalogItemId_args:
21037 
  """
21038 
  Attributes:
21039 
   - catalog_item_id
21040 
  """
21041 
 
21042 
  thrift_spec = (
21043 
    None, # 0
21044 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
21045 
  )
21046 
 
21047 
  def __init__(self, catalog_item_id=None,):
21048 
    self.catalog_item_id = catalog_item_id
21049 
 
21050 
  def read(self, iprot):
21051 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21052 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21053 
      return
21054 
    iprot.readStructBegin()
21055 
    while True:
21056 
      (fname, ftype, fid) = iprot.readFieldBegin()
21057 
      if ftype == TType.STOP:
21058 
        break
21059 
      if fid == 1:
21060 
        if ftype == TType.I64:
21061 
          self.catalog_item_id = iprot.readI64();
21062 
        else:
21063 
          iprot.skip(ftype)
21064 
      else:
21065 
        iprot.skip(ftype)
21066 
      iprot.readFieldEnd()
21067 
    iprot.readStructEnd()
21068 
 
21069 
  def write(self, oprot):
21070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21072 
      return
21073 
    oprot.writeStructBegin('isValidCatalogItemId_args')
21074 
    if self.catalog_item_id is not None:
21075 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
21076 
      oprot.writeI64(self.catalog_item_id)
21077 
      oprot.writeFieldEnd()
21078 
    oprot.writeFieldStop()
21079 
    oprot.writeStructEnd()
21080 
 
21081 
  def validate(self):
21082 
    return
21083 
 
21084 
 
21085 
  def __repr__(self):
21086 
    L = ['%s=%r' % (key, value)
21087 
      for key, value in self.__dict__.iteritems()]
21088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21089 
 
21090 
  def __eq__(self, other):
21091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21092 
 
21093 
  def __ne__(self, other):
21094 
    return not (self == other)
21095 
 
21096 
class isValidCatalogItemId_result:
21097 
  """
21098 
  Attributes:
21099 
   - success
21100 
  """
21101 
 
21102 
  thrift_spec = (
21103 
    (0, TType.BOOL, 'success', None, None, ), # 0
21104 
  )
21105 
 
21106 
  def __init__(self, success=None,):
21107 
    self.success = success
21108 
 
21109 
  def read(self, iprot):
21110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21112 
      return
21113 
    iprot.readStructBegin()
21114 
    while True:
21115 
      (fname, ftype, fid) = iprot.readFieldBegin()
21116 
      if ftype == TType.STOP:
21117 
        break
21118 
      if fid == 0:
21119 
        if ftype == TType.BOOL:
21120 
          self.success = iprot.readBool();
21121 
        else:
21122 
          iprot.skip(ftype)
21123 
      else:
21124 
        iprot.skip(ftype)
21125 
      iprot.readFieldEnd()
21126 
    iprot.readStructEnd()
21127 
 
21128 
  def write(self, oprot):
21129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21131 
      return
21132 
    oprot.writeStructBegin('isValidCatalogItemId_result')
21133 
    if self.success is not None:
21134 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21135 
      oprot.writeBool(self.success)
21136 
      oprot.writeFieldEnd()
21137 
    oprot.writeFieldStop()
21138 
    oprot.writeStructEnd()
21139 
 
21140 
  def validate(self):
21141 
    return
21142 
 
21143 
 
21144 
  def __repr__(self):
21145 
    L = ['%s=%r' % (key, value)
21146 
      for key, value in self.__dict__.iteritems()]
21147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21148 
 
21149 
  def __eq__(self, other):
21150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21151 
 
21152 
  def __ne__(self, other):
21153 
    return not (self == other)
6039 amit.gupta 21154 
 
21155 
class getVatPercentageForItem_args:
21156 
  """
21157 
  Attributes:
21158 
   - itemId
7330 amit.gupta 21159 
   - stateId
6039 amit.gupta 21160 
   - price
21161 
  """
21162 
 
21163 
  thrift_spec = (
21164 
    None, # 0
21165 
    (1, TType.I64, 'itemId', None, None, ), # 1
7330 amit.gupta 21166 
    (2, TType.I64, 'stateId', None, None, ), # 2
21167 
    (3, TType.DOUBLE, 'price', None, None, ), # 3
6039 amit.gupta 21168 
  )
21169 
 
7330 amit.gupta 21170 
  def __init__(self, itemId=None, stateId=None, price=None,):
6039 amit.gupta 21171 
    self.itemId = itemId
7330 amit.gupta 21172 
    self.stateId = stateId
6039 amit.gupta 21173 
    self.price = price
21174 
 
21175 
  def read(self, iprot):
21176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21178 
      return
21179 
    iprot.readStructBegin()
21180 
    while True:
21181 
      (fname, ftype, fid) = iprot.readFieldBegin()
21182 
      if ftype == TType.STOP:
21183 
        break
21184 
      if fid == 1:
21185 
        if ftype == TType.I64:
21186 
          self.itemId = iprot.readI64();
21187 
        else:
21188 
          iprot.skip(ftype)
21189 
      elif fid == 2:
7330 amit.gupta 21190 
        if ftype == TType.I64:
21191 
          self.stateId = iprot.readI64();
21192 
        else:
21193 
          iprot.skip(ftype)
21194 
      elif fid == 3:
6039 amit.gupta 21195 
        if ftype == TType.DOUBLE:
21196 
          self.price = iprot.readDouble();
21197 
        else:
21198 
          iprot.skip(ftype)
21199 
      else:
21200 
        iprot.skip(ftype)
21201 
      iprot.readFieldEnd()
21202 
    iprot.readStructEnd()
21203 
 
21204 
  def write(self, oprot):
21205 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21206 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21207 
      return
21208 
    oprot.writeStructBegin('getVatPercentageForItem_args')
21209 
    if self.itemId is not None:
21210 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
21211 
      oprot.writeI64(self.itemId)
21212 
      oprot.writeFieldEnd()
7330 amit.gupta 21213 
    if self.stateId is not None:
21214 
      oprot.writeFieldBegin('stateId', TType.I64, 2)
21215 
      oprot.writeI64(self.stateId)
21216 
      oprot.writeFieldEnd()
6039 amit.gupta 21217 
    if self.price is not None:
7330 amit.gupta 21218 
      oprot.writeFieldBegin('price', TType.DOUBLE, 3)
6039 amit.gupta 21219 
      oprot.writeDouble(self.price)
21220 
      oprot.writeFieldEnd()
21221 
    oprot.writeFieldStop()
21222 
    oprot.writeStructEnd()
21223 
 
21224 
  def validate(self):
21225 
    return
21226 
 
21227 
 
21228 
  def __repr__(self):
21229 
    L = ['%s=%r' % (key, value)
21230 
      for key, value in self.__dict__.iteritems()]
21231 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21232 
 
21233 
  def __eq__(self, other):
21234 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21235 
 
21236 
  def __ne__(self, other):
21237 
    return not (self == other)
21238 
 
21239 
class getVatPercentageForItem_result:
21240 
  """
21241 
  Attributes:
21242 
   - success
7340 amit.gupta 21243 
   - cex
6039 amit.gupta 21244 
  """
21245 
 
21246 
  thrift_spec = (
21247 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
7340 amit.gupta 21248 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6039 amit.gupta 21249 
  )
21250 
 
7340 amit.gupta 21251 
  def __init__(self, success=None, cex=None,):
6039 amit.gupta 21252 
    self.success = success
7340 amit.gupta 21253 
    self.cex = cex
6039 amit.gupta 21254 
 
21255 
  def read(self, iprot):
21256 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21257 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21258 
      return
21259 
    iprot.readStructBegin()
21260 
    while True:
21261 
      (fname, ftype, fid) = iprot.readFieldBegin()
21262 
      if ftype == TType.STOP:
21263 
        break
21264 
      if fid == 0:
21265 
        if ftype == TType.DOUBLE:
21266 
          self.success = iprot.readDouble();
21267 
        else:
21268 
          iprot.skip(ftype)
7340 amit.gupta 21269 
      elif fid == 1:
21270 
        if ftype == TType.STRUCT:
21271 
          self.cex = CatalogServiceException()
21272 
          self.cex.read(iprot)
21273 
        else:
21274 
          iprot.skip(ftype)
6039 amit.gupta 21275 
      else:
21276 
        iprot.skip(ftype)
21277 
      iprot.readFieldEnd()
21278 
    iprot.readStructEnd()
21279 
 
21280 
  def write(self, oprot):
21281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21283 
      return
21284 
    oprot.writeStructBegin('getVatPercentageForItem_result')
21285 
    if self.success is not None:
21286 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
21287 
      oprot.writeDouble(self.success)
21288 
      oprot.writeFieldEnd()
7340 amit.gupta 21289 
    if self.cex is not None:
21290 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
21291 
      self.cex.write(oprot)
21292 
      oprot.writeFieldEnd()
6039 amit.gupta 21293 
    oprot.writeFieldStop()
21294 
    oprot.writeStructEnd()
21295 
 
21296 
  def validate(self):
21297 
    return
21298 
 
21299 
 
21300 
  def __repr__(self):
21301 
    L = ['%s=%r' % (key, value)
21302 
      for key, value in self.__dict__.iteritems()]
21303 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21304 
 
21305 
  def __eq__(self, other):
21306 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21307 
 
21308 
  def __ne__(self, other):
21309 
    return not (self == other)
21310 
 
21311 
class getVatAmountForItem_args:
21312 
  """
21313 
  Attributes:
21314 
   - itemId
21315 
   - price
21316 
  """
21317 
 
21318 
  thrift_spec = (
21319 
    None, # 0
21320 
    (1, TType.I64, 'itemId', None, None, ), # 1
21321 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
21322 
  )
21323 
 
21324 
  def __init__(self, itemId=None, price=None,):
21325 
    self.itemId = itemId
21326 
    self.price = price
21327 
 
21328 
  def read(self, iprot):
21329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21331 
      return
21332 
    iprot.readStructBegin()
21333 
    while True:
21334 
      (fname, ftype, fid) = iprot.readFieldBegin()
21335 
      if ftype == TType.STOP:
21336 
        break
21337 
      if fid == 1:
21338 
        if ftype == TType.I64:
21339 
          self.itemId = iprot.readI64();
21340 
        else:
21341 
          iprot.skip(ftype)
21342 
      elif fid == 2:
21343 
        if ftype == TType.DOUBLE:
21344 
          self.price = iprot.readDouble();
21345 
        else:
21346 
          iprot.skip(ftype)
21347 
      else:
21348 
        iprot.skip(ftype)
21349 
      iprot.readFieldEnd()
21350 
    iprot.readStructEnd()
21351 
 
21352 
  def write(self, oprot):
21353 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21354 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21355 
      return
21356 
    oprot.writeStructBegin('getVatAmountForItem_args')
21357 
    if self.itemId is not None:
21358 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
21359 
      oprot.writeI64(self.itemId)
21360 
      oprot.writeFieldEnd()
21361 
    if self.price is not None:
21362 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
21363 
      oprot.writeDouble(self.price)
21364 
      oprot.writeFieldEnd()
21365 
    oprot.writeFieldStop()
21366 
    oprot.writeStructEnd()
21367 
 
21368 
  def validate(self):
21369 
    return
21370 
 
21371 
 
21372 
  def __repr__(self):
21373 
    L = ['%s=%r' % (key, value)
21374 
      for key, value in self.__dict__.iteritems()]
21375 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21376 
 
21377 
  def __eq__(self, other):
21378 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21379 
 
21380 
  def __ne__(self, other):
21381 
    return not (self == other)
21382 
 
21383 
class getVatAmountForItem_result:
21384 
  """
21385 
  Attributes:
21386 
   - success
21387 
  """
21388 
 
21389 
  thrift_spec = (
21390 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
21391 
  )
21392 
 
21393 
  def __init__(self, success=None,):
21394 
    self.success = success
21395 
 
21396 
  def read(self, iprot):
21397 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21398 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21399 
      return
21400 
    iprot.readStructBegin()
21401 
    while True:
21402 
      (fname, ftype, fid) = iprot.readFieldBegin()
21403 
      if ftype == TType.STOP:
21404 
        break
21405 
      if fid == 0:
21406 
        if ftype == TType.DOUBLE:
21407 
          self.success = iprot.readDouble();
21408 
        else:
21409 
          iprot.skip(ftype)
21410 
      else:
21411 
        iprot.skip(ftype)
21412 
      iprot.readFieldEnd()
21413 
    iprot.readStructEnd()
21414 
 
21415 
  def write(self, oprot):
21416 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21417 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21418 
      return
21419 
    oprot.writeStructBegin('getVatAmountForItem_result')
21420 
    if self.success is not None:
21421 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
21422 
      oprot.writeDouble(self.success)
21423 
      oprot.writeFieldEnd()
21424 
    oprot.writeFieldStop()
21425 
    oprot.writeStructEnd()
21426 
 
21427 
  def validate(self):
21428 
    return
21429 
 
21430 
 
21431 
  def __repr__(self):
21432 
    L = ['%s=%r' % (key, value)
21433 
      for key, value in self.__dict__.iteritems()]
21434 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21435 
 
21436 
  def __eq__(self, other):
21437 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21438 
 
21439 
  def __ne__(self, other):
21440 
    return not (self == other)
6531 vikram.rag 21441 
 
21442 
class getAllIgnoredInventoryUpdateItemsList_args:
21443 
  """
21444 
  Attributes:
21445 
   - offset
21446 
   - limit
21447 
  """
21448 
 
21449 
  thrift_spec = (
21450 
    None, # 0
21451 
    (1, TType.I32, 'offset', None, None, ), # 1
21452 
    (2, TType.I32, 'limit', None, None, ), # 2
21453 
  )
21454 
 
21455 
  def __init__(self, offset=None, limit=None,):
21456 
    self.offset = offset
21457 
    self.limit = limit
21458 
 
21459 
  def read(self, iprot):
21460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21462 
      return
21463 
    iprot.readStructBegin()
21464 
    while True:
21465 
      (fname, ftype, fid) = iprot.readFieldBegin()
21466 
      if ftype == TType.STOP:
21467 
        break
21468 
      if fid == 1:
21469 
        if ftype == TType.I32:
21470 
          self.offset = iprot.readI32();
21471 
        else:
21472 
          iprot.skip(ftype)
21473 
      elif fid == 2:
21474 
        if ftype == TType.I32:
21475 
          self.limit = iprot.readI32();
21476 
        else:
21477 
          iprot.skip(ftype)
21478 
      else:
21479 
        iprot.skip(ftype)
21480 
      iprot.readFieldEnd()
21481 
    iprot.readStructEnd()
21482 
 
21483 
  def write(self, oprot):
21484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21486 
      return
21487 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_args')
21488 
    if self.offset is not None:
21489 
      oprot.writeFieldBegin('offset', TType.I32, 1)
21490 
      oprot.writeI32(self.offset)
21491 
      oprot.writeFieldEnd()
21492 
    if self.limit is not None:
21493 
      oprot.writeFieldBegin('limit', TType.I32, 2)
21494 
      oprot.writeI32(self.limit)
21495 
      oprot.writeFieldEnd()
21496 
    oprot.writeFieldStop()
21497 
    oprot.writeStructEnd()
21498 
 
21499 
  def validate(self):
21500 
    return
21501 
 
21502 
 
21503 
  def __repr__(self):
21504 
    L = ['%s=%r' % (key, value)
21505 
      for key, value in self.__dict__.iteritems()]
21506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21507 
 
21508 
  def __eq__(self, other):
21509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21510 
 
21511 
  def __ne__(self, other):
21512 
    return not (self == other)
21513 
 
21514 
class getAllIgnoredInventoryUpdateItemsList_result:
21515 
  """
21516 
  Attributes:
21517 
   - success
21518 
  """
21519 
 
21520 
  thrift_spec = (
21521 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
21522 
  )
21523 
 
21524 
  def __init__(self, success=None,):
21525 
    self.success = success
21526 
 
21527 
  def read(self, iprot):
21528 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21529 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21530 
      return
21531 
    iprot.readStructBegin()
21532 
    while True:
21533 
      (fname, ftype, fid) = iprot.readFieldBegin()
21534 
      if ftype == TType.STOP:
21535 
        break
21536 
      if fid == 0:
21537 
        if ftype == TType.LIST:
21538 
          self.success = []
13493 amit.gupta 21539 
          (_etype395, _size392) = iprot.readListBegin()
21540 
          for _i396 in xrange(_size392):
21541 
            _elem397 = Item()
21542 
            _elem397.read(iprot)
21543 
            self.success.append(_elem397)
6531 vikram.rag 21544 
          iprot.readListEnd()
21545 
        else:
21546 
          iprot.skip(ftype)
21547 
      else:
21548 
        iprot.skip(ftype)
21549 
      iprot.readFieldEnd()
21550 
    iprot.readStructEnd()
21551 
 
21552 
  def write(self, oprot):
21553 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21554 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21555 
      return
21556 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_result')
21557 
    if self.success is not None:
21558 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21559 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 21560 
      for iter398 in self.success:
21561 
        iter398.write(oprot)
6531 vikram.rag 21562 
      oprot.writeListEnd()
21563 
      oprot.writeFieldEnd()
21564 
    oprot.writeFieldStop()
21565 
    oprot.writeStructEnd()
21566 
 
21567 
  def validate(self):
21568 
    return
21569 
 
21570 
 
21571 
  def __repr__(self):
21572 
    L = ['%s=%r' % (key, value)
21573 
      for key, value in self.__dict__.iteritems()]
21574 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21575 
 
21576 
  def __eq__(self, other):
21577 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21578 
 
21579 
  def __ne__(self, other):
21580 
    return not (self == other)
6805 anupam.sin 21581 
 
6821 amar.kumar 21582 
class getAllAliveItems_args:
21583 
 
21584 
  thrift_spec = (
21585 
  )
21586 
 
21587 
  def read(self, iprot):
21588 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21589 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21590 
      return
21591 
    iprot.readStructBegin()
21592 
    while True:
21593 
      (fname, ftype, fid) = iprot.readFieldBegin()
21594 
      if ftype == TType.STOP:
21595 
        break
21596 
      else:
21597 
        iprot.skip(ftype)
21598 
      iprot.readFieldEnd()
21599 
    iprot.readStructEnd()
21600 
 
21601 
  def write(self, oprot):
21602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21604 
      return
21605 
    oprot.writeStructBegin('getAllAliveItems_args')
21606 
    oprot.writeFieldStop()
21607 
    oprot.writeStructEnd()
21608 
 
21609 
  def validate(self):
21610 
    return
21611 
 
21612 
 
21613 
  def __repr__(self):
21614 
    L = ['%s=%r' % (key, value)
21615 
      for key, value in self.__dict__.iteritems()]
21616 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21617 
 
21618 
  def __eq__(self, other):
21619 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21620 
 
21621 
  def __ne__(self, other):
21622 
    return not (self == other)
21623 
 
21624 
class getAllAliveItems_result:
21625 
  """
21626 
  Attributes:
21627 
   - success
21628 
  """
21629 
 
21630 
  thrift_spec = (
21631 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
21632 
  )
21633 
 
21634 
  def __init__(self, success=None,):
21635 
    self.success = success
21636 
 
21637 
  def read(self, iprot):
21638 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21639 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21640 
      return
21641 
    iprot.readStructBegin()
21642 
    while True:
21643 
      (fname, ftype, fid) = iprot.readFieldBegin()
21644 
      if ftype == TType.STOP:
21645 
        break
21646 
      if fid == 0:
21647 
        if ftype == TType.LIST:
21648 
          self.success = []
13493 amit.gupta 21649 
          (_etype402, _size399) = iprot.readListBegin()
21650 
          for _i403 in xrange(_size399):
21651 
            _elem404 = Item()
21652 
            _elem404.read(iprot)
21653 
            self.success.append(_elem404)
6821 amar.kumar 21654 
          iprot.readListEnd()
21655 
        else:
21656 
          iprot.skip(ftype)
21657 
      else:
21658 
        iprot.skip(ftype)
21659 
      iprot.readFieldEnd()
21660 
    iprot.readStructEnd()
21661 
 
21662 
  def write(self, oprot):
21663 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21664 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21665 
      return
21666 
    oprot.writeStructBegin('getAllAliveItems_result')
21667 
    if self.success is not None:
21668 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21669 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 21670 
      for iter405 in self.success:
21671 
        iter405.write(oprot)
6821 amar.kumar 21672 
      oprot.writeListEnd()
21673 
      oprot.writeFieldEnd()
21674 
    oprot.writeFieldStop()
21675 
    oprot.writeStructEnd()
21676 
 
21677 
  def validate(self):
21678 
    return
21679 
 
21680 
 
21681 
  def __repr__(self):
21682 
    L = ['%s=%r' % (key, value)
21683 
      for key, value in self.__dict__.iteritems()]
21684 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21685 
 
21686 
  def __eq__(self, other):
21687 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21688 
 
21689 
  def __ne__(self, other):
21690 
    return not (self == other)
21691 
 
6805 anupam.sin 21692 
class getInsuranceAmount_args:
21693 
  """
21694 
  Attributes:
21695 
   - itemId
6921 anupam.sin 21696 
   - price
6805 anupam.sin 21697 
   - insurerId
21698 
   - quantity
21699 
  """
21700 
 
21701 
  thrift_spec = (
21702 
    None, # 0
21703 
    (1, TType.I64, 'itemId', None, None, ), # 1
6921 anupam.sin 21704 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
21705 
    (3, TType.I64, 'insurerId', None, None, ), # 3
21706 
    (4, TType.I64, 'quantity', None, None, ), # 4
6805 anupam.sin 21707 
  )
21708 
 
6921 anupam.sin 21709 
  def __init__(self, itemId=None, price=None, insurerId=None, quantity=None,):
6805 anupam.sin 21710 
    self.itemId = itemId
6921 anupam.sin 21711 
    self.price = price
6805 anupam.sin 21712 
    self.insurerId = insurerId
21713 
    self.quantity = quantity
21714 
 
21715 
  def read(self, iprot):
21716 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21717 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21718 
      return
21719 
    iprot.readStructBegin()
21720 
    while True:
21721 
      (fname, ftype, fid) = iprot.readFieldBegin()
21722 
      if ftype == TType.STOP:
21723 
        break
21724 
      if fid == 1:
21725 
        if ftype == TType.I64:
21726 
          self.itemId = iprot.readI64();
21727 
        else:
21728 
          iprot.skip(ftype)
21729 
      elif fid == 2:
6921 anupam.sin 21730 
        if ftype == TType.DOUBLE:
21731 
          self.price = iprot.readDouble();
21732 
        else:
21733 
          iprot.skip(ftype)
21734 
      elif fid == 3:
6805 anupam.sin 21735 
        if ftype == TType.I64:
21736 
          self.insurerId = iprot.readI64();
21737 
        else:
21738 
          iprot.skip(ftype)
6921 anupam.sin 21739 
      elif fid == 4:
6805 anupam.sin 21740 
        if ftype == TType.I64:
21741 
          self.quantity = iprot.readI64();
21742 
        else:
21743 
          iprot.skip(ftype)
21744 
      else:
21745 
        iprot.skip(ftype)
21746 
      iprot.readFieldEnd()
21747 
    iprot.readStructEnd()
21748 
 
21749 
  def write(self, oprot):
21750 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21751 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21752 
      return
21753 
    oprot.writeStructBegin('getInsuranceAmount_args')
21754 
    if self.itemId is not None:
21755 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
21756 
      oprot.writeI64(self.itemId)
21757 
      oprot.writeFieldEnd()
6921 anupam.sin 21758 
    if self.price is not None:
21759 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
21760 
      oprot.writeDouble(self.price)
21761 
      oprot.writeFieldEnd()
6805 anupam.sin 21762 
    if self.insurerId is not None:
6921 anupam.sin 21763 
      oprot.writeFieldBegin('insurerId', TType.I64, 3)
6805 anupam.sin 21764 
      oprot.writeI64(self.insurerId)
21765 
      oprot.writeFieldEnd()
21766 
    if self.quantity is not None:
6921 anupam.sin 21767 
      oprot.writeFieldBegin('quantity', TType.I64, 4)
6805 anupam.sin 21768 
      oprot.writeI64(self.quantity)
21769 
      oprot.writeFieldEnd()
21770 
    oprot.writeFieldStop()
21771 
    oprot.writeStructEnd()
21772 
 
21773 
  def validate(self):
21774 
    return
21775 
 
21776 
 
21777 
  def __repr__(self):
21778 
    L = ['%s=%r' % (key, value)
21779 
      for key, value in self.__dict__.iteritems()]
21780 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21781 
 
21782 
  def __eq__(self, other):
21783 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21784 
 
21785 
  def __ne__(self, other):
21786 
    return not (self == other)
21787 
 
21788 
class getInsuranceAmount_result:
21789 
  """
21790 
  Attributes:
21791 
   - success
21792 
  """
21793 
 
21794 
  thrift_spec = (
21795 
    (0, TType.I64, 'success', None, None, ), # 0
21796 
  )
21797 
 
21798 
  def __init__(self, success=None,):
21799 
    self.success = success
21800 
 
21801 
  def read(self, iprot):
21802 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21803 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21804 
      return
21805 
    iprot.readStructBegin()
21806 
    while True:
21807 
      (fname, ftype, fid) = iprot.readFieldBegin()
21808 
      if ftype == TType.STOP:
21809 
        break
21810 
      if fid == 0:
21811 
        if ftype == TType.I64:
21812 
          self.success = iprot.readI64();
21813 
        else:
21814 
          iprot.skip(ftype)
21815 
      else:
21816 
        iprot.skip(ftype)
21817 
      iprot.readFieldEnd()
21818 
    iprot.readStructEnd()
21819 
 
21820 
  def write(self, oprot):
21821 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21822 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21823 
      return
21824 
    oprot.writeStructBegin('getInsuranceAmount_result')
21825 
    if self.success is not None:
21826 
      oprot.writeFieldBegin('success', TType.I64, 0)
21827 
      oprot.writeI64(self.success)
21828 
      oprot.writeFieldEnd()
21829 
    oprot.writeFieldStop()
21830 
    oprot.writeStructEnd()
21831 
 
21832 
  def validate(self):
21833 
    return
21834 
 
21835 
 
21836 
  def __repr__(self):
21837 
    L = ['%s=%r' % (key, value)
21838 
      for key, value in self.__dict__.iteritems()]
21839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21840 
 
21841 
  def __eq__(self, other):
21842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21843 
 
21844 
  def __ne__(self, other):
21845 
    return not (self == other)
21846 
 
21847 
class getInsurer_args:
21848 
  """
21849 
  Attributes:
21850 
   - insurerId
21851 
  """
21852 
 
21853 
  thrift_spec = (
21854 
    None, # 0
21855 
    (1, TType.I64, 'insurerId', None, None, ), # 1
21856 
  )
21857 
 
21858 
  def __init__(self, insurerId=None,):
21859 
    self.insurerId = insurerId
21860 
 
21861 
  def read(self, iprot):
21862 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21863 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21864 
      return
21865 
    iprot.readStructBegin()
21866 
    while True:
21867 
      (fname, ftype, fid) = iprot.readFieldBegin()
21868 
      if ftype == TType.STOP:
21869 
        break
21870 
      if fid == 1:
21871 
        if ftype == TType.I64:
21872 
          self.insurerId = iprot.readI64();
21873 
        else:
21874 
          iprot.skip(ftype)
21875 
      else:
21876 
        iprot.skip(ftype)
21877 
      iprot.readFieldEnd()
21878 
    iprot.readStructEnd()
21879 
 
21880 
  def write(self, oprot):
21881 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21882 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21883 
      return
21884 
    oprot.writeStructBegin('getInsurer_args')
21885 
    if self.insurerId is not None:
21886 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
21887 
      oprot.writeI64(self.insurerId)
21888 
      oprot.writeFieldEnd()
21889 
    oprot.writeFieldStop()
21890 
    oprot.writeStructEnd()
21891 
 
21892 
  def validate(self):
21893 
    return
21894 
 
21895 
 
21896 
  def __repr__(self):
21897 
    L = ['%s=%r' % (key, value)
21898 
      for key, value in self.__dict__.iteritems()]
21899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21900 
 
21901 
  def __eq__(self, other):
21902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21903 
 
21904 
  def __ne__(self, other):
21905 
    return not (self == other)
21906 
 
21907 
class getInsurer_result:
21908 
  """
21909 
  Attributes:
21910 
   - success
21911 
  """
21912 
 
21913 
  thrift_spec = (
21914 
    (0, TType.STRUCT, 'success', (Insurer, Insurer.thrift_spec), None, ), # 0
21915 
  )
21916 
 
21917 
  def __init__(self, success=None,):
21918 
    self.success = success
21919 
 
21920 
  def read(self, iprot):
21921 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21922 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21923 
      return
21924 
    iprot.readStructBegin()
21925 
    while True:
21926 
      (fname, ftype, fid) = iprot.readFieldBegin()
21927 
      if ftype == TType.STOP:
21928 
        break
21929 
      if fid == 0:
21930 
        if ftype == TType.STRUCT:
21931 
          self.success = Insurer()
21932 
          self.success.read(iprot)
21933 
        else:
21934 
          iprot.skip(ftype)
21935 
      else:
21936 
        iprot.skip(ftype)
21937 
      iprot.readFieldEnd()
21938 
    iprot.readStructEnd()
21939 
 
21940 
  def write(self, oprot):
21941 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21942 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21943 
      return
21944 
    oprot.writeStructBegin('getInsurer_result')
21945 
    if self.success is not None:
21946 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21947 
      self.success.write(oprot)
21948 
      oprot.writeFieldEnd()
21949 
    oprot.writeFieldStop()
21950 
    oprot.writeStructEnd()
21951 
 
21952 
  def validate(self):
21953 
    return
21954 
 
21955 
 
21956 
  def __repr__(self):
21957 
    L = ['%s=%r' % (key, value)
21958 
      for key, value in self.__dict__.iteritems()]
21959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21960 
 
21961 
  def __eq__(self, other):
21962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21963 
 
21964 
  def __ne__(self, other):
21965 
    return not (self == other)
6838 vikram.rag 21966 
 
21967 
class getAllInsurers_args:
21968 
 
21969 
  thrift_spec = (
21970 
  )
21971 
 
21972 
  def read(self, iprot):
21973 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21974 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21975 
      return
21976 
    iprot.readStructBegin()
21977 
    while True:
21978 
      (fname, ftype, fid) = iprot.readFieldBegin()
21979 
      if ftype == TType.STOP:
21980 
        break
21981 
      else:
21982 
        iprot.skip(ftype)
21983 
      iprot.readFieldEnd()
21984 
    iprot.readStructEnd()
21985 
 
21986 
  def write(self, oprot):
21987 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21988 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21989 
      return
21990 
    oprot.writeStructBegin('getAllInsurers_args')
21991 
    oprot.writeFieldStop()
21992 
    oprot.writeStructEnd()
21993 
 
21994 
  def validate(self):
21995 
    return
21996 
 
21997 
 
21998 
  def __repr__(self):
21999 
    L = ['%s=%r' % (key, value)
22000 
      for key, value in self.__dict__.iteritems()]
22001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22002 
 
22003 
  def __eq__(self, other):
22004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22005 
 
22006 
  def __ne__(self, other):
22007 
    return not (self == other)
22008 
 
22009 
class getAllInsurers_result:
22010 
  """
22011 
  Attributes:
22012 
   - success
22013 
  """
22014 
 
22015 
  thrift_spec = (
22016 
    (0, TType.LIST, 'success', (TType.STRUCT,(Insurer, Insurer.thrift_spec)), None, ), # 0
22017 
  )
22018 
 
22019 
  def __init__(self, success=None,):
22020 
    self.success = success
22021 
 
22022 
  def read(self, iprot):
22023 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22024 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22025 
      return
22026 
    iprot.readStructBegin()
22027 
    while True:
22028 
      (fname, ftype, fid) = iprot.readFieldBegin()
22029 
      if ftype == TType.STOP:
22030 
        break
22031 
      if fid == 0:
22032 
        if ftype == TType.LIST:
22033 
          self.success = []
13493 amit.gupta 22034 
          (_etype409, _size406) = iprot.readListBegin()
22035 
          for _i410 in xrange(_size406):
22036 
            _elem411 = Insurer()
22037 
            _elem411.read(iprot)
22038 
            self.success.append(_elem411)
6838 vikram.rag 22039 
          iprot.readListEnd()
22040 
        else:
22041 
          iprot.skip(ftype)
22042 
      else:
22043 
        iprot.skip(ftype)
22044 
      iprot.readFieldEnd()
22045 
    iprot.readStructEnd()
22046 
 
22047 
  def write(self, oprot):
22048 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22049 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22050 
      return
22051 
    oprot.writeStructBegin('getAllInsurers_result')
22052 
    if self.success is not None:
22053 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22054 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 22055 
      for iter412 in self.success:
22056 
        iter412.write(oprot)
6838 vikram.rag 22057 
      oprot.writeListEnd()
22058 
      oprot.writeFieldEnd()
22059 
    oprot.writeFieldStop()
22060 
    oprot.writeStructEnd()
22061 
 
22062 
  def validate(self):
22063 
    return
22064 
 
22065 
 
22066 
  def __repr__(self):
22067 
    L = ['%s=%r' % (key, value)
22068 
      for key, value in self.__dict__.iteritems()]
22069 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22070 
 
22071 
  def __eq__(self, other):
22072 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22073 
 
22074 
  def __ne__(self, other):
22075 
    return not (self == other)
6962 rajveer 22076 
 
22077 
class updateInsuranceDeclaredAmount_args:
22078 
  """
22079 
  Attributes:
22080 
   - insurerId
22081 
   - amount
22082 
  """
22083 
 
22084 
  thrift_spec = (
22085 
    None, # 0
22086 
    (1, TType.I64, 'insurerId', None, None, ), # 1
22087 
    (2, TType.DOUBLE, 'amount', None, None, ), # 2
22088 
  )
22089 
 
22090 
  def __init__(self, insurerId=None, amount=None,):
22091 
    self.insurerId = insurerId
22092 
    self.amount = amount
22093 
 
22094 
  def read(self, iprot):
22095 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22096 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22097 
      return
22098 
    iprot.readStructBegin()
22099 
    while True:
22100 
      (fname, ftype, fid) = iprot.readFieldBegin()
22101 
      if ftype == TType.STOP:
22102 
        break
22103 
      if fid == 1:
22104 
        if ftype == TType.I64:
22105 
          self.insurerId = iprot.readI64();
22106 
        else:
22107 
          iprot.skip(ftype)
22108 
      elif fid == 2:
22109 
        if ftype == TType.DOUBLE:
22110 
          self.amount = iprot.readDouble();
22111 
        else:
22112 
          iprot.skip(ftype)
22113 
      else:
22114 
        iprot.skip(ftype)
22115 
      iprot.readFieldEnd()
22116 
    iprot.readStructEnd()
22117 
 
22118 
  def write(self, oprot):
22119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22121 
      return
22122 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_args')
22123 
    if self.insurerId is not None:
22124 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
22125 
      oprot.writeI64(self.insurerId)
22126 
      oprot.writeFieldEnd()
22127 
    if self.amount is not None:
22128 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 2)
22129 
      oprot.writeDouble(self.amount)
22130 
      oprot.writeFieldEnd()
22131 
    oprot.writeFieldStop()
22132 
    oprot.writeStructEnd()
22133 
 
22134 
  def validate(self):
22135 
    return
22136 
 
22137 
 
22138 
  def __repr__(self):
22139 
    L = ['%s=%r' % (key, value)
22140 
      for key, value in self.__dict__.iteritems()]
22141 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22142 
 
22143 
  def __eq__(self, other):
22144 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22145 
 
22146 
  def __ne__(self, other):
22147 
    return not (self == other)
22148 
 
22149 
class updateInsuranceDeclaredAmount_result:
22150 
 
22151 
  thrift_spec = (
22152 
  )
22153 
 
22154 
  def read(self, iprot):
22155 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22156 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22157 
      return
22158 
    iprot.readStructBegin()
22159 
    while True:
22160 
      (fname, ftype, fid) = iprot.readFieldBegin()
22161 
      if ftype == TType.STOP:
22162 
        break
22163 
      else:
22164 
        iprot.skip(ftype)
22165 
      iprot.readFieldEnd()
22166 
    iprot.readStructEnd()
22167 
 
22168 
  def write(self, oprot):
22169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22171 
      return
22172 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_result')
22173 
    oprot.writeFieldStop()
22174 
    oprot.writeStructEnd()
22175 
 
22176 
  def validate(self):
22177 
    return
22178 
 
22179 
 
22180 
  def __repr__(self):
22181 
    L = ['%s=%r' % (key, value)
22182 
      for key, value in self.__dict__.iteritems()]
22183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22184 
 
22185 
  def __eq__(self, other):
22186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22187 
 
22188 
  def __ne__(self, other):
22189 
    return not (self == other)
7190 amar.kumar 22190 
 
22191 
class getFreebieForItem_args:
22192 
  """
22193 
  Attributes:
22194 
   - itemId
22195 
  """
22196 
 
22197 
  thrift_spec = (
22198 
    None, # 0
22199 
    (1, TType.I64, 'itemId', None, None, ), # 1
22200 
  )
22201 
 
22202 
  def __init__(self, itemId=None,):
22203 
    self.itemId = itemId
22204 
 
22205 
  def read(self, iprot):
22206 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22207 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22208 
      return
22209 
    iprot.readStructBegin()
22210 
    while True:
22211 
      (fname, ftype, fid) = iprot.readFieldBegin()
22212 
      if ftype == TType.STOP:
22213 
        break
22214 
      if fid == 1:
22215 
        if ftype == TType.I64:
22216 
          self.itemId = iprot.readI64();
22217 
        else:
22218 
          iprot.skip(ftype)
22219 
      else:
22220 
        iprot.skip(ftype)
22221 
      iprot.readFieldEnd()
22222 
    iprot.readStructEnd()
22223 
 
22224 
  def write(self, oprot):
22225 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22226 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22227 
      return
22228 
    oprot.writeStructBegin('getFreebieForItem_args')
22229 
    if self.itemId is not None:
22230 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
22231 
      oprot.writeI64(self.itemId)
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 
 
22251 
class getFreebieForItem_result:
22252 
  """
22253 
  Attributes:
22254 
   - success
22255 
  """
22256 
 
22257 
  thrift_spec = (
22258 
    (0, TType.I64, 'success', None, None, ), # 0
22259 
  )
22260 
 
22261 
  def __init__(self, success=None,):
22262 
    self.success = success
22263 
 
22264 
  def read(self, iprot):
22265 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22266 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22267 
      return
22268 
    iprot.readStructBegin()
22269 
    while True:
22270 
      (fname, ftype, fid) = iprot.readFieldBegin()
22271 
      if ftype == TType.STOP:
22272 
        break
22273 
      if fid == 0:
22274 
        if ftype == TType.I64:
22275 
          self.success = iprot.readI64();
22276 
        else:
22277 
          iprot.skip(ftype)
22278 
      else:
22279 
        iprot.skip(ftype)
22280 
      iprot.readFieldEnd()
22281 
    iprot.readStructEnd()
22282 
 
22283 
  def write(self, oprot):
22284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22286 
      return
22287 
    oprot.writeStructBegin('getFreebieForItem_result')
22288 
    if self.success is not None:
22289 
      oprot.writeFieldBegin('success', TType.I64, 0)
22290 
      oprot.writeI64(self.success)
22291 
      oprot.writeFieldEnd()
22292 
    oprot.writeFieldStop()
22293 
    oprot.writeStructEnd()
22294 
 
22295 
  def validate(self):
22296 
    return
22297 
 
22298 
 
22299 
  def __repr__(self):
22300 
    L = ['%s=%r' % (key, value)
22301 
      for key, value in self.__dict__.iteritems()]
22302 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22303 
 
22304 
  def __eq__(self, other):
22305 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22306 
 
22307 
  def __ne__(self, other):
22308 
    return not (self == other)
22309 
 
22310 
class addOrUpdateFreebieForItem_args:
22311 
  """
22312 
  Attributes:
22313 
   - freebieItem
22314 
  """
22315 
 
22316 
  thrift_spec = (
22317 
    None, # 0
22318 
    (1, TType.STRUCT, 'freebieItem', (FreebieItem, FreebieItem.thrift_spec), None, ), # 1
22319 
  )
22320 
 
22321 
  def __init__(self, freebieItem=None,):
22322 
    self.freebieItem = freebieItem
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 == 1:
22334 
        if ftype == TType.STRUCT:
22335 
          self.freebieItem = FreebieItem()
22336 
          self.freebieItem.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('addOrUpdateFreebieForItem_args')
22349 
    if self.freebieItem is not None:
22350 
      oprot.writeFieldBegin('freebieItem', TType.STRUCT, 1)
22351 
      self.freebieItem.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)
22370 
 
22371 
class addOrUpdateFreebieForItem_result:
22372 
 
22373 
  thrift_spec = (
22374 
  )
22375 
 
22376 
  def read(self, iprot):
22377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22379 
      return
22380 
    iprot.readStructBegin()
22381 
    while True:
22382 
      (fname, ftype, fid) = iprot.readFieldBegin()
22383 
      if ftype == TType.STOP:
22384 
        break
22385 
      else:
22386 
        iprot.skip(ftype)
22387 
      iprot.readFieldEnd()
22388 
    iprot.readStructEnd()
22389 
 
22390 
  def write(self, oprot):
22391 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22392 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22393 
      return
22394 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_result')
22395 
    oprot.writeFieldStop()
22396 
    oprot.writeStructEnd()
22397 
 
22398 
  def validate(self):
22399 
    return
22400 
 
22401 
 
22402 
  def __repr__(self):
22403 
    L = ['%s=%r' % (key, value)
22404 
      for key, value in self.__dict__.iteritems()]
22405 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22406 
 
22407 
  def __eq__(self, other):
22408 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22409 
 
22410 
  def __ne__(self, other):
22411 
    return not (self == other)
7256 rajveer 22412 
 
7272 amit.gupta 22413 
class addOrUpdateBrandInfo_args:
22414 
  """
22415 
  Attributes:
22416 
   - brandInfo
22417 
  """
22418 
 
22419 
  thrift_spec = (
22420 
    None, # 0
22421 
    (1, TType.STRUCT, 'brandInfo', (BrandInfo, BrandInfo.thrift_spec), None, ), # 1
22422 
  )
22423 
 
22424 
  def __init__(self, brandInfo=None,):
22425 
    self.brandInfo = brandInfo
22426 
 
22427 
  def read(self, iprot):
22428 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22429 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22430 
      return
22431 
    iprot.readStructBegin()
22432 
    while True:
22433 
      (fname, ftype, fid) = iprot.readFieldBegin()
22434 
      if ftype == TType.STOP:
22435 
        break
22436 
      if fid == 1:
22437 
        if ftype == TType.STRUCT:
22438 
          self.brandInfo = BrandInfo()
22439 
          self.brandInfo.read(iprot)
22440 
        else:
22441 
          iprot.skip(ftype)
22442 
      else:
22443 
        iprot.skip(ftype)
22444 
      iprot.readFieldEnd()
22445 
    iprot.readStructEnd()
22446 
 
22447 
  def write(self, oprot):
22448 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22449 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22450 
      return
22451 
    oprot.writeStructBegin('addOrUpdateBrandInfo_args')
22452 
    if self.brandInfo is not None:
22453 
      oprot.writeFieldBegin('brandInfo', TType.STRUCT, 1)
22454 
      self.brandInfo.write(oprot)
22455 
      oprot.writeFieldEnd()
22456 
    oprot.writeFieldStop()
22457 
    oprot.writeStructEnd()
22458 
 
22459 
  def validate(self):
22460 
    return
22461 
 
22462 
 
22463 
  def __repr__(self):
22464 
    L = ['%s=%r' % (key, value)
22465 
      for key, value in self.__dict__.iteritems()]
22466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22467 
 
22468 
  def __eq__(self, other):
22469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22470 
 
22471 
  def __ne__(self, other):
22472 
    return not (self == other)
22473 
 
22474 
class addOrUpdateBrandInfo_result:
22475 
 
22476 
  thrift_spec = (
22477 
  )
22478 
 
22479 
  def read(self, iprot):
22480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22482 
      return
22483 
    iprot.readStructBegin()
22484 
    while True:
22485 
      (fname, ftype, fid) = iprot.readFieldBegin()
22486 
      if ftype == TType.STOP:
22487 
        break
22488 
      else:
22489 
        iprot.skip(ftype)
22490 
      iprot.readFieldEnd()
22491 
    iprot.readStructEnd()
22492 
 
22493 
  def write(self, oprot):
22494 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22495 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22496 
      return
22497 
    oprot.writeStructBegin('addOrUpdateBrandInfo_result')
22498 
    oprot.writeFieldStop()
22499 
    oprot.writeStructEnd()
22500 
 
22501 
  def validate(self):
22502 
    return
22503 
 
22504 
 
22505 
  def __repr__(self):
22506 
    L = ['%s=%r' % (key, value)
22507 
      for key, value in self.__dict__.iteritems()]
22508 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22509 
 
22510 
  def __eq__(self, other):
22511 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22512 
 
22513 
  def __ne__(self, other):
22514 
    return not (self == other)
22515 
 
22516 
class getBrandInfo_args:
22517 
 
22518 
  thrift_spec = (
22519 
  )
22520 
 
22521 
  def read(self, iprot):
22522 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22523 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22524 
      return
22525 
    iprot.readStructBegin()
22526 
    while True:
22527 
      (fname, ftype, fid) = iprot.readFieldBegin()
22528 
      if ftype == TType.STOP:
22529 
        break
22530 
      else:
22531 
        iprot.skip(ftype)
22532 
      iprot.readFieldEnd()
22533 
    iprot.readStructEnd()
22534 
 
22535 
  def write(self, oprot):
22536 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22537 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22538 
      return
22539 
    oprot.writeStructBegin('getBrandInfo_args')
22540 
    oprot.writeFieldStop()
22541 
    oprot.writeStructEnd()
22542 
 
22543 
  def validate(self):
22544 
    return
22545 
 
22546 
 
22547 
  def __repr__(self):
22548 
    L = ['%s=%r' % (key, value)
22549 
      for key, value in self.__dict__.iteritems()]
22550 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22551 
 
22552 
  def __eq__(self, other):
22553 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22554 
 
22555 
  def __ne__(self, other):
22556 
    return not (self == other)
22557 
 
22558 
class getBrandInfo_result:
22559 
  """
22560 
  Attributes:
22561 
   - success
22562 
  """
22563 
 
22564 
  thrift_spec = (
22565 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(BrandInfo, BrandInfo.thrift_spec)), None, ), # 0
22566 
  )
22567 
 
22568 
  def __init__(self, success=None,):
22569 
    self.success = success
22570 
 
22571 
  def read(self, iprot):
22572 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22573 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22574 
      return
22575 
    iprot.readStructBegin()
22576 
    while True:
22577 
      (fname, ftype, fid) = iprot.readFieldBegin()
22578 
      if ftype == TType.STOP:
22579 
        break
22580 
      if fid == 0:
22581 
        if ftype == TType.MAP:
22582 
          self.success = {}
13493 amit.gupta 22583 
          (_ktype414, _vtype415, _size413 ) = iprot.readMapBegin()
22584 
          for _i417 in xrange(_size413):
22585 
            _key418 = iprot.readString();
22586 
            _val419 = BrandInfo()
22587 
            _val419.read(iprot)
22588 
            self.success[_key418] = _val419
7272 amit.gupta 22589 
          iprot.readMapEnd()
22590 
        else:
22591 
          iprot.skip(ftype)
22592 
      else:
22593 
        iprot.skip(ftype)
22594 
      iprot.readFieldEnd()
22595 
    iprot.readStructEnd()
22596 
 
22597 
  def write(self, oprot):
22598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22600 
      return
22601 
    oprot.writeStructBegin('getBrandInfo_result')
22602 
    if self.success is not None:
22603 
      oprot.writeFieldBegin('success', TType.MAP, 0)
22604 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
13493 amit.gupta 22605 
      for kiter420,viter421 in self.success.items():
22606 
        oprot.writeString(kiter420)
22607 
        viter421.write(oprot)
7272 amit.gupta 22608 
      oprot.writeMapEnd()
22609 
      oprot.writeFieldEnd()
22610 
    oprot.writeFieldStop()
22611 
    oprot.writeStructEnd()
22612 
 
22613 
  def validate(self):
22614 
    return
22615 
 
22616 
 
22617 
  def __repr__(self):
22618 
    L = ['%s=%r' % (key, value)
22619 
      for key, value in self.__dict__.iteritems()]
22620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22621 
 
22622 
  def __eq__(self, other):
22623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22624 
 
22625 
  def __ne__(self, other):
22626 
    return not (self == other)
22627 
 
7256 rajveer 22628 
class getStorePricing_args:
22629 
  """
22630 
  Attributes:
22631 
   - itemId
22632 
  """
22633 
 
22634 
  thrift_spec = (
22635 
    None, # 0
22636 
    (1, TType.I64, 'itemId', None, None, ), # 1
22637 
  )
22638 
 
22639 
  def __init__(self, itemId=None,):
22640 
    self.itemId = itemId
22641 
 
22642 
  def read(self, iprot):
22643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22645 
      return
22646 
    iprot.readStructBegin()
22647 
    while True:
22648 
      (fname, ftype, fid) = iprot.readFieldBegin()
22649 
      if ftype == TType.STOP:
22650 
        break
22651 
      if fid == 1:
22652 
        if ftype == TType.I64:
22653 
          self.itemId = iprot.readI64();
22654 
        else:
22655 
          iprot.skip(ftype)
22656 
      else:
22657 
        iprot.skip(ftype)
22658 
      iprot.readFieldEnd()
22659 
    iprot.readStructEnd()
22660 
 
22661 
  def write(self, oprot):
22662 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22663 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22664 
      return
22665 
    oprot.writeStructBegin('getStorePricing_args')
22666 
    if self.itemId is not None:
22667 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
22668 
      oprot.writeI64(self.itemId)
22669 
      oprot.writeFieldEnd()
22670 
    oprot.writeFieldStop()
22671 
    oprot.writeStructEnd()
22672 
 
22673 
  def validate(self):
22674 
    return
22675 
 
22676 
 
22677 
  def __repr__(self):
22678 
    L = ['%s=%r' % (key, value)
22679 
      for key, value in self.__dict__.iteritems()]
22680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22681 
 
22682 
  def __eq__(self, other):
22683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22684 
 
22685 
  def __ne__(self, other):
22686 
    return not (self == other)
22687 
 
22688 
class getStorePricing_result:
22689 
  """
22690 
  Attributes:
22691 
   - success
22692 
  """
22693 
 
22694 
  thrift_spec = (
22695 
    (0, TType.STRUCT, 'success', (StorePricing, StorePricing.thrift_spec), None, ), # 0
22696 
  )
22697 
 
22698 
  def __init__(self, success=None,):
22699 
    self.success = success
22700 
 
22701 
  def read(self, iprot):
22702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22704 
      return
22705 
    iprot.readStructBegin()
22706 
    while True:
22707 
      (fname, ftype, fid) = iprot.readFieldBegin()
22708 
      if ftype == TType.STOP:
22709 
        break
22710 
      if fid == 0:
22711 
        if ftype == TType.STRUCT:
22712 
          self.success = StorePricing()
22713 
          self.success.read(iprot)
22714 
        else:
22715 
          iprot.skip(ftype)
22716 
      else:
22717 
        iprot.skip(ftype)
22718 
      iprot.readFieldEnd()
22719 
    iprot.readStructEnd()
22720 
 
22721 
  def write(self, oprot):
22722 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22723 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22724 
      return
22725 
    oprot.writeStructBegin('getStorePricing_result')
22726 
    if self.success is not None:
22727 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22728 
      self.success.write(oprot)
22729 
      oprot.writeFieldEnd()
22730 
    oprot.writeFieldStop()
22731 
    oprot.writeStructEnd()
22732 
 
22733 
  def validate(self):
22734 
    return
22735 
 
22736 
 
22737 
  def __repr__(self):
22738 
    L = ['%s=%r' % (key, value)
22739 
      for key, value in self.__dict__.iteritems()]
22740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22741 
 
22742 
  def __eq__(self, other):
22743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22744 
 
22745 
  def __ne__(self, other):
22746 
    return not (self == other)
7265 rajveer 22747 
 
7306 rajveer 22748 
class getStorePricings_args:
22749 
  """
22750 
  Attributes:
22751 
   - itemIds
22752 
  """
22753 
 
22754 
  thrift_spec = (
22755 
    None, # 0
22756 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
22757 
  )
22758 
 
22759 
  def __init__(self, itemIds=None,):
22760 
    self.itemIds = itemIds
22761 
 
22762 
  def read(self, iprot):
22763 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22764 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22765 
      return
22766 
    iprot.readStructBegin()
22767 
    while True:
22768 
      (fname, ftype, fid) = iprot.readFieldBegin()
22769 
      if ftype == TType.STOP:
22770 
        break
22771 
      if fid == 1:
22772 
        if ftype == TType.LIST:
22773 
          self.itemIds = []
13493 amit.gupta 22774 
          (_etype425, _size422) = iprot.readListBegin()
22775 
          for _i426 in xrange(_size422):
22776 
            _elem427 = iprot.readI64();
22777 
            self.itemIds.append(_elem427)
7306 rajveer 22778 
          iprot.readListEnd()
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('getStorePricings_args')
22791 
    if self.itemIds is not None:
22792 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
22793 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
13493 amit.gupta 22794 
      for iter428 in self.itemIds:
22795 
        oprot.writeI64(iter428)
7306 rajveer 22796 
      oprot.writeListEnd()
22797 
      oprot.writeFieldEnd()
22798 
    oprot.writeFieldStop()
22799 
    oprot.writeStructEnd()
22800 
 
22801 
  def validate(self):
22802 
    return
22803 
 
22804 
 
22805 
  def __repr__(self):
22806 
    L = ['%s=%r' % (key, value)
22807 
      for key, value in self.__dict__.iteritems()]
22808 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22809 
 
22810 
  def __eq__(self, other):
22811 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22812 
 
22813 
  def __ne__(self, other):
22814 
    return not (self == other)
22815 
 
22816 
class getStorePricings_result:
22817 
  """
22818 
  Attributes:
22819 
   - success
22820 
  """
22821 
 
22822 
  thrift_spec = (
22823 
    (0, TType.LIST, 'success', (TType.STRUCT,(StorePricing, StorePricing.thrift_spec)), None, ), # 0
22824 
  )
22825 
 
22826 
  def __init__(self, success=None,):
22827 
    self.success = success
22828 
 
22829 
  def read(self, iprot):
22830 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22831 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22832 
      return
22833 
    iprot.readStructBegin()
22834 
    while True:
22835 
      (fname, ftype, fid) = iprot.readFieldBegin()
22836 
      if ftype == TType.STOP:
22837 
        break
22838 
      if fid == 0:
22839 
        if ftype == TType.LIST:
22840 
          self.success = []
13493 amit.gupta 22841 
          (_etype432, _size429) = iprot.readListBegin()
22842 
          for _i433 in xrange(_size429):
22843 
            _elem434 = StorePricing()
22844 
            _elem434.read(iprot)
22845 
            self.success.append(_elem434)
7306 rajveer 22846 
          iprot.readListEnd()
22847 
        else:
22848 
          iprot.skip(ftype)
22849 
      else:
22850 
        iprot.skip(ftype)
22851 
      iprot.readFieldEnd()
22852 
    iprot.readStructEnd()
22853 
 
22854 
  def write(self, oprot):
22855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22857 
      return
22858 
    oprot.writeStructBegin('getStorePricings_result')
22859 
    if self.success is not None:
22860 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22861 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 22862 
      for iter435 in self.success:
22863 
        iter435.write(oprot)
7306 rajveer 22864 
      oprot.writeListEnd()
22865 
      oprot.writeFieldEnd()
22866 
    oprot.writeFieldStop()
22867 
    oprot.writeStructEnd()
22868 
 
22869 
  def validate(self):
22870 
    return
22871 
 
22872 
 
22873 
  def __repr__(self):
22874 
    L = ['%s=%r' % (key, value)
22875 
      for key, value in self.__dict__.iteritems()]
22876 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22877 
 
22878 
  def __eq__(self, other):
22879 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22880 
 
22881 
  def __ne__(self, other):
22882 
    return not (self == other)
22883 
 
7265 rajveer 22884 
class updateStorePricing_args:
22885 
  """
22886 
  Attributes:
22887 
   - sp
7382 rajveer 22888 
   - allColors
7265 rajveer 22889 
  """
22890 
 
22891 
  thrift_spec = (
22892 
    None, # 0
22893 
    (1, TType.STRUCT, 'sp', (StorePricing, StorePricing.thrift_spec), None, ), # 1
7382 rajveer 22894 
    (2, TType.BOOL, 'allColors', None, None, ), # 2
7265 rajveer 22895 
  )
22896 
 
7382 rajveer 22897 
  def __init__(self, sp=None, allColors=None,):
7265 rajveer 22898 
    self.sp = sp
7382 rajveer 22899 
    self.allColors = allColors
7265 rajveer 22900 
 
22901 
  def read(self, iprot):
22902 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22903 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22904 
      return
22905 
    iprot.readStructBegin()
22906 
    while True:
22907 
      (fname, ftype, fid) = iprot.readFieldBegin()
22908 
      if ftype == TType.STOP:
22909 
        break
22910 
      if fid == 1:
22911 
        if ftype == TType.STRUCT:
22912 
          self.sp = StorePricing()
22913 
          self.sp.read(iprot)
22914 
        else:
22915 
          iprot.skip(ftype)
7382 rajveer 22916 
      elif fid == 2:
22917 
        if ftype == TType.BOOL:
22918 
          self.allColors = iprot.readBool();
22919 
        else:
22920 
          iprot.skip(ftype)
7265 rajveer 22921 
      else:
22922 
        iprot.skip(ftype)
22923 
      iprot.readFieldEnd()
22924 
    iprot.readStructEnd()
22925 
 
22926 
  def write(self, oprot):
22927 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22928 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22929 
      return
22930 
    oprot.writeStructBegin('updateStorePricing_args')
22931 
    if self.sp is not None:
22932 
      oprot.writeFieldBegin('sp', TType.STRUCT, 1)
22933 
      self.sp.write(oprot)
22934 
      oprot.writeFieldEnd()
7382 rajveer 22935 
    if self.allColors is not None:
22936 
      oprot.writeFieldBegin('allColors', TType.BOOL, 2)
22937 
      oprot.writeBool(self.allColors)
22938 
      oprot.writeFieldEnd()
7265 rajveer 22939 
    oprot.writeFieldStop()
22940 
    oprot.writeStructEnd()
22941 
 
22942 
  def validate(self):
22943 
    return
22944 
 
22945 
 
22946 
  def __repr__(self):
22947 
    L = ['%s=%r' % (key, value)
22948 
      for key, value in self.__dict__.iteritems()]
22949 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22950 
 
22951 
  def __eq__(self, other):
22952 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22953 
 
22954 
  def __ne__(self, other):
22955 
    return not (self == other)
22956 
 
22957 
class updateStorePricing_result:
22958 
 
22959 
  thrift_spec = (
22960 
  )
22961 
 
22962 
  def read(self, iprot):
22963 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22964 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22965 
      return
22966 
    iprot.readStructBegin()
22967 
    while True:
22968 
      (fname, ftype, fid) = iprot.readFieldBegin()
22969 
      if ftype == TType.STOP:
22970 
        break
22971 
      else:
22972 
        iprot.skip(ftype)
22973 
      iprot.readFieldEnd()
22974 
    iprot.readStructEnd()
22975 
 
22976 
  def write(self, oprot):
22977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22979 
      return
22980 
    oprot.writeStructBegin('updateStorePricing_result')
22981 
    oprot.writeFieldStop()
22982 
    oprot.writeStructEnd()
22983 
 
22984 
  def validate(self):
22985 
    return
22986 
 
22987 
 
22988 
  def __repr__(self):
22989 
    L = ['%s=%r' % (key, value)
22990 
      for key, value in self.__dict__.iteritems()]
22991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22992 
 
22993 
  def __eq__(self, other):
22994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22995 
 
22996 
  def __ne__(self, other):
22997 
    return not (self == other)
7281 kshitij.so 22998 
 
22999 
class getAllAmazonListedItems_args:
23000 
 
23001 
  thrift_spec = (
23002 
  )
23003 
 
23004 
  def read(self, iprot):
23005 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23006 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23007 
      return
23008 
    iprot.readStructBegin()
23009 
    while True:
23010 
      (fname, ftype, fid) = iprot.readFieldBegin()
23011 
      if ftype == TType.STOP:
23012 
        break
23013 
      else:
23014 
        iprot.skip(ftype)
23015 
      iprot.readFieldEnd()
23016 
    iprot.readStructEnd()
23017 
 
23018 
  def write(self, oprot):
23019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23021 
      return
23022 
    oprot.writeStructBegin('getAllAmazonListedItems_args')
23023 
    oprot.writeFieldStop()
23024 
    oprot.writeStructEnd()
23025 
 
23026 
  def validate(self):
23027 
    return
23028 
 
23029 
 
23030 
  def __repr__(self):
23031 
    L = ['%s=%r' % (key, value)
23032 
      for key, value in self.__dict__.iteritems()]
23033 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23034 
 
23035 
  def __eq__(self, other):
23036 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23037 
 
23038 
  def __ne__(self, other):
23039 
    return not (self == other)
23040 
 
23041 
class getAllAmazonListedItems_result:
23042 
  """
23043 
  Attributes:
23044 
   - success
23045 
  """
23046 
 
23047 
  thrift_spec = (
23048 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
23049 
  )
23050 
 
23051 
  def __init__(self, success=None,):
23052 
    self.success = success
23053 
 
23054 
  def read(self, iprot):
23055 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23056 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23057 
      return
23058 
    iprot.readStructBegin()
23059 
    while True:
23060 
      (fname, ftype, fid) = iprot.readFieldBegin()
23061 
      if ftype == TType.STOP:
23062 
        break
23063 
      if fid == 0:
23064 
        if ftype == TType.LIST:
23065 
          self.success = []
13493 amit.gupta 23066 
          (_etype439, _size436) = iprot.readListBegin()
23067 
          for _i440 in xrange(_size436):
23068 
            _elem441 = Amazonlisted()
23069 
            _elem441.read(iprot)
23070 
            self.success.append(_elem441)
7281 kshitij.so 23071 
          iprot.readListEnd()
23072 
        else:
23073 
          iprot.skip(ftype)
23074 
      else:
23075 
        iprot.skip(ftype)
23076 
      iprot.readFieldEnd()
23077 
    iprot.readStructEnd()
23078 
 
23079 
  def write(self, oprot):
23080 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23081 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23082 
      return
23083 
    oprot.writeStructBegin('getAllAmazonListedItems_result')
23084 
    if self.success is not None:
23085 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23086 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 23087 
      for iter442 in self.success:
23088 
        iter442.write(oprot)
7281 kshitij.so 23089 
      oprot.writeListEnd()
23090 
      oprot.writeFieldEnd()
23091 
    oprot.writeFieldStop()
23092 
    oprot.writeStructEnd()
23093 
 
23094 
  def validate(self):
23095 
    return
23096 
 
23097 
 
23098 
  def __repr__(self):
23099 
    L = ['%s=%r' % (key, value)
23100 
      for key, value in self.__dict__.iteritems()]
23101 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23102 
 
23103 
  def __eq__(self, other):
23104 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23105 
 
23106 
  def __ne__(self, other):
23107 
    return not (self == other)
23108 
 
8619 kshitij.so 23109 
class searchAmazonItems_args:
23110 
  """
23111 
  Attributes:
23112 
   - searchTerm
23113 
   - offset
23114 
   - limit
23115 
  """
23116 
 
23117 
  thrift_spec = (
23118 
    None, # 0
23119 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
23120 
    (2, TType.I64, 'offset', None, None, ), # 2
23121 
    (3, TType.I64, 'limit', None, None, ), # 3
23122 
  )
23123 
 
23124 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
23125 
    self.searchTerm = searchTerm
23126 
    self.offset = offset
23127 
    self.limit = limit
23128 
 
23129 
  def read(self, iprot):
23130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23132 
      return
23133 
    iprot.readStructBegin()
23134 
    while True:
23135 
      (fname, ftype, fid) = iprot.readFieldBegin()
23136 
      if ftype == TType.STOP:
23137 
        break
23138 
      if fid == 1:
23139 
        if ftype == TType.LIST:
23140 
          self.searchTerm = []
13493 amit.gupta 23141 
          (_etype446, _size443) = iprot.readListBegin()
23142 
          for _i447 in xrange(_size443):
23143 
            _elem448 = iprot.readString();
23144 
            self.searchTerm.append(_elem448)
8619 kshitij.so 23145 
          iprot.readListEnd()
23146 
        else:
23147 
          iprot.skip(ftype)
23148 
      elif fid == 2:
23149 
        if ftype == TType.I64:
23150 
          self.offset = iprot.readI64();
23151 
        else:
23152 
          iprot.skip(ftype)
23153 
      elif fid == 3:
23154 
        if ftype == TType.I64:
23155 
          self.limit = iprot.readI64();
23156 
        else:
23157 
          iprot.skip(ftype)
23158 
      else:
23159 
        iprot.skip(ftype)
23160 
      iprot.readFieldEnd()
23161 
    iprot.readStructEnd()
23162 
 
23163 
  def write(self, oprot):
23164 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23165 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23166 
      return
23167 
    oprot.writeStructBegin('searchAmazonItems_args')
23168 
    if self.searchTerm is not None:
23169 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
23170 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
13493 amit.gupta 23171 
      for iter449 in self.searchTerm:
23172 
        oprot.writeString(iter449)
8619 kshitij.so 23173 
      oprot.writeListEnd()
23174 
      oprot.writeFieldEnd()
23175 
    if self.offset is not None:
23176 
      oprot.writeFieldBegin('offset', TType.I64, 2)
23177 
      oprot.writeI64(self.offset)
23178 
      oprot.writeFieldEnd()
23179 
    if self.limit is not None:
23180 
      oprot.writeFieldBegin('limit', TType.I64, 3)
23181 
      oprot.writeI64(self.limit)
23182 
      oprot.writeFieldEnd()
23183 
    oprot.writeFieldStop()
23184 
    oprot.writeStructEnd()
23185 
 
23186 
  def validate(self):
23187 
    return
23188 
 
23189 
 
23190 
  def __repr__(self):
23191 
    L = ['%s=%r' % (key, value)
23192 
      for key, value in self.__dict__.iteritems()]
23193 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23194 
 
23195 
  def __eq__(self, other):
23196 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23197 
 
23198 
  def __ne__(self, other):
23199 
    return not (self == other)
23200 
 
23201 
class searchAmazonItems_result:
23202 
  """
23203 
  Attributes:
23204 
   - success
23205 
  """
23206 
 
23207 
  thrift_spec = (
23208 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
23209 
  )
23210 
 
23211 
  def __init__(self, success=None,):
23212 
    self.success = success
23213 
 
23214 
  def read(self, iprot):
23215 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23216 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23217 
      return
23218 
    iprot.readStructBegin()
23219 
    while True:
23220 
      (fname, ftype, fid) = iprot.readFieldBegin()
23221 
      if ftype == TType.STOP:
23222 
        break
23223 
      if fid == 0:
23224 
        if ftype == TType.LIST:
23225 
          self.success = []
13493 amit.gupta 23226 
          (_etype453, _size450) = iprot.readListBegin()
23227 
          for _i454 in xrange(_size450):
23228 
            _elem455 = Amazonlisted()
23229 
            _elem455.read(iprot)
23230 
            self.success.append(_elem455)
8619 kshitij.so 23231 
          iprot.readListEnd()
23232 
        else:
23233 
          iprot.skip(ftype)
23234 
      else:
23235 
        iprot.skip(ftype)
23236 
      iprot.readFieldEnd()
23237 
    iprot.readStructEnd()
23238 
 
23239 
  def write(self, oprot):
23240 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23241 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23242 
      return
23243 
    oprot.writeStructBegin('searchAmazonItems_result')
23244 
    if self.success is not None:
23245 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23246 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 23247 
      for iter456 in self.success:
23248 
        iter456.write(oprot)
8619 kshitij.so 23249 
      oprot.writeListEnd()
23250 
      oprot.writeFieldEnd()
23251 
    oprot.writeFieldStop()
23252 
    oprot.writeStructEnd()
23253 
 
23254 
  def validate(self):
23255 
    return
23256 
 
23257 
 
23258 
  def __repr__(self):
23259 
    L = ['%s=%r' % (key, value)
23260 
      for key, value in self.__dict__.iteritems()]
23261 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23262 
 
23263 
  def __eq__(self, other):
23264 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23265 
 
23266 
  def __ne__(self, other):
23267 
    return not (self == other)
23268 
 
23269 
class getAmazonSearchResultCount_args:
23270 
  """
23271 
  Attributes:
23272 
   - searchTerm
23273 
  """
23274 
 
23275 
  thrift_spec = (
23276 
    None, # 0
23277 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
23278 
  )
23279 
 
23280 
  def __init__(self, searchTerm=None,):
23281 
    self.searchTerm = searchTerm
23282 
 
23283 
  def read(self, iprot):
23284 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23285 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23286 
      return
23287 
    iprot.readStructBegin()
23288 
    while True:
23289 
      (fname, ftype, fid) = iprot.readFieldBegin()
23290 
      if ftype == TType.STOP:
23291 
        break
23292 
      if fid == 1:
23293 
        if ftype == TType.LIST:
23294 
          self.searchTerm = []
13493 amit.gupta 23295 
          (_etype460, _size457) = iprot.readListBegin()
23296 
          for _i461 in xrange(_size457):
23297 
            _elem462 = iprot.readString();
23298 
            self.searchTerm.append(_elem462)
8619 kshitij.so 23299 
          iprot.readListEnd()
23300 
        else:
23301 
          iprot.skip(ftype)
23302 
      else:
23303 
        iprot.skip(ftype)
23304 
      iprot.readFieldEnd()
23305 
    iprot.readStructEnd()
23306 
 
23307 
  def write(self, oprot):
23308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23310 
      return
23311 
    oprot.writeStructBegin('getAmazonSearchResultCount_args')
23312 
    if self.searchTerm is not None:
23313 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
23314 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
13493 amit.gupta 23315 
      for iter463 in self.searchTerm:
23316 
        oprot.writeString(iter463)
8619 kshitij.so 23317 
      oprot.writeListEnd()
23318 
      oprot.writeFieldEnd()
23319 
    oprot.writeFieldStop()
23320 
    oprot.writeStructEnd()
23321 
 
23322 
  def validate(self):
23323 
    return
23324 
 
23325 
 
23326 
  def __repr__(self):
23327 
    L = ['%s=%r' % (key, value)
23328 
      for key, value in self.__dict__.iteritems()]
23329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23330 
 
23331 
  def __eq__(self, other):
23332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23333 
 
23334 
  def __ne__(self, other):
23335 
    return not (self == other)
23336 
 
23337 
class getAmazonSearchResultCount_result:
23338 
  """
23339 
  Attributes:
23340 
   - success
23341 
  """
23342 
 
23343 
  thrift_spec = (
23344 
    (0, TType.I64, 'success', None, None, ), # 0
23345 
  )
23346 
 
23347 
  def __init__(self, success=None,):
23348 
    self.success = success
23349 
 
23350 
  def read(self, iprot):
23351 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23352 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23353 
      return
23354 
    iprot.readStructBegin()
23355 
    while True:
23356 
      (fname, ftype, fid) = iprot.readFieldBegin()
23357 
      if ftype == TType.STOP:
23358 
        break
23359 
      if fid == 0:
23360 
        if ftype == TType.I64:
23361 
          self.success = iprot.readI64();
23362 
        else:
23363 
          iprot.skip(ftype)
23364 
      else:
23365 
        iprot.skip(ftype)
23366 
      iprot.readFieldEnd()
23367 
    iprot.readStructEnd()
23368 
 
23369 
  def write(self, oprot):
23370 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23371 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23372 
      return
23373 
    oprot.writeStructBegin('getAmazonSearchResultCount_result')
23374 
    if self.success is not None:
23375 
      oprot.writeFieldBegin('success', TType.I64, 0)
23376 
      oprot.writeI64(self.success)
23377 
      oprot.writeFieldEnd()
23378 
    oprot.writeFieldStop()
23379 
    oprot.writeStructEnd()
23380 
 
23381 
  def validate(self):
23382 
    return
23383 
 
23384 
 
23385 
  def __repr__(self):
23386 
    L = ['%s=%r' % (key, value)
23387 
      for key, value in self.__dict__.iteritems()]
23388 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23389 
 
23390 
  def __eq__(self, other):
23391 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23392 
 
23393 
  def __ne__(self, other):
23394 
    return not (self == other)
23395 
 
23396 
class getCountForAmazonlistedItems_args:
23397 
 
23398 
  thrift_spec = (
23399 
  )
23400 
 
23401 
  def read(self, iprot):
23402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23404 
      return
23405 
    iprot.readStructBegin()
23406 
    while True:
23407 
      (fname, ftype, fid) = iprot.readFieldBegin()
23408 
      if ftype == TType.STOP:
23409 
        break
23410 
      else:
23411 
        iprot.skip(ftype)
23412 
      iprot.readFieldEnd()
23413 
    iprot.readStructEnd()
23414 
 
23415 
  def write(self, oprot):
23416 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23417 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23418 
      return
23419 
    oprot.writeStructBegin('getCountForAmazonlistedItems_args')
23420 
    oprot.writeFieldStop()
23421 
    oprot.writeStructEnd()
23422 
 
23423 
  def validate(self):
23424 
    return
23425 
 
23426 
 
23427 
  def __repr__(self):
23428 
    L = ['%s=%r' % (key, value)
23429 
      for key, value in self.__dict__.iteritems()]
23430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23431 
 
23432 
  def __eq__(self, other):
23433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23434 
 
23435 
  def __ne__(self, other):
23436 
    return not (self == other)
23437 
 
23438 
class getCountForAmazonlistedItems_result:
23439 
  """
23440 
  Attributes:
23441 
   - success
23442 
  """
23443 
 
23444 
  thrift_spec = (
23445 
    (0, TType.I64, 'success', None, None, ), # 0
23446 
  )
23447 
 
23448 
  def __init__(self, success=None,):
23449 
    self.success = success
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 
      if fid == 0:
23461 
        if ftype == TType.I64:
23462 
          self.success = iprot.readI64();
23463 
        else:
23464 
          iprot.skip(ftype)
23465 
      else:
23466 
        iprot.skip(ftype)
23467 
      iprot.readFieldEnd()
23468 
    iprot.readStructEnd()
23469 
 
23470 
  def write(self, oprot):
23471 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23472 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23473 
      return
23474 
    oprot.writeStructBegin('getCountForAmazonlistedItems_result')
23475 
    if self.success is not None:
23476 
      oprot.writeFieldBegin('success', TType.I64, 0)
23477 
      oprot.writeI64(self.success)
23478 
      oprot.writeFieldEnd()
23479 
    oprot.writeFieldStop()
23480 
    oprot.writeStructEnd()
23481 
 
23482 
  def validate(self):
23483 
    return
23484 
 
23485 
 
23486 
  def __repr__(self):
23487 
    L = ['%s=%r' % (key, value)
23488 
      for key, value in self.__dict__.iteritems()]
23489 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23490 
 
23491 
  def __eq__(self, other):
23492 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23493 
 
23494 
  def __ne__(self, other):
23495 
    return not (self == other)
23496 
 
7281 kshitij.so 23497 
class getAmazonItemDetails_args:
23498 
  """
23499 
  Attributes:
23500 
   - itemId
23501 
  """
23502 
 
23503 
  thrift_spec = (
23504 
    None, # 0
23505 
    (1, TType.I64, 'itemId', None, None, ), # 1
23506 
  )
23507 
 
23508 
  def __init__(self, itemId=None,):
23509 
    self.itemId = itemId
23510 
 
23511 
  def read(self, iprot):
23512 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23513 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23514 
      return
23515 
    iprot.readStructBegin()
23516 
    while True:
23517 
      (fname, ftype, fid) = iprot.readFieldBegin()
23518 
      if ftype == TType.STOP:
23519 
        break
23520 
      if fid == 1:
23521 
        if ftype == TType.I64:
23522 
          self.itemId = iprot.readI64();
23523 
        else:
23524 
          iprot.skip(ftype)
23525 
      else:
23526 
        iprot.skip(ftype)
23527 
      iprot.readFieldEnd()
23528 
    iprot.readStructEnd()
23529 
 
23530 
  def write(self, oprot):
23531 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23532 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23533 
      return
23534 
    oprot.writeStructBegin('getAmazonItemDetails_args')
23535 
    if self.itemId is not None:
23536 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
23537 
      oprot.writeI64(self.itemId)
23538 
      oprot.writeFieldEnd()
23539 
    oprot.writeFieldStop()
23540 
    oprot.writeStructEnd()
23541 
 
23542 
  def validate(self):
23543 
    return
23544 
 
23545 
 
23546 
  def __repr__(self):
23547 
    L = ['%s=%r' % (key, value)
23548 
      for key, value in self.__dict__.iteritems()]
23549 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23550 
 
23551 
  def __eq__(self, other):
23552 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23553 
 
23554 
  def __ne__(self, other):
23555 
    return not (self == other)
23556 
 
23557 
class getAmazonItemDetails_result:
23558 
  """
23559 
  Attributes:
23560 
   - success
23561 
  """
23562 
 
23563 
  thrift_spec = (
23564 
    (0, TType.STRUCT, 'success', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 0
23565 
  )
23566 
 
23567 
  def __init__(self, success=None,):
23568 
    self.success = success
23569 
 
23570 
  def read(self, iprot):
23571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23573 
      return
23574 
    iprot.readStructBegin()
23575 
    while True:
23576 
      (fname, ftype, fid) = iprot.readFieldBegin()
23577 
      if ftype == TType.STOP:
23578 
        break
23579 
      if fid == 0:
23580 
        if ftype == TType.STRUCT:
23581 
          self.success = Amazonlisted()
23582 
          self.success.read(iprot)
23583 
        else:
23584 
          iprot.skip(ftype)
23585 
      else:
23586 
        iprot.skip(ftype)
23587 
      iprot.readFieldEnd()
23588 
    iprot.readStructEnd()
23589 
 
23590 
  def write(self, oprot):
23591 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23592 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23593 
      return
23594 
    oprot.writeStructBegin('getAmazonItemDetails_result')
23595 
    if self.success is not None:
23596 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23597 
      self.success.write(oprot)
23598 
      oprot.writeFieldEnd()
23599 
    oprot.writeFieldStop()
23600 
    oprot.writeStructEnd()
23601 
 
23602 
  def validate(self):
23603 
    return
23604 
 
23605 
 
23606 
  def __repr__(self):
23607 
    L = ['%s=%r' % (key, value)
23608 
      for key, value in self.__dict__.iteritems()]
23609 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23610 
 
23611 
  def __eq__(self, other):
23612 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23613 
 
23614 
  def __ne__(self, other):
23615 
    return not (self == other)
23616 
 
23617 
class updateAmazonItemDetails_args:
23618 
  """
23619 
  Attributes:
8168 kshitij.so 23620 
   - amazonlisted
7281 kshitij.so 23621 
  """
23622 
 
23623 
  thrift_spec = (
23624 
    None, # 0
8168 kshitij.so 23625 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
7281 kshitij.so 23626 
  )
23627 
 
8168 kshitij.so 23628 
  def __init__(self, amazonlisted=None,):
23629 
    self.amazonlisted = amazonlisted
7281 kshitij.so 23630 
 
23631 
  def read(self, iprot):
23632 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23633 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23634 
      return
23635 
    iprot.readStructBegin()
23636 
    while True:
23637 
      (fname, ftype, fid) = iprot.readFieldBegin()
23638 
      if ftype == TType.STOP:
23639 
        break
23640 
      if fid == 1:
8168 kshitij.so 23641 
        if ftype == TType.STRUCT:
23642 
          self.amazonlisted = Amazonlisted()
23643 
          self.amazonlisted.read(iprot)
7281 kshitij.so 23644 
        else:
23645 
          iprot.skip(ftype)
23646 
      else:
23647 
        iprot.skip(ftype)
23648 
      iprot.readFieldEnd()
23649 
    iprot.readStructEnd()
23650 
 
23651 
  def write(self, oprot):
23652 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23653 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23654 
      return
23655 
    oprot.writeStructBegin('updateAmazonItemDetails_args')
8168 kshitij.so 23656 
    if self.amazonlisted is not None:
23657 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
23658 
      self.amazonlisted.write(oprot)
7281 kshitij.so 23659 
      oprot.writeFieldEnd()
23660 
    oprot.writeFieldStop()
23661 
    oprot.writeStructEnd()
23662 
 
23663 
  def validate(self):
23664 
    return
23665 
 
23666 
 
23667 
  def __repr__(self):
23668 
    L = ['%s=%r' % (key, value)
23669 
      for key, value in self.__dict__.iteritems()]
23670 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23671 
 
23672 
  def __eq__(self, other):
23673 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23674 
 
23675 
  def __ne__(self, other):
23676 
    return not (self == other)
23677 
 
23678 
class updateAmazonItemDetails_result:
23679 
 
23680 
  thrift_spec = (
23681 
  )
23682 
 
23683 
  def read(self, iprot):
23684 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23685 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23686 
      return
23687 
    iprot.readStructBegin()
23688 
    while True:
23689 
      (fname, ftype, fid) = iprot.readFieldBegin()
23690 
      if ftype == TType.STOP:
23691 
        break
23692 
      else:
23693 
        iprot.skip(ftype)
23694 
      iprot.readFieldEnd()
23695 
    iprot.readStructEnd()
23696 
 
23697 
  def write(self, oprot):
23698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23700 
      return
23701 
    oprot.writeStructBegin('updateAmazonItemDetails_result')
23702 
    oprot.writeFieldStop()
23703 
    oprot.writeStructEnd()
23704 
 
23705 
  def validate(self):
23706 
    return
23707 
 
23708 
 
23709 
  def __repr__(self):
23710 
    L = ['%s=%r' % (key, value)
23711 
      for key, value in self.__dict__.iteritems()]
23712 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23713 
 
23714 
  def __eq__(self, other):
23715 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23716 
 
23717 
  def __ne__(self, other):
23718 
    return not (self == other)
23719 
 
23720 
class addAmazonItem_args:
23721 
  """
23722 
  Attributes:
23723 
   - amazonlisted
23724 
  """
23725 
 
23726 
  thrift_spec = (
23727 
    None, # 0
23728 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
23729 
  )
23730 
 
23731 
  def __init__(self, amazonlisted=None,):
23732 
    self.amazonlisted = amazonlisted
23733 
 
23734 
  def read(self, iprot):
23735 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23736 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23737 
      return
23738 
    iprot.readStructBegin()
23739 
    while True:
23740 
      (fname, ftype, fid) = iprot.readFieldBegin()
23741 
      if ftype == TType.STOP:
23742 
        break
23743 
      if fid == 1:
23744 
        if ftype == TType.STRUCT:
23745 
          self.amazonlisted = Amazonlisted()
23746 
          self.amazonlisted.read(iprot)
23747 
        else:
23748 
          iprot.skip(ftype)
23749 
      else:
23750 
        iprot.skip(ftype)
23751 
      iprot.readFieldEnd()
23752 
    iprot.readStructEnd()
23753 
 
23754 
  def write(self, oprot):
23755 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23756 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23757 
      return
23758 
    oprot.writeStructBegin('addAmazonItem_args')
23759 
    if self.amazonlisted is not None:
23760 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
23761 
      self.amazonlisted.write(oprot)
23762 
      oprot.writeFieldEnd()
23763 
    oprot.writeFieldStop()
23764 
    oprot.writeStructEnd()
23765 
 
23766 
  def validate(self):
23767 
    return
23768 
 
23769 
 
23770 
  def __repr__(self):
23771 
    L = ['%s=%r' % (key, value)
23772 
      for key, value in self.__dict__.iteritems()]
23773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23774 
 
23775 
  def __eq__(self, other):
23776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23777 
 
23778 
  def __ne__(self, other):
23779 
    return not (self == other)
23780 
 
23781 
class addAmazonItem_result:
23782 
 
23783 
  thrift_spec = (
23784 
  )
23785 
 
23786 
  def read(self, iprot):
23787 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23788 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23789 
      return
23790 
    iprot.readStructBegin()
23791 
    while True:
23792 
      (fname, ftype, fid) = iprot.readFieldBegin()
23793 
      if ftype == TType.STOP:
23794 
        break
23795 
      else:
23796 
        iprot.skip(ftype)
23797 
      iprot.readFieldEnd()
23798 
    iprot.readStructEnd()
23799 
 
23800 
  def write(self, oprot):
23801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23803 
      return
23804 
    oprot.writeStructBegin('addAmazonItem_result')
23805 
    oprot.writeFieldStop()
23806 
    oprot.writeStructEnd()
23807 
 
23808 
  def validate(self):
23809 
    return
23810 
 
23811 
 
23812 
  def __repr__(self):
23813 
    L = ['%s=%r' % (key, value)
23814 
      for key, value in self.__dict__.iteritems()]
23815 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23816 
 
23817 
  def __eq__(self, other):
23818 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23819 
 
23820 
  def __ne__(self, other):
23821 
    return not (self == other)
7291 vikram.rag 23822 
 
23823 
class getAsinItems_args:
23824 
 
23825 
  thrift_spec = (
23826 
  )
23827 
 
23828 
  def read(self, iprot):
23829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23831 
      return
23832 
    iprot.readStructBegin()
23833 
    while True:
23834 
      (fname, ftype, fid) = iprot.readFieldBegin()
23835 
      if ftype == TType.STOP:
23836 
        break
23837 
      else:
23838 
        iprot.skip(ftype)
23839 
      iprot.readFieldEnd()
23840 
    iprot.readStructEnd()
23841 
 
23842 
  def write(self, oprot):
23843 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23844 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23845 
      return
23846 
    oprot.writeStructBegin('getAsinItems_args')
23847 
    oprot.writeFieldStop()
23848 
    oprot.writeStructEnd()
23849 
 
23850 
  def validate(self):
23851 
    return
23852 
 
23853 
 
23854 
  def __repr__(self):
23855 
    L = ['%s=%r' % (key, value)
23856 
      for key, value in self.__dict__.iteritems()]
23857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23858 
 
23859 
  def __eq__(self, other):
23860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23861 
 
23862 
  def __ne__(self, other):
23863 
    return not (self == other)
23864 
 
23865 
class getAsinItems_result:
23866 
  """
23867 
  Attributes:
23868 
   - success
23869 
  """
23870 
 
23871 
  thrift_spec = (
23872 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
23873 
  )
23874 
 
23875 
  def __init__(self, success=None,):
23876 
    self.success = success
23877 
 
23878 
  def read(self, iprot):
23879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23881 
      return
23882 
    iprot.readStructBegin()
23883 
    while True:
23884 
      (fname, ftype, fid) = iprot.readFieldBegin()
23885 
      if ftype == TType.STOP:
23886 
        break
23887 
      if fid == 0:
23888 
        if ftype == TType.LIST:
23889 
          self.success = []
13493 amit.gupta 23890 
          (_etype467, _size464) = iprot.readListBegin()
23891 
          for _i468 in xrange(_size464):
23892 
            _elem469 = Item()
23893 
            _elem469.read(iprot)
23894 
            self.success.append(_elem469)
7291 vikram.rag 23895 
          iprot.readListEnd()
23896 
        else:
23897 
          iprot.skip(ftype)
23898 
      else:
23899 
        iprot.skip(ftype)
23900 
      iprot.readFieldEnd()
23901 
    iprot.readStructEnd()
23902 
 
23903 
  def write(self, oprot):
23904 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23905 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23906 
      return
23907 
    oprot.writeStructBegin('getAsinItems_result')
23908 
    if self.success is not None:
23909 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23910 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 23911 
      for iter470 in self.success:
23912 
        iter470.write(oprot)
7291 vikram.rag 23913 
      oprot.writeListEnd()
23914 
      oprot.writeFieldEnd()
23915 
    oprot.writeFieldStop()
23916 
    oprot.writeStructEnd()
23917 
 
23918 
  def validate(self):
23919 
    return
23920 
 
23921 
 
23922 
  def __repr__(self):
23923 
    L = ['%s=%r' % (key, value)
23924 
      for key, value in self.__dict__.iteritems()]
23925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23926 
 
23927 
  def __eq__(self, other):
23928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23929 
 
23930 
  def __ne__(self, other):
23931 
    return not (self == other)
23932 
 
23933 
class getAllFbaListedItems_args:
23934 
 
23935 
  thrift_spec = (
23936 
  )
23937 
 
23938 
  def read(self, iprot):
23939 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23940 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23941 
      return
23942 
    iprot.readStructBegin()
23943 
    while True:
23944 
      (fname, ftype, fid) = iprot.readFieldBegin()
23945 
      if ftype == TType.STOP:
23946 
        break
23947 
      else:
23948 
        iprot.skip(ftype)
23949 
      iprot.readFieldEnd()
23950 
    iprot.readStructEnd()
23951 
 
23952 
  def write(self, oprot):
23953 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23954 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23955 
      return
23956 
    oprot.writeStructBegin('getAllFbaListedItems_args')
23957 
    oprot.writeFieldStop()
23958 
    oprot.writeStructEnd()
23959 
 
23960 
  def validate(self):
23961 
    return
23962 
 
23963 
 
23964 
  def __repr__(self):
23965 
    L = ['%s=%r' % (key, value)
23966 
      for key, value in self.__dict__.iteritems()]
23967 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23968 
 
23969 
  def __eq__(self, other):
23970 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23971 
 
23972 
  def __ne__(self, other):
23973 
    return not (self == other)
23974 
 
23975 
class getAllFbaListedItems_result:
23976 
  """
23977 
  Attributes:
23978 
   - success
23979 
  """
23980 
 
23981 
  thrift_spec = (
23982 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
23983 
  )
23984 
 
23985 
  def __init__(self, success=None,):
23986 
    self.success = success
23987 
 
23988 
  def read(self, iprot):
23989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23991 
      return
23992 
    iprot.readStructBegin()
23993 
    while True:
23994 
      (fname, ftype, fid) = iprot.readFieldBegin()
23995 
      if ftype == TType.STOP:
23996 
        break
23997 
      if fid == 0:
23998 
        if ftype == TType.LIST:
23999 
          self.success = []
13493 amit.gupta 24000 
          (_etype474, _size471) = iprot.readListBegin()
24001 
          for _i475 in xrange(_size471):
24002 
            _elem476 = Amazonlisted()
24003 
            _elem476.read(iprot)
24004 
            self.success.append(_elem476)
7291 vikram.rag 24005 
          iprot.readListEnd()
24006 
        else:
24007 
          iprot.skip(ftype)
24008 
      else:
24009 
        iprot.skip(ftype)
24010 
      iprot.readFieldEnd()
24011 
    iprot.readStructEnd()
24012 
 
24013 
  def write(self, oprot):
24014 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24015 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24016 
      return
24017 
    oprot.writeStructBegin('getAllFbaListedItems_result')
24018 
    if self.success is not None:
24019 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24020 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 24021 
      for iter477 in self.success:
24022 
        iter477.write(oprot)
7291 vikram.rag 24023 
      oprot.writeListEnd()
24024 
      oprot.writeFieldEnd()
24025 
    oprot.writeFieldStop()
24026 
    oprot.writeStructEnd()
24027 
 
24028 
  def validate(self):
24029 
    return
24030 
 
24031 
 
24032 
  def __repr__(self):
24033 
    L = ['%s=%r' % (key, value)
24034 
      for key, value in self.__dict__.iteritems()]
24035 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24036 
 
24037 
  def __eq__(self, other):
24038 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24039 
 
24040 
  def __ne__(self, other):
24041 
    return not (self == other)
24042 
 
24043 
class getAllNonFbaListedItems_args:
24044 
 
24045 
  thrift_spec = (
24046 
  )
24047 
 
24048 
  def read(self, iprot):
24049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24051 
      return
24052 
    iprot.readStructBegin()
24053 
    while True:
24054 
      (fname, ftype, fid) = iprot.readFieldBegin()
24055 
      if ftype == TType.STOP:
24056 
        break
24057 
      else:
24058 
        iprot.skip(ftype)
24059 
      iprot.readFieldEnd()
24060 
    iprot.readStructEnd()
24061 
 
24062 
  def write(self, oprot):
24063 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24064 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24065 
      return
24066 
    oprot.writeStructBegin('getAllNonFbaListedItems_args')
24067 
    oprot.writeFieldStop()
24068 
    oprot.writeStructEnd()
24069 
 
24070 
  def validate(self):
24071 
    return
24072 
 
24073 
 
24074 
  def __repr__(self):
24075 
    L = ['%s=%r' % (key, value)
24076 
      for key, value in self.__dict__.iteritems()]
24077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24078 
 
24079 
  def __eq__(self, other):
24080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24081 
 
24082 
  def __ne__(self, other):
24083 
    return not (self == other)
24084 
 
24085 
class getAllNonFbaListedItems_result:
24086 
  """
24087 
  Attributes:
24088 
   - success
24089 
  """
24090 
 
24091 
  thrift_spec = (
24092 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
24093 
  )
24094 
 
24095 
  def __init__(self, success=None,):
24096 
    self.success = success
24097 
 
24098 
  def read(self, iprot):
24099 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24100 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24101 
      return
24102 
    iprot.readStructBegin()
24103 
    while True:
24104 
      (fname, ftype, fid) = iprot.readFieldBegin()
24105 
      if ftype == TType.STOP:
24106 
        break
24107 
      if fid == 0:
24108 
        if ftype == TType.LIST:
24109 
          self.success = []
13493 amit.gupta 24110 
          (_etype481, _size478) = iprot.readListBegin()
24111 
          for _i482 in xrange(_size478):
24112 
            _elem483 = Amazonlisted()
24113 
            _elem483.read(iprot)
24114 
            self.success.append(_elem483)
7291 vikram.rag 24115 
          iprot.readListEnd()
24116 
        else:
24117 
          iprot.skip(ftype)
24118 
      else:
24119 
        iprot.skip(ftype)
24120 
      iprot.readFieldEnd()
24121 
    iprot.readStructEnd()
24122 
 
24123 
  def write(self, oprot):
24124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24126 
      return
24127 
    oprot.writeStructBegin('getAllNonFbaListedItems_result')
24128 
    if self.success is not None:
24129 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24130 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 24131 
      for iter484 in self.success:
24132 
        iter484.write(oprot)
7291 vikram.rag 24133 
      oprot.writeListEnd()
24134 
      oprot.writeFieldEnd()
24135 
    oprot.writeFieldStop()
24136 
    oprot.writeStructEnd()
24137 
 
24138 
  def validate(self):
24139 
    return
24140 
 
24141 
 
24142 
  def __repr__(self):
24143 
    L = ['%s=%r' % (key, value)
24144 
      for key, value in self.__dict__.iteritems()]
24145 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24146 
 
24147 
  def __eq__(self, other):
24148 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24149 
 
24150 
  def __ne__(self, other):
24151 
    return not (self == other)
7460 kshitij.so 24152 
 
24153 
class updateItemInventory_args:
24154 
  """
24155 
  Attributes:
24156 
   - itemId
24157 
   - holdInventory
24158 
   - defaultInventory
24159 
  """
24160 
 
24161 
  thrift_spec = (
24162 
    None, # 0
24163 
    (1, TType.I64, 'itemId', None, None, ), # 1
24164 
    (2, TType.I64, 'holdInventory', None, None, ), # 2
24165 
    (3, TType.I64, 'defaultInventory', None, None, ), # 3
24166 
  )
24167 
 
24168 
  def __init__(self, itemId=None, holdInventory=None, defaultInventory=None,):
24169 
    self.itemId = itemId
24170 
    self.holdInventory = holdInventory
24171 
    self.defaultInventory = defaultInventory
24172 
 
24173 
  def read(self, iprot):
24174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24176 
      return
24177 
    iprot.readStructBegin()
24178 
    while True:
24179 
      (fname, ftype, fid) = iprot.readFieldBegin()
24180 
      if ftype == TType.STOP:
24181 
        break
24182 
      if fid == 1:
24183 
        if ftype == TType.I64:
24184 
          self.itemId = iprot.readI64();
24185 
        else:
24186 
          iprot.skip(ftype)
24187 
      elif fid == 2:
24188 
        if ftype == TType.I64:
24189 
          self.holdInventory = iprot.readI64();
24190 
        else:
24191 
          iprot.skip(ftype)
24192 
      elif fid == 3:
24193 
        if ftype == TType.I64:
24194 
          self.defaultInventory = iprot.readI64();
24195 
        else:
24196 
          iprot.skip(ftype)
24197 
      else:
24198 
        iprot.skip(ftype)
24199 
      iprot.readFieldEnd()
24200 
    iprot.readStructEnd()
24201 
 
24202 
  def write(self, oprot):
24203 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24204 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24205 
      return
24206 
    oprot.writeStructBegin('updateItemInventory_args')
24207 
    if self.itemId is not None:
24208 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
24209 
      oprot.writeI64(self.itemId)
24210 
      oprot.writeFieldEnd()
24211 
    if self.holdInventory is not None:
24212 
      oprot.writeFieldBegin('holdInventory', TType.I64, 2)
24213 
      oprot.writeI64(self.holdInventory)
24214 
      oprot.writeFieldEnd()
24215 
    if self.defaultInventory is not None:
24216 
      oprot.writeFieldBegin('defaultInventory', TType.I64, 3)
24217 
      oprot.writeI64(self.defaultInventory)
24218 
      oprot.writeFieldEnd()
24219 
    oprot.writeFieldStop()
24220 
    oprot.writeStructEnd()
24221 
 
24222 
  def validate(self):
24223 
    return
24224 
 
24225 
 
24226 
  def __repr__(self):
24227 
    L = ['%s=%r' % (key, value)
24228 
      for key, value in self.__dict__.iteritems()]
24229 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24230 
 
24231 
  def __eq__(self, other):
24232 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24233 
 
24234 
  def __ne__(self, other):
24235 
    return not (self == other)
24236 
 
24237 
class updateItemInventory_result:
24238 
  """
24239 
  Attributes:
24240 
   - success
24241 
  """
24242 
 
24243 
  thrift_spec = (
24244 
    (0, TType.BOOL, 'success', None, None, ), # 0
24245 
  )
24246 
 
24247 
  def __init__(self, success=None,):
24248 
    self.success = success
24249 
 
24250 
  def read(self, iprot):
24251 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24252 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24253 
      return
24254 
    iprot.readStructBegin()
24255 
    while True:
24256 
      (fname, ftype, fid) = iprot.readFieldBegin()
24257 
      if ftype == TType.STOP:
24258 
        break
24259 
      if fid == 0:
24260 
        if ftype == TType.BOOL:
24261 
          self.success = iprot.readBool();
24262 
        else:
24263 
          iprot.skip(ftype)
24264 
      else:
24265 
        iprot.skip(ftype)
24266 
      iprot.readFieldEnd()
24267 
    iprot.readStructEnd()
24268 
 
24269 
  def write(self, oprot):
24270 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24271 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24272 
      return
24273 
    oprot.writeStructBegin('updateItemInventory_result')
24274 
    if self.success is not None:
24275 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
24276 
      oprot.writeBool(self.success)
24277 
      oprot.writeFieldEnd()
24278 
    oprot.writeFieldStop()
24279 
    oprot.writeStructEnd()
24280 
 
24281 
  def validate(self):
24282 
    return
24283 
 
24284 
 
24285 
  def __repr__(self):
24286 
    L = ['%s=%r' % (key, value)
24287 
      for key, value in self.__dict__.iteritems()]
24288 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24289 
 
24290 
  def __eq__(self, other):
24291 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24292 
 
24293 
  def __ne__(self, other):
24294 
    return not (self == other)
7770 kshitij.so 24295 
 
24296 
class updateTimestampForAmazonFeeds_args:
24297 
  """
24298 
  Attributes:
24299 
   - type
24300 
   - sku
24301 
   - timestamp
24302 
  """
24303 
 
24304 
  thrift_spec = (
24305 
    None, # 0
24306 
    (1, TType.STRING, 'type', None, None, ), # 1
24307 
    (2, TType.LIST, 'sku', (TType.I64,None), None, ), # 2
24308 
    (3, TType.I64, 'timestamp', None, None, ), # 3
24309 
  )
24310 
 
24311 
  def __init__(self, type=None, sku=None, timestamp=None,):
24312 
    self.type = type
24313 
    self.sku = sku
24314 
    self.timestamp = timestamp
24315 
 
24316 
  def read(self, iprot):
24317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24319 
      return
24320 
    iprot.readStructBegin()
24321 
    while True:
24322 
      (fname, ftype, fid) = iprot.readFieldBegin()
24323 
      if ftype == TType.STOP:
24324 
        break
24325 
      if fid == 1:
24326 
        if ftype == TType.STRING:
24327 
          self.type = iprot.readString();
24328 
        else:
24329 
          iprot.skip(ftype)
24330 
      elif fid == 2:
24331 
        if ftype == TType.LIST:
24332 
          self.sku = []
13493 amit.gupta 24333 
          (_etype488, _size485) = iprot.readListBegin()
24334 
          for _i489 in xrange(_size485):
24335 
            _elem490 = iprot.readI64();
24336 
            self.sku.append(_elem490)
7770 kshitij.so 24337 
          iprot.readListEnd()
24338 
        else:
24339 
          iprot.skip(ftype)
24340 
      elif fid == 3:
24341 
        if ftype == TType.I64:
24342 
          self.timestamp = iprot.readI64();
24343 
        else:
24344 
          iprot.skip(ftype)
24345 
      else:
24346 
        iprot.skip(ftype)
24347 
      iprot.readFieldEnd()
24348 
    iprot.readStructEnd()
24349 
 
24350 
  def write(self, oprot):
24351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24353 
      return
24354 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_args')
24355 
    if self.type is not None:
24356 
      oprot.writeFieldBegin('type', TType.STRING, 1)
24357 
      oprot.writeString(self.type)
24358 
      oprot.writeFieldEnd()
24359 
    if self.sku is not None:
24360 
      oprot.writeFieldBegin('sku', TType.LIST, 2)
24361 
      oprot.writeListBegin(TType.I64, len(self.sku))
13493 amit.gupta 24362 
      for iter491 in self.sku:
24363 
        oprot.writeI64(iter491)
7770 kshitij.so 24364 
      oprot.writeListEnd()
24365 
      oprot.writeFieldEnd()
24366 
    if self.timestamp is not None:
24367 
      oprot.writeFieldBegin('timestamp', TType.I64, 3)
24368 
      oprot.writeI64(self.timestamp)
24369 
      oprot.writeFieldEnd()
24370 
    oprot.writeFieldStop()
24371 
    oprot.writeStructEnd()
24372 
 
24373 
  def validate(self):
24374 
    return
24375 
 
24376 
 
24377 
  def __repr__(self):
24378 
    L = ['%s=%r' % (key, value)
24379 
      for key, value in self.__dict__.iteritems()]
24380 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24381 
 
24382 
  def __eq__(self, other):
24383 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24384 
 
24385 
  def __ne__(self, other):
24386 
    return not (self == other)
24387 
 
24388 
class updateTimestampForAmazonFeeds_result:
24389 
  """
24390 
  Attributes:
24391 
   - success
24392 
  """
24393 
 
24394 
  thrift_spec = (
24395 
    (0, TType.BOOL, 'success', None, None, ), # 0
24396 
  )
24397 
 
24398 
  def __init__(self, success=None,):
24399 
    self.success = success
24400 
 
24401 
  def read(self, iprot):
24402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24404 
      return
24405 
    iprot.readStructBegin()
24406 
    while True:
24407 
      (fname, ftype, fid) = iprot.readFieldBegin()
24408 
      if ftype == TType.STOP:
24409 
        break
24410 
      if fid == 0:
24411 
        if ftype == TType.BOOL:
24412 
          self.success = iprot.readBool();
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('updateTimestampForAmazonFeeds_result')
24425 
    if self.success is not None:
24426 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
24427 
      oprot.writeBool(self.success)
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)
7897 amar.kumar 24446 
 
24447 
class getAllParentCategories_args:
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('getAllParentCategories_args')
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 getAllParentCategories_result:
24490 
  """
24491 
  Attributes:
24492 
   - success
24493 
  """
24494 
 
24495 
  thrift_spec = (
24496 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
24497 
  )
24498 
 
24499 
  def __init__(self, success=None,):
24500 
    self.success = success
24501 
 
24502 
  def read(self, iprot):
24503 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24504 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24505 
      return
24506 
    iprot.readStructBegin()
24507 
    while True:
24508 
      (fname, ftype, fid) = iprot.readFieldBegin()
24509 
      if ftype == TType.STOP:
24510 
        break
24511 
      if fid == 0:
24512 
        if ftype == TType.LIST:
24513 
          self.success = []
13493 amit.gupta 24514 
          (_etype495, _size492) = iprot.readListBegin()
24515 
          for _i496 in xrange(_size492):
24516 
            _elem497 = Category()
24517 
            _elem497.read(iprot)
24518 
            self.success.append(_elem497)
7897 amar.kumar 24519 
          iprot.readListEnd()
24520 
        else:
24521 
          iprot.skip(ftype)
24522 
      else:
24523 
        iprot.skip(ftype)
24524 
      iprot.readFieldEnd()
24525 
    iprot.readStructEnd()
24526 
 
24527 
  def write(self, oprot):
24528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24530 
      return
24531 
    oprot.writeStructBegin('getAllParentCategories_result')
24532 
    if self.success is not None:
24533 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24534 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 24535 
      for iter498 in self.success:
24536 
        iter498.write(oprot)
7897 amar.kumar 24537 
      oprot.writeListEnd()
24538 
      oprot.writeFieldEnd()
24539 
    oprot.writeFieldStop()
24540 
    oprot.writeStructEnd()
24541 
 
24542 
  def validate(self):
24543 
    return
24544 
 
24545 
 
24546 
  def __repr__(self):
24547 
    L = ['%s=%r' % (key, value)
24548 
      for key, value in self.__dict__.iteritems()]
24549 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24550 
 
24551 
  def __eq__(self, other):
24552 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24553 
 
24554 
  def __ne__(self, other):
24555 
    return not (self == other)
7977 kshitij.so 24556 
 
24557 
class addPageViewEvent_args:
24558 
  """
24559 
  Attributes:
24560 
   - pageViewEvents
24561 
  """
24562 
 
24563 
  thrift_spec = (
24564 
    None, # 0
24565 
    (1, TType.STRUCT, 'pageViewEvents', (PageViewEvents, PageViewEvents.thrift_spec), None, ), # 1
24566 
  )
24567 
 
24568 
  def __init__(self, pageViewEvents=None,):
24569 
    self.pageViewEvents = pageViewEvents
24570 
 
24571 
  def read(self, iprot):
24572 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24573 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24574 
      return
24575 
    iprot.readStructBegin()
24576 
    while True:
24577 
      (fname, ftype, fid) = iprot.readFieldBegin()
24578 
      if ftype == TType.STOP:
24579 
        break
24580 
      if fid == 1:
24581 
        if ftype == TType.STRUCT:
24582 
          self.pageViewEvents = PageViewEvents()
24583 
          self.pageViewEvents.read(iprot)
24584 
        else:
24585 
          iprot.skip(ftype)
24586 
      else:
24587 
        iprot.skip(ftype)
24588 
      iprot.readFieldEnd()
24589 
    iprot.readStructEnd()
24590 
 
24591 
  def write(self, oprot):
24592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24594 
      return
24595 
    oprot.writeStructBegin('addPageViewEvent_args')
24596 
    if self.pageViewEvents is not None:
24597 
      oprot.writeFieldBegin('pageViewEvents', TType.STRUCT, 1)
24598 
      self.pageViewEvents.write(oprot)
24599 
      oprot.writeFieldEnd()
24600 
    oprot.writeFieldStop()
24601 
    oprot.writeStructEnd()
24602 
 
24603 
  def validate(self):
24604 
    return
24605 
 
24606 
 
24607 
  def __repr__(self):
24608 
    L = ['%s=%r' % (key, value)
24609 
      for key, value in self.__dict__.iteritems()]
24610 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24611 
 
24612 
  def __eq__(self, other):
24613 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24614 
 
24615 
  def __ne__(self, other):
24616 
    return not (self == other)
24617 
 
24618 
class addPageViewEvent_result:
24619 
 
24620 
  thrift_spec = (
24621 
  )
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 
      else:
24633 
        iprot.skip(ftype)
24634 
      iprot.readFieldEnd()
24635 
    iprot.readStructEnd()
24636 
 
24637 
  def write(self, oprot):
24638 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24639 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24640 
      return
24641 
    oprot.writeStructBegin('addPageViewEvent_result')
24642 
    oprot.writeFieldStop()
24643 
    oprot.writeStructEnd()
24644 
 
24645 
  def validate(self):
24646 
    return
24647 
 
24648 
 
24649 
  def __repr__(self):
24650 
    L = ['%s=%r' % (key, value)
24651 
      for key, value in self.__dict__.iteritems()]
24652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24653 
 
24654 
  def __eq__(self, other):
24655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24656 
 
24657 
  def __ne__(self, other):
24658 
    return not (self == other)
24659 
 
24660 
class addCartEvent_args:
24661 
  """
24662 
  Attributes:
24663 
   - cartEvents
24664 
  """
24665 
 
24666 
  thrift_spec = (
24667 
    None, # 0
24668 
    (1, TType.STRUCT, 'cartEvents', (CartEvents, CartEvents.thrift_spec), None, ), # 1
24669 
  )
24670 
 
24671 
  def __init__(self, cartEvents=None,):
24672 
    self.cartEvents = cartEvents
24673 
 
24674 
  def read(self, iprot):
24675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24677 
      return
24678 
    iprot.readStructBegin()
24679 
    while True:
24680 
      (fname, ftype, fid) = iprot.readFieldBegin()
24681 
      if ftype == TType.STOP:
24682 
        break
24683 
      if fid == 1:
24684 
        if ftype == TType.STRUCT:
24685 
          self.cartEvents = CartEvents()
24686 
          self.cartEvents.read(iprot)
24687 
        else:
24688 
          iprot.skip(ftype)
24689 
      else:
24690 
        iprot.skip(ftype)
24691 
      iprot.readFieldEnd()
24692 
    iprot.readStructEnd()
24693 
 
24694 
  def write(self, oprot):
24695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24697 
      return
24698 
    oprot.writeStructBegin('addCartEvent_args')
24699 
    if self.cartEvents is not None:
24700 
      oprot.writeFieldBegin('cartEvents', TType.STRUCT, 1)
24701 
      self.cartEvents.write(oprot)
24702 
      oprot.writeFieldEnd()
24703 
    oprot.writeFieldStop()
24704 
    oprot.writeStructEnd()
24705 
 
24706 
  def validate(self):
24707 
    return
24708 
 
24709 
 
24710 
  def __repr__(self):
24711 
    L = ['%s=%r' % (key, value)
24712 
      for key, value in self.__dict__.iteritems()]
24713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24714 
 
24715 
  def __eq__(self, other):
24716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24717 
 
24718 
  def __ne__(self, other):
24719 
    return not (self == other)
24720 
 
24721 
class addCartEvent_result:
24722 
 
24723 
  thrift_spec = (
24724 
  )
24725 
 
24726 
  def read(self, iprot):
24727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24729 
      return
24730 
    iprot.readStructBegin()
24731 
    while True:
24732 
      (fname, ftype, fid) = iprot.readFieldBegin()
24733 
      if ftype == TType.STOP:
24734 
        break
24735 
      else:
24736 
        iprot.skip(ftype)
24737 
      iprot.readFieldEnd()
24738 
    iprot.readStructEnd()
24739 
 
24740 
  def write(self, oprot):
24741 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24742 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24743 
      return
24744 
    oprot.writeStructBegin('addCartEvent_result')
24745 
    oprot.writeFieldStop()
24746 
    oprot.writeStructEnd()
24747 
 
24748 
  def validate(self):
24749 
    return
24750 
 
24751 
 
24752 
  def __repr__(self):
24753 
    L = ['%s=%r' % (key, value)
24754 
      for key, value in self.__dict__.iteritems()]
24755 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24756 
 
24757 
  def __eq__(self, other):
24758 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24759 
 
24760 
  def __ne__(self, other):
24761 
    return not (self == other)
8139 kshitij.so 24762 
 
8182 amar.kumar 24763 
class addEbayItem_args:
24764 
  """
24765 
  Attributes:
24766 
   - ebayItem
24767 
  """
24768 
 
24769 
  thrift_spec = (
24770 
    None, # 0
24771 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
24772 
  )
24773 
 
24774 
  def __init__(self, ebayItem=None,):
24775 
    self.ebayItem = ebayItem
24776 
 
24777 
  def read(self, iprot):
24778 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24779 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24780 
      return
24781 
    iprot.readStructBegin()
24782 
    while True:
24783 
      (fname, ftype, fid) = iprot.readFieldBegin()
24784 
      if ftype == TType.STOP:
24785 
        break
24786 
      if fid == 1:
24787 
        if ftype == TType.STRUCT:
24788 
          self.ebayItem = EbayItem()
24789 
          self.ebayItem.read(iprot)
24790 
        else:
24791 
          iprot.skip(ftype)
24792 
      else:
24793 
        iprot.skip(ftype)
24794 
      iprot.readFieldEnd()
24795 
    iprot.readStructEnd()
24796 
 
24797 
  def write(self, oprot):
24798 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24799 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24800 
      return
24801 
    oprot.writeStructBegin('addEbayItem_args')
24802 
    if self.ebayItem is not None:
24803 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
24804 
      self.ebayItem.write(oprot)
24805 
      oprot.writeFieldEnd()
24806 
    oprot.writeFieldStop()
24807 
    oprot.writeStructEnd()
24808 
 
24809 
  def validate(self):
24810 
    return
24811 
 
24812 
 
24813 
  def __repr__(self):
24814 
    L = ['%s=%r' % (key, value)
24815 
      for key, value in self.__dict__.iteritems()]
24816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24817 
 
24818 
  def __eq__(self, other):
24819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24820 
 
24821 
  def __ne__(self, other):
24822 
    return not (self == other)
24823 
 
24824 
class addEbayItem_result:
24825 
 
24826 
  thrift_spec = (
24827 
  )
24828 
 
24829 
  def read(self, iprot):
24830 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24831 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24832 
      return
24833 
    iprot.readStructBegin()
24834 
    while True:
24835 
      (fname, ftype, fid) = iprot.readFieldBegin()
24836 
      if ftype == TType.STOP:
24837 
        break
24838 
      else:
24839 
        iprot.skip(ftype)
24840 
      iprot.readFieldEnd()
24841 
    iprot.readStructEnd()
24842 
 
24843 
  def write(self, oprot):
24844 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24845 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24846 
      return
24847 
    oprot.writeStructBegin('addEbayItem_result')
24848 
    oprot.writeFieldStop()
24849 
    oprot.writeStructEnd()
24850 
 
24851 
  def validate(self):
24852 
    return
24853 
 
24854 
 
24855 
  def __repr__(self):
24856 
    L = ['%s=%r' % (key, value)
24857 
      for key, value in self.__dict__.iteritems()]
24858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24859 
 
24860 
  def __eq__(self, other):
24861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24862 
 
24863 
  def __ne__(self, other):
24864 
    return not (self == other)
24865 
 
24866 
class getEbayItem_args:
24867 
  """
24868 
  Attributes:
24869 
   - listingId
24870 
  """
24871 
 
24872 
  thrift_spec = (
24873 
    None, # 0
24874 
    (1, TType.STRING, 'listingId', None, None, ), # 1
24875 
  )
24876 
 
24877 
  def __init__(self, listingId=None,):
24878 
    self.listingId = listingId
24879 
 
24880 
  def read(self, iprot):
24881 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24882 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24883 
      return
24884 
    iprot.readStructBegin()
24885 
    while True:
24886 
      (fname, ftype, fid) = iprot.readFieldBegin()
24887 
      if ftype == TType.STOP:
24888 
        break
24889 
      if fid == 1:
24890 
        if ftype == TType.STRING:
24891 
          self.listingId = iprot.readString();
24892 
        else:
24893 
          iprot.skip(ftype)
24894 
      else:
24895 
        iprot.skip(ftype)
24896 
      iprot.readFieldEnd()
24897 
    iprot.readStructEnd()
24898 
 
24899 
  def write(self, oprot):
24900 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24901 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24902 
      return
24903 
    oprot.writeStructBegin('getEbayItem_args')
24904 
    if self.listingId is not None:
24905 
      oprot.writeFieldBegin('listingId', TType.STRING, 1)
24906 
      oprot.writeString(self.listingId)
24907 
      oprot.writeFieldEnd()
24908 
    oprot.writeFieldStop()
24909 
    oprot.writeStructEnd()
24910 
 
24911 
  def validate(self):
24912 
    return
24913 
 
24914 
 
24915 
  def __repr__(self):
24916 
    L = ['%s=%r' % (key, value)
24917 
      for key, value in self.__dict__.iteritems()]
24918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24919 
 
24920 
  def __eq__(self, other):
24921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24922 
 
24923 
  def __ne__(self, other):
24924 
    return not (self == other)
24925 
 
24926 
class getEbayItem_result:
24927 
  """
24928 
  Attributes:
24929 
   - success
24930 
  """
24931 
 
24932 
  thrift_spec = (
24933 
    (0, TType.STRUCT, 'success', (EbayItem, EbayItem.thrift_spec), None, ), # 0
24934 
  )
24935 
 
24936 
  def __init__(self, success=None,):
24937 
    self.success = success
24938 
 
24939 
  def read(self, iprot):
24940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24942 
      return
24943 
    iprot.readStructBegin()
24944 
    while True:
24945 
      (fname, ftype, fid) = iprot.readFieldBegin()
24946 
      if ftype == TType.STOP:
24947 
        break
24948 
      if fid == 0:
24949 
        if ftype == TType.STRUCT:
24950 
          self.success = EbayItem()
24951 
          self.success.read(iprot)
24952 
        else:
24953 
          iprot.skip(ftype)
24954 
      else:
24955 
        iprot.skip(ftype)
24956 
      iprot.readFieldEnd()
24957 
    iprot.readStructEnd()
24958 
 
24959 
  def write(self, oprot):
24960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24962 
      return
24963 
    oprot.writeStructBegin('getEbayItem_result')
24964 
    if self.success is not None:
24965 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24966 
      self.success.write(oprot)
24967 
      oprot.writeFieldEnd()
24968 
    oprot.writeFieldStop()
24969 
    oprot.writeStructEnd()
24970 
 
24971 
  def validate(self):
24972 
    return
24973 
 
24974 
 
24975 
  def __repr__(self):
24976 
    L = ['%s=%r' % (key, value)
24977 
      for key, value in self.__dict__.iteritems()]
24978 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24979 
 
24980 
  def __eq__(self, other):
24981 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24982 
 
24983 
  def __ne__(self, other):
24984 
    return not (self == other)
24985 
 
24986 
class updateEbayItem_args:
24987 
  """
24988 
  Attributes:
24989 
   - ebayItem
24990 
  """
24991 
 
24992 
  thrift_spec = (
24993 
    None, # 0
24994 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
24995 
  )
24996 
 
24997 
  def __init__(self, ebayItem=None,):
24998 
    self.ebayItem = ebayItem
24999 
 
25000 
  def read(self, iprot):
25001 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25002 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25003 
      return
25004 
    iprot.readStructBegin()
25005 
    while True:
25006 
      (fname, ftype, fid) = iprot.readFieldBegin()
25007 
      if ftype == TType.STOP:
25008 
        break
25009 
      if fid == 1:
25010 
        if ftype == TType.STRUCT:
25011 
          self.ebayItem = EbayItem()
25012 
          self.ebayItem.read(iprot)
25013 
        else:
25014 
          iprot.skip(ftype)
25015 
      else:
25016 
        iprot.skip(ftype)
25017 
      iprot.readFieldEnd()
25018 
    iprot.readStructEnd()
25019 
 
25020 
  def write(self, oprot):
25021 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25022 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25023 
      return
25024 
    oprot.writeStructBegin('updateEbayItem_args')
25025 
    if self.ebayItem is not None:
25026 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
25027 
      self.ebayItem.write(oprot)
25028 
      oprot.writeFieldEnd()
25029 
    oprot.writeFieldStop()
25030 
    oprot.writeStructEnd()
25031 
 
25032 
  def validate(self):
25033 
    return
25034 
 
25035 
 
25036 
  def __repr__(self):
25037 
    L = ['%s=%r' % (key, value)
25038 
      for key, value in self.__dict__.iteritems()]
25039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25040 
 
25041 
  def __eq__(self, other):
25042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25043 
 
25044 
  def __ne__(self, other):
25045 
    return not (self == other)
25046 
 
25047 
class updateEbayItem_result:
25048 
 
25049 
  thrift_spec = (
25050 
  )
25051 
 
25052 
  def read(self, iprot):
25053 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25054 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25055 
      return
25056 
    iprot.readStructBegin()
25057 
    while True:
25058 
      (fname, ftype, fid) = iprot.readFieldBegin()
25059 
      if ftype == TType.STOP:
25060 
        break
25061 
      else:
25062 
        iprot.skip(ftype)
25063 
      iprot.readFieldEnd()
25064 
    iprot.readStructEnd()
25065 
 
25066 
  def write(self, oprot):
25067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25069 
      return
25070 
    oprot.writeStructBegin('updateEbayItem_result')
25071 
    oprot.writeFieldStop()
25072 
    oprot.writeStructEnd()
25073 
 
25074 
  def validate(self):
25075 
    return
25076 
 
25077 
 
25078 
  def __repr__(self):
25079 
    L = ['%s=%r' % (key, value)
25080 
      for key, value in self.__dict__.iteritems()]
25081 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25082 
 
25083 
  def __eq__(self, other):
25084 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25085 
 
25086 
  def __ne__(self, other):
25087 
    return not (self == other)
25088 
 
8139 kshitij.so 25089 
class getAmazonListedItems_args:
25090 
  """
25091 
  Attributes:
25092 
   - offset
25093 
   - limit
25094 
  """
25095 
 
25096 
  thrift_spec = (
25097 
    None, # 0
25098 
    (1, TType.I64, 'offset', None, None, ), # 1
25099 
    (2, TType.I64, 'limit', None, None, ), # 2
25100 
  )
25101 
 
25102 
  def __init__(self, offset=None, limit=None,):
25103 
    self.offset = offset
25104 
    self.limit = limit
25105 
 
25106 
  def read(self, iprot):
25107 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25108 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25109 
      return
25110 
    iprot.readStructBegin()
25111 
    while True:
25112 
      (fname, ftype, fid) = iprot.readFieldBegin()
25113 
      if ftype == TType.STOP:
25114 
        break
25115 
      if fid == 1:
25116 
        if ftype == TType.I64:
25117 
          self.offset = iprot.readI64();
25118 
        else:
25119 
          iprot.skip(ftype)
25120 
      elif fid == 2:
25121 
        if ftype == TType.I64:
25122 
          self.limit = iprot.readI64();
25123 
        else:
25124 
          iprot.skip(ftype)
25125 
      else:
25126 
        iprot.skip(ftype)
25127 
      iprot.readFieldEnd()
25128 
    iprot.readStructEnd()
25129 
 
25130 
  def write(self, oprot):
25131 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25132 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25133 
      return
25134 
    oprot.writeStructBegin('getAmazonListedItems_args')
25135 
    if self.offset is not None:
25136 
      oprot.writeFieldBegin('offset', TType.I64, 1)
25137 
      oprot.writeI64(self.offset)
25138 
      oprot.writeFieldEnd()
25139 
    if self.limit is not None:
25140 
      oprot.writeFieldBegin('limit', TType.I64, 2)
25141 
      oprot.writeI64(self.limit)
25142 
      oprot.writeFieldEnd()
25143 
    oprot.writeFieldStop()
25144 
    oprot.writeStructEnd()
25145 
 
25146 
  def validate(self):
25147 
    return
25148 
 
25149 
 
25150 
  def __repr__(self):
25151 
    L = ['%s=%r' % (key, value)
25152 
      for key, value in self.__dict__.iteritems()]
25153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25154 
 
25155 
  def __eq__(self, other):
25156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25157 
 
25158 
  def __ne__(self, other):
25159 
    return not (self == other)
25160 
 
25161 
class getAmazonListedItems_result:
25162 
  """
25163 
  Attributes:
25164 
   - success
25165 
  """
25166 
 
25167 
  thrift_spec = (
25168 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
25169 
  )
25170 
 
25171 
  def __init__(self, success=None,):
25172 
    self.success = success
25173 
 
25174 
  def read(self, iprot):
25175 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25176 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25177 
      return
25178 
    iprot.readStructBegin()
25179 
    while True:
25180 
      (fname, ftype, fid) = iprot.readFieldBegin()
25181 
      if ftype == TType.STOP:
25182 
        break
25183 
      if fid == 0:
25184 
        if ftype == TType.LIST:
25185 
          self.success = []
13493 amit.gupta 25186 
          (_etype502, _size499) = iprot.readListBegin()
25187 
          for _i503 in xrange(_size499):
25188 
            _elem504 = Amazonlisted()
25189 
            _elem504.read(iprot)
25190 
            self.success.append(_elem504)
8139 kshitij.so 25191 
          iprot.readListEnd()
25192 
        else:
25193 
          iprot.skip(ftype)
25194 
      else:
25195 
        iprot.skip(ftype)
25196 
      iprot.readFieldEnd()
25197 
    iprot.readStructEnd()
25198 
 
25199 
  def write(self, oprot):
25200 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25201 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25202 
      return
25203 
    oprot.writeStructBegin('getAmazonListedItems_result')
25204 
    if self.success is not None:
25205 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25206 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 25207 
      for iter505 in self.success:
25208 
        iter505.write(oprot)
8139 kshitij.so 25209 
      oprot.writeListEnd()
25210 
      oprot.writeFieldEnd()
25211 
    oprot.writeFieldStop()
25212 
    oprot.writeStructEnd()
25213 
 
25214 
  def validate(self):
25215 
    return
25216 
 
25217 
 
25218 
  def __repr__(self):
25219 
    L = ['%s=%r' % (key, value)
25220 
      for key, value in self.__dict__.iteritems()]
25221 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25222 
 
25223 
  def __eq__(self, other):
25224 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25225 
 
25226 
  def __ne__(self, other):
25227 
    return not (self == other)
8168 kshitij.so 25228 
 
25229 
class updateAmazonAttributesInBulk_args:
25230 
  """
25231 
  Attributes:
25232 
   - amazonlisted
25233 
  """
25234 
 
25235 
  thrift_spec = (
25236 
    None, # 0
25237 
    (1, TType.MAP, 'amazonlisted', (TType.I64,None,TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 1
25238 
  )
25239 
 
25240 
  def __init__(self, amazonlisted=None,):
25241 
    self.amazonlisted = amazonlisted
25242 
 
25243 
  def read(self, iprot):
25244 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25245 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25246 
      return
25247 
    iprot.readStructBegin()
25248 
    while True:
25249 
      (fname, ftype, fid) = iprot.readFieldBegin()
25250 
      if ftype == TType.STOP:
25251 
        break
25252 
      if fid == 1:
25253 
        if ftype == TType.MAP:
25254 
          self.amazonlisted = {}
13493 amit.gupta 25255 
          (_ktype507, _vtype508, _size506 ) = iprot.readMapBegin()
25256 
          for _i510 in xrange(_size506):
25257 
            _key511 = iprot.readI64();
25258 
            _val512 = Amazonlisted()
25259 
            _val512.read(iprot)
25260 
            self.amazonlisted[_key511] = _val512
8168 kshitij.so 25261 
          iprot.readMapEnd()
25262 
        else:
25263 
          iprot.skip(ftype)
25264 
      else:
25265 
        iprot.skip(ftype)
25266 
      iprot.readFieldEnd()
25267 
    iprot.readStructEnd()
25268 
 
25269 
  def write(self, oprot):
25270 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25271 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25272 
      return
25273 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_args')
25274 
    if self.amazonlisted is not None:
25275 
      oprot.writeFieldBegin('amazonlisted', TType.MAP, 1)
25276 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.amazonlisted))
13493 amit.gupta 25277 
      for kiter513,viter514 in self.amazonlisted.items():
25278 
        oprot.writeI64(kiter513)
25279 
        viter514.write(oprot)
8168 kshitij.so 25280 
      oprot.writeMapEnd()
25281 
      oprot.writeFieldEnd()
25282 
    oprot.writeFieldStop()
25283 
    oprot.writeStructEnd()
25284 
 
25285 
  def validate(self):
25286 
    return
25287 
 
25288 
 
25289 
  def __repr__(self):
25290 
    L = ['%s=%r' % (key, value)
25291 
      for key, value in self.__dict__.iteritems()]
25292 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25293 
 
25294 
  def __eq__(self, other):
25295 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25296 
 
25297 
  def __ne__(self, other):
25298 
    return not (self == other)
25299 
 
25300 
class updateAmazonAttributesInBulk_result:
25301 
  """
25302 
  Attributes:
25303 
   - success
25304 
  """
25305 
 
25306 
  thrift_spec = (
25307 
    (0, TType.BOOL, 'success', None, None, ), # 0
25308 
  )
25309 
 
25310 
  def __init__(self, success=None,):
25311 
    self.success = success
25312 
 
25313 
  def read(self, iprot):
25314 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25315 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25316 
      return
25317 
    iprot.readStructBegin()
25318 
    while True:
25319 
      (fname, ftype, fid) = iprot.readFieldBegin()
25320 
      if ftype == TType.STOP:
25321 
        break
25322 
      if fid == 0:
25323 
        if ftype == TType.BOOL:
25324 
          self.success = iprot.readBool();
25325 
        else:
25326 
          iprot.skip(ftype)
25327 
      else:
25328 
        iprot.skip(ftype)
25329 
      iprot.readFieldEnd()
25330 
    iprot.readStructEnd()
25331 
 
25332 
  def write(self, oprot):
25333 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25334 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25335 
      return
25336 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_result')
25337 
    if self.success is not None:
25338 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
25339 
      oprot.writeBool(self.success)
25340 
      oprot.writeFieldEnd()
25341 
    oprot.writeFieldStop()
25342 
    oprot.writeStructEnd()
25343 
 
25344 
  def validate(self):
25345 
    return
25346 
 
25347 
 
25348 
  def __repr__(self):
25349 
    L = ['%s=%r' % (key, value)
25350 
      for key, value in self.__dict__.iteritems()]
25351 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25352 
 
25353 
  def __eq__(self, other):
25354 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25355 
 
25356 
  def __ne__(self, other):
25357 
    return not (self == other)
8379 vikram.rag 25358 
 
25359 
class getAllItemstoListOnFba_args:
25360 
 
25361 
  thrift_spec = (
25362 
  )
25363 
 
25364 
  def read(self, iprot):
25365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25367 
      return
25368 
    iprot.readStructBegin()
25369 
    while True:
25370 
      (fname, ftype, fid) = iprot.readFieldBegin()
25371 
      if ftype == TType.STOP:
25372 
        break
25373 
      else:
25374 
        iprot.skip(ftype)
25375 
      iprot.readFieldEnd()
25376 
    iprot.readStructEnd()
25377 
 
25378 
  def write(self, oprot):
25379 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25380 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25381 
      return
25382 
    oprot.writeStructBegin('getAllItemstoListOnFba_args')
25383 
    oprot.writeFieldStop()
25384 
    oprot.writeStructEnd()
25385 
 
25386 
  def validate(self):
25387 
    return
25388 
 
25389 
 
25390 
  def __repr__(self):
25391 
    L = ['%s=%r' % (key, value)
25392 
      for key, value in self.__dict__.iteritems()]
25393 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25394 
 
25395 
  def __eq__(self, other):
25396 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25397 
 
25398 
  def __ne__(self, other):
25399 
    return not (self == other)
25400 
 
25401 
class getAllItemstoListOnFba_result:
25402 
  """
25403 
  Attributes:
25404 
   - success
25405 
  """
25406 
 
25407 
  thrift_spec = (
25408 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
25409 
  )
25410 
 
25411 
  def __init__(self, success=None,):
25412 
    self.success = success
25413 
 
25414 
  def read(self, iprot):
25415 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25416 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25417 
      return
25418 
    iprot.readStructBegin()
25419 
    while True:
25420 
      (fname, ftype, fid) = iprot.readFieldBegin()
25421 
      if ftype == TType.STOP:
25422 
        break
25423 
      if fid == 0:
25424 
        if ftype == TType.LIST:
25425 
          self.success = []
13493 amit.gupta 25426 
          (_etype518, _size515) = iprot.readListBegin()
25427 
          for _i519 in xrange(_size515):
25428 
            _elem520 = Amazonlisted()
25429 
            _elem520.read(iprot)
25430 
            self.success.append(_elem520)
8379 vikram.rag 25431 
          iprot.readListEnd()
25432 
        else:
25433 
          iprot.skip(ftype)
25434 
      else:
25435 
        iprot.skip(ftype)
25436 
      iprot.readFieldEnd()
25437 
    iprot.readStructEnd()
25438 
 
25439 
  def write(self, oprot):
25440 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25441 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25442 
      return
25443 
    oprot.writeStructBegin('getAllItemstoListOnFba_result')
25444 
    if self.success is not None:
25445 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25446 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 25447 
      for iter521 in self.success:
25448 
        iter521.write(oprot)
8379 vikram.rag 25449 
      oprot.writeListEnd()
25450 
      oprot.writeFieldEnd()
25451 
    oprot.writeFieldStop()
25452 
    oprot.writeStructEnd()
25453 
 
25454 
  def validate(self):
25455 
    return
25456 
 
25457 
 
25458 
  def __repr__(self):
25459 
    L = ['%s=%r' % (key, value)
25460 
      for key, value in self.__dict__.iteritems()]
25461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25462 
 
25463 
  def __eq__(self, other):
25464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25465 
 
25466 
  def __ne__(self, other):
25467 
    return not (self == other)
25468 
 
25469 
class getAllItemstoListOnNonFba_args:
25470 
 
25471 
  thrift_spec = (
25472 
  )
25473 
 
25474 
  def read(self, iprot):
25475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25477 
      return
25478 
    iprot.readStructBegin()
25479 
    while True:
25480 
      (fname, ftype, fid) = iprot.readFieldBegin()
25481 
      if ftype == TType.STOP:
25482 
        break
25483 
      else:
25484 
        iprot.skip(ftype)
25485 
      iprot.readFieldEnd()
25486 
    iprot.readStructEnd()
25487 
 
25488 
  def write(self, oprot):
25489 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25490 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25491 
      return
25492 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_args')
25493 
    oprot.writeFieldStop()
25494 
    oprot.writeStructEnd()
25495 
 
25496 
  def validate(self):
25497 
    return
25498 
 
25499 
 
25500 
  def __repr__(self):
25501 
    L = ['%s=%r' % (key, value)
25502 
      for key, value in self.__dict__.iteritems()]
25503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25504 
 
25505 
  def __eq__(self, other):
25506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25507 
 
25508 
  def __ne__(self, other):
25509 
    return not (self == other)
25510 
 
25511 
class getAllItemstoListOnNonFba_result:
25512 
  """
25513 
  Attributes:
25514 
   - success
25515 
  """
25516 
 
25517 
  thrift_spec = (
25518 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
25519 
  )
25520 
 
25521 
  def __init__(self, success=None,):
25522 
    self.success = success
25523 
 
25524 
  def read(self, iprot):
25525 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25526 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25527 
      return
25528 
    iprot.readStructBegin()
25529 
    while True:
25530 
      (fname, ftype, fid) = iprot.readFieldBegin()
25531 
      if ftype == TType.STOP:
25532 
        break
25533 
      if fid == 0:
25534 
        if ftype == TType.LIST:
25535 
          self.success = []
13493 amit.gupta 25536 
          (_etype525, _size522) = iprot.readListBegin()
25537 
          for _i526 in xrange(_size522):
25538 
            _elem527 = Amazonlisted()
25539 
            _elem527.read(iprot)
25540 
            self.success.append(_elem527)
8379 vikram.rag 25541 
          iprot.readListEnd()
25542 
        else:
25543 
          iprot.skip(ftype)
25544 
      else:
25545 
        iprot.skip(ftype)
25546 
      iprot.readFieldEnd()
25547 
    iprot.readStructEnd()
25548 
 
25549 
  def write(self, oprot):
25550 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25551 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25552 
      return
25553 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_result')
25554 
    if self.success is not None:
25555 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25556 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 25557 
      for iter528 in self.success:
25558 
        iter528.write(oprot)
8379 vikram.rag 25559 
      oprot.writeListEnd()
25560 
      oprot.writeFieldEnd()
25561 
    oprot.writeFieldStop()
25562 
    oprot.writeStructEnd()
25563 
 
25564 
  def validate(self):
25565 
    return
25566 
 
25567 
 
25568 
  def __repr__(self):
25569 
    L = ['%s=%r' % (key, value)
25570 
      for key, value in self.__dict__.iteritems()]
25571 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25572 
 
25573 
  def __eq__(self, other):
25574 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25575 
 
25576 
  def __ne__(self, other):
25577 
    return not (self == other)
8616 vikram.rag 25578 
 
9242 kshitij.so 25579 
class updateAsin_args:
25580 
  """
25581 
  Attributes:
25582 
   - item
25583 
  """
8616 vikram.rag 25584 
 
25585 
  thrift_spec = (
9242 kshitij.so 25586 
    None, # 0
25587 
    (1, TType.MAP, 'item', (TType.I64,None,TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 1
8616 vikram.rag 25588 
  )
25589 
 
9242 kshitij.so 25590 
  def __init__(self, item=None,):
25591 
    self.item = item
25592 
 
8616 vikram.rag 25593 
  def read(self, iprot):
25594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25596 
      return
25597 
    iprot.readStructBegin()
25598 
    while True:
25599 
      (fname, ftype, fid) = iprot.readFieldBegin()
25600 
      if ftype == TType.STOP:
25601 
        break
9242 kshitij.so 25602 
      if fid == 1:
25603 
        if ftype == TType.MAP:
25604 
          self.item = {}
13493 amit.gupta 25605 
          (_ktype530, _vtype531, _size529 ) = iprot.readMapBegin()
25606 
          for _i533 in xrange(_size529):
25607 
            _key534 = iprot.readI64();
25608 
            _val535 = Item()
25609 
            _val535.read(iprot)
25610 
            self.item[_key534] = _val535
9242 kshitij.so 25611 
          iprot.readMapEnd()
25612 
        else:
25613 
          iprot.skip(ftype)
8616 vikram.rag 25614 
      else:
25615 
        iprot.skip(ftype)
25616 
      iprot.readFieldEnd()
25617 
    iprot.readStructEnd()
25618 
 
25619 
  def write(self, oprot):
25620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25622 
      return
9242 kshitij.so 25623 
    oprot.writeStructBegin('updateAsin_args')
25624 
    if self.item is not None:
25625 
      oprot.writeFieldBegin('item', TType.MAP, 1)
25626 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.item))
13493 amit.gupta 25627 
      for kiter536,viter537 in self.item.items():
25628 
        oprot.writeI64(kiter536)
25629 
        viter537.write(oprot)
9242 kshitij.so 25630 
      oprot.writeMapEnd()
25631 
      oprot.writeFieldEnd()
8616 vikram.rag 25632 
    oprot.writeFieldStop()
25633 
    oprot.writeStructEnd()
25634 
 
25635 
  def validate(self):
25636 
    return
25637 
 
25638 
 
25639 
  def __repr__(self):
25640 
    L = ['%s=%r' % (key, value)
25641 
      for key, value in self.__dict__.iteritems()]
25642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25643 
 
25644 
  def __eq__(self, other):
25645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25646 
 
25647 
  def __ne__(self, other):
25648 
    return not (self == other)
25649 
 
9242 kshitij.so 25650 
class updateAsin_result:
8616 vikram.rag 25651 
 
25652 
  thrift_spec = (
25653 
  )
25654 
 
25655 
  def read(self, iprot):
25656 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25657 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25658 
      return
25659 
    iprot.readStructBegin()
25660 
    while True:
25661 
      (fname, ftype, fid) = iprot.readFieldBegin()
25662 
      if ftype == TType.STOP:
25663 
        break
25664 
      else:
25665 
        iprot.skip(ftype)
25666 
      iprot.readFieldEnd()
25667 
    iprot.readStructEnd()
25668 
 
25669 
  def write(self, oprot):
25670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25672 
      return
9242 kshitij.so 25673 
    oprot.writeStructBegin('updateAsin_result')
8616 vikram.rag 25674 
    oprot.writeFieldStop()
25675 
    oprot.writeStructEnd()
25676 
 
25677 
  def validate(self):
25678 
    return
25679 
 
25680 
 
25681 
  def __repr__(self):
25682 
    L = ['%s=%r' % (key, value)
25683 
      for key, value in self.__dict__.iteritems()]
25684 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25685 
 
25686 
  def __eq__(self, other):
25687 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25688 
 
25689 
  def __ne__(self, other):
25690 
    return not (self == other)
8619 kshitij.so 25691 
 
9242 kshitij.so 25692 
class addOrUpdateSnapdealItem_args:
8619 kshitij.so 25693 
  """
25694 
  Attributes:
9242 kshitij.so 25695 
   - snapdealitem
8619 kshitij.so 25696 
  """
25697 
 
9242 kshitij.so 25698 
  thrift_spec = None
25699 
  def __init__(self, snapdealitem=None,):
25700 
    self.snapdealitem = snapdealitem
8619 kshitij.so 25701 
 
25702 
  def read(self, iprot):
25703 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25704 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25705 
      return
25706 
    iprot.readStructBegin()
25707 
    while True:
25708 
      (fname, ftype, fid) = iprot.readFieldBegin()
25709 
      if ftype == TType.STOP:
25710 
        break
9242 kshitij.so 25711 
      if fid == -1:
25712 
        if ftype == TType.STRUCT:
25713 
          self.snapdealitem = SnapdealItem()
25714 
          self.snapdealitem.read(iprot)
8619 kshitij.so 25715 
        else:
25716 
          iprot.skip(ftype)
25717 
      else:
25718 
        iprot.skip(ftype)
25719 
      iprot.readFieldEnd()
25720 
    iprot.readStructEnd()
25721 
 
25722 
  def write(self, oprot):
25723 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25724 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25725 
      return
9242 kshitij.so 25726 
    oprot.writeStructBegin('addOrUpdateSnapdealItem_args')
25727 
    if self.snapdealitem is not None:
25728 
      oprot.writeFieldBegin('snapdealitem', TType.STRUCT, -1)
25729 
      self.snapdealitem.write(oprot)
8619 kshitij.so 25730 
      oprot.writeFieldEnd()
25731 
    oprot.writeFieldStop()
25732 
    oprot.writeStructEnd()
25733 
 
25734 
  def validate(self):
25735 
    return
25736 
 
25737 
 
25738 
  def __repr__(self):
25739 
    L = ['%s=%r' % (key, value)
25740 
      for key, value in self.__dict__.iteritems()]
25741 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25742 
 
25743 
  def __eq__(self, other):
25744 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25745 
 
25746 
  def __ne__(self, other):
25747 
    return not (self == other)
25748 
 
9242 kshitij.so 25749 
class addOrUpdateSnapdealItem_result:
25750 
  """
25751 
  Attributes:
25752 
   - success
25753 
  """
8619 kshitij.so 25754 
 
25755 
  thrift_spec = (
9242 kshitij.so 25756 
    (0, TType.BOOL, 'success', None, None, ), # 0
8619 kshitij.so 25757 
  )
25758 
 
9242 kshitij.so 25759 
  def __init__(self, success=None,):
25760 
    self.success = success
25761 
 
8619 kshitij.so 25762 
  def read(self, iprot):
25763 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25764 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25765 
      return
25766 
    iprot.readStructBegin()
25767 
    while True:
25768 
      (fname, ftype, fid) = iprot.readFieldBegin()
25769 
      if ftype == TType.STOP:
25770 
        break
9242 kshitij.so 25771 
      if fid == 0:
25772 
        if ftype == TType.BOOL:
25773 
          self.success = iprot.readBool();
25774 
        else:
25775 
          iprot.skip(ftype)
8619 kshitij.so 25776 
      else:
25777 
        iprot.skip(ftype)
25778 
      iprot.readFieldEnd()
25779 
    iprot.readStructEnd()
25780 
 
25781 
  def write(self, oprot):
25782 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25783 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25784 
      return
9242 kshitij.so 25785 
    oprot.writeStructBegin('addOrUpdateSnapdealItem_result')
25786 
    if self.success is not None:
25787 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
25788 
      oprot.writeBool(self.success)
25789 
      oprot.writeFieldEnd()
8619 kshitij.so 25790 
    oprot.writeFieldStop()
25791 
    oprot.writeStructEnd()
25792 
 
25793 
  def validate(self):
25794 
    return
25795 
 
25796 
 
25797 
  def __repr__(self):
25798 
    L = ['%s=%r' % (key, value)
25799 
      for key, value in self.__dict__.iteritems()]
25800 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25801 
 
25802 
  def __eq__(self, other):
25803 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25804 
 
25805 
  def __ne__(self, other):
25806 
    return not (self == other)
8739 vikram.rag 25807 
 
9242 kshitij.so 25808 
class getSnapdealItem_args:
8739 vikram.rag 25809 
  """
25810 
  Attributes:
9242 kshitij.so 25811 
   - item_id
8739 vikram.rag 25812 
  """
25813 
 
9242 kshitij.so 25814 
  thrift_spec = (
25815 
    None, # 0
25816 
    (1, TType.I64, 'item_id', None, None, ), # 1
25817 
  )
8739 vikram.rag 25818 
 
9242 kshitij.so 25819 
  def __init__(self, item_id=None,):
25820 
    self.item_id = item_id
25821 
 
8739 vikram.rag 25822 
  def read(self, iprot):
25823 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25824 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25825 
      return
25826 
    iprot.readStructBegin()
25827 
    while True:
25828 
      (fname, ftype, fid) = iprot.readFieldBegin()
25829 
      if ftype == TType.STOP:
25830 
        break
9242 kshitij.so 25831 
      if fid == 1:
25832 
        if ftype == TType.I64:
25833 
          self.item_id = iprot.readI64();
8739 vikram.rag 25834 
        else:
25835 
          iprot.skip(ftype)
25836 
      else:
25837 
        iprot.skip(ftype)
25838 
      iprot.readFieldEnd()
25839 
    iprot.readStructEnd()
25840 
 
25841 
  def write(self, oprot):
25842 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25843 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25844 
      return
9242 kshitij.so 25845 
    oprot.writeStructBegin('getSnapdealItem_args')
25846 
    if self.item_id is not None:
25847 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
25848 
      oprot.writeI64(self.item_id)
8739 vikram.rag 25849 
      oprot.writeFieldEnd()
25850 
    oprot.writeFieldStop()
25851 
    oprot.writeStructEnd()
25852 
 
25853 
  def validate(self):
25854 
    return
25855 
 
25856 
 
25857 
  def __repr__(self):
25858 
    L = ['%s=%r' % (key, value)
25859 
      for key, value in self.__dict__.iteritems()]
25860 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25861 
 
25862 
  def __eq__(self, other):
25863 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25864 
 
25865 
  def __ne__(self, other):
25866 
    return not (self == other)
25867 
 
9242 kshitij.so 25868 
class getSnapdealItem_result:
8739 vikram.rag 25869 
  """
25870 
  Attributes:
25871 
   - success
25872 
  """
25873 
 
25874 
  thrift_spec = (
9242 kshitij.so 25875 
    (0, TType.STRUCT, 'success', (SnapdealItem, SnapdealItem.thrift_spec), None, ), # 0
8739 vikram.rag 25876 
  )
25877 
 
25878 
  def __init__(self, success=None,):
25879 
    self.success = success
25880 
 
25881 
  def read(self, iprot):
25882 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25883 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25884 
      return
25885 
    iprot.readStructBegin()
25886 
    while True:
25887 
      (fname, ftype, fid) = iprot.readFieldBegin()
25888 
      if ftype == TType.STOP:
25889 
        break
25890 
      if fid == 0:
9242 kshitij.so 25891 
        if ftype == TType.STRUCT:
25892 
          self.success = SnapdealItem()
25893 
          self.success.read(iprot)
8739 vikram.rag 25894 
        else:
25895 
          iprot.skip(ftype)
25896 
      else:
25897 
        iprot.skip(ftype)
25898 
      iprot.readFieldEnd()
25899 
    iprot.readStructEnd()
25900 
 
25901 
  def write(self, oprot):
25902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25904 
      return
9242 kshitij.so 25905 
    oprot.writeStructBegin('getSnapdealItem_result')
8739 vikram.rag 25906 
    if self.success is not None:
9242 kshitij.so 25907 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
25908 
      self.success.write(oprot)
8739 vikram.rag 25909 
      oprot.writeFieldEnd()
25910 
    oprot.writeFieldStop()
25911 
    oprot.writeStructEnd()
25912 
 
25913 
  def validate(self):
25914 
    return
25915 
 
25916 
 
25917 
  def __repr__(self):
25918 
    L = ['%s=%r' % (key, value)
25919 
      for key, value in self.__dict__.iteritems()]
25920 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25921 
 
25922 
  def __eq__(self, other):
25923 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25924 
 
25925 
  def __ne__(self, other):
25926 
    return not (self == other)
25927 
 
9242 kshitij.so 25928 
class getSnapdealItemDetails_args:
8739 vikram.rag 25929 
  """
25930 
  Attributes:
25931 
   - item_id
25932 
  """
25933 
 
25934 
  thrift_spec = (
25935 
    None, # 0
25936 
    (1, TType.I64, 'item_id', None, None, ), # 1
25937 
  )
25938 
 
25939 
  def __init__(self, item_id=None,):
25940 
    self.item_id = item_id
25941 
 
25942 
  def read(self, iprot):
25943 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25944 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25945 
      return
25946 
    iprot.readStructBegin()
25947 
    while True:
25948 
      (fname, ftype, fid) = iprot.readFieldBegin()
25949 
      if ftype == TType.STOP:
25950 
        break
25951 
      if fid == 1:
25952 
        if ftype == TType.I64:
25953 
          self.item_id = iprot.readI64();
25954 
        else:
25955 
          iprot.skip(ftype)
25956 
      else:
25957 
        iprot.skip(ftype)
25958 
      iprot.readFieldEnd()
25959 
    iprot.readStructEnd()
25960 
 
25961 
  def write(self, oprot):
25962 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25963 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25964 
      return
9242 kshitij.so 25965 
    oprot.writeStructBegin('getSnapdealItemDetails_args')
8739 vikram.rag 25966 
    if self.item_id is not None:
25967 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
25968 
      oprot.writeI64(self.item_id)
25969 
      oprot.writeFieldEnd()
25970 
    oprot.writeFieldStop()
25971 
    oprot.writeStructEnd()
25972 
 
25973 
  def validate(self):
25974 
    return
25975 
 
25976 
 
25977 
  def __repr__(self):
25978 
    L = ['%s=%r' % (key, value)
25979 
      for key, value in self.__dict__.iteritems()]
25980 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25981 
 
25982 
  def __eq__(self, other):
25983 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25984 
 
25985 
  def __ne__(self, other):
25986 
    return not (self == other)
25987 
 
9242 kshitij.so 25988 
class getSnapdealItemDetails_result:
8739 vikram.rag 25989 
  """
25990 
  Attributes:
25991 
   - success
25992 
  """
25993 
 
25994 
  thrift_spec = (
9242 kshitij.so 25995 
    (0, TType.STRUCT, 'success', (SnapdealItemDetails, SnapdealItemDetails.thrift_spec), None, ), # 0
8739 vikram.rag 25996 
  )
25997 
 
25998 
  def __init__(self, success=None,):
25999 
    self.success = success
26000 
 
26001 
  def read(self, iprot):
26002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26004 
      return
26005 
    iprot.readStructBegin()
26006 
    while True:
26007 
      (fname, ftype, fid) = iprot.readFieldBegin()
26008 
      if ftype == TType.STOP:
26009 
        break
26010 
      if fid == 0:
26011 
        if ftype == TType.STRUCT:
9242 kshitij.so 26012 
          self.success = SnapdealItemDetails()
8739 vikram.rag 26013 
          self.success.read(iprot)
26014 
        else:
26015 
          iprot.skip(ftype)
26016 
      else:
26017 
        iprot.skip(ftype)
26018 
      iprot.readFieldEnd()
26019 
    iprot.readStructEnd()
26020 
 
26021 
  def write(self, oprot):
26022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26024 
      return
9242 kshitij.so 26025 
    oprot.writeStructBegin('getSnapdealItemDetails_result')
8739 vikram.rag 26026 
    if self.success is not None:
26027 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26028 
      self.success.write(oprot)
26029 
      oprot.writeFieldEnd()
26030 
    oprot.writeFieldStop()
26031 
    oprot.writeStructEnd()
26032 
 
26033 
  def validate(self):
26034 
    return
26035 
 
26036 
 
26037 
  def __repr__(self):
26038 
    L = ['%s=%r' % (key, value)
26039 
      for key, value in self.__dict__.iteritems()]
26040 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26041 
 
26042 
  def __eq__(self, other):
26043 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26044 
 
26045 
  def __ne__(self, other):
26046 
    return not (self == other)
26047 
 
26048 
class getAllSnapdealItems_args:
26049 
 
26050 
  thrift_spec = (
26051 
  )
26052 
 
26053 
  def read(self, iprot):
26054 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26055 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26056 
      return
26057 
    iprot.readStructBegin()
26058 
    while True:
26059 
      (fname, ftype, fid) = iprot.readFieldBegin()
26060 
      if ftype == TType.STOP:
26061 
        break
26062 
      else:
26063 
        iprot.skip(ftype)
26064 
      iprot.readFieldEnd()
26065 
    iprot.readStructEnd()
26066 
 
26067 
  def write(self, oprot):
26068 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26069 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26070 
      return
26071 
    oprot.writeStructBegin('getAllSnapdealItems_args')
26072 
    oprot.writeFieldStop()
26073 
    oprot.writeStructEnd()
26074 
 
26075 
  def validate(self):
26076 
    return
26077 
 
26078 
 
26079 
  def __repr__(self):
26080 
    L = ['%s=%r' % (key, value)
26081 
      for key, value in self.__dict__.iteritems()]
26082 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26083 
 
26084 
  def __eq__(self, other):
26085 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26086 
 
26087 
  def __ne__(self, other):
26088 
    return not (self == other)
26089 
 
26090 
class getAllSnapdealItems_result:
26091 
  """
26092 
  Attributes:
26093 
   - success
26094 
  """
26095 
 
26096 
  thrift_spec = (
9242 kshitij.so 26097 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
8739 vikram.rag 26098 
  )
26099 
 
26100 
  def __init__(self, success=None,):
26101 
    self.success = success
26102 
 
26103 
  def read(self, iprot):
26104 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26105 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26106 
      return
26107 
    iprot.readStructBegin()
26108 
    while True:
26109 
      (fname, ftype, fid) = iprot.readFieldBegin()
26110 
      if ftype == TType.STOP:
26111 
        break
26112 
      if fid == 0:
26113 
        if ftype == TType.LIST:
26114 
          self.success = []
13493 amit.gupta 26115 
          (_etype541, _size538) = iprot.readListBegin()
26116 
          for _i542 in xrange(_size538):
26117 
            _elem543 = SnapdealItemDetails()
26118 
            _elem543.read(iprot)
26119 
            self.success.append(_elem543)
9242 kshitij.so 26120 
          iprot.readListEnd()
26121 
        else:
26122 
          iprot.skip(ftype)
26123 
      else:
26124 
        iprot.skip(ftype)
26125 
      iprot.readFieldEnd()
26126 
    iprot.readStructEnd()
26127 
 
26128 
  def write(self, oprot):
26129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26131 
      return
26132 
    oprot.writeStructBegin('getAllSnapdealItems_result')
26133 
    if self.success is not None:
26134 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26135 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 26136 
      for iter544 in self.success:
26137 
        iter544.write(oprot)
9242 kshitij.so 26138 
      oprot.writeListEnd()
26139 
      oprot.writeFieldEnd()
26140 
    oprot.writeFieldStop()
26141 
    oprot.writeStructEnd()
26142 
 
26143 
  def validate(self):
26144 
    return
26145 
 
26146 
 
26147 
  def __repr__(self):
26148 
    L = ['%s=%r' % (key, value)
26149 
      for key, value in self.__dict__.iteritems()]
26150 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26151 
 
26152 
  def __eq__(self, other):
26153 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26154 
 
26155 
  def __ne__(self, other):
26156 
    return not (self == other)
26157 
 
26158 
class getSnapdealItems_args:
26159 
  """
26160 
  Attributes:
26161 
   - offset
26162 
   - limit
26163 
  """
26164 
 
26165 
  thrift_spec = (
26166 
    None, # 0
26167 
    (1, TType.I64, 'offset', None, None, ), # 1
26168 
    (2, TType.I64, 'limit', None, None, ), # 2
26169 
  )
26170 
 
26171 
  def __init__(self, offset=None, limit=None,):
26172 
    self.offset = offset
26173 
    self.limit = limit
26174 
 
26175 
  def read(self, iprot):
26176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26178 
      return
26179 
    iprot.readStructBegin()
26180 
    while True:
26181 
      (fname, ftype, fid) = iprot.readFieldBegin()
26182 
      if ftype == TType.STOP:
26183 
        break
26184 
      if fid == 1:
26185 
        if ftype == TType.I64:
26186 
          self.offset = iprot.readI64();
26187 
        else:
26188 
          iprot.skip(ftype)
26189 
      elif fid == 2:
26190 
        if ftype == TType.I64:
26191 
          self.limit = iprot.readI64();
26192 
        else:
26193 
          iprot.skip(ftype)
26194 
      else:
26195 
        iprot.skip(ftype)
26196 
      iprot.readFieldEnd()
26197 
    iprot.readStructEnd()
26198 
 
26199 
  def write(self, oprot):
26200 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26201 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26202 
      return
26203 
    oprot.writeStructBegin('getSnapdealItems_args')
26204 
    if self.offset is not None:
26205 
      oprot.writeFieldBegin('offset', TType.I64, 1)
26206 
      oprot.writeI64(self.offset)
26207 
      oprot.writeFieldEnd()
26208 
    if self.limit is not None:
26209 
      oprot.writeFieldBegin('limit', TType.I64, 2)
26210 
      oprot.writeI64(self.limit)
26211 
      oprot.writeFieldEnd()
26212 
    oprot.writeFieldStop()
26213 
    oprot.writeStructEnd()
26214 
 
26215 
  def validate(self):
26216 
    return
26217 
 
26218 
 
26219 
  def __repr__(self):
26220 
    L = ['%s=%r' % (key, value)
26221 
      for key, value in self.__dict__.iteritems()]
26222 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26223 
 
26224 
  def __eq__(self, other):
26225 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26226 
 
26227 
  def __ne__(self, other):
26228 
    return not (self == other)
26229 
 
26230 
class getSnapdealItems_result:
26231 
  """
26232 
  Attributes:
26233 
   - success
26234 
  """
26235 
 
26236 
  thrift_spec = (
26237 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
26238 
  )
26239 
 
26240 
  def __init__(self, success=None,):
26241 
    self.success = success
26242 
 
26243 
  def read(self, iprot):
26244 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26245 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26246 
      return
26247 
    iprot.readStructBegin()
26248 
    while True:
26249 
      (fname, ftype, fid) = iprot.readFieldBegin()
26250 
      if ftype == TType.STOP:
26251 
        break
26252 
      if fid == 0:
26253 
        if ftype == TType.LIST:
26254 
          self.success = []
13493 amit.gupta 26255 
          (_etype548, _size545) = iprot.readListBegin()
26256 
          for _i549 in xrange(_size545):
26257 
            _elem550 = SnapdealItemDetails()
26258 
            _elem550.read(iprot)
26259 
            self.success.append(_elem550)
8739 vikram.rag 26260 
          iprot.readListEnd()
26261 
        else:
26262 
          iprot.skip(ftype)
26263 
      else:
26264 
        iprot.skip(ftype)
26265 
      iprot.readFieldEnd()
26266 
    iprot.readStructEnd()
26267 
 
26268 
  def write(self, oprot):
26269 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26270 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26271 
      return
9242 kshitij.so 26272 
    oprot.writeStructBegin('getSnapdealItems_result')
8739 vikram.rag 26273 
    if self.success is not None:
26274 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26275 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 26276 
      for iter551 in self.success:
26277 
        iter551.write(oprot)
8739 vikram.rag 26278 
      oprot.writeListEnd()
26279 
      oprot.writeFieldEnd()
26280 
    oprot.writeFieldStop()
26281 
    oprot.writeStructEnd()
26282 
 
26283 
  def validate(self):
26284 
    return
26285 
 
26286 
 
26287 
  def __repr__(self):
26288 
    L = ['%s=%r' % (key, value)
26289 
      for key, value in self.__dict__.iteritems()]
26290 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26291 
 
26292 
  def __eq__(self, other):
26293 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26294 
 
26295 
  def __ne__(self, other):
26296 
    return not (self == other)
9242 kshitij.so 26297 
 
26298 
class searchSnapdealItems_args:
26299 
  """
26300 
  Attributes:
26301 
   - searchTerm
26302 
   - offset
26303 
   - limit
26304 
  """
26305 
 
26306 
  thrift_spec = (
26307 
    None, # 0
26308 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
26309 
    (2, TType.I64, 'offset', None, None, ), # 2
26310 
    (3, TType.I64, 'limit', None, None, ), # 3
26311 
  )
26312 
 
26313 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
26314 
    self.searchTerm = searchTerm
26315 
    self.offset = offset
26316 
    self.limit = limit
26317 
 
26318 
  def read(self, iprot):
26319 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26320 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26321 
      return
26322 
    iprot.readStructBegin()
26323 
    while True:
26324 
      (fname, ftype, fid) = iprot.readFieldBegin()
26325 
      if ftype == TType.STOP:
26326 
        break
26327 
      if fid == 1:
26328 
        if ftype == TType.LIST:
26329 
          self.searchTerm = []
13493 amit.gupta 26330 
          (_etype555, _size552) = iprot.readListBegin()
26331 
          for _i556 in xrange(_size552):
26332 
            _elem557 = iprot.readString();
26333 
            self.searchTerm.append(_elem557)
9242 kshitij.so 26334 
          iprot.readListEnd()
26335 
        else:
26336 
          iprot.skip(ftype)
26337 
      elif fid == 2:
26338 
        if ftype == TType.I64:
26339 
          self.offset = iprot.readI64();
26340 
        else:
26341 
          iprot.skip(ftype)
26342 
      elif fid == 3:
26343 
        if ftype == TType.I64:
26344 
          self.limit = iprot.readI64();
26345 
        else:
26346 
          iprot.skip(ftype)
26347 
      else:
26348 
        iprot.skip(ftype)
26349 
      iprot.readFieldEnd()
26350 
    iprot.readStructEnd()
26351 
 
26352 
  def write(self, oprot):
26353 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26354 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26355 
      return
26356 
    oprot.writeStructBegin('searchSnapdealItems_args')
26357 
    if self.searchTerm is not None:
26358 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
26359 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
13493 amit.gupta 26360 
      for iter558 in self.searchTerm:
26361 
        oprot.writeString(iter558)
9242 kshitij.so 26362 
      oprot.writeListEnd()
26363 
      oprot.writeFieldEnd()
26364 
    if self.offset is not None:
26365 
      oprot.writeFieldBegin('offset', TType.I64, 2)
26366 
      oprot.writeI64(self.offset)
26367 
      oprot.writeFieldEnd()
26368 
    if self.limit is not None:
26369 
      oprot.writeFieldBegin('limit', TType.I64, 3)
26370 
      oprot.writeI64(self.limit)
26371 
      oprot.writeFieldEnd()
26372 
    oprot.writeFieldStop()
26373 
    oprot.writeStructEnd()
26374 
 
26375 
  def validate(self):
26376 
    return
26377 
 
26378 
 
26379 
  def __repr__(self):
26380 
    L = ['%s=%r' % (key, value)
26381 
      for key, value in self.__dict__.iteritems()]
26382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26383 
 
26384 
  def __eq__(self, other):
26385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26386 
 
26387 
  def __ne__(self, other):
26388 
    return not (self == other)
26389 
 
26390 
class searchSnapdealItems_result:
26391 
  """
26392 
  Attributes:
26393 
   - success
26394 
  """
26395 
 
26396 
  thrift_spec = (
26397 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
26398 
  )
26399 
 
26400 
  def __init__(self, success=None,):
26401 
    self.success = success
26402 
 
26403 
  def read(self, iprot):
26404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26406 
      return
26407 
    iprot.readStructBegin()
26408 
    while True:
26409 
      (fname, ftype, fid) = iprot.readFieldBegin()
26410 
      if ftype == TType.STOP:
26411 
        break
26412 
      if fid == 0:
26413 
        if ftype == TType.LIST:
26414 
          self.success = []
13493 amit.gupta 26415 
          (_etype562, _size559) = iprot.readListBegin()
26416 
          for _i563 in xrange(_size559):
26417 
            _elem564 = SnapdealItemDetails()
26418 
            _elem564.read(iprot)
26419 
            self.success.append(_elem564)
9242 kshitij.so 26420 
          iprot.readListEnd()
26421 
        else:
26422 
          iprot.skip(ftype)
26423 
      else:
26424 
        iprot.skip(ftype)
26425 
      iprot.readFieldEnd()
26426 
    iprot.readStructEnd()
26427 
 
26428 
  def write(self, oprot):
26429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26431 
      return
26432 
    oprot.writeStructBegin('searchSnapdealItems_result')
26433 
    if self.success is not None:
26434 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26435 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 26436 
      for iter565 in self.success:
26437 
        iter565.write(oprot)
9242 kshitij.so 26438 
      oprot.writeListEnd()
26439 
      oprot.writeFieldEnd()
26440 
    oprot.writeFieldStop()
26441 
    oprot.writeStructEnd()
26442 
 
26443 
  def validate(self):
26444 
    return
26445 
 
26446 
 
26447 
  def __repr__(self):
26448 
    L = ['%s=%r' % (key, value)
26449 
      for key, value in self.__dict__.iteritems()]
26450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26451 
 
26452 
  def __eq__(self, other):
26453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26454 
 
26455 
  def __ne__(self, other):
26456 
    return not (self == other)
26457 
 
26458 
class getCountForSnapdealItems_args:
26459 
 
26460 
  thrift_spec = (
26461 
  )
26462 
 
26463 
  def read(self, iprot):
26464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26466 
      return
26467 
    iprot.readStructBegin()
26468 
    while True:
26469 
      (fname, ftype, fid) = iprot.readFieldBegin()
26470 
      if ftype == TType.STOP:
26471 
        break
26472 
      else:
26473 
        iprot.skip(ftype)
26474 
      iprot.readFieldEnd()
26475 
    iprot.readStructEnd()
26476 
 
26477 
  def write(self, oprot):
26478 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26479 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26480 
      return
26481 
    oprot.writeStructBegin('getCountForSnapdealItems_args')
26482 
    oprot.writeFieldStop()
26483 
    oprot.writeStructEnd()
26484 
 
26485 
  def validate(self):
26486 
    return
26487 
 
26488 
 
26489 
  def __repr__(self):
26490 
    L = ['%s=%r' % (key, value)
26491 
      for key, value in self.__dict__.iteritems()]
26492 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26493 
 
26494 
  def __eq__(self, other):
26495 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26496 
 
26497 
  def __ne__(self, other):
26498 
    return not (self == other)
26499 
 
26500 
class getCountForSnapdealItems_result:
26501 
  """
26502 
  Attributes:
26503 
   - success
26504 
  """
26505 
 
26506 
  thrift_spec = (
26507 
    (0, TType.I64, 'success', None, None, ), # 0
26508 
  )
26509 
 
26510 
  def __init__(self, success=None,):
26511 
    self.success = success
26512 
 
26513 
  def read(self, iprot):
26514 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26515 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26516 
      return
26517 
    iprot.readStructBegin()
26518 
    while True:
26519 
      (fname, ftype, fid) = iprot.readFieldBegin()
26520 
      if ftype == TType.STOP:
26521 
        break
26522 
      if fid == 0:
26523 
        if ftype == TType.I64:
26524 
          self.success = iprot.readI64();
26525 
        else:
26526 
          iprot.skip(ftype)
26527 
      else:
26528 
        iprot.skip(ftype)
26529 
      iprot.readFieldEnd()
26530 
    iprot.readStructEnd()
26531 
 
26532 
  def write(self, oprot):
26533 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26534 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26535 
      return
26536 
    oprot.writeStructBegin('getCountForSnapdealItems_result')
26537 
    if self.success is not None:
26538 
      oprot.writeFieldBegin('success', TType.I64, 0)
26539 
      oprot.writeI64(self.success)
26540 
      oprot.writeFieldEnd()
26541 
    oprot.writeFieldStop()
26542 
    oprot.writeStructEnd()
26543 
 
26544 
  def validate(self):
26545 
    return
26546 
 
26547 
 
26548 
  def __repr__(self):
26549 
    L = ['%s=%r' % (key, value)
26550 
      for key, value in self.__dict__.iteritems()]
26551 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26552 
 
26553 
  def __eq__(self, other):
26554 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26555 
 
26556 
  def __ne__(self, other):
26557 
    return not (self == other)
26558 
 
26559 
class getSnapdealSearchResultCount_args:
26560 
  """
26561 
  Attributes:
26562 
   - searchTerm
26563 
  """
26564 
 
26565 
  thrift_spec = (
26566 
    None, # 0
26567 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
26568 
  )
26569 
 
26570 
  def __init__(self, searchTerm=None,):
26571 
    self.searchTerm = searchTerm
26572 
 
26573 
  def read(self, iprot):
26574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26576 
      return
26577 
    iprot.readStructBegin()
26578 
    while True:
26579 
      (fname, ftype, fid) = iprot.readFieldBegin()
26580 
      if ftype == TType.STOP:
26581 
        break
26582 
      if fid == 1:
26583 
        if ftype == TType.LIST:
26584 
          self.searchTerm = []
13493 amit.gupta 26585 
          (_etype569, _size566) = iprot.readListBegin()
26586 
          for _i570 in xrange(_size566):
26587 
            _elem571 = iprot.readString();
26588 
            self.searchTerm.append(_elem571)
9242 kshitij.so 26589 
          iprot.readListEnd()
26590 
        else:
26591 
          iprot.skip(ftype)
26592 
      else:
26593 
        iprot.skip(ftype)
26594 
      iprot.readFieldEnd()
26595 
    iprot.readStructEnd()
26596 
 
26597 
  def write(self, oprot):
26598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26600 
      return
26601 
    oprot.writeStructBegin('getSnapdealSearchResultCount_args')
26602 
    if self.searchTerm is not None:
26603 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
26604 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
13493 amit.gupta 26605 
      for iter572 in self.searchTerm:
26606 
        oprot.writeString(iter572)
9242 kshitij.so 26607 
      oprot.writeListEnd()
26608 
      oprot.writeFieldEnd()
26609 
    oprot.writeFieldStop()
26610 
    oprot.writeStructEnd()
26611 
 
26612 
  def validate(self):
26613 
    return
26614 
 
26615 
 
26616 
  def __repr__(self):
26617 
    L = ['%s=%r' % (key, value)
26618 
      for key, value in self.__dict__.iteritems()]
26619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26620 
 
26621 
  def __eq__(self, other):
26622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26623 
 
26624 
  def __ne__(self, other):
26625 
    return not (self == other)
26626 
 
26627 
class getSnapdealSearchResultCount_result:
26628 
  """
26629 
  Attributes:
26630 
   - success
26631 
  """
26632 
 
26633 
  thrift_spec = (
26634 
    (0, TType.I64, 'success', None, None, ), # 0
26635 
  )
26636 
 
26637 
  def __init__(self, success=None,):
26638 
    self.success = success
26639 
 
26640 
  def read(self, iprot):
26641 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26642 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26643 
      return
26644 
    iprot.readStructBegin()
26645 
    while True:
26646 
      (fname, ftype, fid) = iprot.readFieldBegin()
26647 
      if ftype == TType.STOP:
26648 
        break
26649 
      if fid == 0:
26650 
        if ftype == TType.I64:
26651 
          self.success = iprot.readI64();
26652 
        else:
26653 
          iprot.skip(ftype)
26654 
      else:
26655 
        iprot.skip(ftype)
26656 
      iprot.readFieldEnd()
26657 
    iprot.readStructEnd()
26658 
 
26659 
  def write(self, oprot):
26660 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26661 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26662 
      return
26663 
    oprot.writeStructBegin('getSnapdealSearchResultCount_result')
26664 
    if self.success is not None:
26665 
      oprot.writeFieldBegin('success', TType.I64, 0)
26666 
      oprot.writeI64(self.success)
26667 
      oprot.writeFieldEnd()
26668 
    oprot.writeFieldStop()
26669 
    oprot.writeStructEnd()
26670 
 
26671 
  def validate(self):
26672 
    return
26673 
 
26674 
 
26675 
  def __repr__(self):
26676 
    L = ['%s=%r' % (key, value)
26677 
      for key, value in self.__dict__.iteritems()]
26678 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26679 
 
26680 
  def __eq__(self, other):
26681 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26682 
 
26683 
  def __ne__(self, other):
26684 
    return not (self == other)
9299 kshitij.so 26685 
 
26686 
class getPrefferedInsurerForItem_args:
26687 
  """
26688 
  Attributes:
26689 
   - itemId
26690 
   - insurerType
26691 
  """
26692 
 
26693 
  thrift_spec = (
26694 
    None, # 0
26695 
    (1, TType.I64, 'itemId', None, None, ), # 1
26696 
    (2, TType.I32, 'insurerType', None, None, ), # 2
26697 
  )
26698 
 
26699 
  def __init__(self, itemId=None, insurerType=None,):
26700 
    self.itemId = itemId
26701 
    self.insurerType = insurerType
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.I64:
26714 
          self.itemId = iprot.readI64();
26715 
        else:
26716 
          iprot.skip(ftype)
26717 
      elif fid == 2:
26718 
        if ftype == TType.I32:
26719 
          self.insurerType = iprot.readI32();
26720 
        else:
26721 
          iprot.skip(ftype)
26722 
      else:
26723 
        iprot.skip(ftype)
26724 
      iprot.readFieldEnd()
26725 
    iprot.readStructEnd()
26726 
 
26727 
  def write(self, oprot):
26728 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26729 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26730 
      return
26731 
    oprot.writeStructBegin('getPrefferedInsurerForItem_args')
26732 
    if self.itemId is not None:
26733 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
26734 
      oprot.writeI64(self.itemId)
26735 
      oprot.writeFieldEnd()
26736 
    if self.insurerType is not None:
26737 
      oprot.writeFieldBegin('insurerType', TType.I32, 2)
26738 
      oprot.writeI32(self.insurerType)
26739 
      oprot.writeFieldEnd()
26740 
    oprot.writeFieldStop()
26741 
    oprot.writeStructEnd()
26742 
 
26743 
  def validate(self):
26744 
    return
26745 
 
26746 
 
26747 
  def __repr__(self):
26748 
    L = ['%s=%r' % (key, value)
26749 
      for key, value in self.__dict__.iteritems()]
26750 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26751 
 
26752 
  def __eq__(self, other):
26753 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26754 
 
26755 
  def __ne__(self, other):
26756 
    return not (self == other)
26757 
 
26758 
class getPrefferedInsurerForItem_result:
26759 
  """
26760 
  Attributes:
26761 
   - success
26762 
  """
26763 
 
26764 
  thrift_spec = (
26765 
    (0, TType.I64, 'success', None, None, ), # 0
26766 
  )
26767 
 
26768 
  def __init__(self, success=None,):
26769 
    self.success = success
26770 
 
26771 
  def read(self, iprot):
26772 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26773 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26774 
      return
26775 
    iprot.readStructBegin()
26776 
    while True:
26777 
      (fname, ftype, fid) = iprot.readFieldBegin()
26778 
      if ftype == TType.STOP:
26779 
        break
26780 
      if fid == 0:
26781 
        if ftype == TType.I64:
26782 
          self.success = iprot.readI64();
26783 
        else:
26784 
          iprot.skip(ftype)
26785 
      else:
26786 
        iprot.skip(ftype)
26787 
      iprot.readFieldEnd()
26788 
    iprot.readStructEnd()
26789 
 
26790 
  def write(self, oprot):
26791 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26792 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26793 
      return
26794 
    oprot.writeStructBegin('getPrefferedInsurerForItem_result')
26795 
    if self.success is not None:
26796 
      oprot.writeFieldBegin('success', TType.I64, 0)
26797 
      oprot.writeI64(self.success)
26798 
      oprot.writeFieldEnd()
26799 
    oprot.writeFieldStop()
26800 
    oprot.writeStructEnd()
26801 
 
26802 
  def validate(self):
26803 
    return
26804 
 
26805 
 
26806 
  def __repr__(self):
26807 
    L = ['%s=%r' % (key, value)
26808 
      for key, value in self.__dict__.iteritems()]
26809 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26810 
 
26811 
  def __eq__(self, other):
26812 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26813 
 
26814 
  def __ne__(self, other):
26815 
    return not (self == other)
9456 vikram.rag 26816 
 
26817 
class getSnapdealItembySkuAtSnapdeal_args:
26818 
  """
26819 
  Attributes:
26820 
   - skuAtSnapdeal
26821 
  """
26822 
 
26823 
  thrift_spec = None
26824 
  def __init__(self, skuAtSnapdeal=None,):
26825 
    self.skuAtSnapdeal = skuAtSnapdeal
26826 
 
26827 
  def read(self, iprot):
26828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26830 
      return
26831 
    iprot.readStructBegin()
26832 
    while True:
26833 
      (fname, ftype, fid) = iprot.readFieldBegin()
26834 
      if ftype == TType.STOP:
26835 
        break
26836 
      if fid == -1:
26837 
        if ftype == TType.STRING:
26838 
          self.skuAtSnapdeal = iprot.readString();
26839 
        else:
26840 
          iprot.skip(ftype)
26841 
      else:
26842 
        iprot.skip(ftype)
26843 
      iprot.readFieldEnd()
26844 
    iprot.readStructEnd()
26845 
 
26846 
  def write(self, oprot):
26847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26849 
      return
26850 
    oprot.writeStructBegin('getSnapdealItembySkuAtSnapdeal_args')
26851 
    if self.skuAtSnapdeal is not None:
26852 
      oprot.writeFieldBegin('skuAtSnapdeal', TType.STRING, -1)
26853 
      oprot.writeString(self.skuAtSnapdeal)
26854 
      oprot.writeFieldEnd()
26855 
    oprot.writeFieldStop()
26856 
    oprot.writeStructEnd()
26857 
 
26858 
  def validate(self):
26859 
    return
26860 
 
26861 
 
26862 
  def __repr__(self):
26863 
    L = ['%s=%r' % (key, value)
26864 
      for key, value in self.__dict__.iteritems()]
26865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26866 
 
26867 
  def __eq__(self, other):
26868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26869 
 
26870 
  def __ne__(self, other):
26871 
    return not (self == other)
26872 
 
26873 
class getSnapdealItembySkuAtSnapdeal_result:
26874 
  """
26875 
  Attributes:
26876 
   - success
26877 
  """
26878 
 
26879 
  thrift_spec = (
26880 
    (0, TType.STRUCT, 'success', (SnapdealItem, SnapdealItem.thrift_spec), None, ), # 0
26881 
  )
26882 
 
26883 
  def __init__(self, success=None,):
26884 
    self.success = success
26885 
 
26886 
  def read(self, iprot):
26887 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26888 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26889 
      return
26890 
    iprot.readStructBegin()
26891 
    while True:
26892 
      (fname, ftype, fid) = iprot.readFieldBegin()
26893 
      if ftype == TType.STOP:
26894 
        break
26895 
      if fid == 0:
26896 
        if ftype == TType.STRUCT:
26897 
          self.success = SnapdealItem()
26898 
          self.success.read(iprot)
26899 
        else:
26900 
          iprot.skip(ftype)
26901 
      else:
26902 
        iprot.skip(ftype)
26903 
      iprot.readFieldEnd()
26904 
    iprot.readStructEnd()
26905 
 
26906 
  def write(self, oprot):
26907 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26908 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26909 
      return
26910 
    oprot.writeStructBegin('getSnapdealItembySkuAtSnapdeal_result')
26911 
    if self.success is not None:
26912 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26913 
      self.success.write(oprot)
26914 
      oprot.writeFieldEnd()
26915 
    oprot.writeFieldStop()
26916 
    oprot.writeStructEnd()
26917 
 
26918 
  def validate(self):
26919 
    return
26920 
 
26921 
 
26922 
  def __repr__(self):
26923 
    L = ['%s=%r' % (key, value)
26924 
      for key, value in self.__dict__.iteritems()]
26925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26926 
 
26927 
  def __eq__(self, other):
26928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26929 
 
26930 
  def __ne__(self, other):
26931 
    return not (self == other)
9621 manish.sha 26932 
 
26933 
class getProductFeedSubmit_args:
26934 
  """
26935 
  Attributes:
26936 
   - catalogItemId
26937 
  """
26938 
 
26939 
  thrift_spec = (
26940 
    None, # 0
26941 
    (1, TType.I64, 'catalogItemId', None, None, ), # 1
26942 
  )
26943 
 
26944 
  def __init__(self, catalogItemId=None,):
26945 
    self.catalogItemId = catalogItemId
26946 
 
26947 
  def read(self, iprot):
26948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26950 
      return
26951 
    iprot.readStructBegin()
26952 
    while True:
26953 
      (fname, ftype, fid) = iprot.readFieldBegin()
26954 
      if ftype == TType.STOP:
26955 
        break
26956 
      if fid == 1:
26957 
        if ftype == TType.I64:
26958 
          self.catalogItemId = iprot.readI64();
26959 
        else:
26960 
          iprot.skip(ftype)
26961 
      else:
26962 
        iprot.skip(ftype)
26963 
      iprot.readFieldEnd()
26964 
    iprot.readStructEnd()
26965 
 
26966 
  def write(self, oprot):
26967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26969 
      return
26970 
    oprot.writeStructBegin('getProductFeedSubmit_args')
26971 
    if self.catalogItemId is not None:
26972 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 1)
26973 
      oprot.writeI64(self.catalogItemId)
26974 
      oprot.writeFieldEnd()
26975 
    oprot.writeFieldStop()
26976 
    oprot.writeStructEnd()
26977 
 
26978 
  def validate(self):
26979 
    return
26980 
 
26981 
 
26982 
  def __repr__(self):
26983 
    L = ['%s=%r' % (key, value)
26984 
      for key, value in self.__dict__.iteritems()]
26985 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26986 
 
26987 
  def __eq__(self, other):
26988 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26989 
 
26990 
  def __ne__(self, other):
26991 
    return not (self == other)
26992 
 
26993 
class getProductFeedSubmit_result:
26994 
  """
26995 
  Attributes:
26996 
   - success
26997 
   - cex
26998 
  """
26999 
 
27000 
  thrift_spec = (
27001 
    (0, TType.STRUCT, 'success', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 0
27002 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
27003 
  )
27004 
 
27005 
  def __init__(self, success=None, cex=None,):
27006 
    self.success = success
27007 
    self.cex = cex
27008 
 
27009 
  def read(self, iprot):
27010 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27011 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27012 
      return
27013 
    iprot.readStructBegin()
27014 
    while True:
27015 
      (fname, ftype, fid) = iprot.readFieldBegin()
27016 
      if ftype == TType.STOP:
27017 
        break
27018 
      if fid == 0:
27019 
        if ftype == TType.STRUCT:
27020 
          self.success = ProductFeedSubmit()
27021 
          self.success.read(iprot)
27022 
        else:
27023 
          iprot.skip(ftype)
27024 
      elif fid == 1:
27025 
        if ftype == TType.STRUCT:
27026 
          self.cex = CatalogServiceException()
27027 
          self.cex.read(iprot)
27028 
        else:
27029 
          iprot.skip(ftype)
27030 
      else:
27031 
        iprot.skip(ftype)
27032 
      iprot.readFieldEnd()
27033 
    iprot.readStructEnd()
27034 
 
27035 
  def write(self, oprot):
27036 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27037 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27038 
      return
27039 
    oprot.writeStructBegin('getProductFeedSubmit_result')
27040 
    if self.success is not None:
27041 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27042 
      self.success.write(oprot)
27043 
      oprot.writeFieldEnd()
27044 
    if self.cex is not None:
27045 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
27046 
      self.cex.write(oprot)
27047 
      oprot.writeFieldEnd()
27048 
    oprot.writeFieldStop()
27049 
    oprot.writeStructEnd()
27050 
 
27051 
  def validate(self):
27052 
    return
27053 
 
27054 
 
27055 
  def __repr__(self):
27056 
    L = ['%s=%r' % (key, value)
27057 
      for key, value in self.__dict__.iteritems()]
27058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27059 
 
27060 
  def __eq__(self, other):
27061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27062 
 
27063 
  def __ne__(self, other):
27064 
    return not (self == other)
27065 
 
27066 
class addProductFeedSubmit_args:
27067 
  """
27068 
  Attributes:
27069 
   - productFeedSubmit
27070 
  """
27071 
 
27072 
  thrift_spec = (
27073 
    None, # 0
27074 
    (1, TType.STRUCT, 'productFeedSubmit', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 1
27075 
  )
27076 
 
27077 
  def __init__(self, productFeedSubmit=None,):
27078 
    self.productFeedSubmit = productFeedSubmit
27079 
 
27080 
  def read(self, iprot):
27081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27083 
      return
27084 
    iprot.readStructBegin()
27085 
    while True:
27086 
      (fname, ftype, fid) = iprot.readFieldBegin()
27087 
      if ftype == TType.STOP:
27088 
        break
27089 
      if fid == 1:
27090 
        if ftype == TType.STRUCT:
27091 
          self.productFeedSubmit = ProductFeedSubmit()
27092 
          self.productFeedSubmit.read(iprot)
27093 
        else:
27094 
          iprot.skip(ftype)
27095 
      else:
27096 
        iprot.skip(ftype)
27097 
      iprot.readFieldEnd()
27098 
    iprot.readStructEnd()
27099 
 
27100 
  def write(self, oprot):
27101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27103 
      return
27104 
    oprot.writeStructBegin('addProductFeedSubmit_args')
27105 
    if self.productFeedSubmit is not None:
27106 
      oprot.writeFieldBegin('productFeedSubmit', TType.STRUCT, 1)
27107 
      self.productFeedSubmit.write(oprot)
27108 
      oprot.writeFieldEnd()
27109 
    oprot.writeFieldStop()
27110 
    oprot.writeStructEnd()
27111 
 
27112 
  def validate(self):
27113 
    return
27114 
 
27115 
 
27116 
  def __repr__(self):
27117 
    L = ['%s=%r' % (key, value)
27118 
      for key, value in self.__dict__.iteritems()]
27119 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27120 
 
27121 
  def __eq__(self, other):
27122 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27123 
 
27124 
  def __ne__(self, other):
27125 
    return not (self == other)
27126 
 
27127 
class addProductFeedSubmit_result:
27128 
  """
27129 
  Attributes:
27130 
   - success
27131 
   - cex
27132 
  """
27133 
 
27134 
  thrift_spec = (
27135 
    (0, TType.BOOL, 'success', None, None, ), # 0
27136 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
27137 
  )
27138 
 
27139 
  def __init__(self, success=None, cex=None,):
27140 
    self.success = success
27141 
    self.cex = cex
27142 
 
27143 
  def read(self, iprot):
27144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27146 
      return
27147 
    iprot.readStructBegin()
27148 
    while True:
27149 
      (fname, ftype, fid) = iprot.readFieldBegin()
27150 
      if ftype == TType.STOP:
27151 
        break
27152 
      if fid == 0:
27153 
        if ftype == TType.BOOL:
27154 
          self.success = iprot.readBool();
27155 
        else:
27156 
          iprot.skip(ftype)
27157 
      elif fid == 1:
27158 
        if ftype == TType.STRUCT:
27159 
          self.cex = CatalogServiceException()
27160 
          self.cex.read(iprot)
27161 
        else:
27162 
          iprot.skip(ftype)
27163 
      else:
27164 
        iprot.skip(ftype)
27165 
      iprot.readFieldEnd()
27166 
    iprot.readStructEnd()
27167 
 
27168 
  def write(self, oprot):
27169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27171 
      return
27172 
    oprot.writeStructBegin('addProductFeedSubmit_result')
27173 
    if self.success is not None:
27174 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27175 
      oprot.writeBool(self.success)
27176 
      oprot.writeFieldEnd()
27177 
    if self.cex is not None:
27178 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
27179 
      self.cex.write(oprot)
27180 
      oprot.writeFieldEnd()
27181 
    oprot.writeFieldStop()
27182 
    oprot.writeStructEnd()
27183 
 
27184 
  def validate(self):
27185 
    return
27186 
 
27187 
 
27188 
  def __repr__(self):
27189 
    L = ['%s=%r' % (key, value)
27190 
      for key, value in self.__dict__.iteritems()]
27191 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27192 
 
27193 
  def __eq__(self, other):
27194 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27195 
 
27196 
  def __ne__(self, other):
27197 
    return not (self == other)
27198 
 
27199 
class updateProductFeedSubmit_args:
27200 
  """
27201 
  Attributes:
27202 
   - productFeedSubmit
27203 
  """
27204 
 
27205 
  thrift_spec = (
27206 
    None, # 0
27207 
    (1, TType.STRUCT, 'productFeedSubmit', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 1
27208 
  )
27209 
 
27210 
  def __init__(self, productFeedSubmit=None,):
27211 
    self.productFeedSubmit = productFeedSubmit
27212 
 
27213 
  def read(self, iprot):
27214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27216 
      return
27217 
    iprot.readStructBegin()
27218 
    while True:
27219 
      (fname, ftype, fid) = iprot.readFieldBegin()
27220 
      if ftype == TType.STOP:
27221 
        break
27222 
      if fid == 1:
27223 
        if ftype == TType.STRUCT:
27224 
          self.productFeedSubmit = ProductFeedSubmit()
27225 
          self.productFeedSubmit.read(iprot)
27226 
        else:
27227 
          iprot.skip(ftype)
27228 
      else:
27229 
        iprot.skip(ftype)
27230 
      iprot.readFieldEnd()
27231 
    iprot.readStructEnd()
27232 
 
27233 
  def write(self, oprot):
27234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27236 
      return
27237 
    oprot.writeStructBegin('updateProductFeedSubmit_args')
27238 
    if self.productFeedSubmit is not None:
27239 
      oprot.writeFieldBegin('productFeedSubmit', TType.STRUCT, 1)
27240 
      self.productFeedSubmit.write(oprot)
27241 
      oprot.writeFieldEnd()
27242 
    oprot.writeFieldStop()
27243 
    oprot.writeStructEnd()
27244 
 
27245 
  def validate(self):
27246 
    return
27247 
 
27248 
 
27249 
  def __repr__(self):
27250 
    L = ['%s=%r' % (key, value)
27251 
      for key, value in self.__dict__.iteritems()]
27252 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27253 
 
27254 
  def __eq__(self, other):
27255 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27256 
 
27257 
  def __ne__(self, other):
27258 
    return not (self == other)
27259 
 
27260 
class updateProductFeedSubmit_result:
27261 
  """
27262 
  Attributes:
27263 
   - success
27264 
   - cex
27265 
  """
27266 
 
27267 
  thrift_spec = (
27268 
    (0, TType.BOOL, 'success', None, None, ), # 0
27269 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
27270 
  )
27271 
 
27272 
  def __init__(self, success=None, cex=None,):
27273 
    self.success = success
27274 
    self.cex = cex
27275 
 
27276 
  def read(self, iprot):
27277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27279 
      return
27280 
    iprot.readStructBegin()
27281 
    while True:
27282 
      (fname, ftype, fid) = iprot.readFieldBegin()
27283 
      if ftype == TType.STOP:
27284 
        break
27285 
      if fid == 0:
27286 
        if ftype == TType.BOOL:
27287 
          self.success = iprot.readBool();
27288 
        else:
27289 
          iprot.skip(ftype)
27290 
      elif fid == 1:
27291 
        if ftype == TType.STRUCT:
27292 
          self.cex = CatalogServiceException()
27293 
          self.cex.read(iprot)
27294 
        else:
27295 
          iprot.skip(ftype)
27296 
      else:
27297 
        iprot.skip(ftype)
27298 
      iprot.readFieldEnd()
27299 
    iprot.readStructEnd()
27300 
 
27301 
  def write(self, oprot):
27302 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27303 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27304 
      return
27305 
    oprot.writeStructBegin('updateProductFeedSubmit_result')
27306 
    if self.success is not None:
27307 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27308 
      oprot.writeBool(self.success)
27309 
      oprot.writeFieldEnd()
27310 
    if self.cex is not None:
27311 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
27312 
      self.cex.write(oprot)
27313 
      oprot.writeFieldEnd()
27314 
    oprot.writeFieldStop()
27315 
    oprot.writeStructEnd()
27316 
 
27317 
  def validate(self):
27318 
    return
27319 
 
27320 
 
27321 
  def __repr__(self):
27322 
    L = ['%s=%r' % (key, value)
27323 
      for key, value in self.__dict__.iteritems()]
27324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27325 
 
27326 
  def __eq__(self, other):
27327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27328 
 
27329 
  def __ne__(self, other):
27330 
    return not (self == other)
27331 
 
27332 
class deleteProductFeedSubmit_args:
27333 
  """
27334 
  Attributes:
27335 
   - catalogItemId
27336 
  """
27337 
 
27338 
  thrift_spec = (
27339 
    None, # 0
27340 
    (1, TType.I64, 'catalogItemId', None, None, ), # 1
27341 
  )
27342 
 
27343 
  def __init__(self, catalogItemId=None,):
27344 
    self.catalogItemId = catalogItemId
27345 
 
27346 
  def read(self, iprot):
27347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27349 
      return
27350 
    iprot.readStructBegin()
27351 
    while True:
27352 
      (fname, ftype, fid) = iprot.readFieldBegin()
27353 
      if ftype == TType.STOP:
27354 
        break
27355 
      if fid == 1:
27356 
        if ftype == TType.I64:
27357 
          self.catalogItemId = iprot.readI64();
27358 
        else:
27359 
          iprot.skip(ftype)
27360 
      else:
27361 
        iprot.skip(ftype)
27362 
      iprot.readFieldEnd()
27363 
    iprot.readStructEnd()
27364 
 
27365 
  def write(self, oprot):
27366 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27367 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27368 
      return
27369 
    oprot.writeStructBegin('deleteProductFeedSubmit_args')
27370 
    if self.catalogItemId is not None:
27371 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 1)
27372 
      oprot.writeI64(self.catalogItemId)
27373 
      oprot.writeFieldEnd()
27374 
    oprot.writeFieldStop()
27375 
    oprot.writeStructEnd()
27376 
 
27377 
  def validate(self):
27378 
    return
27379 
 
27380 
 
27381 
  def __repr__(self):
27382 
    L = ['%s=%r' % (key, value)
27383 
      for key, value in self.__dict__.iteritems()]
27384 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27385 
 
27386 
  def __eq__(self, other):
27387 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27388 
 
27389 
  def __ne__(self, other):
27390 
    return not (self == other)
27391 
 
27392 
class deleteProductFeedSubmit_result:
27393 
  """
27394 
  Attributes:
27395 
   - success
27396 
   - cex
27397 
  """
27398 
 
27399 
  thrift_spec = (
27400 
    (0, TType.BOOL, 'success', None, None, ), # 0
27401 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
27402 
  )
27403 
 
27404 
  def __init__(self, success=None, cex=None,):
27405 
    self.success = success
27406 
    self.cex = cex
27407 
 
27408 
  def read(self, iprot):
27409 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27410 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27411 
      return
27412 
    iprot.readStructBegin()
27413 
    while True:
27414 
      (fname, ftype, fid) = iprot.readFieldBegin()
27415 
      if ftype == TType.STOP:
27416 
        break
27417 
      if fid == 0:
27418 
        if ftype == TType.BOOL:
27419 
          self.success = iprot.readBool();
27420 
        else:
27421 
          iprot.skip(ftype)
27422 
      elif fid == 1:
27423 
        if ftype == TType.STRUCT:
27424 
          self.cex = CatalogServiceException()
27425 
          self.cex.read(iprot)
27426 
        else:
27427 
          iprot.skip(ftype)
27428 
      else:
27429 
        iprot.skip(ftype)
27430 
      iprot.readFieldEnd()
27431 
    iprot.readStructEnd()
27432 
 
27433 
  def write(self, oprot):
27434 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27435 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27436 
      return
27437 
    oprot.writeStructBegin('deleteProductFeedSubmit_result')
27438 
    if self.success is not None:
27439 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27440 
      oprot.writeBool(self.success)
27441 
      oprot.writeFieldEnd()
27442 
    if self.cex is not None:
27443 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
27444 
      self.cex.write(oprot)
27445 
      oprot.writeFieldEnd()
27446 
    oprot.writeFieldStop()
27447 
    oprot.writeStructEnd()
27448 
 
27449 
  def validate(self):
27450 
    return
27451 
 
27452 
 
27453 
  def __repr__(self):
27454 
    L = ['%s=%r' % (key, value)
27455 
      for key, value in self.__dict__.iteritems()]
27456 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27457 
 
27458 
  def __eq__(self, other):
27459 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27460 
 
27461 
  def __ne__(self, other):
27462 
    return not (self == other)
27463 
 
27464 
class getAllProductFeedSubmit_args:
27465 
 
27466 
  thrift_spec = (
27467 
  )
27468 
 
27469 
  def read(self, iprot):
27470 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27471 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27472 
      return
27473 
    iprot.readStructBegin()
27474 
    while True:
27475 
      (fname, ftype, fid) = iprot.readFieldBegin()
27476 
      if ftype == TType.STOP:
27477 
        break
27478 
      else:
27479 
        iprot.skip(ftype)
27480 
      iprot.readFieldEnd()
27481 
    iprot.readStructEnd()
27482 
 
27483 
  def write(self, oprot):
27484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27486 
      return
27487 
    oprot.writeStructBegin('getAllProductFeedSubmit_args')
27488 
    oprot.writeFieldStop()
27489 
    oprot.writeStructEnd()
27490 
 
27491 
  def validate(self):
27492 
    return
27493 
 
27494 
 
27495 
  def __repr__(self):
27496 
    L = ['%s=%r' % (key, value)
27497 
      for key, value in self.__dict__.iteritems()]
27498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27499 
 
27500 
  def __eq__(self, other):
27501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27502 
 
27503 
  def __ne__(self, other):
27504 
    return not (self == other)
27505 
 
27506 
class getAllProductFeedSubmit_result:
27507 
  """
27508 
  Attributes:
27509 
   - success
27510 
   - cex
27511 
  """
27512 
 
27513 
  thrift_spec = (
27514 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductFeedSubmit, ProductFeedSubmit.thrift_spec)), None, ), # 0
27515 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
27516 
  )
27517 
 
27518 
  def __init__(self, success=None, cex=None,):
27519 
    self.success = success
27520 
    self.cex = cex
27521 
 
27522 
  def read(self, iprot):
27523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27525 
      return
27526 
    iprot.readStructBegin()
27527 
    while True:
27528 
      (fname, ftype, fid) = iprot.readFieldBegin()
27529 
      if ftype == TType.STOP:
27530 
        break
27531 
      if fid == 0:
27532 
        if ftype == TType.LIST:
27533 
          self.success = []
13493 amit.gupta 27534 
          (_etype576, _size573) = iprot.readListBegin()
27535 
          for _i577 in xrange(_size573):
27536 
            _elem578 = ProductFeedSubmit()
27537 
            _elem578.read(iprot)
27538 
            self.success.append(_elem578)
9621 manish.sha 27539 
          iprot.readListEnd()
27540 
        else:
27541 
          iprot.skip(ftype)
27542 
      elif fid == 1:
27543 
        if ftype == TType.STRUCT:
27544 
          self.cex = CatalogServiceException()
27545 
          self.cex.read(iprot)
27546 
        else:
27547 
          iprot.skip(ftype)
27548 
      else:
27549 
        iprot.skip(ftype)
27550 
      iprot.readFieldEnd()
27551 
    iprot.readStructEnd()
27552 
 
27553 
  def write(self, oprot):
27554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27556 
      return
27557 
    oprot.writeStructBegin('getAllProductFeedSubmit_result')
27558 
    if self.success is not None:
27559 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27560 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 27561 
      for iter579 in self.success:
27562 
        iter579.write(oprot)
9621 manish.sha 27563 
      oprot.writeListEnd()
27564 
      oprot.writeFieldEnd()
27565 
    if self.cex is not None:
27566 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
27567 
      self.cex.write(oprot)
27568 
      oprot.writeFieldEnd()
27569 
    oprot.writeFieldStop()
27570 
    oprot.writeStructEnd()
27571 
 
27572 
  def validate(self):
27573 
    return
27574 
 
27575 
 
27576 
  def __repr__(self):
27577 
    L = ['%s=%r' % (key, value)
27578 
      for key, value in self.__dict__.iteritems()]
27579 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27580 
 
27581 
  def __eq__(self, other):
27582 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27583 
 
27584 
  def __ne__(self, other):
27585 
    return not (self == other)
9724 kshitij.so 27586 
 
27587 
class getMarketplacedetailsForItem_args:
27588 
  """
27589 
  Attributes:
27590 
   - itemId
27591 
   - sourceId
27592 
  """
27593 
 
27594 
  thrift_spec = (
27595 
    None, # 0
27596 
    (1, TType.I64, 'itemId', None, None, ), # 1
27597 
    (2, TType.I64, 'sourceId', None, None, ), # 2
27598 
  )
27599 
 
27600 
  def __init__(self, itemId=None, sourceId=None,):
27601 
    self.itemId = itemId
27602 
    self.sourceId = sourceId
27603 
 
27604 
  def read(self, iprot):
27605 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27606 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27607 
      return
27608 
    iprot.readStructBegin()
27609 
    while True:
27610 
      (fname, ftype, fid) = iprot.readFieldBegin()
27611 
      if ftype == TType.STOP:
27612 
        break
27613 
      if fid == 1:
27614 
        if ftype == TType.I64:
27615 
          self.itemId = iprot.readI64();
27616 
        else:
27617 
          iprot.skip(ftype)
27618 
      elif fid == 2:
27619 
        if ftype == TType.I64:
27620 
          self.sourceId = iprot.readI64();
27621 
        else:
27622 
          iprot.skip(ftype)
27623 
      else:
27624 
        iprot.skip(ftype)
27625 
      iprot.readFieldEnd()
27626 
    iprot.readStructEnd()
27627 
 
27628 
  def write(self, oprot):
27629 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27630 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27631 
      return
27632 
    oprot.writeStructBegin('getMarketplacedetailsForItem_args')
27633 
    if self.itemId is not None:
27634 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
27635 
      oprot.writeI64(self.itemId)
27636 
      oprot.writeFieldEnd()
27637 
    if self.sourceId is not None:
27638 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
27639 
      oprot.writeI64(self.sourceId)
27640 
      oprot.writeFieldEnd()
27641 
    oprot.writeFieldStop()
27642 
    oprot.writeStructEnd()
27643 
 
27644 
  def validate(self):
27645 
    return
27646 
 
27647 
 
27648 
  def __repr__(self):
27649 
    L = ['%s=%r' % (key, value)
27650 
      for key, value in self.__dict__.iteritems()]
27651 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27652 
 
27653 
  def __eq__(self, other):
27654 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27655 
 
27656 
  def __ne__(self, other):
27657 
    return not (self == other)
27658 
 
27659 
class getMarketplacedetailsForItem_result:
27660 
  """
27661 
  Attributes:
27662 
   - success
27663 
  """
27664 
 
27665 
  thrift_spec = (
27666 
    (0, TType.STRUCT, 'success', (MarketplaceItems, MarketplaceItems.thrift_spec), None, ), # 0
27667 
  )
27668 
 
27669 
  def __init__(self, success=None,):
27670 
    self.success = success
27671 
 
27672 
  def read(self, iprot):
27673 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27674 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27675 
      return
27676 
    iprot.readStructBegin()
27677 
    while True:
27678 
      (fname, ftype, fid) = iprot.readFieldBegin()
27679 
      if ftype == TType.STOP:
27680 
        break
27681 
      if fid == 0:
27682 
        if ftype == TType.STRUCT:
27683 
          self.success = MarketplaceItems()
27684 
          self.success.read(iprot)
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('getMarketplacedetailsForItem_result')
27697 
    if self.success is not None:
27698 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27699 
      self.success.write(oprot)
27700 
      oprot.writeFieldEnd()
27701 
    oprot.writeFieldStop()
27702 
    oprot.writeStructEnd()
27703 
 
27704 
  def validate(self):
27705 
    return
27706 
 
27707 
 
27708 
  def __repr__(self):
27709 
    L = ['%s=%r' % (key, value)
27710 
      for key, value in self.__dict__.iteritems()]
27711 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27712 
 
27713 
  def __eq__(self, other):
27714 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27715 
 
27716 
  def __ne__(self, other):
27717 
    return not (self == other)
27718 
 
27719 
class updateMarketplaceAttributesForItem_args:
27720 
  """
27721 
  Attributes:
27722 
   - marketPlaceItem
27723 
  """
27724 
 
27725 
  thrift_spec = (
27726 
    None, # 0
27727 
    (1, TType.STRUCT, 'marketPlaceItem', (MarketplaceItems, MarketplaceItems.thrift_spec), None, ), # 1
27728 
  )
27729 
 
27730 
  def __init__(self, marketPlaceItem=None,):
27731 
    self.marketPlaceItem = marketPlaceItem
27732 
 
27733 
  def read(self, iprot):
27734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27736 
      return
27737 
    iprot.readStructBegin()
27738 
    while True:
27739 
      (fname, ftype, fid) = iprot.readFieldBegin()
27740 
      if ftype == TType.STOP:
27741 
        break
27742 
      if fid == 1:
27743 
        if ftype == TType.STRUCT:
27744 
          self.marketPlaceItem = MarketplaceItems()
27745 
          self.marketPlaceItem.read(iprot)
27746 
        else:
27747 
          iprot.skip(ftype)
27748 
      else:
27749 
        iprot.skip(ftype)
27750 
      iprot.readFieldEnd()
27751 
    iprot.readStructEnd()
27752 
 
27753 
  def write(self, oprot):
27754 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27755 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27756 
      return
27757 
    oprot.writeStructBegin('updateMarketplaceAttributesForItem_args')
27758 
    if self.marketPlaceItem is not None:
27759 
      oprot.writeFieldBegin('marketPlaceItem', TType.STRUCT, 1)
27760 
      self.marketPlaceItem.write(oprot)
27761 
      oprot.writeFieldEnd()
27762 
    oprot.writeFieldStop()
27763 
    oprot.writeStructEnd()
27764 
 
27765 
  def validate(self):
27766 
    return
27767 
 
27768 
 
27769 
  def __repr__(self):
27770 
    L = ['%s=%r' % (key, value)
27771 
      for key, value in self.__dict__.iteritems()]
27772 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27773 
 
27774 
  def __eq__(self, other):
27775 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27776 
 
27777 
  def __ne__(self, other):
27778 
    return not (self == other)
27779 
 
27780 
class updateMarketplaceAttributesForItem_result:
27781 
  """
27782 
  Attributes:
27783 
   - success
27784 
  """
27785 
 
27786 
  thrift_spec = (
27787 
    (0, TType.BOOL, 'success', None, None, ), # 0
27788 
  )
27789 
 
27790 
  def __init__(self, success=None,):
27791 
    self.success = success
27792 
 
27793 
  def read(self, iprot):
27794 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27795 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27796 
      return
27797 
    iprot.readStructBegin()
27798 
    while True:
27799 
      (fname, ftype, fid) = iprot.readFieldBegin()
27800 
      if ftype == TType.STOP:
27801 
        break
27802 
      if fid == 0:
27803 
        if ftype == TType.BOOL:
27804 
          self.success = iprot.readBool();
27805 
        else:
27806 
          iprot.skip(ftype)
27807 
      else:
27808 
        iprot.skip(ftype)
27809 
      iprot.readFieldEnd()
27810 
    iprot.readStructEnd()
27811 
 
27812 
  def write(self, oprot):
27813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27815 
      return
27816 
    oprot.writeStructBegin('updateMarketplaceAttributesForItem_result')
27817 
    if self.success is not None:
27818 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27819 
      oprot.writeBool(self.success)
27820 
      oprot.writeFieldEnd()
27821 
    oprot.writeFieldStop()
27822 
    oprot.writeStructEnd()
27823 
 
27824 
  def validate(self):
27825 
    return
27826 
 
27827 
 
27828 
  def __repr__(self):
27829 
    L = ['%s=%r' % (key, value)
27830 
      for key, value in self.__dict__.iteritems()]
27831 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27832 
 
27833 
  def __eq__(self, other):
27834 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27835 
 
27836 
  def __ne__(self, other):
27837 
    return not (self == other)
9776 vikram.rag 27838 
 
9779 kshitij.so 27839 
class getCostingForMarketplace_args:
27840 
  """
27841 
  Attributes:
27842 
   - source
27843 
   - item_id
27844 
  """
27845 
 
27846 
  thrift_spec = (
27847 
    None, # 0
27848 
    (1, TType.I64, 'source', None, None, ), # 1
27849 
    (2, TType.I64, 'item_id', None, None, ), # 2
27850 
  )
27851 
 
27852 
  def __init__(self, source=None, item_id=None,):
27853 
    self.source = source
27854 
    self.item_id = item_id
27855 
 
27856 
  def read(self, iprot):
27857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27859 
      return
27860 
    iprot.readStructBegin()
27861 
    while True:
27862 
      (fname, ftype, fid) = iprot.readFieldBegin()
27863 
      if ftype == TType.STOP:
27864 
        break
27865 
      if fid == 1:
27866 
        if ftype == TType.I64:
27867 
          self.source = iprot.readI64();
27868 
        else:
27869 
          iprot.skip(ftype)
27870 
      elif fid == 2:
27871 
        if ftype == TType.I64:
27872 
          self.item_id = iprot.readI64();
27873 
        else:
27874 
          iprot.skip(ftype)
27875 
      else:
27876 
        iprot.skip(ftype)
27877 
      iprot.readFieldEnd()
27878 
    iprot.readStructEnd()
27879 
 
27880 
  def write(self, oprot):
27881 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27882 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27883 
      return
27884 
    oprot.writeStructBegin('getCostingForMarketplace_args')
27885 
    if self.source is not None:
27886 
      oprot.writeFieldBegin('source', TType.I64, 1)
27887 
      oprot.writeI64(self.source)
27888 
      oprot.writeFieldEnd()
27889 
    if self.item_id is not None:
27890 
      oprot.writeFieldBegin('item_id', TType.I64, 2)
27891 
      oprot.writeI64(self.item_id)
27892 
      oprot.writeFieldEnd()
27893 
    oprot.writeFieldStop()
27894 
    oprot.writeStructEnd()
27895 
 
27896 
  def validate(self):
27897 
    return
27898 
 
27899 
 
27900 
  def __repr__(self):
27901 
    L = ['%s=%r' % (key, value)
27902 
      for key, value in self.__dict__.iteritems()]
27903 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27904 
 
27905 
  def __eq__(self, other):
27906 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27907 
 
27908 
  def __ne__(self, other):
27909 
    return not (self == other)
27910 
 
27911 
class getCostingForMarketplace_result:
27912 
  """
27913 
  Attributes:
27914 
   - success
27915 
  """
27916 
 
27917 
  thrift_spec = (
27918 
    (0, TType.STRUCT, 'success', (MarketplacePercentage, MarketplacePercentage.thrift_spec), None, ), # 0
27919 
  )
27920 
 
27921 
  def __init__(self, success=None,):
27922 
    self.success = success
27923 
 
27924 
  def read(self, iprot):
27925 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27926 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27927 
      return
27928 
    iprot.readStructBegin()
27929 
    while True:
27930 
      (fname, ftype, fid) = iprot.readFieldBegin()
27931 
      if ftype == TType.STOP:
27932 
        break
27933 
      if fid == 0:
27934 
        if ftype == TType.STRUCT:
27935 
          self.success = MarketplacePercentage()
27936 
          self.success.read(iprot)
27937 
        else:
27938 
          iprot.skip(ftype)
27939 
      else:
27940 
        iprot.skip(ftype)
27941 
      iprot.readFieldEnd()
27942 
    iprot.readStructEnd()
27943 
 
27944 
  def write(self, oprot):
27945 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27946 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27947 
      return
27948 
    oprot.writeStructBegin('getCostingForMarketplace_result')
27949 
    if self.success is not None:
27950 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27951 
      self.success.write(oprot)
27952 
      oprot.writeFieldEnd()
27953 
    oprot.writeFieldStop()
27954 
    oprot.writeStructEnd()
27955 
 
27956 
  def validate(self):
27957 
    return
27958 
 
27959 
 
27960 
  def __repr__(self):
27961 
    L = ['%s=%r' % (key, value)
27962 
      for key, value in self.__dict__.iteritems()]
27963 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27964 
 
27965 
  def __eq__(self, other):
27966 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27967 
 
27968 
  def __ne__(self, other):
27969 
    return not (self == other)
27970 
 
9776 vikram.rag 27971 
class getMarketPlaceItemsForPriceUpdate_args:
27972 
  """
27973 
  Attributes:
27974 
   - source
27975 
  """
27976 
 
27977 
  thrift_spec = (
27978 
    None, # 0
27979 
    (1, TType.I64, 'source', None, None, ), # 1
27980 
  )
27981 
 
27982 
  def __init__(self, source=None,):
27983 
    self.source = source
27984 
 
27985 
  def read(self, iprot):
27986 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27987 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27988 
      return
27989 
    iprot.readStructBegin()
27990 
    while True:
27991 
      (fname, ftype, fid) = iprot.readFieldBegin()
27992 
      if ftype == TType.STOP:
27993 
        break
27994 
      if fid == 1:
27995 
        if ftype == TType.I64:
27996 
          self.source = iprot.readI64();
27997 
        else:
27998 
          iprot.skip(ftype)
27999 
      else:
28000 
        iprot.skip(ftype)
28001 
      iprot.readFieldEnd()
28002 
    iprot.readStructEnd()
28003 
 
28004 
  def write(self, oprot):
28005 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28006 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28007 
      return
28008 
    oprot.writeStructBegin('getMarketPlaceItemsForPriceUpdate_args')
28009 
    if self.source is not None:
28010 
      oprot.writeFieldBegin('source', TType.I64, 1)
28011 
      oprot.writeI64(self.source)
28012 
      oprot.writeFieldEnd()
28013 
    oprot.writeFieldStop()
28014 
    oprot.writeStructEnd()
28015 
 
28016 
  def validate(self):
28017 
    return
28018 
 
28019 
 
28020 
  def __repr__(self):
28021 
    L = ['%s=%r' % (key, value)
28022 
      for key, value in self.__dict__.iteritems()]
28023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28024 
 
28025 
  def __eq__(self, other):
28026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28027 
 
28028 
  def __ne__(self, other):
28029 
    return not (self == other)
28030 
 
28031 
class getMarketPlaceItemsForPriceUpdate_result:
28032 
  """
28033 
  Attributes:
28034 
   - success
28035 
  """
28036 
 
28037 
  thrift_spec = (
28038 
    (0, TType.LIST, 'success', (TType.STRUCT,(MarketPlaceItemPrice, MarketPlaceItemPrice.thrift_spec)), None, ), # 0
28039 
  )
28040 
 
28041 
  def __init__(self, success=None,):
28042 
    self.success = success
28043 
 
28044 
  def read(self, iprot):
28045 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28046 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28047 
      return
28048 
    iprot.readStructBegin()
28049 
    while True:
28050 
      (fname, ftype, fid) = iprot.readFieldBegin()
28051 
      if ftype == TType.STOP:
28052 
        break
28053 
      if fid == 0:
28054 
        if ftype == TType.LIST:
28055 
          self.success = []
13493 amit.gupta 28056 
          (_etype583, _size580) = iprot.readListBegin()
28057 
          for _i584 in xrange(_size580):
28058 
            _elem585 = MarketPlaceItemPrice()
28059 
            _elem585.read(iprot)
28060 
            self.success.append(_elem585)
9776 vikram.rag 28061 
          iprot.readListEnd()
28062 
        else:
28063 
          iprot.skip(ftype)
28064 
      else:
28065 
        iprot.skip(ftype)
28066 
      iprot.readFieldEnd()
28067 
    iprot.readStructEnd()
28068 
 
28069 
  def write(self, oprot):
28070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28072 
      return
28073 
    oprot.writeStructBegin('getMarketPlaceItemsForPriceUpdate_result')
28074 
    if self.success is not None:
28075 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28076 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 28077 
      for iter586 in self.success:
28078 
        iter586.write(oprot)
9776 vikram.rag 28079 
      oprot.writeListEnd()
28080 
      oprot.writeFieldEnd()
28081 
    oprot.writeFieldStop()
28082 
    oprot.writeStructEnd()
28083 
 
28084 
  def validate(self):
28085 
    return
28086 
 
28087 
 
28088 
  def __repr__(self):
28089 
    L = ['%s=%r' % (key, value)
28090 
      for key, value in self.__dict__.iteritems()]
28091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28092 
 
28093 
  def __eq__(self, other):
28094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28095 
 
28096 
  def __ne__(self, other):
28097 
    return not (self == other)
28098 
 
28099 
class updateMarketPlacePriceUpdateStatus_args:
28100 
  """
28101 
  Attributes:
28102 
   - skulist
28103 
   - timestamp
9816 kshitij.so 28104 
   - source
9776 vikram.rag 28105 
  """
28106 
 
28107 
  thrift_spec = (
28108 
    None, # 0
28109 
    (1, TType.LIST, 'skulist', (TType.I64,None), None, ), # 1
28110 
    (2, TType.I64, 'timestamp', None, None, ), # 2
9816 kshitij.so 28111 
    (3, TType.I64, 'source', None, None, ), # 3
9776 vikram.rag 28112 
  )
28113 
 
9816 kshitij.so 28114 
  def __init__(self, skulist=None, timestamp=None, source=None,):
9776 vikram.rag 28115 
    self.skulist = skulist
28116 
    self.timestamp = timestamp
9816 kshitij.so 28117 
    self.source = source
9776 vikram.rag 28118 
 
28119 
  def read(self, iprot):
28120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28122 
      return
28123 
    iprot.readStructBegin()
28124 
    while True:
28125 
      (fname, ftype, fid) = iprot.readFieldBegin()
28126 
      if ftype == TType.STOP:
28127 
        break
28128 
      if fid == 1:
28129 
        if ftype == TType.LIST:
28130 
          self.skulist = []
13493 amit.gupta 28131 
          (_etype590, _size587) = iprot.readListBegin()
28132 
          for _i591 in xrange(_size587):
28133 
            _elem592 = iprot.readI64();
28134 
            self.skulist.append(_elem592)
9776 vikram.rag 28135 
          iprot.readListEnd()
28136 
        else:
28137 
          iprot.skip(ftype)
28138 
      elif fid == 2:
28139 
        if ftype == TType.I64:
28140 
          self.timestamp = iprot.readI64();
28141 
        else:
28142 
          iprot.skip(ftype)
9816 kshitij.so 28143 
      elif fid == 3:
28144 
        if ftype == TType.I64:
28145 
          self.source = iprot.readI64();
28146 
        else:
28147 
          iprot.skip(ftype)
9776 vikram.rag 28148 
      else:
28149 
        iprot.skip(ftype)
28150 
      iprot.readFieldEnd()
28151 
    iprot.readStructEnd()
28152 
 
28153 
  def write(self, oprot):
28154 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28155 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28156 
      return
28157 
    oprot.writeStructBegin('updateMarketPlacePriceUpdateStatus_args')
28158 
    if self.skulist is not None:
28159 
      oprot.writeFieldBegin('skulist', TType.LIST, 1)
28160 
      oprot.writeListBegin(TType.I64, len(self.skulist))
13493 amit.gupta 28161 
      for iter593 in self.skulist:
28162 
        oprot.writeI64(iter593)
9776 vikram.rag 28163 
      oprot.writeListEnd()
28164 
      oprot.writeFieldEnd()
28165 
    if self.timestamp is not None:
28166 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
28167 
      oprot.writeI64(self.timestamp)
28168 
      oprot.writeFieldEnd()
9816 kshitij.so 28169 
    if self.source is not None:
28170 
      oprot.writeFieldBegin('source', TType.I64, 3)
28171 
      oprot.writeI64(self.source)
28172 
      oprot.writeFieldEnd()
9776 vikram.rag 28173 
    oprot.writeFieldStop()
28174 
    oprot.writeStructEnd()
28175 
 
28176 
  def validate(self):
28177 
    return
28178 
 
28179 
 
28180 
  def __repr__(self):
28181 
    L = ['%s=%r' % (key, value)
28182 
      for key, value in self.__dict__.iteritems()]
28183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28184 
 
28185 
  def __eq__(self, other):
28186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28187 
 
28188 
  def __ne__(self, other):
28189 
    return not (self == other)
28190 
 
28191 
class updateMarketPlacePriceUpdateStatus_result:
28192 
 
28193 
  thrift_spec = (
28194 
  )
28195 
 
28196 
  def read(self, iprot):
28197 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28198 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28199 
      return
28200 
    iprot.readStructBegin()
28201 
    while True:
28202 
      (fname, ftype, fid) = iprot.readFieldBegin()
28203 
      if ftype == TType.STOP:
28204 
        break
28205 
      else:
28206 
        iprot.skip(ftype)
28207 
      iprot.readFieldEnd()
28208 
    iprot.readStructEnd()
28209 
 
28210 
  def write(self, oprot):
28211 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28212 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28213 
      return
28214 
    oprot.writeStructBegin('updateMarketPlacePriceUpdateStatus_result')
28215 
    oprot.writeFieldStop()
28216 
    oprot.writeStructEnd()
28217 
 
28218 
  def validate(self):
28219 
    return
28220 
 
28221 
 
28222 
  def __repr__(self):
28223 
    L = ['%s=%r' % (key, value)
28224 
      for key, value in self.__dict__.iteritems()]
28225 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28226 
 
28227 
  def __eq__(self, other):
28228 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28229 
 
28230 
  def __ne__(self, other):
28231 
    return not (self == other)
9861 rajveer 28232 
 
28233 
class updateItemHoldInventory_args:
28234 
  """
28235 
  Attributes:
28236 
   - itemHoldMap
28237 
  """
28238 
 
28239 
  thrift_spec = (
28240 
    None, # 0
28241 
    (1, TType.MAP, 'itemHoldMap', (TType.I64,None,TType.I64,None), None, ), # 1
28242 
  )
28243 
 
28244 
  def __init__(self, itemHoldMap=None,):
28245 
    self.itemHoldMap = itemHoldMap
28246 
 
28247 
  def read(self, iprot):
28248 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28249 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28250 
      return
28251 
    iprot.readStructBegin()
28252 
    while True:
28253 
      (fname, ftype, fid) = iprot.readFieldBegin()
28254 
      if ftype == TType.STOP:
28255 
        break
28256 
      if fid == 1:
28257 
        if ftype == TType.MAP:
28258 
          self.itemHoldMap = {}
13493 amit.gupta 28259 
          (_ktype595, _vtype596, _size594 ) = iprot.readMapBegin()
28260 
          for _i598 in xrange(_size594):
28261 
            _key599 = iprot.readI64();
28262 
            _val600 = iprot.readI64();
28263 
            self.itemHoldMap[_key599] = _val600
9861 rajveer 28264 
          iprot.readMapEnd()
28265 
        else:
28266 
          iprot.skip(ftype)
28267 
      else:
28268 
        iprot.skip(ftype)
28269 
      iprot.readFieldEnd()
28270 
    iprot.readStructEnd()
28271 
 
28272 
  def write(self, oprot):
28273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28275 
      return
28276 
    oprot.writeStructBegin('updateItemHoldInventory_args')
28277 
    if self.itemHoldMap is not None:
28278 
      oprot.writeFieldBegin('itemHoldMap', TType.MAP, 1)
28279 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.itemHoldMap))
13493 amit.gupta 28280 
      for kiter601,viter602 in self.itemHoldMap.items():
28281 
        oprot.writeI64(kiter601)
28282 
        oprot.writeI64(viter602)
9861 rajveer 28283 
      oprot.writeMapEnd()
28284 
      oprot.writeFieldEnd()
28285 
    oprot.writeFieldStop()
28286 
    oprot.writeStructEnd()
28287 
 
28288 
  def validate(self):
28289 
    return
28290 
 
28291 
 
28292 
  def __repr__(self):
28293 
    L = ['%s=%r' % (key, value)
28294 
      for key, value in self.__dict__.iteritems()]
28295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28296 
 
28297 
  def __eq__(self, other):
28298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28299 
 
28300 
  def __ne__(self, other):
28301 
    return not (self == other)
28302 
 
28303 
class updateItemHoldInventory_result:
28304 
 
28305 
  thrift_spec = (
28306 
  )
28307 
 
28308 
  def read(self, iprot):
28309 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28310 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28311 
      return
28312 
    iprot.readStructBegin()
28313 
    while True:
28314 
      (fname, ftype, fid) = iprot.readFieldBegin()
28315 
      if ftype == TType.STOP:
28316 
        break
28317 
      else:
28318 
        iprot.skip(ftype)
28319 
      iprot.readFieldEnd()
28320 
    iprot.readStructEnd()
28321 
 
28322 
  def write(self, oprot):
28323 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28324 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28325 
      return
28326 
    oprot.writeStructBegin('updateItemHoldInventory_result')
28327 
    oprot.writeFieldStop()
28328 
    oprot.writeStructEnd()
28329 
 
28330 
  def validate(self):
28331 
    return
28332 
 
28333 
 
28334 
  def __repr__(self):
28335 
    L = ['%s=%r' % (key, value)
28336 
      for key, value in self.__dict__.iteritems()]
28337 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28338 
 
28339 
  def __eq__(self, other):
28340 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28341 
 
28342 
  def __ne__(self, other):
28343 
    return not (self == other)
9895 vikram.rag 28344 
 
28345 
class updateNlcAtMarketplaces_args:
28346 
  """
28347 
  Attributes:
28348 
   - item_id
28349 
   - vendor_id
28350 
   - nlc
28351 
  """
28352 
 
28353 
  thrift_spec = None
28354 
  def __init__(self, item_id=None, vendor_id=None, nlc=None,):
28355 
    self.item_id = item_id
28356 
    self.vendor_id = vendor_id
28357 
    self.nlc = nlc
28358 
 
28359 
  def read(self, iprot):
28360 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28361 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28362 
      return
28363 
    iprot.readStructBegin()
28364 
    while True:
28365 
      (fname, ftype, fid) = iprot.readFieldBegin()
28366 
      if ftype == TType.STOP:
28367 
        break
28368 
      if fid == 1:
28369 
        if ftype == TType.I64:
28370 
          self.item_id = iprot.readI64();
28371 
        else:
28372 
          iprot.skip(ftype)
28373 
      elif fid == 2:
28374 
        if ftype == TType.I64:
28375 
          self.vendor_id = iprot.readI64();
28376 
        else:
28377 
          iprot.skip(ftype)
28378 
      elif fid == -1:
28379 
        if ftype == TType.DOUBLE:
28380 
          self.nlc = iprot.readDouble();
28381 
        else:
28382 
          iprot.skip(ftype)
28383 
      else:
28384 
        iprot.skip(ftype)
28385 
      iprot.readFieldEnd()
28386 
    iprot.readStructEnd()
28387 
 
28388 
  def write(self, oprot):
28389 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28390 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28391 
      return
28392 
    oprot.writeStructBegin('updateNlcAtMarketplaces_args')
28393 
    if self.nlc is not None:
28394 
      oprot.writeFieldBegin('nlc', TType.DOUBLE, -1)
28395 
      oprot.writeDouble(self.nlc)
28396 
      oprot.writeFieldEnd()
28397 
    if self.item_id is not None:
28398 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
28399 
      oprot.writeI64(self.item_id)
28400 
      oprot.writeFieldEnd()
28401 
    if self.vendor_id is not None:
28402 
      oprot.writeFieldBegin('vendor_id', TType.I64, 2)
28403 
      oprot.writeI64(self.vendor_id)
28404 
      oprot.writeFieldEnd()
28405 
    oprot.writeFieldStop()
28406 
    oprot.writeStructEnd()
28407 
 
28408 
  def validate(self):
28409 
    return
28410 
 
28411 
 
28412 
  def __repr__(self):
28413 
    L = ['%s=%r' % (key, value)
28414 
      for key, value in self.__dict__.iteritems()]
28415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28416 
 
28417 
  def __eq__(self, other):
28418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28419 
 
28420 
  def __ne__(self, other):
28421 
    return not (self == other)
28422 
 
28423 
class updateNlcAtMarketplaces_result:
28424 
 
28425 
  thrift_spec = (
28426 
  )
28427 
 
28428 
  def read(self, iprot):
28429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28431 
      return
28432 
    iprot.readStructBegin()
28433 
    while True:
28434 
      (fname, ftype, fid) = iprot.readFieldBegin()
28435 
      if ftype == TType.STOP:
28436 
        break
28437 
      else:
28438 
        iprot.skip(ftype)
28439 
      iprot.readFieldEnd()
28440 
    iprot.readStructEnd()
28441 
 
28442 
  def write(self, oprot):
28443 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28444 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28445 
      return
28446 
    oprot.writeStructBegin('updateNlcAtMarketplaces_result')
28447 
    oprot.writeFieldStop()
28448 
    oprot.writeStructEnd()
28449 
 
28450 
  def validate(self):
28451 
    return
28452 
 
28453 
 
28454 
  def __repr__(self):
28455 
    L = ['%s=%r' % (key, value)
28456 
      for key, value in self.__dict__.iteritems()]
28457 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28458 
 
28459 
  def __eq__(self, other):
28460 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28461 
 
28462 
  def __ne__(self, other):
28463 
    return not (self == other)
9945 vikram.rag 28464 
 
28465 
class getAllFlipkartItems_args:
28466 
 
28467 
  thrift_spec = (
28468 
  )
28469 
 
28470 
  def read(self, iprot):
28471 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28472 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28473 
      return
28474 
    iprot.readStructBegin()
28475 
    while True:
28476 
      (fname, ftype, fid) = iprot.readFieldBegin()
28477 
      if ftype == TType.STOP:
28478 
        break
28479 
      else:
28480 
        iprot.skip(ftype)
28481 
      iprot.readFieldEnd()
28482 
    iprot.readStructEnd()
28483 
 
28484 
  def write(self, oprot):
28485 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28486 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28487 
      return
28488 
    oprot.writeStructBegin('getAllFlipkartItems_args')
28489 
    oprot.writeFieldStop()
28490 
    oprot.writeStructEnd()
28491 
 
28492 
  def validate(self):
28493 
    return
28494 
 
28495 
 
28496 
  def __repr__(self):
28497 
    L = ['%s=%r' % (key, value)
28498 
      for key, value in self.__dict__.iteritems()]
28499 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28500 
 
28501 
  def __eq__(self, other):
28502 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28503 
 
28504 
  def __ne__(self, other):
28505 
    return not (self == other)
28506 
 
28507 
class getAllFlipkartItems_result:
28508 
  """
28509 
  Attributes:
28510 
   - success
28511 
  """
28512 
 
28513 
  thrift_spec = (
28514 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartItem, FlipkartItem.thrift_spec)), None, ), # 0
28515 
  )
28516 
 
28517 
  def __init__(self, success=None,):
28518 
    self.success = success
28519 
 
28520 
  def read(self, iprot):
28521 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28522 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28523 
      return
28524 
    iprot.readStructBegin()
28525 
    while True:
28526 
      (fname, ftype, fid) = iprot.readFieldBegin()
28527 
      if ftype == TType.STOP:
28528 
        break
28529 
      if fid == 0:
28530 
        if ftype == TType.LIST:
28531 
          self.success = []
13493 amit.gupta 28532 
          (_etype606, _size603) = iprot.readListBegin()
28533 
          for _i607 in xrange(_size603):
28534 
            _elem608 = FlipkartItem()
28535 
            _elem608.read(iprot)
28536 
            self.success.append(_elem608)
9945 vikram.rag 28537 
          iprot.readListEnd()
28538 
        else:
28539 
          iprot.skip(ftype)
28540 
      else:
28541 
        iprot.skip(ftype)
28542 
      iprot.readFieldEnd()
28543 
    iprot.readStructEnd()
28544 
 
28545 
  def write(self, oprot):
28546 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28547 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28548 
      return
28549 
    oprot.writeStructBegin('getAllFlipkartItems_result')
28550 
    if self.success is not None:
28551 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28552 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 28553 
      for iter609 in self.success:
28554 
        iter609.write(oprot)
9945 vikram.rag 28555 
      oprot.writeListEnd()
28556 
      oprot.writeFieldEnd()
28557 
    oprot.writeFieldStop()
28558 
    oprot.writeStructEnd()
28559 
 
28560 
  def validate(self):
28561 
    return
28562 
 
28563 
 
28564 
  def __repr__(self):
28565 
    L = ['%s=%r' % (key, value)
28566 
      for key, value in self.__dict__.iteritems()]
28567 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28568 
 
28569 
  def __eq__(self, other):
28570 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28571 
 
28572 
  def __ne__(self, other):
28573 
    return not (self == other)
10097 kshitij.so 28574 
 
28575 
class addOrUpdateFlipkartItem_args:
28576 
  """
28577 
  Attributes:
28578 
   - flipkartitem
28579 
  """
28580 
 
28581 
  thrift_spec = None
28582 
  def __init__(self, flipkartitem=None,):
28583 
    self.flipkartitem = flipkartitem
28584 
 
28585 
  def read(self, iprot):
28586 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28587 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28588 
      return
28589 
    iprot.readStructBegin()
28590 
    while True:
28591 
      (fname, ftype, fid) = iprot.readFieldBegin()
28592 
      if ftype == TType.STOP:
28593 
        break
28594 
      if fid == -1:
28595 
        if ftype == TType.STRUCT:
28596 
          self.flipkartitem = FlipkartItem()
28597 
          self.flipkartitem.read(iprot)
28598 
        else:
28599 
          iprot.skip(ftype)
28600 
      else:
28601 
        iprot.skip(ftype)
28602 
      iprot.readFieldEnd()
28603 
    iprot.readStructEnd()
28604 
 
28605 
  def write(self, oprot):
28606 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28607 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28608 
      return
28609 
    oprot.writeStructBegin('addOrUpdateFlipkartItem_args')
28610 
    if self.flipkartitem is not None:
28611 
      oprot.writeFieldBegin('flipkartitem', TType.STRUCT, -1)
28612 
      self.flipkartitem.write(oprot)
28613 
      oprot.writeFieldEnd()
28614 
    oprot.writeFieldStop()
28615 
    oprot.writeStructEnd()
28616 
 
28617 
  def validate(self):
28618 
    return
28619 
 
28620 
 
28621 
  def __repr__(self):
28622 
    L = ['%s=%r' % (key, value)
28623 
      for key, value in self.__dict__.iteritems()]
28624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28625 
 
28626 
  def __eq__(self, other):
28627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28628 
 
28629 
  def __ne__(self, other):
28630 
    return not (self == other)
28631 
 
28632 
class addOrUpdateFlipkartItem_result:
28633 
  """
28634 
  Attributes:
28635 
   - success
28636 
  """
28637 
 
28638 
  thrift_spec = (
28639 
    (0, TType.BOOL, 'success', None, None, ), # 0
28640 
  )
28641 
 
28642 
  def __init__(self, success=None,):
28643 
    self.success = success
28644 
 
28645 
  def read(self, iprot):
28646 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28647 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28648 
      return
28649 
    iprot.readStructBegin()
28650 
    while True:
28651 
      (fname, ftype, fid) = iprot.readFieldBegin()
28652 
      if ftype == TType.STOP:
28653 
        break
28654 
      if fid == 0:
28655 
        if ftype == TType.BOOL:
28656 
          self.success = iprot.readBool();
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('addOrUpdateFlipkartItem_result')
28669 
    if self.success is not None:
28670 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
28671 
      oprot.writeBool(self.success)
28672 
      oprot.writeFieldEnd()
28673 
    oprot.writeFieldStop()
28674 
    oprot.writeStructEnd()
28675 
 
28676 
  def validate(self):
28677 
    return
28678 
 
28679 
 
28680 
  def __repr__(self):
28681 
    L = ['%s=%r' % (key, value)
28682 
      for key, value in self.__dict__.iteritems()]
28683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28684 
 
28685 
  def __eq__(self, other):
28686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28687 
 
28688 
  def __ne__(self, other):
28689 
    return not (self == other)
28690 
 
28691 
class getFlipkartItem_args:
28692 
  """
28693 
  Attributes:
28694 
   - item_id
28695 
  """
28696 
 
28697 
  thrift_spec = (
28698 
    None, # 0
28699 
    (1, TType.I64, 'item_id', None, None, ), # 1
28700 
  )
28701 
 
28702 
  def __init__(self, item_id=None,):
28703 
    self.item_id = item_id
28704 
 
28705 
  def read(self, iprot):
28706 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28707 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28708 
      return
28709 
    iprot.readStructBegin()
28710 
    while True:
28711 
      (fname, ftype, fid) = iprot.readFieldBegin()
28712 
      if ftype == TType.STOP:
28713 
        break
28714 
      if fid == 1:
28715 
        if ftype == TType.I64:
28716 
          self.item_id = iprot.readI64();
28717 
        else:
28718 
          iprot.skip(ftype)
28719 
      else:
28720 
        iprot.skip(ftype)
28721 
      iprot.readFieldEnd()
28722 
    iprot.readStructEnd()
28723 
 
28724 
  def write(self, oprot):
28725 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28726 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28727 
      return
28728 
    oprot.writeStructBegin('getFlipkartItem_args')
28729 
    if self.item_id is not None:
28730 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
28731 
      oprot.writeI64(self.item_id)
28732 
      oprot.writeFieldEnd()
28733 
    oprot.writeFieldStop()
28734 
    oprot.writeStructEnd()
28735 
 
28736 
  def validate(self):
28737 
    return
28738 
 
28739 
 
28740 
  def __repr__(self):
28741 
    L = ['%s=%r' % (key, value)
28742 
      for key, value in self.__dict__.iteritems()]
28743 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28744 
 
28745 
  def __eq__(self, other):
28746 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28747 
 
28748 
  def __ne__(self, other):
28749 
    return not (self == other)
28750 
 
28751 
class getFlipkartItem_result:
28752 
  """
28753 
  Attributes:
28754 
   - success
28755 
  """
28756 
 
28757 
  thrift_spec = (
28758 
    (0, TType.STRUCT, 'success', (FlipkartItem, FlipkartItem.thrift_spec), None, ), # 0
28759 
  )
28760 
 
28761 
  def __init__(self, success=None,):
28762 
    self.success = success
28763 
 
28764 
  def read(self, iprot):
28765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28767 
      return
28768 
    iprot.readStructBegin()
28769 
    while True:
28770 
      (fname, ftype, fid) = iprot.readFieldBegin()
28771 
      if ftype == TType.STOP:
28772 
        break
28773 
      if fid == 0:
28774 
        if ftype == TType.STRUCT:
28775 
          self.success = FlipkartItem()
28776 
          self.success.read(iprot)
28777 
        else:
28778 
          iprot.skip(ftype)
28779 
      else:
28780 
        iprot.skip(ftype)
28781 
      iprot.readFieldEnd()
28782 
    iprot.readStructEnd()
28783 
 
28784 
  def write(self, oprot):
28785 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28786 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28787 
      return
28788 
    oprot.writeStructBegin('getFlipkartItem_result')
28789 
    if self.success is not None:
28790 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28791 
      self.success.write(oprot)
28792 
      oprot.writeFieldEnd()
28793 
    oprot.writeFieldStop()
28794 
    oprot.writeStructEnd()
28795 
 
28796 
  def validate(self):
28797 
    return
28798 
 
28799 
 
28800 
  def __repr__(self):
28801 
    L = ['%s=%r' % (key, value)
28802 
      for key, value in self.__dict__.iteritems()]
28803 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28804 
 
28805 
  def __eq__(self, other):
28806 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28807 
 
28808 
  def __ne__(self, other):
28809 
    return not (self == other)
28810 
 
28811 
class getFlipkartItemDetails_args:
28812 
  """
28813 
  Attributes:
28814 
   - item_id
28815 
  """
28816 
 
28817 
  thrift_spec = (
28818 
    None, # 0
28819 
    (1, TType.I64, 'item_id', None, None, ), # 1
28820 
  )
28821 
 
28822 
  def __init__(self, item_id=None,):
28823 
    self.item_id = item_id
28824 
 
28825 
  def read(self, iprot):
28826 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28827 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28828 
      return
28829 
    iprot.readStructBegin()
28830 
    while True:
28831 
      (fname, ftype, fid) = iprot.readFieldBegin()
28832 
      if ftype == TType.STOP:
28833 
        break
28834 
      if fid == 1:
28835 
        if ftype == TType.I64:
28836 
          self.item_id = iprot.readI64();
28837 
        else:
28838 
          iprot.skip(ftype)
28839 
      else:
28840 
        iprot.skip(ftype)
28841 
      iprot.readFieldEnd()
28842 
    iprot.readStructEnd()
28843 
 
28844 
  def write(self, oprot):
28845 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28846 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28847 
      return
28848 
    oprot.writeStructBegin('getFlipkartItemDetails_args')
28849 
    if self.item_id is not None:
28850 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
28851 
      oprot.writeI64(self.item_id)
28852 
      oprot.writeFieldEnd()
28853 
    oprot.writeFieldStop()
28854 
    oprot.writeStructEnd()
28855 
 
28856 
  def validate(self):
28857 
    return
28858 
 
28859 
 
28860 
  def __repr__(self):
28861 
    L = ['%s=%r' % (key, value)
28862 
      for key, value in self.__dict__.iteritems()]
28863 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28864 
 
28865 
  def __eq__(self, other):
28866 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28867 
 
28868 
  def __ne__(self, other):
28869 
    return not (self == other)
28870 
 
28871 
class getFlipkartItemDetails_result:
28872 
  """
28873 
  Attributes:
28874 
   - success
28875 
  """
28876 
 
28877 
  thrift_spec = (
28878 
    (0, TType.STRUCT, 'success', (FlipkartItemDetails, FlipkartItemDetails.thrift_spec), None, ), # 0
28879 
  )
28880 
 
28881 
  def __init__(self, success=None,):
28882 
    self.success = success
28883 
 
28884 
  def read(self, iprot):
28885 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28886 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28887 
      return
28888 
    iprot.readStructBegin()
28889 
    while True:
28890 
      (fname, ftype, fid) = iprot.readFieldBegin()
28891 
      if ftype == TType.STOP:
28892 
        break
28893 
      if fid == 0:
28894 
        if ftype == TType.STRUCT:
28895 
          self.success = FlipkartItemDetails()
28896 
          self.success.read(iprot)
28897 
        else:
28898 
          iprot.skip(ftype)
28899 
      else:
28900 
        iprot.skip(ftype)
28901 
      iprot.readFieldEnd()
28902 
    iprot.readStructEnd()
28903 
 
28904 
  def write(self, oprot):
28905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28907 
      return
28908 
    oprot.writeStructBegin('getFlipkartItemDetails_result')
28909 
    if self.success is not None:
28910 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28911 
      self.success.write(oprot)
28912 
      oprot.writeFieldEnd()
28913 
    oprot.writeFieldStop()
28914 
    oprot.writeStructEnd()
28915 
 
28916 
  def validate(self):
28917 
    return
28918 
 
28919 
 
28920 
  def __repr__(self):
28921 
    L = ['%s=%r' % (key, value)
28922 
      for key, value in self.__dict__.iteritems()]
28923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28924 
 
28925 
  def __eq__(self, other):
28926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28927 
 
28928 
  def __ne__(self, other):
28929 
    return not (self == other)
28930 
 
28931 
class getFlipkartItems_args:
28932 
  """
28933 
  Attributes:
28934 
   - offset
28935 
   - limit
28936 
  """
28937 
 
28938 
  thrift_spec = (
28939 
    None, # 0
28940 
    (1, TType.I64, 'offset', None, None, ), # 1
28941 
    (2, TType.I64, 'limit', None, None, ), # 2
28942 
  )
28943 
 
28944 
  def __init__(self, offset=None, limit=None,):
28945 
    self.offset = offset
28946 
    self.limit = limit
28947 
 
28948 
  def read(self, iprot):
28949 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28950 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28951 
      return
28952 
    iprot.readStructBegin()
28953 
    while True:
28954 
      (fname, ftype, fid) = iprot.readFieldBegin()
28955 
      if ftype == TType.STOP:
28956 
        break
28957 
      if fid == 1:
28958 
        if ftype == TType.I64:
28959 
          self.offset = iprot.readI64();
28960 
        else:
28961 
          iprot.skip(ftype)
28962 
      elif fid == 2:
28963 
        if ftype == TType.I64:
28964 
          self.limit = iprot.readI64();
28965 
        else:
28966 
          iprot.skip(ftype)
28967 
      else:
28968 
        iprot.skip(ftype)
28969 
      iprot.readFieldEnd()
28970 
    iprot.readStructEnd()
28971 
 
28972 
  def write(self, oprot):
28973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28975 
      return
28976 
    oprot.writeStructBegin('getFlipkartItems_args')
28977 
    if self.offset is not None:
28978 
      oprot.writeFieldBegin('offset', TType.I64, 1)
28979 
      oprot.writeI64(self.offset)
28980 
      oprot.writeFieldEnd()
28981 
    if self.limit is not None:
28982 
      oprot.writeFieldBegin('limit', TType.I64, 2)
28983 
      oprot.writeI64(self.limit)
28984 
      oprot.writeFieldEnd()
28985 
    oprot.writeFieldStop()
28986 
    oprot.writeStructEnd()
28987 
 
28988 
  def validate(self):
28989 
    return
28990 
 
28991 
 
28992 
  def __repr__(self):
28993 
    L = ['%s=%r' % (key, value)
28994 
      for key, value in self.__dict__.iteritems()]
28995 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28996 
 
28997 
  def __eq__(self, other):
28998 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28999 
 
29000 
  def __ne__(self, other):
29001 
    return not (self == other)
29002 
 
29003 
class getFlipkartItems_result:
29004 
  """
29005 
  Attributes:
29006 
   - success
29007 
  """
29008 
 
29009 
  thrift_spec = (
29010 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartItemDetails, FlipkartItemDetails.thrift_spec)), None, ), # 0
29011 
  )
29012 
 
29013 
  def __init__(self, success=None,):
29014 
    self.success = success
29015 
 
29016 
  def read(self, iprot):
29017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29019 
      return
29020 
    iprot.readStructBegin()
29021 
    while True:
29022 
      (fname, ftype, fid) = iprot.readFieldBegin()
29023 
      if ftype == TType.STOP:
29024 
        break
29025 
      if fid == 0:
29026 
        if ftype == TType.LIST:
29027 
          self.success = []
13493 amit.gupta 29028 
          (_etype613, _size610) = iprot.readListBegin()
29029 
          for _i614 in xrange(_size610):
29030 
            _elem615 = FlipkartItemDetails()
29031 
            _elem615.read(iprot)
29032 
            self.success.append(_elem615)
10097 kshitij.so 29033 
          iprot.readListEnd()
29034 
        else:
29035 
          iprot.skip(ftype)
29036 
      else:
29037 
        iprot.skip(ftype)
29038 
      iprot.readFieldEnd()
29039 
    iprot.readStructEnd()
29040 
 
29041 
  def write(self, oprot):
29042 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29043 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29044 
      return
29045 
    oprot.writeStructBegin('getFlipkartItems_result')
29046 
    if self.success is not None:
29047 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29048 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 29049 
      for iter616 in self.success:
29050 
        iter616.write(oprot)
10097 kshitij.so 29051 
      oprot.writeListEnd()
29052 
      oprot.writeFieldEnd()
29053 
    oprot.writeFieldStop()
29054 
    oprot.writeStructEnd()
29055 
 
29056 
  def validate(self):
29057 
    return
29058 
 
29059 
 
29060 
  def __repr__(self):
29061 
    L = ['%s=%r' % (key, value)
29062 
      for key, value in self.__dict__.iteritems()]
29063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29064 
 
29065 
  def __eq__(self, other):
29066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29067 
 
29068 
  def __ne__(self, other):
29069 
    return not (self == other)
29070 
 
29071 
class searchFlipkartItems_args:
29072 
  """
29073 
  Attributes:
29074 
   - searchTerm
29075 
   - offset
29076 
   - limit
29077 
  """
29078 
 
29079 
  thrift_spec = (
29080 
    None, # 0
29081 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
29082 
    (2, TType.I64, 'offset', None, None, ), # 2
29083 
    (3, TType.I64, 'limit', None, None, ), # 3
29084 
  )
29085 
 
29086 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
29087 
    self.searchTerm = searchTerm
29088 
    self.offset = offset
29089 
    self.limit = limit
29090 
 
29091 
  def read(self, iprot):
29092 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29093 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29094 
      return
29095 
    iprot.readStructBegin()
29096 
    while True:
29097 
      (fname, ftype, fid) = iprot.readFieldBegin()
29098 
      if ftype == TType.STOP:
29099 
        break
29100 
      if fid == 1:
29101 
        if ftype == TType.LIST:
29102 
          self.searchTerm = []
13493 amit.gupta 29103 
          (_etype620, _size617) = iprot.readListBegin()
29104 
          for _i621 in xrange(_size617):
29105 
            _elem622 = iprot.readString();
29106 
            self.searchTerm.append(_elem622)
10097 kshitij.so 29107 
          iprot.readListEnd()
29108 
        else:
29109 
          iprot.skip(ftype)
29110 
      elif fid == 2:
29111 
        if ftype == TType.I64:
29112 
          self.offset = iprot.readI64();
29113 
        else:
29114 
          iprot.skip(ftype)
29115 
      elif fid == 3:
29116 
        if ftype == TType.I64:
29117 
          self.limit = iprot.readI64();
29118 
        else:
29119 
          iprot.skip(ftype)
29120 
      else:
29121 
        iprot.skip(ftype)
29122 
      iprot.readFieldEnd()
29123 
    iprot.readStructEnd()
29124 
 
29125 
  def write(self, oprot):
29126 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29127 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29128 
      return
29129 
    oprot.writeStructBegin('searchFlipkartItems_args')
29130 
    if self.searchTerm is not None:
29131 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
29132 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
13493 amit.gupta 29133 
      for iter623 in self.searchTerm:
29134 
        oprot.writeString(iter623)
10097 kshitij.so 29135 
      oprot.writeListEnd()
29136 
      oprot.writeFieldEnd()
29137 
    if self.offset is not None:
29138 
      oprot.writeFieldBegin('offset', TType.I64, 2)
29139 
      oprot.writeI64(self.offset)
29140 
      oprot.writeFieldEnd()
29141 
    if self.limit is not None:
29142 
      oprot.writeFieldBegin('limit', TType.I64, 3)
29143 
      oprot.writeI64(self.limit)
29144 
      oprot.writeFieldEnd()
29145 
    oprot.writeFieldStop()
29146 
    oprot.writeStructEnd()
29147 
 
29148 
  def validate(self):
29149 
    return
29150 
 
29151 
 
29152 
  def __repr__(self):
29153 
    L = ['%s=%r' % (key, value)
29154 
      for key, value in self.__dict__.iteritems()]
29155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29156 
 
29157 
  def __eq__(self, other):
29158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29159 
 
29160 
  def __ne__(self, other):
29161 
    return not (self == other)
29162 
 
29163 
class searchFlipkartItems_result:
29164 
  """
29165 
  Attributes:
29166 
   - success
29167 
  """
29168 
 
29169 
  thrift_spec = (
29170 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartItemDetails, FlipkartItemDetails.thrift_spec)), None, ), # 0
29171 
  )
29172 
 
29173 
  def __init__(self, success=None,):
29174 
    self.success = success
29175 
 
29176 
  def read(self, iprot):
29177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29179 
      return
29180 
    iprot.readStructBegin()
29181 
    while True:
29182 
      (fname, ftype, fid) = iprot.readFieldBegin()
29183 
      if ftype == TType.STOP:
29184 
        break
29185 
      if fid == 0:
29186 
        if ftype == TType.LIST:
29187 
          self.success = []
13493 amit.gupta 29188 
          (_etype627, _size624) = iprot.readListBegin()
29189 
          for _i628 in xrange(_size624):
29190 
            _elem629 = FlipkartItemDetails()
29191 
            _elem629.read(iprot)
29192 
            self.success.append(_elem629)
10097 kshitij.so 29193 
          iprot.readListEnd()
29194 
        else:
29195 
          iprot.skip(ftype)
29196 
      else:
29197 
        iprot.skip(ftype)
29198 
      iprot.readFieldEnd()
29199 
    iprot.readStructEnd()
29200 
 
29201 
  def write(self, oprot):
29202 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29203 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29204 
      return
29205 
    oprot.writeStructBegin('searchFlipkartItems_result')
29206 
    if self.success is not None:
29207 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29208 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 29209 
      for iter630 in self.success:
29210 
        iter630.write(oprot)
10097 kshitij.so 29211 
      oprot.writeListEnd()
29212 
      oprot.writeFieldEnd()
29213 
    oprot.writeFieldStop()
29214 
    oprot.writeStructEnd()
29215 
 
29216 
  def validate(self):
29217 
    return
29218 
 
29219 
 
29220 
  def __repr__(self):
29221 
    L = ['%s=%r' % (key, value)
29222 
      for key, value in self.__dict__.iteritems()]
29223 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29224 
 
29225 
  def __eq__(self, other):
29226 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29227 
 
29228 
  def __ne__(self, other):
29229 
    return not (self == other)
29230 
 
29231 
class getCountForFlipkartItems_args:
29232 
 
29233 
  thrift_spec = (
29234 
  )
29235 
 
29236 
  def read(self, iprot):
29237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29239 
      return
29240 
    iprot.readStructBegin()
29241 
    while True:
29242 
      (fname, ftype, fid) = iprot.readFieldBegin()
29243 
      if ftype == TType.STOP:
29244 
        break
29245 
      else:
29246 
        iprot.skip(ftype)
29247 
      iprot.readFieldEnd()
29248 
    iprot.readStructEnd()
29249 
 
29250 
  def write(self, oprot):
29251 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29252 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29253 
      return
29254 
    oprot.writeStructBegin('getCountForFlipkartItems_args')
29255 
    oprot.writeFieldStop()
29256 
    oprot.writeStructEnd()
29257 
 
29258 
  def validate(self):
29259 
    return
29260 
 
29261 
 
29262 
  def __repr__(self):
29263 
    L = ['%s=%r' % (key, value)
29264 
      for key, value in self.__dict__.iteritems()]
29265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29266 
 
29267 
  def __eq__(self, other):
29268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29269 
 
29270 
  def __ne__(self, other):
29271 
    return not (self == other)
29272 
 
29273 
class getCountForFlipkartItems_result:
29274 
  """
29275 
  Attributes:
29276 
   - success
29277 
  """
29278 
 
29279 
  thrift_spec = (
29280 
    (0, TType.I64, 'success', None, None, ), # 0
29281 
  )
29282 
 
29283 
  def __init__(self, success=None,):
29284 
    self.success = success
29285 
 
29286 
  def read(self, iprot):
29287 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29288 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29289 
      return
29290 
    iprot.readStructBegin()
29291 
    while True:
29292 
      (fname, ftype, fid) = iprot.readFieldBegin()
29293 
      if ftype == TType.STOP:
29294 
        break
29295 
      if fid == 0:
29296 
        if ftype == TType.I64:
29297 
          self.success = iprot.readI64();
29298 
        else:
29299 
          iprot.skip(ftype)
29300 
      else:
29301 
        iprot.skip(ftype)
29302 
      iprot.readFieldEnd()
29303 
    iprot.readStructEnd()
29304 
 
29305 
  def write(self, oprot):
29306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29308 
      return
29309 
    oprot.writeStructBegin('getCountForFlipkartItems_result')
29310 
    if self.success is not None:
29311 
      oprot.writeFieldBegin('success', TType.I64, 0)
29312 
      oprot.writeI64(self.success)
29313 
      oprot.writeFieldEnd()
29314 
    oprot.writeFieldStop()
29315 
    oprot.writeStructEnd()
29316 
 
29317 
  def validate(self):
29318 
    return
29319 
 
29320 
 
29321 
  def __repr__(self):
29322 
    L = ['%s=%r' % (key, value)
29323 
      for key, value in self.__dict__.iteritems()]
29324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29325 
 
29326 
  def __eq__(self, other):
29327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29328 
 
29329 
  def __ne__(self, other):
29330 
    return not (self == other)
29331 
 
29332 
class getFlipkartSearchResultCount_args:
29333 
  """
29334 
  Attributes:
29335 
   - searchTerm
29336 
  """
29337 
 
29338 
  thrift_spec = (
29339 
    None, # 0
29340 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
29341 
  )
29342 
 
29343 
  def __init__(self, searchTerm=None,):
29344 
    self.searchTerm = searchTerm
29345 
 
29346 
  def read(self, iprot):
29347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29349 
      return
29350 
    iprot.readStructBegin()
29351 
    while True:
29352 
      (fname, ftype, fid) = iprot.readFieldBegin()
29353 
      if ftype == TType.STOP:
29354 
        break
29355 
      if fid == 1:
29356 
        if ftype == TType.LIST:
29357 
          self.searchTerm = []
13493 amit.gupta 29358 
          (_etype634, _size631) = iprot.readListBegin()
29359 
          for _i635 in xrange(_size631):
29360 
            _elem636 = iprot.readString();
29361 
            self.searchTerm.append(_elem636)
10097 kshitij.so 29362 
          iprot.readListEnd()
29363 
        else:
29364 
          iprot.skip(ftype)
29365 
      else:
29366 
        iprot.skip(ftype)
29367 
      iprot.readFieldEnd()
29368 
    iprot.readStructEnd()
29369 
 
29370 
  def write(self, oprot):
29371 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29372 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29373 
      return
29374 
    oprot.writeStructBegin('getFlipkartSearchResultCount_args')
29375 
    if self.searchTerm is not None:
29376 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
29377 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
13493 amit.gupta 29378 
      for iter637 in self.searchTerm:
29379 
        oprot.writeString(iter637)
10097 kshitij.so 29380 
      oprot.writeListEnd()
29381 
      oprot.writeFieldEnd()
29382 
    oprot.writeFieldStop()
29383 
    oprot.writeStructEnd()
29384 
 
29385 
  def validate(self):
29386 
    return
29387 
 
29388 
 
29389 
  def __repr__(self):
29390 
    L = ['%s=%r' % (key, value)
29391 
      for key, value in self.__dict__.iteritems()]
29392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29393 
 
29394 
  def __eq__(self, other):
29395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29396 
 
29397 
  def __ne__(self, other):
29398 
    return not (self == other)
29399 
 
29400 
class getFlipkartSearchResultCount_result:
29401 
  """
29402 
  Attributes:
29403 
   - success
29404 
  """
29405 
 
29406 
  thrift_spec = (
29407 
    (0, TType.I64, 'success', None, None, ), # 0
29408 
  )
29409 
 
29410 
  def __init__(self, success=None,):
29411 
    self.success = success
29412 
 
29413 
  def read(self, iprot):
29414 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29415 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29416 
      return
29417 
    iprot.readStructBegin()
29418 
    while True:
29419 
      (fname, ftype, fid) = iprot.readFieldBegin()
29420 
      if ftype == TType.STOP:
29421 
        break
29422 
      if fid == 0:
29423 
        if ftype == TType.I64:
29424 
          self.success = iprot.readI64();
29425 
        else:
29426 
          iprot.skip(ftype)
29427 
      else:
29428 
        iprot.skip(ftype)
29429 
      iprot.readFieldEnd()
29430 
    iprot.readStructEnd()
29431 
 
29432 
  def write(self, oprot):
29433 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29434 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29435 
      return
29436 
    oprot.writeStructBegin('getFlipkartSearchResultCount_result')
29437 
    if self.success is not None:
29438 
      oprot.writeFieldBegin('success', TType.I64, 0)
29439 
      oprot.writeI64(self.success)
29440 
      oprot.writeFieldEnd()
29441 
    oprot.writeFieldStop()
29442 
    oprot.writeStructEnd()
29443 
 
29444 
  def validate(self):
29445 
    return
29446 
 
29447 
 
29448 
  def __repr__(self):
29449 
    L = ['%s=%r' % (key, value)
29450 
      for key, value in self.__dict__.iteritems()]
29451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29452 
 
29453 
  def __eq__(self, other):
29454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29455 
 
29456 
  def __ne__(self, other):
29457 
    return not (self == other)
29458 
 
29459 
class getAllFkItems_args:
29460 
 
29461 
  thrift_spec = (
29462 
  )
29463 
 
29464 
  def read(self, iprot):
29465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29467 
      return
29468 
    iprot.readStructBegin()
29469 
    while True:
29470 
      (fname, ftype, fid) = iprot.readFieldBegin()
29471 
      if ftype == TType.STOP:
29472 
        break
29473 
      else:
29474 
        iprot.skip(ftype)
29475 
      iprot.readFieldEnd()
29476 
    iprot.readStructEnd()
29477 
 
29478 
  def write(self, oprot):
29479 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29480 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29481 
      return
29482 
    oprot.writeStructBegin('getAllFkItems_args')
29483 
    oprot.writeFieldStop()
29484 
    oprot.writeStructEnd()
29485 
 
29486 
  def validate(self):
29487 
    return
29488 
 
29489 
 
29490 
  def __repr__(self):
29491 
    L = ['%s=%r' % (key, value)
29492 
      for key, value in self.__dict__.iteritems()]
29493 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29494 
 
29495 
  def __eq__(self, other):
29496 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29497 
 
29498 
  def __ne__(self, other):
29499 
    return not (self == other)
29500 
 
29501 
class getAllFkItems_result:
29502 
  """
29503 
  Attributes:
29504 
   - success
29505 
  """
29506 
 
29507 
  thrift_spec = (
29508 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartItemDetails, FlipkartItemDetails.thrift_spec)), None, ), # 0
29509 
  )
29510 
 
29511 
  def __init__(self, success=None,):
29512 
    self.success = success
29513 
 
29514 
  def read(self, iprot):
29515 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29516 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29517 
      return
29518 
    iprot.readStructBegin()
29519 
    while True:
29520 
      (fname, ftype, fid) = iprot.readFieldBegin()
29521 
      if ftype == TType.STOP:
29522 
        break
29523 
      if fid == 0:
29524 
        if ftype == TType.LIST:
29525 
          self.success = []
13493 amit.gupta 29526 
          (_etype641, _size638) = iprot.readListBegin()
29527 
          for _i642 in xrange(_size638):
29528 
            _elem643 = FlipkartItemDetails()
29529 
            _elem643.read(iprot)
29530 
            self.success.append(_elem643)
10097 kshitij.so 29531 
          iprot.readListEnd()
29532 
        else:
29533 
          iprot.skip(ftype)
29534 
      else:
29535 
        iprot.skip(ftype)
29536 
      iprot.readFieldEnd()
29537 
    iprot.readStructEnd()
29538 
 
29539 
  def write(self, oprot):
29540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29542 
      return
29543 
    oprot.writeStructBegin('getAllFkItems_result')
29544 
    if self.success is not None:
29545 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29546 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 29547 
      for iter644 in self.success:
29548 
        iter644.write(oprot)
10097 kshitij.so 29549 
      oprot.writeListEnd()
29550 
      oprot.writeFieldEnd()
29551 
    oprot.writeFieldStop()
29552 
    oprot.writeStructEnd()
29553 
 
29554 
  def validate(self):
29555 
    return
29556 
 
29557 
 
29558 
  def __repr__(self):
29559 
    L = ['%s=%r' % (key, value)
29560 
      for key, value in self.__dict__.iteritems()]
29561 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29562 
 
29563 
  def __eq__(self, other):
29564 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29565 
 
29566 
  def __ne__(self, other):
29567 
    return not (self == other)
10140 vikram.rag 29568 
 
29569 
class getFlipkartItemBySkyAtFlipkart_args:
29570 
  """
29571 
  Attributes:
29572 
   - sku
29573 
  """
29574 
 
11531 vikram.rag 29575 
  thrift_spec = None
10140 vikram.rag 29576 
  def __init__(self, sku=None,):
29577 
    self.sku = sku
29578 
 
29579 
  def read(self, iprot):
29580 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29581 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29582 
      return
29583 
    iprot.readStructBegin()
29584 
    while True:
29585 
      (fname, ftype, fid) = iprot.readFieldBegin()
29586 
      if ftype == TType.STOP:
29587 
        break
11531 vikram.rag 29588 
      if fid == -1:
10140 vikram.rag 29589 
        if ftype == TType.STRING:
29590 
          self.sku = iprot.readString();
29591 
        else:
29592 
          iprot.skip(ftype)
29593 
      else:
29594 
        iprot.skip(ftype)
29595 
      iprot.readFieldEnd()
29596 
    iprot.readStructEnd()
29597 
 
29598 
  def write(self, oprot):
29599 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29600 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29601 
      return
29602 
    oprot.writeStructBegin('getFlipkartItemBySkyAtFlipkart_args')
29603 
    if self.sku is not None:
11531 vikram.rag 29604 
      oprot.writeFieldBegin('sku', TType.STRING, -1)
10140 vikram.rag 29605 
      oprot.writeString(self.sku)
29606 
      oprot.writeFieldEnd()
29607 
    oprot.writeFieldStop()
29608 
    oprot.writeStructEnd()
29609 
 
29610 
  def validate(self):
29611 
    return
29612 
 
29613 
 
29614 
  def __repr__(self):
29615 
    L = ['%s=%r' % (key, value)
29616 
      for key, value in self.__dict__.iteritems()]
29617 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29618 
 
29619 
  def __eq__(self, other):
29620 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29621 
 
29622 
  def __ne__(self, other):
29623 
    return not (self == other)
29624 
 
29625 
class getFlipkartItemBySkyAtFlipkart_result:
29626 
  """
29627 
  Attributes:
29628 
   - success
29629 
  """
29630 
 
29631 
  thrift_spec = (
29632 
    (0, TType.STRUCT, 'success', (FlipkartItem, FlipkartItem.thrift_spec), None, ), # 0
29633 
  )
29634 
 
29635 
  def __init__(self, success=None,):
29636 
    self.success = success
29637 
 
29638 
  def read(self, iprot):
29639 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29640 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29641 
      return
29642 
    iprot.readStructBegin()
29643 
    while True:
29644 
      (fname, ftype, fid) = iprot.readFieldBegin()
29645 
      if ftype == TType.STOP:
29646 
        break
29647 
      if fid == 0:
29648 
        if ftype == TType.STRUCT:
29649 
          self.success = FlipkartItem()
29650 
          self.success.read(iprot)
29651 
        else:
29652 
          iprot.skip(ftype)
29653 
      else:
29654 
        iprot.skip(ftype)
29655 
      iprot.readFieldEnd()
29656 
    iprot.readStructEnd()
29657 
 
29658 
  def write(self, oprot):
29659 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29660 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29661 
      return
29662 
    oprot.writeStructBegin('getFlipkartItemBySkyAtFlipkart_result')
29663 
    if self.success is not None:
29664 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
29665 
      self.success.write(oprot)
29666 
      oprot.writeFieldEnd()
29667 
    oprot.writeFieldStop()
29668 
    oprot.writeStructEnd()
29669 
 
29670 
  def validate(self):
29671 
    return
29672 
 
29673 
 
29674 
  def __repr__(self):
29675 
    L = ['%s=%r' % (key, value)
29676 
      for key, value in self.__dict__.iteritems()]
29677 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29678 
 
29679 
  def __eq__(self, other):
29680 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29681 
 
29682 
  def __ne__(self, other):
29683 
    return not (self == other)
10909 vikram.rag 29684 
 
11015 kshitij.so 29685 
class getMarketplaceHistory_args:
29686 
  """
29687 
  Attributes:
29688 
   - source
29689 
   - offset
29690 
   - itemId
29691 
  """
10909 vikram.rag 29692 
 
29693 
  thrift_spec = (
11015 kshitij.so 29694 
    None, # 0
29695 
    (1, TType.I64, 'source', None, None, ), # 1
29696 
    (2, TType.I64, 'offset', None, None, ), # 2
29697 
    (3, TType.I64, 'itemId', None, None, ), # 3
10909 vikram.rag 29698 
  )
29699 
 
11015 kshitij.so 29700 
  def __init__(self, source=None, offset=None, itemId=None,):
29701 
    self.source = source
29702 
    self.offset = offset
29703 
    self.itemId = itemId
29704 
 
10909 vikram.rag 29705 
  def read(self, iprot):
29706 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29707 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29708 
      return
29709 
    iprot.readStructBegin()
29710 
    while True:
29711 
      (fname, ftype, fid) = iprot.readFieldBegin()
29712 
      if ftype == TType.STOP:
29713 
        break
11015 kshitij.so 29714 
      if fid == 1:
29715 
        if ftype == TType.I64:
29716 
          self.source = iprot.readI64();
29717 
        else:
29718 
          iprot.skip(ftype)
29719 
      elif fid == 2:
29720 
        if ftype == TType.I64:
29721 
          self.offset = iprot.readI64();
29722 
        else:
29723 
          iprot.skip(ftype)
29724 
      elif fid == 3:
29725 
        if ftype == TType.I64:
29726 
          self.itemId = iprot.readI64();
29727 
        else:
29728 
          iprot.skip(ftype)
10909 vikram.rag 29729 
      else:
29730 
        iprot.skip(ftype)
29731 
      iprot.readFieldEnd()
29732 
    iprot.readStructEnd()
29733 
 
29734 
  def write(self, oprot):
29735 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29736 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29737 
      return
11015 kshitij.so 29738 
    oprot.writeStructBegin('getMarketplaceHistory_args')
29739 
    if self.source is not None:
29740 
      oprot.writeFieldBegin('source', TType.I64, 1)
29741 
      oprot.writeI64(self.source)
29742 
      oprot.writeFieldEnd()
29743 
    if self.offset is not None:
29744 
      oprot.writeFieldBegin('offset', TType.I64, 2)
29745 
      oprot.writeI64(self.offset)
29746 
      oprot.writeFieldEnd()
29747 
    if self.itemId is not None:
29748 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
29749 
      oprot.writeI64(self.itemId)
29750 
      oprot.writeFieldEnd()
10909 vikram.rag 29751 
    oprot.writeFieldStop()
29752 
    oprot.writeStructEnd()
29753 
 
29754 
  def validate(self):
29755 
    return
29756 
 
29757 
 
29758 
  def __repr__(self):
29759 
    L = ['%s=%r' % (key, value)
29760 
      for key, value in self.__dict__.iteritems()]
29761 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29762 
 
29763 
  def __eq__(self, other):
29764 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29765 
 
29766 
  def __ne__(self, other):
29767 
    return not (self == other)
29768 
 
11015 kshitij.so 29769 
class getMarketplaceHistory_result:
10909 vikram.rag 29770 
  """
29771 
  Attributes:
29772 
   - success
29773 
  """
29774 
 
29775 
  thrift_spec = (
11015 kshitij.so 29776 
    (0, TType.LIST, 'success', (TType.STRUCT,(MarketplaceHistory, MarketplaceHistory.thrift_spec)), None, ), # 0
10909 vikram.rag 29777 
  )
29778 
 
29779 
  def __init__(self, success=None,):
29780 
    self.success = success
29781 
 
29782 
  def read(self, iprot):
29783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29785 
      return
29786 
    iprot.readStructBegin()
29787 
    while True:
29788 
      (fname, ftype, fid) = iprot.readFieldBegin()
29789 
      if ftype == TType.STOP:
29790 
        break
29791 
      if fid == 0:
29792 
        if ftype == TType.LIST:
29793 
          self.success = []
13493 amit.gupta 29794 
          (_etype648, _size645) = iprot.readListBegin()
29795 
          for _i649 in xrange(_size645):
29796 
            _elem650 = MarketplaceHistory()
29797 
            _elem650.read(iprot)
29798 
            self.success.append(_elem650)
10909 vikram.rag 29799 
          iprot.readListEnd()
29800 
        else:
29801 
          iprot.skip(ftype)
29802 
      else:
29803 
        iprot.skip(ftype)
29804 
      iprot.readFieldEnd()
29805 
    iprot.readStructEnd()
29806 
 
29807 
  def write(self, oprot):
29808 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29809 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29810 
      return
11015 kshitij.so 29811 
    oprot.writeStructBegin('getMarketplaceHistory_result')
10909 vikram.rag 29812 
    if self.success is not None:
29813 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29814 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 29815 
      for iter651 in self.success:
29816 
        iter651.write(oprot)
10909 vikram.rag 29817 
      oprot.writeListEnd()
29818 
      oprot.writeFieldEnd()
29819 
    oprot.writeFieldStop()
29820 
    oprot.writeStructEnd()
29821 
 
29822 
  def validate(self):
29823 
    return
29824 
 
29825 
 
29826 
  def __repr__(self):
29827 
    L = ['%s=%r' % (key, value)
29828 
      for key, value in self.__dict__.iteritems()]
29829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29830 
 
29831 
  def __eq__(self, other):
29832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29833 
 
29834 
  def __ne__(self, other):
29835 
    return not (self == other)
10924 vikram.rag 29836 
 
11015 kshitij.so 29837 
class getAllFbbListedItems_args:
10924 vikram.rag 29838 
 
29839 
  thrift_spec = (
29840 
  )
29841 
 
29842 
  def read(self, iprot):
29843 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29844 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29845 
      return
29846 
    iprot.readStructBegin()
29847 
    while True:
29848 
      (fname, ftype, fid) = iprot.readFieldBegin()
29849 
      if ftype == TType.STOP:
29850 
        break
29851 
      else:
29852 
        iprot.skip(ftype)
29853 
      iprot.readFieldEnd()
29854 
    iprot.readStructEnd()
29855 
 
29856 
  def write(self, oprot):
29857 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29858 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29859 
      return
11015 kshitij.so 29860 
    oprot.writeStructBegin('getAllFbbListedItems_args')
10924 vikram.rag 29861 
    oprot.writeFieldStop()
29862 
    oprot.writeStructEnd()
29863 
 
29864 
  def validate(self):
29865 
    return
29866 
 
29867 
 
29868 
  def __repr__(self):
29869 
    L = ['%s=%r' % (key, value)
29870 
      for key, value in self.__dict__.iteritems()]
29871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29872 
 
29873 
  def __eq__(self, other):
29874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29875 
 
29876 
  def __ne__(self, other):
29877 
    return not (self == other)
29878 
 
11015 kshitij.so 29879 
class getAllFbbListedItems_result:
10924 vikram.rag 29880 
  """
29881 
  Attributes:
29882 
   - success
29883 
  """
29884 
 
29885 
  thrift_spec = (
29886 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
29887 
  )
29888 
 
29889 
  def __init__(self, success=None,):
29890 
    self.success = success
29891 
 
29892 
  def read(self, iprot):
29893 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29894 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29895 
      return
29896 
    iprot.readStructBegin()
29897 
    while True:
29898 
      (fname, ftype, fid) = iprot.readFieldBegin()
29899 
      if ftype == TType.STOP:
29900 
        break
29901 
      if fid == 0:
29902 
        if ftype == TType.LIST:
29903 
          self.success = []
13493 amit.gupta 29904 
          (_etype655, _size652) = iprot.readListBegin()
29905 
          for _i656 in xrange(_size652):
29906 
            _elem657 = Amazonlisted()
29907 
            _elem657.read(iprot)
29908 
            self.success.append(_elem657)
10924 vikram.rag 29909 
          iprot.readListEnd()
29910 
        else:
29911 
          iprot.skip(ftype)
29912 
      else:
29913 
        iprot.skip(ftype)
29914 
      iprot.readFieldEnd()
29915 
    iprot.readStructEnd()
29916 
 
29917 
  def write(self, oprot):
29918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29920 
      return
11015 kshitij.so 29921 
    oprot.writeStructBegin('getAllFbbListedItems_result')
10924 vikram.rag 29922 
    if self.success is not None:
29923 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29924 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 29925 
      for iter658 in self.success:
29926 
        iter658.write(oprot)
10924 vikram.rag 29927 
      oprot.writeListEnd()
29928 
      oprot.writeFieldEnd()
29929 
    oprot.writeFieldStop()
29930 
    oprot.writeStructEnd()
29931 
 
29932 
  def validate(self):
29933 
    return
29934 
 
29935 
 
29936 
  def __repr__(self):
29937 
    L = ['%s=%r' % (key, value)
29938 
      for key, value in self.__dict__.iteritems()]
29939 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29940 
 
29941 
  def __eq__(self, other):
29942 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29943 
 
29944 
  def __ne__(self, other):
29945 
    return not (self == other)
11015 kshitij.so 29946 
 
29947 
class getAllFbbPricingItems_args:
29948 
 
29949 
  thrift_spec = (
29950 
  )
29951 
 
29952 
  def read(self, iprot):
29953 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29954 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29955 
      return
29956 
    iprot.readStructBegin()
29957 
    while True:
29958 
      (fname, ftype, fid) = iprot.readFieldBegin()
29959 
      if ftype == TType.STOP:
29960 
        break
29961 
      else:
29962 
        iprot.skip(ftype)
29963 
      iprot.readFieldEnd()
29964 
    iprot.readStructEnd()
29965 
 
29966 
  def write(self, oprot):
29967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29969 
      return
29970 
    oprot.writeStructBegin('getAllFbbPricingItems_args')
29971 
    oprot.writeFieldStop()
29972 
    oprot.writeStructEnd()
29973 
 
29974 
  def validate(self):
29975 
    return
29976 
 
29977 
 
29978 
  def __repr__(self):
29979 
    L = ['%s=%r' % (key, value)
29980 
      for key, value in self.__dict__.iteritems()]
29981 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29982 
 
29983 
  def __eq__(self, other):
29984 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29985 
 
29986 
  def __ne__(self, other):
29987 
    return not (self == other)
29988 
 
29989 
class getAllFbbPricingItems_result:
29990 
  """
29991 
  Attributes:
29992 
   - success
29993 
  """
29994 
 
29995 
  thrift_spec = (
29996 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
29997 
  )
29998 
 
29999 
  def __init__(self, success=None,):
30000 
    self.success = success
30001 
 
30002 
  def read(self, iprot):
30003 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30004 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30005 
      return
30006 
    iprot.readStructBegin()
30007 
    while True:
30008 
      (fname, ftype, fid) = iprot.readFieldBegin()
30009 
      if ftype == TType.STOP:
30010 
        break
30011 
      if fid == 0:
30012 
        if ftype == TType.LIST:
30013 
          self.success = []
13493 amit.gupta 30014 
          (_etype662, _size659) = iprot.readListBegin()
30015 
          for _i663 in xrange(_size659):
30016 
            _elem664 = Amazonlisted()
30017 
            _elem664.read(iprot)
30018 
            self.success.append(_elem664)
11015 kshitij.so 30019 
          iprot.readListEnd()
30020 
        else:
30021 
          iprot.skip(ftype)
30022 
      else:
30023 
        iprot.skip(ftype)
30024 
      iprot.readFieldEnd()
30025 
    iprot.readStructEnd()
30026 
 
30027 
  def write(self, oprot):
30028 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30029 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30030 
      return
30031 
    oprot.writeStructBegin('getAllFbbPricingItems_result')
30032 
    if self.success is not None:
30033 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30034 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 30035 
      for iter665 in self.success:
30036 
        iter665.write(oprot)
11015 kshitij.so 30037 
      oprot.writeListEnd()
30038 
      oprot.writeFieldEnd()
30039 
    oprot.writeFieldStop()
30040 
    oprot.writeStructEnd()
30041 
 
30042 
  def validate(self):
30043 
    return
30044 
 
30045 
 
30046 
  def __repr__(self):
30047 
    L = ['%s=%r' % (key, value)
30048 
      for key, value in self.__dict__.iteritems()]
30049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30050 
 
30051 
  def __eq__(self, other):
30052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30053 
 
30054 
  def __ne__(self, other):
30055 
    return not (self == other)
30056 
 
30057 
class getCountForMarketplaceHistory_args:
30058 
  """
30059 
  Attributes:
30060 
   - source
30061 
   - itemId
30062 
  """
30063 
 
30064 
  thrift_spec = (
30065 
    None, # 0
30066 
    (1, TType.I64, 'source', None, None, ), # 1
30067 
    (2, TType.I64, 'itemId', None, None, ), # 2
30068 
  )
30069 
 
30070 
  def __init__(self, source=None, itemId=None,):
30071 
    self.source = source
30072 
    self.itemId = itemId
30073 
 
30074 
  def read(self, iprot):
30075 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30076 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30077 
      return
30078 
    iprot.readStructBegin()
30079 
    while True:
30080 
      (fname, ftype, fid) = iprot.readFieldBegin()
30081 
      if ftype == TType.STOP:
30082 
        break
30083 
      if fid == 1:
30084 
        if ftype == TType.I64:
30085 
          self.source = iprot.readI64();
30086 
        else:
30087 
          iprot.skip(ftype)
30088 
      elif fid == 2:
30089 
        if ftype == TType.I64:
30090 
          self.itemId = iprot.readI64();
30091 
        else:
30092 
          iprot.skip(ftype)
30093 
      else:
30094 
        iprot.skip(ftype)
30095 
      iprot.readFieldEnd()
30096 
    iprot.readStructEnd()
30097 
 
30098 
  def write(self, oprot):
30099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30101 
      return
30102 
    oprot.writeStructBegin('getCountForMarketplaceHistory_args')
30103 
    if self.source is not None:
30104 
      oprot.writeFieldBegin('source', TType.I64, 1)
30105 
      oprot.writeI64(self.source)
30106 
      oprot.writeFieldEnd()
30107 
    if self.itemId is not None:
30108 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
30109 
      oprot.writeI64(self.itemId)
30110 
      oprot.writeFieldEnd()
30111 
    oprot.writeFieldStop()
30112 
    oprot.writeStructEnd()
30113 
 
30114 
  def validate(self):
30115 
    return
30116 
 
30117 
 
30118 
  def __repr__(self):
30119 
    L = ['%s=%r' % (key, value)
30120 
      for key, value in self.__dict__.iteritems()]
30121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30122 
 
30123 
  def __eq__(self, other):
30124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30125 
 
30126 
  def __ne__(self, other):
30127 
    return not (self == other)
30128 
 
30129 
class getCountForMarketplaceHistory_result:
30130 
  """
30131 
  Attributes:
30132 
   - success
30133 
  """
30134 
 
30135 
  thrift_spec = (
30136 
    (0, TType.I64, 'success', None, None, ), # 0
30137 
  )
30138 
 
30139 
  def __init__(self, success=None,):
30140 
    self.success = success
30141 
 
30142 
  def read(self, iprot):
30143 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30144 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30145 
      return
30146 
    iprot.readStructBegin()
30147 
    while True:
30148 
      (fname, ftype, fid) = iprot.readFieldBegin()
30149 
      if ftype == TType.STOP:
30150 
        break
30151 
      if fid == 0:
30152 
        if ftype == TType.I64:
30153 
          self.success = iprot.readI64();
30154 
        else:
30155 
          iprot.skip(ftype)
30156 
      else:
30157 
        iprot.skip(ftype)
30158 
      iprot.readFieldEnd()
30159 
    iprot.readStructEnd()
30160 
 
30161 
  def write(self, oprot):
30162 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30163 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30164 
      return
30165 
    oprot.writeStructBegin('getCountForMarketplaceHistory_result')
30166 
    if self.success is not None:
30167 
      oprot.writeFieldBegin('success', TType.I64, 0)
30168 
      oprot.writeI64(self.success)
30169 
      oprot.writeFieldEnd()
30170 
    oprot.writeFieldStop()
30171 
    oprot.writeStructEnd()
30172 
 
30173 
  def validate(self):
30174 
    return
30175 
 
30176 
 
30177 
  def __repr__(self):
30178 
    L = ['%s=%r' % (key, value)
30179 
      for key, value in self.__dict__.iteritems()]
30180 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30181 
 
30182 
  def __eq__(self, other):
30183 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30184 
 
30185 
  def __ne__(self, other):
30186 
    return not (self == other)
30187 
 
30188 
class getMarketplaceHistoryByDate_args:
30189 
  """
30190 
  Attributes:
30191 
   - source
30192 
   - startDate
30193 
   - endDate
30194 
   - offset
30195 
   - limit
30196 
   - itemId
30197 
  """
30198 
 
30199 
  thrift_spec = (
30200 
    None, # 0
30201 
    (1, TType.I64, 'source', None, None, ), # 1
30202 
    (2, TType.I64, 'startDate', None, None, ), # 2
30203 
    (3, TType.I64, 'endDate', None, None, ), # 3
30204 
    (4, TType.I64, 'offset', None, None, ), # 4
30205 
    (5, TType.I64, 'limit', None, None, ), # 5
30206 
    (6, TType.I64, 'itemId', None, None, ), # 6
30207 
  )
30208 
 
30209 
  def __init__(self, source=None, startDate=None, endDate=None, offset=None, limit=None, itemId=None,):
30210 
    self.source = source
30211 
    self.startDate = startDate
30212 
    self.endDate = endDate
30213 
    self.offset = offset
30214 
    self.limit = limit
30215 
    self.itemId = itemId
30216 
 
30217 
  def read(self, iprot):
30218 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30219 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30220 
      return
30221 
    iprot.readStructBegin()
30222 
    while True:
30223 
      (fname, ftype, fid) = iprot.readFieldBegin()
30224 
      if ftype == TType.STOP:
30225 
        break
30226 
      if fid == 1:
30227 
        if ftype == TType.I64:
30228 
          self.source = iprot.readI64();
30229 
        else:
30230 
          iprot.skip(ftype)
30231 
      elif fid == 2:
30232 
        if ftype == TType.I64:
30233 
          self.startDate = iprot.readI64();
30234 
        else:
30235 
          iprot.skip(ftype)
30236 
      elif fid == 3:
30237 
        if ftype == TType.I64:
30238 
          self.endDate = iprot.readI64();
30239 
        else:
30240 
          iprot.skip(ftype)
30241 
      elif fid == 4:
30242 
        if ftype == TType.I64:
30243 
          self.offset = iprot.readI64();
30244 
        else:
30245 
          iprot.skip(ftype)
30246 
      elif fid == 5:
30247 
        if ftype == TType.I64:
30248 
          self.limit = iprot.readI64();
30249 
        else:
30250 
          iprot.skip(ftype)
30251 
      elif fid == 6:
30252 
        if ftype == TType.I64:
30253 
          self.itemId = iprot.readI64();
30254 
        else:
30255 
          iprot.skip(ftype)
30256 
      else:
30257 
        iprot.skip(ftype)
30258 
      iprot.readFieldEnd()
30259 
    iprot.readStructEnd()
30260 
 
30261 
  def write(self, oprot):
30262 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30263 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30264 
      return
30265 
    oprot.writeStructBegin('getMarketplaceHistoryByDate_args')
30266 
    if self.source is not None:
30267 
      oprot.writeFieldBegin('source', TType.I64, 1)
30268 
      oprot.writeI64(self.source)
30269 
      oprot.writeFieldEnd()
30270 
    if self.startDate is not None:
30271 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
30272 
      oprot.writeI64(self.startDate)
30273 
      oprot.writeFieldEnd()
30274 
    if self.endDate is not None:
30275 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
30276 
      oprot.writeI64(self.endDate)
30277 
      oprot.writeFieldEnd()
30278 
    if self.offset is not None:
30279 
      oprot.writeFieldBegin('offset', TType.I64, 4)
30280 
      oprot.writeI64(self.offset)
30281 
      oprot.writeFieldEnd()
30282 
    if self.limit is not None:
30283 
      oprot.writeFieldBegin('limit', TType.I64, 5)
30284 
      oprot.writeI64(self.limit)
30285 
      oprot.writeFieldEnd()
30286 
    if self.itemId is not None:
30287 
      oprot.writeFieldBegin('itemId', TType.I64, 6)
30288 
      oprot.writeI64(self.itemId)
30289 
      oprot.writeFieldEnd()
30290 
    oprot.writeFieldStop()
30291 
    oprot.writeStructEnd()
30292 
 
30293 
  def validate(self):
30294 
    return
30295 
 
30296 
 
30297 
  def __repr__(self):
30298 
    L = ['%s=%r' % (key, value)
30299 
      for key, value in self.__dict__.iteritems()]
30300 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30301 
 
30302 
  def __eq__(self, other):
30303 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30304 
 
30305 
  def __ne__(self, other):
30306 
    return not (self == other)
30307 
 
30308 
class getMarketplaceHistoryByDate_result:
30309 
  """
30310 
  Attributes:
30311 
   - success
30312 
  """
30313 
 
30314 
  thrift_spec = (
30315 
    (0, TType.LIST, 'success', (TType.STRUCT,(MarketplaceHistory, MarketplaceHistory.thrift_spec)), None, ), # 0
30316 
  )
30317 
 
30318 
  def __init__(self, success=None,):
30319 
    self.success = success
30320 
 
30321 
  def read(self, iprot):
30322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30324 
      return
30325 
    iprot.readStructBegin()
30326 
    while True:
30327 
      (fname, ftype, fid) = iprot.readFieldBegin()
30328 
      if ftype == TType.STOP:
30329 
        break
30330 
      if fid == 0:
30331 
        if ftype == TType.LIST:
30332 
          self.success = []
13493 amit.gupta 30333 
          (_etype669, _size666) = iprot.readListBegin()
30334 
          for _i670 in xrange(_size666):
30335 
            _elem671 = MarketplaceHistory()
30336 
            _elem671.read(iprot)
30337 
            self.success.append(_elem671)
11015 kshitij.so 30338 
          iprot.readListEnd()
30339 
        else:
30340 
          iprot.skip(ftype)
30341 
      else:
30342 
        iprot.skip(ftype)
30343 
      iprot.readFieldEnd()
30344 
    iprot.readStructEnd()
30345 
 
30346 
  def write(self, oprot):
30347 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30348 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30349 
      return
30350 
    oprot.writeStructBegin('getMarketplaceHistoryByDate_result')
30351 
    if self.success is not None:
30352 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30353 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 30354 
      for iter672 in self.success:
30355 
        iter672.write(oprot)
11015 kshitij.so 30356 
      oprot.writeListEnd()
30357 
      oprot.writeFieldEnd()
30358 
    oprot.writeFieldStop()
30359 
    oprot.writeStructEnd()
30360 
 
30361 
  def validate(self):
30362 
    return
30363 
 
30364 
 
30365 
  def __repr__(self):
30366 
    L = ['%s=%r' % (key, value)
30367 
      for key, value in self.__dict__.iteritems()]
30368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30369 
 
30370 
  def __eq__(self, other):
30371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30372 
 
30373 
  def __ne__(self, other):
30374 
    return not (self == other)
11531 vikram.rag 30375 
 
30376 
class getPrivateDealDetails_args:
30377 
  """
30378 
  Attributes:
30379 
   - item_id
30380 
  """
30381 
 
30382 
  thrift_spec = (
30383 
    None, # 0
30384 
    (1, TType.I64, 'item_id', None, None, ), # 1
30385 
  )
30386 
 
30387 
  def __init__(self, item_id=None,):
30388 
    self.item_id = item_id
30389 
 
30390 
  def read(self, iprot):
30391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30393 
      return
30394 
    iprot.readStructBegin()
30395 
    while True:
30396 
      (fname, ftype, fid) = iprot.readFieldBegin()
30397 
      if ftype == TType.STOP:
30398 
        break
30399 
      if fid == 1:
30400 
        if ftype == TType.I64:
30401 
          self.item_id = iprot.readI64();
30402 
        else:
30403 
          iprot.skip(ftype)
30404 
      else:
30405 
        iprot.skip(ftype)
30406 
      iprot.readFieldEnd()
30407 
    iprot.readStructEnd()
30408 
 
30409 
  def write(self, oprot):
30410 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30411 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30412 
      return
30413 
    oprot.writeStructBegin('getPrivateDealDetails_args')
30414 
    if self.item_id is not None:
30415 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
30416 
      oprot.writeI64(self.item_id)
30417 
      oprot.writeFieldEnd()
30418 
    oprot.writeFieldStop()
30419 
    oprot.writeStructEnd()
30420 
 
30421 
  def validate(self):
30422 
    return
30423 
 
30424 
 
30425 
  def __repr__(self):
30426 
    L = ['%s=%r' % (key, value)
30427 
      for key, value in self.__dict__.iteritems()]
30428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30429 
 
30430 
  def __eq__(self, other):
30431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30432 
 
30433 
  def __ne__(self, other):
30434 
    return not (self == other)
30435 
 
30436 
class getPrivateDealDetails_result:
30437 
  """
30438 
  Attributes:
30439 
   - success
30440 
  """
30441 
 
30442 
  thrift_spec = (
30443 
    (0, TType.STRUCT, 'success', (PrivateDeal, PrivateDeal.thrift_spec), None, ), # 0
30444 
  )
30445 
 
30446 
  def __init__(self, success=None,):
30447 
    self.success = success
30448 
 
30449 
  def read(self, iprot):
30450 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30451 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30452 
      return
30453 
    iprot.readStructBegin()
30454 
    while True:
30455 
      (fname, ftype, fid) = iprot.readFieldBegin()
30456 
      if ftype == TType.STOP:
30457 
        break
30458 
      if fid == 0:
30459 
        if ftype == TType.STRUCT:
30460 
          self.success = PrivateDeal()
30461 
          self.success.read(iprot)
30462 
        else:
30463 
          iprot.skip(ftype)
30464 
      else:
30465 
        iprot.skip(ftype)
30466 
      iprot.readFieldEnd()
30467 
    iprot.readStructEnd()
30468 
 
30469 
  def write(self, oprot):
30470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30472 
      return
30473 
    oprot.writeStructBegin('getPrivateDealDetails_result')
30474 
    if self.success is not None:
30475 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
30476 
      self.success.write(oprot)
30477 
      oprot.writeFieldEnd()
30478 
    oprot.writeFieldStop()
30479 
    oprot.writeStructEnd()
30480 
 
30481 
  def validate(self):
30482 
    return
30483 
 
30484 
 
30485 
  def __repr__(self):
30486 
    L = ['%s=%r' % (key, value)
30487 
      for key, value in self.__dict__.iteritems()]
30488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30489 
 
30490 
  def __eq__(self, other):
30491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30492 
 
30493 
  def __ne__(self, other):
30494 
    return not (self == other)
30495 
 
30496 
class getPrivateDealItems_args:
30497 
  """
30498 
  Attributes:
30499 
   - offset
30500 
   - limit
30501 
  """
30502 
 
30503 
  thrift_spec = (
30504 
    None, # 0
30505 
    (1, TType.I64, 'offset', None, None, ), # 1
30506 
    (2, TType.I64, 'limit', None, None, ), # 2
30507 
  )
30508 
 
30509 
  def __init__(self, offset=None, limit=None,):
30510 
    self.offset = offset
30511 
    self.limit = limit
30512 
 
30513 
  def read(self, iprot):
30514 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30515 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30516 
      return
30517 
    iprot.readStructBegin()
30518 
    while True:
30519 
      (fname, ftype, fid) = iprot.readFieldBegin()
30520 
      if ftype == TType.STOP:
30521 
        break
30522 
      if fid == 1:
30523 
        if ftype == TType.I64:
30524 
          self.offset = iprot.readI64();
30525 
        else:
30526 
          iprot.skip(ftype)
30527 
      elif fid == 2:
30528 
        if ftype == TType.I64:
30529 
          self.limit = iprot.readI64();
30530 
        else:
30531 
          iprot.skip(ftype)
30532 
      else:
30533 
        iprot.skip(ftype)
30534 
      iprot.readFieldEnd()
30535 
    iprot.readStructEnd()
30536 
 
30537 
  def write(self, oprot):
30538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30540 
      return
30541 
    oprot.writeStructBegin('getPrivateDealItems_args')
30542 
    if self.offset is not None:
30543 
      oprot.writeFieldBegin('offset', TType.I64, 1)
30544 
      oprot.writeI64(self.offset)
30545 
      oprot.writeFieldEnd()
30546 
    if self.limit is not None:
30547 
      oprot.writeFieldBegin('limit', TType.I64, 2)
30548 
      oprot.writeI64(self.limit)
30549 
      oprot.writeFieldEnd()
30550 
    oprot.writeFieldStop()
30551 
    oprot.writeStructEnd()
30552 
 
30553 
  def validate(self):
30554 
    return
30555 
 
30556 
 
30557 
  def __repr__(self):
30558 
    L = ['%s=%r' % (key, value)
30559 
      for key, value in self.__dict__.iteritems()]
30560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30561 
 
30562 
  def __eq__(self, other):
30563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30564 
 
30565 
  def __ne__(self, other):
30566 
    return not (self == other)
30567 
 
30568 
class getPrivateDealItems_result:
30569 
  """
30570 
  Attributes:
30571 
   - success
30572 
  """
30573 
 
30574 
  thrift_spec = (
30575 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
30576 
  )
30577 
 
30578 
  def __init__(self, success=None,):
30579 
    self.success = success
30580 
 
30581 
  def read(self, iprot):
30582 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30583 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30584 
      return
30585 
    iprot.readStructBegin()
30586 
    while True:
30587 
      (fname, ftype, fid) = iprot.readFieldBegin()
30588 
      if ftype == TType.STOP:
30589 
        break
30590 
      if fid == 0:
30591 
        if ftype == TType.LIST:
30592 
          self.success = []
13493 amit.gupta 30593 
          (_etype676, _size673) = iprot.readListBegin()
30594 
          for _i677 in xrange(_size673):
30595 
            _elem678 = Item()
30596 
            _elem678.read(iprot)
30597 
            self.success.append(_elem678)
11531 vikram.rag 30598 
          iprot.readListEnd()
30599 
        else:
30600 
          iprot.skip(ftype)
30601 
      else:
30602 
        iprot.skip(ftype)
30603 
      iprot.readFieldEnd()
30604 
    iprot.readStructEnd()
30605 
 
30606 
  def write(self, oprot):
30607 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30608 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30609 
      return
30610 
    oprot.writeStructBegin('getPrivateDealItems_result')
30611 
    if self.success is not None:
30612 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30613 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 30614 
      for iter679 in self.success:
30615 
        iter679.write(oprot)
11531 vikram.rag 30616 
      oprot.writeListEnd()
30617 
      oprot.writeFieldEnd()
30618 
    oprot.writeFieldStop()
30619 
    oprot.writeStructEnd()
30620 
 
30621 
  def validate(self):
30622 
    return
30623 
 
30624 
 
30625 
  def __repr__(self):
30626 
    L = ['%s=%r' % (key, value)
30627 
      for key, value in self.__dict__.iteritems()]
30628 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30629 
 
30630 
  def __eq__(self, other):
30631 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30632 
 
30633 
  def __ne__(self, other):
30634 
    return not (self == other)
30635 
 
11592 amit.gupta 30636 
class getAllActivePrivateDeals_args:
11653 amit.gupta 30637 
  """
30638 
  Attributes:
30639 
   - itemIds
30640 
   - daysDelta
30641 
  """
11592 amit.gupta 30642 
 
30643 
  thrift_spec = (
11653 amit.gupta 30644 
    None, # 0
30645 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
30646 
    (2, TType.I64, 'daysDelta', None, None, ), # 2
11592 amit.gupta 30647 
  )
30648 
 
11653 amit.gupta 30649 
  def __init__(self, itemIds=None, daysDelta=None,):
30650 
    self.itemIds = itemIds
30651 
    self.daysDelta = daysDelta
30652 
 
11592 amit.gupta 30653 
  def read(self, iprot):
30654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30656 
      return
30657 
    iprot.readStructBegin()
30658 
    while True:
30659 
      (fname, ftype, fid) = iprot.readFieldBegin()
30660 
      if ftype == TType.STOP:
30661 
        break
11653 amit.gupta 30662 
      if fid == 1:
30663 
        if ftype == TType.LIST:
30664 
          self.itemIds = []
13493 amit.gupta 30665 
          (_etype683, _size680) = iprot.readListBegin()
30666 
          for _i684 in xrange(_size680):
30667 
            _elem685 = iprot.readI64();
30668 
            self.itemIds.append(_elem685)
11653 amit.gupta 30669 
          iprot.readListEnd()
30670 
        else:
30671 
          iprot.skip(ftype)
30672 
      elif fid == 2:
30673 
        if ftype == TType.I64:
30674 
          self.daysDelta = iprot.readI64();
30675 
        else:
30676 
          iprot.skip(ftype)
11592 amit.gupta 30677 
      else:
30678 
        iprot.skip(ftype)
30679 
      iprot.readFieldEnd()
30680 
    iprot.readStructEnd()
30681 
 
30682 
  def write(self, oprot):
30683 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30684 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30685 
      return
30686 
    oprot.writeStructBegin('getAllActivePrivateDeals_args')
11653 amit.gupta 30687 
    if self.itemIds is not None:
30688 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
30689 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
13493 amit.gupta 30690 
      for iter686 in self.itemIds:
30691 
        oprot.writeI64(iter686)
11653 amit.gupta 30692 
      oprot.writeListEnd()
30693 
      oprot.writeFieldEnd()
30694 
    if self.daysDelta is not None:
30695 
      oprot.writeFieldBegin('daysDelta', TType.I64, 2)
30696 
      oprot.writeI64(self.daysDelta)
30697 
      oprot.writeFieldEnd()
11592 amit.gupta 30698 
    oprot.writeFieldStop()
30699 
    oprot.writeStructEnd()
30700 
 
30701 
  def validate(self):
30702 
    return
30703 
 
30704 
 
30705 
  def __repr__(self):
30706 
    L = ['%s=%r' % (key, value)
30707 
      for key, value in self.__dict__.iteritems()]
30708 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30709 
 
30710 
  def __eq__(self, other):
30711 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30712 
 
30713 
  def __ne__(self, other):
30714 
    return not (self == other)
30715 
 
30716 
class getAllActivePrivateDeals_result:
30717 
  """
30718 
  Attributes:
30719 
   - success
30720 
  """
30721 
 
30722 
  thrift_spec = (
30723 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRUCT,(PrivateDeal, PrivateDeal.thrift_spec)), None, ), # 0
30724 
  )
30725 
 
30726 
  def __init__(self, success=None,):
30727 
    self.success = success
30728 
 
30729 
  def read(self, iprot):
30730 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30731 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30732 
      return
30733 
    iprot.readStructBegin()
30734 
    while True:
30735 
      (fname, ftype, fid) = iprot.readFieldBegin()
30736 
      if ftype == TType.STOP:
30737 
        break
30738 
      if fid == 0:
30739 
        if ftype == TType.MAP:
30740 
          self.success = {}
13493 amit.gupta 30741 
          (_ktype688, _vtype689, _size687 ) = iprot.readMapBegin()
30742 
          for _i691 in xrange(_size687):
30743 
            _key692 = iprot.readI64();
30744 
            _val693 = PrivateDeal()
30745 
            _val693.read(iprot)
30746 
            self.success[_key692] = _val693
11592 amit.gupta 30747 
          iprot.readMapEnd()
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('getAllActivePrivateDeals_result')
30760 
    if self.success is not None:
30761 
      oprot.writeFieldBegin('success', TType.MAP, 0)
30762 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.success))
13493 amit.gupta 30763 
      for kiter694,viter695 in self.success.items():
30764 
        oprot.writeI64(kiter694)
30765 
        viter695.write(oprot)
11592 amit.gupta 30766 
      oprot.writeMapEnd()
30767 
      oprot.writeFieldEnd()
30768 
    oprot.writeFieldStop()
30769 
    oprot.writeStructEnd()
30770 
 
30771 
  def validate(self):
30772 
    return
30773 
 
30774 
 
30775 
  def __repr__(self):
30776 
    L = ['%s=%r' % (key, value)
30777 
      for key, value in self.__dict__.iteritems()]
30778 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30779 
 
30780 
  def __eq__(self, other):
30781 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30782 
 
30783 
  def __ne__(self, other):
30784 
    return not (self == other)
30785 
 
11531 vikram.rag 30786 
class addOrUpdatePrivateDeal_args:
30787 
  """
30788 
  Attributes:
30789 
   - privateDeal
30790 
  """
30791 
 
30792 
  thrift_spec = (
30793 
    None, # 0
30794 
    (1, TType.STRUCT, 'privateDeal', (PrivateDeal, PrivateDeal.thrift_spec), None, ), # 1
30795 
  )
30796 
 
30797 
  def __init__(self, privateDeal=None,):
30798 
    self.privateDeal = privateDeal
30799 
 
30800 
  def read(self, iprot):
30801 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30802 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30803 
      return
30804 
    iprot.readStructBegin()
30805 
    while True:
30806 
      (fname, ftype, fid) = iprot.readFieldBegin()
30807 
      if ftype == TType.STOP:
30808 
        break
30809 
      if fid == 1:
30810 
        if ftype == TType.STRUCT:
30811 
          self.privateDeal = PrivateDeal()
30812 
          self.privateDeal.read(iprot)
30813 
        else:
30814 
          iprot.skip(ftype)
30815 
      else:
30816 
        iprot.skip(ftype)
30817 
      iprot.readFieldEnd()
30818 
    iprot.readStructEnd()
30819 
 
30820 
  def write(self, oprot):
30821 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30822 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30823 
      return
30824 
    oprot.writeStructBegin('addOrUpdatePrivateDeal_args')
30825 
    if self.privateDeal is not None:
30826 
      oprot.writeFieldBegin('privateDeal', TType.STRUCT, 1)
30827 
      self.privateDeal.write(oprot)
30828 
      oprot.writeFieldEnd()
30829 
    oprot.writeFieldStop()
30830 
    oprot.writeStructEnd()
30831 
 
30832 
  def validate(self):
30833 
    return
30834 
 
30835 
 
30836 
  def __repr__(self):
30837 
    L = ['%s=%r' % (key, value)
30838 
      for key, value in self.__dict__.iteritems()]
30839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30840 
 
30841 
  def __eq__(self, other):
30842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30843 
 
30844 
  def __ne__(self, other):
30845 
    return not (self == other)
30846 
 
30847 
class addOrUpdatePrivateDeal_result:
30848 
  """
30849 
  Attributes:
30850 
   - success
30851 
  """
30852 
 
30853 
  thrift_spec = (
30854 
    (0, TType.BOOL, 'success', None, None, ), # 0
30855 
  )
30856 
 
30857 
  def __init__(self, success=None,):
30858 
    self.success = success
30859 
 
30860 
  def read(self, iprot):
30861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30863 
      return
30864 
    iprot.readStructBegin()
30865 
    while True:
30866 
      (fname, ftype, fid) = iprot.readFieldBegin()
30867 
      if ftype == TType.STOP:
30868 
        break
30869 
      if fid == 0:
30870 
        if ftype == TType.BOOL:
30871 
          self.success = iprot.readBool();
30872 
        else:
30873 
          iprot.skip(ftype)
30874 
      else:
30875 
        iprot.skip(ftype)
30876 
      iprot.readFieldEnd()
30877 
    iprot.readStructEnd()
30878 
 
30879 
  def write(self, oprot):
30880 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30881 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30882 
      return
30883 
    oprot.writeStructBegin('addOrUpdatePrivateDeal_result')
30884 
    if self.success is not None:
30885 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
30886 
      oprot.writeBool(self.success)
30887 
      oprot.writeFieldEnd()
30888 
    oprot.writeFieldStop()
30889 
    oprot.writeStructEnd()
30890 
 
30891 
  def validate(self):
30892 
    return
30893 
 
30894 
 
30895 
  def __repr__(self):
30896 
    L = ['%s=%r' % (key, value)
30897 
      for key, value in self.__dict__.iteritems()]
30898 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30899 
 
30900 
  def __eq__(self, other):
30901 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30902 
 
30903 
  def __ne__(self, other):
30904 
    return not (self == other)
11635 vikram.rag 30905 
 
30906 
class getPrivateDealsCatalogIds_args:
30907 
  """
30908 
  Attributes:
30909 
   - beginIndex
30910 
   - totalItems
30911 
  """
30912 
 
30913 
  thrift_spec = (
30914 
    None, # 0
30915 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
30916 
    (2, TType.I64, 'totalItems', None, None, ), # 2
30917 
  )
30918 
 
30919 
  def __init__(self, beginIndex=None, totalItems=None,):
30920 
    self.beginIndex = beginIndex
30921 
    self.totalItems = totalItems
30922 
 
30923 
  def read(self, iprot):
30924 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30925 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30926 
      return
30927 
    iprot.readStructBegin()
30928 
    while True:
30929 
      (fname, ftype, fid) = iprot.readFieldBegin()
30930 
      if ftype == TType.STOP:
30931 
        break
30932 
      if fid == 1:
30933 
        if ftype == TType.I64:
30934 
          self.beginIndex = iprot.readI64();
30935 
        else:
30936 
          iprot.skip(ftype)
30937 
      elif fid == 2:
30938 
        if ftype == TType.I64:
30939 
          self.totalItems = iprot.readI64();
30940 
        else:
30941 
          iprot.skip(ftype)
30942 
      else:
30943 
        iprot.skip(ftype)
30944 
      iprot.readFieldEnd()
30945 
    iprot.readStructEnd()
30946 
 
30947 
  def write(self, oprot):
30948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30950 
      return
30951 
    oprot.writeStructBegin('getPrivateDealsCatalogIds_args')
30952 
    if self.beginIndex is not None:
30953 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
30954 
      oprot.writeI64(self.beginIndex)
30955 
      oprot.writeFieldEnd()
30956 
    if self.totalItems is not None:
30957 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
30958 
      oprot.writeI64(self.totalItems)
30959 
      oprot.writeFieldEnd()
30960 
    oprot.writeFieldStop()
30961 
    oprot.writeStructEnd()
30962 
 
30963 
  def validate(self):
30964 
    return
30965 
 
30966 
 
30967 
  def __repr__(self):
30968 
    L = ['%s=%r' % (key, value)
30969 
      for key, value in self.__dict__.iteritems()]
30970 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30971 
 
30972 
  def __eq__(self, other):
30973 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30974 
 
30975 
  def __ne__(self, other):
30976 
    return not (self == other)
30977 
 
30978 
class getPrivateDealsCatalogIds_result:
30979 
  """
30980 
  Attributes:
30981 
   - success
30982 
   - cex
30983 
  """
30984 
 
30985 
  thrift_spec = (
30986 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
30987 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
30988 
  )
30989 
 
30990 
  def __init__(self, success=None, cex=None,):
30991 
    self.success = success
30992 
    self.cex = cex
30993 
 
30994 
  def read(self, iprot):
30995 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30996 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30997 
      return
30998 
    iprot.readStructBegin()
30999 
    while True:
31000 
      (fname, ftype, fid) = iprot.readFieldBegin()
31001 
      if ftype == TType.STOP:
31002 
        break
31003 
      if fid == 0:
31004 
        if ftype == TType.LIST:
31005 
          self.success = []
13493 amit.gupta 31006 
          (_etype699, _size696) = iprot.readListBegin()
31007 
          for _i700 in xrange(_size696):
31008 
            _elem701 = iprot.readI64();
31009 
            self.success.append(_elem701)
11635 vikram.rag 31010 
          iprot.readListEnd()
31011 
        else:
31012 
          iprot.skip(ftype)
31013 
      elif fid == 1:
31014 
        if ftype == TType.STRUCT:
31015 
          self.cex = CatalogServiceException()
31016 
          self.cex.read(iprot)
31017 
        else:
31018 
          iprot.skip(ftype)
31019 
      else:
31020 
        iprot.skip(ftype)
31021 
      iprot.readFieldEnd()
31022 
    iprot.readStructEnd()
31023 
 
31024 
  def write(self, oprot):
31025 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31026 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31027 
      return
31028 
    oprot.writeStructBegin('getPrivateDealsCatalogIds_result')
31029 
    if self.success is not None:
31030 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31031 
      oprot.writeListBegin(TType.I64, len(self.success))
13493 amit.gupta 31032 
      for iter702 in self.success:
31033 
        oprot.writeI64(iter702)
11635 vikram.rag 31034 
      oprot.writeListEnd()
31035 
      oprot.writeFieldEnd()
31036 
    if self.cex is not None:
31037 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
31038 
      self.cex.write(oprot)
31039 
      oprot.writeFieldEnd()
31040 
    oprot.writeFieldStop()
31041 
    oprot.writeStructEnd()
31042 
 
31043 
  def validate(self):
31044 
    return
31045 
 
31046 
 
31047 
  def __repr__(self):
31048 
    L = ['%s=%r' % (key, value)
31049 
      for key, value in self.__dict__.iteritems()]
31050 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31051 
 
31052 
  def __eq__(self, other):
31053 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31054 
 
31055 
  def __ne__(self, other):
31056 
    return not (self == other)
11645 amit.gupta 31057 
 
31058 
class getPrivateDealsCount_args:
31059 
 
31060 
  thrift_spec = (
31061 
  )
31062 
 
31063 
  def read(self, iprot):
31064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31066 
      return
31067 
    iprot.readStructBegin()
31068 
    while True:
31069 
      (fname, ftype, fid) = iprot.readFieldBegin()
31070 
      if ftype == TType.STOP:
31071 
        break
31072 
      else:
31073 
        iprot.skip(ftype)
31074 
      iprot.readFieldEnd()
31075 
    iprot.readStructEnd()
31076 
 
31077 
  def write(self, oprot):
31078 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31079 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31080 
      return
31081 
    oprot.writeStructBegin('getPrivateDealsCount_args')
31082 
    oprot.writeFieldStop()
31083 
    oprot.writeStructEnd()
31084 
 
31085 
  def validate(self):
31086 
    return
31087 
 
31088 
 
31089 
  def __repr__(self):
31090 
    L = ['%s=%r' % (key, value)
31091 
      for key, value in self.__dict__.iteritems()]
31092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31093 
 
31094 
  def __eq__(self, other):
31095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31096 
 
31097 
  def __ne__(self, other):
31098 
    return not (self == other)
31099 
 
31100 
class getPrivateDealsCount_result:
31101 
  """
31102 
  Attributes:
31103 
   - success
31104 
  """
31105 
 
31106 
  thrift_spec = (
31107 
    (0, TType.I32, 'success', None, None, ), # 0
31108 
  )
31109 
 
31110 
  def __init__(self, success=None,):
31111 
    self.success = success
31112 
 
31113 
  def read(self, iprot):
31114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31116 
      return
31117 
    iprot.readStructBegin()
31118 
    while True:
31119 
      (fname, ftype, fid) = iprot.readFieldBegin()
31120 
      if ftype == TType.STOP:
31121 
        break
31122 
      if fid == 0:
31123 
        if ftype == TType.I32:
31124 
          self.success = iprot.readI32();
31125 
        else:
31126 
          iprot.skip(ftype)
31127 
      else:
31128 
        iprot.skip(ftype)
31129 
      iprot.readFieldEnd()
31130 
    iprot.readStructEnd()
31131 
 
31132 
  def write(self, oprot):
31133 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31134 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31135 
      return
31136 
    oprot.writeStructBegin('getPrivateDealsCount_result')
31137 
    if self.success is not None:
31138 
      oprot.writeFieldBegin('success', TType.I32, 0)
31139 
      oprot.writeI32(self.success)
31140 
      oprot.writeFieldEnd()
31141 
    oprot.writeFieldStop()
31142 
    oprot.writeStructEnd()
31143 
 
31144 
  def validate(self):
31145 
    return
31146 
 
31147 
 
31148 
  def __repr__(self):
31149 
    L = ['%s=%r' % (key, value)
31150 
      for key, value in self.__dict__.iteritems()]
31151 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31152 
 
31153 
  def __eq__(self, other):
31154 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31155 
 
31156 
  def __ne__(self, other):
31157 
    return not (self == other)
11905 kshitij.so 31158 
 
31159 
class getAmazonOutSyncItems_args:
31160 
  """
31161 
  Attributes:
31162 
   - item_id
31163 
  """
31164 
 
31165 
  thrift_spec = (
31166 
    None, # 0
31167 
    (1, TType.I64, 'item_id', None, None, ), # 1
31168 
  )
31169 
 
31170 
  def __init__(self, item_id=None,):
31171 
    self.item_id = item_id
31172 
 
31173 
  def read(self, iprot):
31174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31176 
      return
31177 
    iprot.readStructBegin()
31178 
    while True:
31179 
      (fname, ftype, fid) = iprot.readFieldBegin()
31180 
      if ftype == TType.STOP:
31181 
        break
31182 
      if fid == 1:
31183 
        if ftype == TType.I64:
31184 
          self.item_id = iprot.readI64();
31185 
        else:
31186 
          iprot.skip(ftype)
31187 
      else:
31188 
        iprot.skip(ftype)
31189 
      iprot.readFieldEnd()
31190 
    iprot.readStructEnd()
31191 
 
31192 
  def write(self, oprot):
31193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31195 
      return
31196 
    oprot.writeStructBegin('getAmazonOutSyncItems_args')
31197 
    if self.item_id is not None:
31198 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
31199 
      oprot.writeI64(self.item_id)
31200 
      oprot.writeFieldEnd()
31201 
    oprot.writeFieldStop()
31202 
    oprot.writeStructEnd()
31203 
 
31204 
  def validate(self):
31205 
    return
31206 
 
31207 
 
31208 
  def __repr__(self):
31209 
    L = ['%s=%r' % (key, value)
31210 
      for key, value in self.__dict__.iteritems()]
31211 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31212 
 
31213 
  def __eq__(self, other):
31214 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31215 
 
31216 
  def __ne__(self, other):
31217 
    return not (self == other)
31218 
 
31219 
class getAmazonOutSyncItems_result:
31220 
  """
31221 
  Attributes:
31222 
   - success
31223 
  """
31224 
 
31225 
  thrift_spec = (
31226 
    (0, TType.STRUCT, 'success', (AmazonOutOfSync, AmazonOutOfSync.thrift_spec), None, ), # 0
31227 
  )
31228 
 
31229 
  def __init__(self, success=None,):
31230 
    self.success = success
31231 
 
31232 
  def read(self, iprot):
31233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31235 
      return
31236 
    iprot.readStructBegin()
31237 
    while True:
31238 
      (fname, ftype, fid) = iprot.readFieldBegin()
31239 
      if ftype == TType.STOP:
31240 
        break
31241 
      if fid == 0:
31242 
        if ftype == TType.STRUCT:
31243 
          self.success = AmazonOutOfSync()
31244 
          self.success.read(iprot)
31245 
        else:
31246 
          iprot.skip(ftype)
31247 
      else:
31248 
        iprot.skip(ftype)
31249 
      iprot.readFieldEnd()
31250 
    iprot.readStructEnd()
31251 
 
31252 
  def write(self, oprot):
31253 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31254 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31255 
      return
31256 
    oprot.writeStructBegin('getAmazonOutSyncItems_result')
31257 
    if self.success is not None:
31258 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
31259 
      self.success.write(oprot)
31260 
      oprot.writeFieldEnd()
31261 
    oprot.writeFieldStop()
31262 
    oprot.writeStructEnd()
31263 
 
31264 
  def validate(self):
31265 
    return
31266 
 
31267 
 
31268 
  def __repr__(self):
31269 
    L = ['%s=%r' % (key, value)
31270 
      for key, value in self.__dict__.iteritems()]
31271 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31272 
 
31273 
  def __eq__(self, other):
31274 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31275 
 
31276 
  def __ne__(self, other):
31277 
    return not (self == other)
31278 
 
31279 
class getAllPrivateDealsComparison_args:
31280 
 
31281 
  thrift_spec = (
31282 
  )
31283 
 
31284 
  def read(self, iprot):
31285 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31286 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31287 
      return
31288 
    iprot.readStructBegin()
31289 
    while True:
31290 
      (fname, ftype, fid) = iprot.readFieldBegin()
31291 
      if ftype == TType.STOP:
31292 
        break
31293 
      else:
31294 
        iprot.skip(ftype)
31295 
      iprot.readFieldEnd()
31296 
    iprot.readStructEnd()
31297 
 
31298 
  def write(self, oprot):
31299 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31300 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31301 
      return
31302 
    oprot.writeStructBegin('getAllPrivateDealsComparison_args')
31303 
    oprot.writeFieldStop()
31304 
    oprot.writeStructEnd()
31305 
 
31306 
  def validate(self):
31307 
    return
31308 
 
31309 
 
31310 
  def __repr__(self):
31311 
    L = ['%s=%r' % (key, value)
31312 
      for key, value in self.__dict__.iteritems()]
31313 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31314 
 
31315 
  def __eq__(self, other):
31316 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31317 
 
31318 
  def __ne__(self, other):
31319 
    return not (self == other)
31320 
 
31321 
class getAllPrivateDealsComparison_result:
31322 
  """
31323 
  Attributes:
31324 
   - success
31325 
  """
31326 
 
31327 
  thrift_spec = (
31328 
    (0, TType.LIST, 'success', (TType.STRUCT,(PdPriceComp, PdPriceComp.thrift_spec)), None, ), # 0
31329 
  )
31330 
 
31331 
  def __init__(self, success=None,):
31332 
    self.success = success
31333 
 
31334 
  def read(self, iprot):
31335 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31336 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31337 
      return
31338 
    iprot.readStructBegin()
31339 
    while True:
31340 
      (fname, ftype, fid) = iprot.readFieldBegin()
31341 
      if ftype == TType.STOP:
31342 
        break
31343 
      if fid == 0:
31344 
        if ftype == TType.LIST:
31345 
          self.success = []
13493 amit.gupta 31346 
          (_etype706, _size703) = iprot.readListBegin()
31347 
          for _i707 in xrange(_size703):
31348 
            _elem708 = PdPriceComp()
31349 
            _elem708.read(iprot)
31350 
            self.success.append(_elem708)
11905 kshitij.so 31351 
          iprot.readListEnd()
31352 
        else:
31353 
          iprot.skip(ftype)
31354 
      else:
31355 
        iprot.skip(ftype)
31356 
      iprot.readFieldEnd()
31357 
    iprot.readStructEnd()
31358 
 
31359 
  def write(self, oprot):
31360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31362 
      return
31363 
    oprot.writeStructBegin('getAllPrivateDealsComparison_result')
31364 
    if self.success is not None:
31365 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31366 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 31367 
      for iter709 in self.success:
31368 
        iter709.write(oprot)
11905 kshitij.so 31369 
      oprot.writeListEnd()
31370 
      oprot.writeFieldEnd()
31371 
    oprot.writeFieldStop()
31372 
    oprot.writeStructEnd()
31373 
 
31374 
  def validate(self):
31375 
    return
31376 
 
31377 
 
31378 
  def __repr__(self):
31379 
    L = ['%s=%r' % (key, value)
31380 
      for key, value in self.__dict__.iteritems()]
31381 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31382 
 
31383 
  def __eq__(self, other):
31384 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31385 
 
31386 
  def __ne__(self, other):
31387 
    return not (self == other)
12133 kshitij.so 31388 
 
31389 
class getAllSnapdealMarketplaceItem_args:
31390 
 
31391 
  thrift_spec = (
31392 
  )
31393 
 
31394 
  def read(self, iprot):
31395 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31396 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31397 
      return
31398 
    iprot.readStructBegin()
31399 
    while True:
31400 
      (fname, ftype, fid) = iprot.readFieldBegin()
31401 
      if ftype == TType.STOP:
31402 
        break
31403 
      else:
31404 
        iprot.skip(ftype)
31405 
      iprot.readFieldEnd()
31406 
    iprot.readStructEnd()
31407 
 
31408 
  def write(self, oprot):
31409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31411 
      return
31412 
    oprot.writeStructBegin('getAllSnapdealMarketplaceItem_args')
31413 
    oprot.writeFieldStop()
31414 
    oprot.writeStructEnd()
31415 
 
31416 
  def validate(self):
31417 
    return
31418 
 
31419 
 
31420 
  def __repr__(self):
31421 
    L = ['%s=%r' % (key, value)
31422 
      for key, value in self.__dict__.iteritems()]
31423 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31424 
 
31425 
  def __eq__(self, other):
31426 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31427 
 
31428 
  def __ne__(self, other):
31429 
    return not (self == other)
31430 
 
31431 
class getAllSnapdealMarketplaceItem_result:
31432 
  """
31433 
  Attributes:
31434 
   - success
31435 
  """
31436 
 
31437 
  thrift_spec = (
31438 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItem, SnapdealItem.thrift_spec)), None, ), # 0
31439 
  )
31440 
 
31441 
  def __init__(self, success=None,):
31442 
    self.success = success
31443 
 
31444 
  def read(self, iprot):
31445 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31446 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31447 
      return
31448 
    iprot.readStructBegin()
31449 
    while True:
31450 
      (fname, ftype, fid) = iprot.readFieldBegin()
31451 
      if ftype == TType.STOP:
31452 
        break
31453 
      if fid == 0:
31454 
        if ftype == TType.LIST:
31455 
          self.success = []
13493 amit.gupta 31456 
          (_etype713, _size710) = iprot.readListBegin()
31457 
          for _i714 in xrange(_size710):
31458 
            _elem715 = SnapdealItem()
31459 
            _elem715.read(iprot)
31460 
            self.success.append(_elem715)
12133 kshitij.so 31461 
          iprot.readListEnd()
31462 
        else:
31463 
          iprot.skip(ftype)
31464 
      else:
31465 
        iprot.skip(ftype)
31466 
      iprot.readFieldEnd()
31467 
    iprot.readStructEnd()
31468 
 
31469 
  def write(self, oprot):
31470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31472 
      return
31473 
    oprot.writeStructBegin('getAllSnapdealMarketplaceItem_result')
31474 
    if self.success is not None:
31475 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31476 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 31477 
      for iter716 in self.success:
31478 
        iter716.write(oprot)
12133 kshitij.so 31479 
      oprot.writeListEnd()
31480 
      oprot.writeFieldEnd()
31481 
    oprot.writeFieldStop()
31482 
    oprot.writeStructEnd()
31483 
 
31484 
  def validate(self):
31485 
    return
31486 
 
31487 
 
31488 
  def __repr__(self):
31489 
    L = ['%s=%r' % (key, value)
31490 
      for key, value in self.__dict__.iteritems()]
31491 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31492 
 
31493 
  def __eq__(self, other):
31494 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31495 
 
31496 
  def __ne__(self, other):
31497 
    return not (self == other)
31498 
 
31499 
class getAllFlipkartMarketplaceItem_args:
31500 
 
31501 
  thrift_spec = (
31502 
  )
31503 
 
31504 
  def read(self, iprot):
31505 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31506 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31507 
      return
31508 
    iprot.readStructBegin()
31509 
    while True:
31510 
      (fname, ftype, fid) = iprot.readFieldBegin()
31511 
      if ftype == TType.STOP:
31512 
        break
31513 
      else:
31514 
        iprot.skip(ftype)
31515 
      iprot.readFieldEnd()
31516 
    iprot.readStructEnd()
31517 
 
31518 
  def write(self, oprot):
31519 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31520 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31521 
      return
31522 
    oprot.writeStructBegin('getAllFlipkartMarketplaceItem_args')
31523 
    oprot.writeFieldStop()
31524 
    oprot.writeStructEnd()
31525 
 
31526 
  def validate(self):
31527 
    return
31528 
 
31529 
 
31530 
  def __repr__(self):
31531 
    L = ['%s=%r' % (key, value)
31532 
      for key, value in self.__dict__.iteritems()]
31533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31534 
 
31535 
  def __eq__(self, other):
31536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31537 
 
31538 
  def __ne__(self, other):
31539 
    return not (self == other)
31540 
 
31541 
class getAllFlipkartMarketplaceItem_result:
31542 
  """
31543 
  Attributes:
31544 
   - success
31545 
  """
31546 
 
31547 
  thrift_spec = (
31548 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartItem, FlipkartItem.thrift_spec)), None, ), # 0
31549 
  )
31550 
 
31551 
  def __init__(self, success=None,):
31552 
    self.success = success
31553 
 
31554 
  def read(self, iprot):
31555 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31556 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31557 
      return
31558 
    iprot.readStructBegin()
31559 
    while True:
31560 
      (fname, ftype, fid) = iprot.readFieldBegin()
31561 
      if ftype == TType.STOP:
31562 
        break
31563 
      if fid == 0:
31564 
        if ftype == TType.LIST:
31565 
          self.success = []
13493 amit.gupta 31566 
          (_etype720, _size717) = iprot.readListBegin()
31567 
          for _i721 in xrange(_size717):
31568 
            _elem722 = FlipkartItem()
31569 
            _elem722.read(iprot)
31570 
            self.success.append(_elem722)
12133 kshitij.so 31571 
          iprot.readListEnd()
31572 
        else:
31573 
          iprot.skip(ftype)
31574 
      else:
31575 
        iprot.skip(ftype)
31576 
      iprot.readFieldEnd()
31577 
    iprot.readStructEnd()
31578 
 
31579 
  def write(self, oprot):
31580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31582 
      return
31583 
    oprot.writeStructBegin('getAllFlipkartMarketplaceItem_result')
31584 
    if self.success is not None:
31585 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31586 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 31587 
      for iter723 in self.success:
31588 
        iter723.write(oprot)
12133 kshitij.so 31589 
      oprot.writeListEnd()
31590 
      oprot.writeFieldEnd()
31591 
    oprot.writeFieldStop()
31592 
    oprot.writeStructEnd()
31593 
 
31594 
  def validate(self):
31595 
    return
31596 
 
31597 
 
31598 
  def __repr__(self):
31599 
    L = ['%s=%r' % (key, value)
31600 
      for key, value in self.__dict__.iteritems()]
31601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31602 
 
31603 
  def __eq__(self, other):
31604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31605 
 
31606 
  def __ne__(self, other):
31607 
    return not (self == other)
12243 kshitij.so 31608 
 
31609 
class addCompetitorScraping_args:
31610 
  """
31611 
  Attributes:
31612 
   - competitorPricingMap
31613 
  """
31614 
 
31615 
  thrift_spec = (
31616 
    None, # 0
31617 
    (1, TType.MAP, 'competitorPricingMap', (TType.I64,None,TType.STRUCT,(CompetitorPricing, CompetitorPricing.thrift_spec)), None, ), # 1
31618 
  )
31619 
 
31620 
  def __init__(self, competitorPricingMap=None,):
31621 
    self.competitorPricingMap = competitorPricingMap
31622 
 
31623 
  def read(self, iprot):
31624 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31625 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31626 
      return
31627 
    iprot.readStructBegin()
31628 
    while True:
31629 
      (fname, ftype, fid) = iprot.readFieldBegin()
31630 
      if ftype == TType.STOP:
31631 
        break
31632 
      if fid == 1:
31633 
        if ftype == TType.MAP:
31634 
          self.competitorPricingMap = {}
13493 amit.gupta 31635 
          (_ktype725, _vtype726, _size724 ) = iprot.readMapBegin()
31636 
          for _i728 in xrange(_size724):
31637 
            _key729 = iprot.readI64();
31638 
            _val730 = CompetitorPricing()
31639 
            _val730.read(iprot)
31640 
            self.competitorPricingMap[_key729] = _val730
12243 kshitij.so 31641 
          iprot.readMapEnd()
31642 
        else:
31643 
          iprot.skip(ftype)
31644 
      else:
31645 
        iprot.skip(ftype)
31646 
      iprot.readFieldEnd()
31647 
    iprot.readStructEnd()
31648 
 
31649 
  def write(self, oprot):
31650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31652 
      return
31653 
    oprot.writeStructBegin('addCompetitorScraping_args')
31654 
    if self.competitorPricingMap is not None:
31655 
      oprot.writeFieldBegin('competitorPricingMap', TType.MAP, 1)
31656 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.competitorPricingMap))
13493 amit.gupta 31657 
      for kiter731,viter732 in self.competitorPricingMap.items():
31658 
        oprot.writeI64(kiter731)
31659 
        viter732.write(oprot)
12243 kshitij.so 31660 
      oprot.writeMapEnd()
31661 
      oprot.writeFieldEnd()
31662 
    oprot.writeFieldStop()
31663 
    oprot.writeStructEnd()
31664 
 
31665 
  def validate(self):
31666 
    return
31667 
 
31668 
 
31669 
  def __repr__(self):
31670 
    L = ['%s=%r' % (key, value)
31671 
      for key, value in self.__dict__.iteritems()]
31672 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31673 
 
31674 
  def __eq__(self, other):
31675 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31676 
 
31677 
  def __ne__(self, other):
31678 
    return not (self == other)
31679 
 
31680 
class addCompetitorScraping_result:
31681 
 
31682 
  thrift_spec = (
31683 
  )
31684 
 
31685 
  def read(self, iprot):
31686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31688 
      return
31689 
    iprot.readStructBegin()
31690 
    while True:
31691 
      (fname, ftype, fid) = iprot.readFieldBegin()
31692 
      if ftype == TType.STOP:
31693 
        break
31694 
      else:
31695 
        iprot.skip(ftype)
31696 
      iprot.readFieldEnd()
31697 
    iprot.readStructEnd()
31698 
 
31699 
  def write(self, oprot):
31700 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31701 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31702 
      return
31703 
    oprot.writeStructBegin('addCompetitorScraping_result')
31704 
    oprot.writeFieldStop()
31705 
    oprot.writeStructEnd()
31706 
 
31707 
  def validate(self):
31708 
    return
31709 
 
31710 
 
31711 
  def __repr__(self):
31712 
    L = ['%s=%r' % (key, value)
31713 
      for key, value in self.__dict__.iteritems()]
31714 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31715 
 
31716 
  def __eq__(self, other):
31717 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31718 
 
31719 
  def __ne__(self, other):
31720 
    return not (self == other)
31721 
 
31722 
class getPreviousCompetitorScraping_args:
31723 
  """
31724 
  Attributes:
31725 
   - delta
31726 
  """
31727 
 
31728 
  thrift_spec = (
31729 
    None, # 0
31730 
    (1, TType.I64, 'delta', None, None, ), # 1
31731 
  )
31732 
 
31733 
  def __init__(self, delta=None,):
31734 
    self.delta = delta
31735 
 
31736 
  def read(self, iprot):
31737 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31738 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31739 
      return
31740 
    iprot.readStructBegin()
31741 
    while True:
31742 
      (fname, ftype, fid) = iprot.readFieldBegin()
31743 
      if ftype == TType.STOP:
31744 
        break
31745 
      if fid == 1:
31746 
        if ftype == TType.I64:
31747 
          self.delta = iprot.readI64();
31748 
        else:
31749 
          iprot.skip(ftype)
31750 
      else:
31751 
        iprot.skip(ftype)
31752 
      iprot.readFieldEnd()
31753 
    iprot.readStructEnd()
31754 
 
31755 
  def write(self, oprot):
31756 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31757 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31758 
      return
31759 
    oprot.writeStructBegin('getPreviousCompetitorScraping_args')
31760 
    if self.delta is not None:
31761 
      oprot.writeFieldBegin('delta', TType.I64, 1)
31762 
      oprot.writeI64(self.delta)
31763 
      oprot.writeFieldEnd()
31764 
    oprot.writeFieldStop()
31765 
    oprot.writeStructEnd()
31766 
 
31767 
  def validate(self):
31768 
    return
31769 
 
31770 
 
31771 
  def __repr__(self):
31772 
    L = ['%s=%r' % (key, value)
31773 
      for key, value in self.__dict__.iteritems()]
31774 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31775 
 
31776 
  def __eq__(self, other):
31777 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31778 
 
31779 
  def __ne__(self, other):
31780 
    return not (self == other)
31781 
 
31782 
class getPreviousCompetitorScraping_result:
31783 
  """
31784 
  Attributes:
31785 
   - success
31786 
  """
31787 
 
31788 
  thrift_spec = (
31789 
    (0, TType.LIST, 'success', (TType.STRUCT,(CompetitorPricing, CompetitorPricing.thrift_spec)), None, ), # 0
31790 
  )
31791 
 
31792 
  def __init__(self, success=None,):
31793 
    self.success = success
31794 
 
31795 
  def read(self, iprot):
31796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31798 
      return
31799 
    iprot.readStructBegin()
31800 
    while True:
31801 
      (fname, ftype, fid) = iprot.readFieldBegin()
31802 
      if ftype == TType.STOP:
31803 
        break
31804 
      if fid == 0:
31805 
        if ftype == TType.LIST:
31806 
          self.success = []
13493 amit.gupta 31807 
          (_etype736, _size733) = iprot.readListBegin()
31808 
          for _i737 in xrange(_size733):
31809 
            _elem738 = CompetitorPricing()
31810 
            _elem738.read(iprot)
31811 
            self.success.append(_elem738)
12243 kshitij.so 31812 
          iprot.readListEnd()
31813 
        else:
31814 
          iprot.skip(ftype)
31815 
      else:
31816 
        iprot.skip(ftype)
31817 
      iprot.readFieldEnd()
31818 
    iprot.readStructEnd()
31819 
 
31820 
  def write(self, oprot):
31821 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31822 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31823 
      return
31824 
    oprot.writeStructBegin('getPreviousCompetitorScraping_result')
31825 
    if self.success is not None:
31826 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31827 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 31828 
      for iter739 in self.success:
31829 
        iter739.write(oprot)
12243 kshitij.so 31830 
      oprot.writeListEnd()
31831 
      oprot.writeFieldEnd()
31832 
    oprot.writeFieldStop()
31833 
    oprot.writeStructEnd()
31834 
 
31835 
  def validate(self):
31836 
    return
31837 
 
31838 
 
31839 
  def __repr__(self):
31840 
    L = ['%s=%r' % (key, value)
31841 
      for key, value in self.__dict__.iteritems()]
31842 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31843 
 
31844 
  def __eq__(self, other):
31845 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31846 
 
31847 
  def __ne__(self, other):
31848 
    return not (self == other)
12256 kshitij.so 31849 
 
31850 
class getUploadResultById_args:
31851 
  """
31852 
  Attributes:
31853 
   - uploadId
31854 
  """
31855 
 
31856 
  thrift_spec = (
31857 
    None, # 0
31858 
    (1, TType.I64, 'uploadId', None, None, ), # 1
31859 
  )
31860 
 
31861 
  def __init__(self, uploadId=None,):
31862 
    self.uploadId = uploadId
31863 
 
31864 
  def read(self, iprot):
31865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31867 
      return
31868 
    iprot.readStructBegin()
31869 
    while True:
31870 
      (fname, ftype, fid) = iprot.readFieldBegin()
31871 
      if ftype == TType.STOP:
31872 
        break
31873 
      if fid == 1:
31874 
        if ftype == TType.I64:
31875 
          self.uploadId = iprot.readI64();
31876 
        else:
31877 
          iprot.skip(ftype)
31878 
      else:
31879 
        iprot.skip(ftype)
31880 
      iprot.readFieldEnd()
31881 
    iprot.readStructEnd()
31882 
 
31883 
  def write(self, oprot):
31884 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31885 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31886 
      return
31887 
    oprot.writeStructBegin('getUploadResultById_args')
31888 
    if self.uploadId is not None:
31889 
      oprot.writeFieldBegin('uploadId', TType.I64, 1)
31890 
      oprot.writeI64(self.uploadId)
31891 
      oprot.writeFieldEnd()
31892 
    oprot.writeFieldStop()
31893 
    oprot.writeStructEnd()
31894 
 
31895 
  def validate(self):
31896 
    return
31897 
 
31898 
 
31899 
  def __repr__(self):
31900 
    L = ['%s=%r' % (key, value)
31901 
      for key, value in self.__dict__.iteritems()]
31902 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31903 
 
31904 
  def __eq__(self, other):
31905 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31906 
 
31907 
  def __ne__(self, other):
31908 
    return not (self == other)
31909 
 
31910 
class getUploadResultById_result:
31911 
  """
31912 
  Attributes:
31913 
   - success
31914 
  """
31915 
 
31916 
  thrift_spec = (
31917 
    (0, TType.LIST, 'success', (TType.STRUCT,(CompetitorPricing, CompetitorPricing.thrift_spec)), None, ), # 0
31918 
  )
31919 
 
31920 
  def __init__(self, success=None,):
31921 
    self.success = success
31922 
 
31923 
  def read(self, iprot):
31924 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31925 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31926 
      return
31927 
    iprot.readStructBegin()
31928 
    while True:
31929 
      (fname, ftype, fid) = iprot.readFieldBegin()
31930 
      if ftype == TType.STOP:
31931 
        break
31932 
      if fid == 0:
31933 
        if ftype == TType.LIST:
31934 
          self.success = []
13493 amit.gupta 31935 
          (_etype743, _size740) = iprot.readListBegin()
31936 
          for _i744 in xrange(_size740):
31937 
            _elem745 = CompetitorPricing()
31938 
            _elem745.read(iprot)
31939 
            self.success.append(_elem745)
12256 kshitij.so 31940 
          iprot.readListEnd()
31941 
        else:
31942 
          iprot.skip(ftype)
31943 
      else:
31944 
        iprot.skip(ftype)
31945 
      iprot.readFieldEnd()
31946 
    iprot.readStructEnd()
31947 
 
31948 
  def write(self, oprot):
31949 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31950 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31951 
      return
31952 
    oprot.writeStructBegin('getUploadResultById_result')
31953 
    if self.success is not None:
31954 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31955 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 31956 
      for iter746 in self.success:
31957 
        iter746.write(oprot)
12256 kshitij.so 31958 
      oprot.writeListEnd()
31959 
      oprot.writeFieldEnd()
31960 
    oprot.writeFieldStop()
31961 
    oprot.writeStructEnd()
31962 
 
31963 
  def validate(self):
31964 
    return
31965 
 
31966 
 
31967 
  def __repr__(self):
31968 
    L = ['%s=%r' % (key, value)
31969 
      for key, value in self.__dict__.iteritems()]
31970 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31971 
 
31972 
  def __eq__(self, other):
31973 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31974 
 
31975 
  def __ne__(self, other):
31976 
    return not (self == other)
12363 kshitij.so 31977 
 
31978 
class addAmazonPromotion_args:
31979 
  """
31980 
  Attributes:
31981 
   - amazonPromotions
31982 
  """
31983 
 
31984 
  thrift_spec = (
31985 
    None, # 0
31986 
    (1, TType.MAP, 'amazonPromotions', (TType.STRING,None,TType.STRUCT,(AmazonPromotion, AmazonPromotion.thrift_spec)), None, ), # 1
31987 
  )
31988 
 
31989 
  def __init__(self, amazonPromotions=None,):
31990 
    self.amazonPromotions = amazonPromotions
31991 
 
31992 
  def read(self, iprot):
31993 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31994 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31995 
      return
31996 
    iprot.readStructBegin()
31997 
    while True:
31998 
      (fname, ftype, fid) = iprot.readFieldBegin()
31999 
      if ftype == TType.STOP:
32000 
        break
32001 
      if fid == 1:
32002 
        if ftype == TType.MAP:
32003 
          self.amazonPromotions = {}
13493 amit.gupta 32004 
          (_ktype748, _vtype749, _size747 ) = iprot.readMapBegin()
32005 
          for _i751 in xrange(_size747):
32006 
            _key752 = iprot.readString();
32007 
            _val753 = AmazonPromotion()
32008 
            _val753.read(iprot)
32009 
            self.amazonPromotions[_key752] = _val753
12363 kshitij.so 32010 
          iprot.readMapEnd()
32011 
        else:
32012 
          iprot.skip(ftype)
32013 
      else:
32014 
        iprot.skip(ftype)
32015 
      iprot.readFieldEnd()
32016 
    iprot.readStructEnd()
32017 
 
32018 
  def write(self, oprot):
32019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32021 
      return
32022 
    oprot.writeStructBegin('addAmazonPromotion_args')
32023 
    if self.amazonPromotions is not None:
32024 
      oprot.writeFieldBegin('amazonPromotions', TType.MAP, 1)
32025 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.amazonPromotions))
13493 amit.gupta 32026 
      for kiter754,viter755 in self.amazonPromotions.items():
32027 
        oprot.writeString(kiter754)
32028 
        viter755.write(oprot)
12363 kshitij.so 32029 
      oprot.writeMapEnd()
32030 
      oprot.writeFieldEnd()
32031 
    oprot.writeFieldStop()
32032 
    oprot.writeStructEnd()
32033 
 
32034 
  def validate(self):
32035 
    return
32036 
 
32037 
 
32038 
  def __repr__(self):
32039 
    L = ['%s=%r' % (key, value)
32040 
      for key, value in self.__dict__.iteritems()]
32041 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32042 
 
32043 
  def __eq__(self, other):
32044 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32045 
 
32046 
  def __ne__(self, other):
32047 
    return not (self == other)
32048 
 
32049 
class addAmazonPromotion_result:
32050 
  """
32051 
  Attributes:
32052 
   - success
12947 kshitij.so 32053 
   - cex
12363 kshitij.so 32054 
  """
32055 
 
32056 
  thrift_spec = (
12947 kshitij.so 32057 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
32058 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12363 kshitij.so 32059 
  )
32060 
 
12947 kshitij.so 32061 
  def __init__(self, success=None, cex=None,):
12363 kshitij.so 32062 
    self.success = success
12947 kshitij.so 32063 
    self.cex = cex
12363 kshitij.so 32064 
 
32065 
  def read(self, iprot):
32066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32068 
      return
32069 
    iprot.readStructBegin()
32070 
    while True:
32071 
      (fname, ftype, fid) = iprot.readFieldBegin()
32072 
      if ftype == TType.STOP:
32073 
        break
32074 
      if fid == 0:
12947 kshitij.so 32075 
        if ftype == TType.LIST:
32076 
          self.success = []
13493 amit.gupta 32077 
          (_etype759, _size756) = iprot.readListBegin()
32078 
          for _i760 in xrange(_size756):
32079 
            _elem761 = iprot.readString();
32080 
            self.success.append(_elem761)
12947 kshitij.so 32081 
          iprot.readListEnd()
12363 kshitij.so 32082 
        else:
32083 
          iprot.skip(ftype)
12947 kshitij.so 32084 
      elif fid == 1:
32085 
        if ftype == TType.STRUCT:
32086 
          self.cex = CatalogServiceException()
32087 
          self.cex.read(iprot)
32088 
        else:
32089 
          iprot.skip(ftype)
12363 kshitij.so 32090 
      else:
32091 
        iprot.skip(ftype)
32092 
      iprot.readFieldEnd()
32093 
    iprot.readStructEnd()
32094 
 
32095 
  def write(self, oprot):
32096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32098 
      return
32099 
    oprot.writeStructBegin('addAmazonPromotion_result')
32100 
    if self.success is not None:
12947 kshitij.so 32101 
      oprot.writeFieldBegin('success', TType.LIST, 0)
32102 
      oprot.writeListBegin(TType.STRING, len(self.success))
13493 amit.gupta 32103 
      for iter762 in self.success:
32104 
        oprot.writeString(iter762)
12947 kshitij.so 32105 
      oprot.writeListEnd()
12363 kshitij.so 32106 
      oprot.writeFieldEnd()
12947 kshitij.so 32107 
    if self.cex is not None:
32108 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
32109 
      self.cex.write(oprot)
32110 
      oprot.writeFieldEnd()
12363 kshitij.so 32111 
    oprot.writeFieldStop()
32112 
    oprot.writeStructEnd()
32113 
 
32114 
  def validate(self):
32115 
    return
32116 
 
32117 
 
32118 
  def __repr__(self):
32119 
    L = ['%s=%r' % (key, value)
32120 
      for key, value in self.__dict__.iteritems()]
32121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32122 
 
32123 
  def __eq__(self, other):
32124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32125 
 
32126 
  def __ne__(self, other):
32127 
    return not (self == other)
32128 
 
32129 
class getAmazonPromotion_args:
32130 
  """
32131 
  Attributes:
32132 
   - startDate
32133 
   - endDate
32134 
  """
32135 
 
32136 
  thrift_spec = (
32137 
    None, # 0
32138 
    (1, TType.I64, 'startDate', None, None, ), # 1
32139 
    (2, TType.I64, 'endDate', None, None, ), # 2
32140 
  )
32141 
 
32142 
  def __init__(self, startDate=None, endDate=None,):
32143 
    self.startDate = startDate
32144 
    self.endDate = endDate
32145 
 
32146 
  def read(self, iprot):
32147 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32148 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32149 
      return
32150 
    iprot.readStructBegin()
32151 
    while True:
32152 
      (fname, ftype, fid) = iprot.readFieldBegin()
32153 
      if ftype == TType.STOP:
32154 
        break
32155 
      if fid == 1:
32156 
        if ftype == TType.I64:
32157 
          self.startDate = iprot.readI64();
32158 
        else:
32159 
          iprot.skip(ftype)
32160 
      elif fid == 2:
32161 
        if ftype == TType.I64:
32162 
          self.endDate = iprot.readI64();
32163 
        else:
32164 
          iprot.skip(ftype)
32165 
      else:
32166 
        iprot.skip(ftype)
32167 
      iprot.readFieldEnd()
32168 
    iprot.readStructEnd()
32169 
 
32170 
  def write(self, oprot):
32171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32173 
      return
32174 
    oprot.writeStructBegin('getAmazonPromotion_args')
32175 
    if self.startDate is not None:
32176 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
32177 
      oprot.writeI64(self.startDate)
32178 
      oprot.writeFieldEnd()
32179 
    if self.endDate is not None:
32180 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
32181 
      oprot.writeI64(self.endDate)
32182 
      oprot.writeFieldEnd()
32183 
    oprot.writeFieldStop()
32184 
    oprot.writeStructEnd()
32185 
 
32186 
  def validate(self):
32187 
    return
32188 
 
32189 
 
32190 
  def __repr__(self):
32191 
    L = ['%s=%r' % (key, value)
32192 
      for key, value in self.__dict__.iteritems()]
32193 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32194 
 
32195 
  def __eq__(self, other):
32196 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32197 
 
32198 
  def __ne__(self, other):
32199 
    return not (self == other)
32200 
 
32201 
class getAmazonPromotion_result:
32202 
  """
32203 
  Attributes:
32204 
   - success
32205 
  """
32206 
 
32207 
  thrift_spec = (
32208 
    (0, TType.LIST, 'success', (TType.STRUCT,(AmazonPromotion, AmazonPromotion.thrift_spec)), None, ), # 0
32209 
  )
32210 
 
32211 
  def __init__(self, success=None,):
32212 
    self.success = success
32213 
 
32214 
  def read(self, iprot):
32215 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32216 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32217 
      return
32218 
    iprot.readStructBegin()
32219 
    while True:
32220 
      (fname, ftype, fid) = iprot.readFieldBegin()
32221 
      if ftype == TType.STOP:
32222 
        break
32223 
      if fid == 0:
32224 
        if ftype == TType.LIST:
32225 
          self.success = []
13493 amit.gupta 32226 
          (_etype766, _size763) = iprot.readListBegin()
32227 
          for _i767 in xrange(_size763):
32228 
            _elem768 = AmazonPromotion()
32229 
            _elem768.read(iprot)
32230 
            self.success.append(_elem768)
12363 kshitij.so 32231 
          iprot.readListEnd()
32232 
        else:
32233 
          iprot.skip(ftype)
32234 
      else:
32235 
        iprot.skip(ftype)
32236 
      iprot.readFieldEnd()
32237 
    iprot.readStructEnd()
32238 
 
32239 
  def write(self, oprot):
32240 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32241 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32242 
      return
32243 
    oprot.writeStructBegin('getAmazonPromotion_result')
32244 
    if self.success is not None:
32245 
      oprot.writeFieldBegin('success', TType.LIST, 0)
32246 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 32247 
      for iter769 in self.success:
32248 
        iter769.write(oprot)
12363 kshitij.so 32249 
      oprot.writeListEnd()
32250 
      oprot.writeFieldEnd()
32251 
    oprot.writeFieldStop()
32252 
    oprot.writeStructEnd()
32253 
 
32254 
  def validate(self):
32255 
    return
32256 
 
32257 
 
32258 
  def __repr__(self):
32259 
    L = ['%s=%r' % (key, value)
32260 
      for key, value in self.__dict__.iteritems()]
32261 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32262 
 
32263 
  def __eq__(self, other):
32264 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32265 
 
32266 
  def __ne__(self, other):
32267 
    return not (self == other)
32268 
 
32269 
class updateAmazonPromotion_args:
32270 
  """
32271 
  Attributes:
32272 
   - amazonPromotions
32273 
  """
32274 
 
32275 
  thrift_spec = (
32276 
    None, # 0
32277 
    (1, TType.LIST, 'amazonPromotions', (TType.STRUCT,(AmazonPromotion, AmazonPromotion.thrift_spec)), None, ), # 1
32278 
  )
32279 
 
32280 
  def __init__(self, amazonPromotions=None,):
32281 
    self.amazonPromotions = amazonPromotions
32282 
 
32283 
  def read(self, iprot):
32284 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32285 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32286 
      return
32287 
    iprot.readStructBegin()
32288 
    while True:
32289 
      (fname, ftype, fid) = iprot.readFieldBegin()
32290 
      if ftype == TType.STOP:
32291 
        break
32292 
      if fid == 1:
32293 
        if ftype == TType.LIST:
32294 
          self.amazonPromotions = []
13493 amit.gupta 32295 
          (_etype773, _size770) = iprot.readListBegin()
32296 
          for _i774 in xrange(_size770):
32297 
            _elem775 = AmazonPromotion()
32298 
            _elem775.read(iprot)
32299 
            self.amazonPromotions.append(_elem775)
12363 kshitij.so 32300 
          iprot.readListEnd()
32301 
        else:
32302 
          iprot.skip(ftype)
32303 
      else:
32304 
        iprot.skip(ftype)
32305 
      iprot.readFieldEnd()
32306 
    iprot.readStructEnd()
32307 
 
32308 
  def write(self, oprot):
32309 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32310 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32311 
      return
32312 
    oprot.writeStructBegin('updateAmazonPromotion_args')
32313 
    if self.amazonPromotions is not None:
32314 
      oprot.writeFieldBegin('amazonPromotions', TType.LIST, 1)
32315 
      oprot.writeListBegin(TType.STRUCT, len(self.amazonPromotions))
13493 amit.gupta 32316 
      for iter776 in self.amazonPromotions:
32317 
        iter776.write(oprot)
12363 kshitij.so 32318 
      oprot.writeListEnd()
32319 
      oprot.writeFieldEnd()
32320 
    oprot.writeFieldStop()
32321 
    oprot.writeStructEnd()
32322 
 
32323 
  def validate(self):
32324 
    return
32325 
 
32326 
 
32327 
  def __repr__(self):
32328 
    L = ['%s=%r' % (key, value)
32329 
      for key, value in self.__dict__.iteritems()]
32330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32331 
 
32332 
  def __eq__(self, other):
32333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32334 
 
32335 
  def __ne__(self, other):
32336 
    return not (self == other)
32337 
 
32338 
class updateAmazonPromotion_result:
32339 
  """
32340 
  Attributes:
32341 
   - success
32342 
  """
32343 
 
32344 
  thrift_spec = (
32345 
    (0, TType.BOOL, 'success', None, None, ), # 0
32346 
  )
32347 
 
32348 
  def __init__(self, success=None,):
32349 
    self.success = success
32350 
 
32351 
  def read(self, iprot):
32352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32354 
      return
32355 
    iprot.readStructBegin()
32356 
    while True:
32357 
      (fname, ftype, fid) = iprot.readFieldBegin()
32358 
      if ftype == TType.STOP:
32359 
        break
32360 
      if fid == 0:
32361 
        if ftype == TType.BOOL:
32362 
          self.success = iprot.readBool();
32363 
        else:
32364 
          iprot.skip(ftype)
32365 
      else:
32366 
        iprot.skip(ftype)
32367 
      iprot.readFieldEnd()
32368 
    iprot.readStructEnd()
32369 
 
32370 
  def write(self, oprot):
32371 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32372 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32373 
      return
32374 
    oprot.writeStructBegin('updateAmazonPromotion_result')
32375 
    if self.success is not None:
32376 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
32377 
      oprot.writeBool(self.success)
32378 
      oprot.writeFieldEnd()
32379 
    oprot.writeFieldStop()
32380 
    oprot.writeStructEnd()
32381 
 
32382 
  def validate(self):
32383 
    return
32384 
 
32385 
 
32386 
  def __repr__(self):
32387 
    L = ['%s=%r' % (key, value)
32388 
      for key, value in self.__dict__.iteritems()]
32389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32390 
 
32391 
  def __eq__(self, other):
32392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32393 
 
32394 
  def __ne__(self, other):
32395 
    return not (self == other)
12567 amit.gupta 32396 
 
32397 
class markPartiallyActive_args:
32398 
  """
32399 
  Attributes:
32400 
   - itemId
32401 
   - categoryId
32402 
  """
32403 
 
32404 
  thrift_spec = (
32405 
    None, # 0
32406 
    (1, TType.I64, 'itemId', None, None, ), # 1
32407 
    (2, TType.I64, 'categoryId', None, None, ), # 2
32408 
  )
32409 
 
32410 
  def __init__(self, itemId=None, categoryId=None,):
32411 
    self.itemId = itemId
32412 
    self.categoryId = categoryId
32413 
 
32414 
  def read(self, iprot):
32415 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32416 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32417 
      return
32418 
    iprot.readStructBegin()
32419 
    while True:
32420 
      (fname, ftype, fid) = iprot.readFieldBegin()
32421 
      if ftype == TType.STOP:
32422 
        break
32423 
      if fid == 1:
32424 
        if ftype == TType.I64:
32425 
          self.itemId = iprot.readI64();
32426 
        else:
32427 
          iprot.skip(ftype)
32428 
      elif fid == 2:
32429 
        if ftype == TType.I64:
32430 
          self.categoryId = iprot.readI64();
32431 
        else:
32432 
          iprot.skip(ftype)
32433 
      else:
32434 
        iprot.skip(ftype)
32435 
      iprot.readFieldEnd()
32436 
    iprot.readStructEnd()
32437 
 
32438 
  def write(self, oprot):
32439 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32440 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32441 
      return
32442 
    oprot.writeStructBegin('markPartiallyActive_args')
32443 
    if self.itemId is not None:
32444 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
32445 
      oprot.writeI64(self.itemId)
32446 
      oprot.writeFieldEnd()
32447 
    if self.categoryId is not None:
32448 
      oprot.writeFieldBegin('categoryId', TType.I64, 2)
32449 
      oprot.writeI64(self.categoryId)
32450 
      oprot.writeFieldEnd()
32451 
    oprot.writeFieldStop()
32452 
    oprot.writeStructEnd()
32453 
 
32454 
  def validate(self):
32455 
    return
32456 
 
32457 
 
32458 
  def __repr__(self):
32459 
    L = ['%s=%r' % (key, value)
32460 
      for key, value in self.__dict__.iteritems()]
32461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32462 
 
32463 
  def __eq__(self, other):
32464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32465 
 
32466 
  def __ne__(self, other):
32467 
    return not (self == other)
32468 
 
32469 
class markPartiallyActive_result:
32470 
  """
32471 
  Attributes:
32472 
   - success
32473 
  """
32474 
 
32475 
  thrift_spec = (
32476 
    (0, TType.BOOL, 'success', None, None, ), # 0
32477 
  )
32478 
 
32479 
  def __init__(self, success=None,):
32480 
    self.success = success
32481 
 
32482 
  def read(self, iprot):
32483 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32484 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32485 
      return
32486 
    iprot.readStructBegin()
32487 
    while True:
32488 
      (fname, ftype, fid) = iprot.readFieldBegin()
32489 
      if ftype == TType.STOP:
32490 
        break
32491 
      if fid == 0:
32492 
        if ftype == TType.BOOL:
32493 
          self.success = iprot.readBool();
32494 
        else:
32495 
          iprot.skip(ftype)
32496 
      else:
32497 
        iprot.skip(ftype)
32498 
      iprot.readFieldEnd()
32499 
    iprot.readStructEnd()
32500 
 
32501 
  def write(self, oprot):
32502 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32503 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32504 
      return
32505 
    oprot.writeStructBegin('markPartiallyActive_result')
32506 
    if self.success is not None:
32507 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
32508 
      oprot.writeBool(self.success)
32509 
      oprot.writeFieldEnd()
32510 
    oprot.writeFieldStop()
32511 
    oprot.writeStructEnd()
32512 
 
32513 
  def validate(self):
32514 
    return
32515 
 
32516 
 
32517 
  def __repr__(self):
32518 
    L = ['%s=%r' % (key, value)
32519 
      for key, value in self.__dict__.iteritems()]
32520 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32521 
 
32522 
  def __eq__(self, other):
32523 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32524 
 
32525 
  def __ne__(self, other):
32526 
    return not (self == other)
32527 
 
32528 
class updateItemStateVat_args:
32529 
  """
32530 
  Attributes:
32531 
   - itemId
32532 
   - statevat
32533 
  """
32534 
 
32535 
  thrift_spec = (
32536 
    None, # 0
32537 
    (1, TType.I64, 'itemId', None, None, ), # 1
32538 
    (2, TType.MAP, 'statevat', (TType.I64,None,TType.DOUBLE,None), None, ), # 2
32539 
  )
32540 
 
32541 
  def __init__(self, itemId=None, statevat=None,):
32542 
    self.itemId = itemId
32543 
    self.statevat = statevat
32544 
 
32545 
  def read(self, iprot):
32546 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32547 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32548 
      return
32549 
    iprot.readStructBegin()
32550 
    while True:
32551 
      (fname, ftype, fid) = iprot.readFieldBegin()
32552 
      if ftype == TType.STOP:
32553 
        break
32554 
      if fid == 1:
32555 
        if ftype == TType.I64:
32556 
          self.itemId = iprot.readI64();
32557 
        else:
32558 
          iprot.skip(ftype)
32559 
      elif fid == 2:
32560 
        if ftype == TType.MAP:
32561 
          self.statevat = {}
13493 amit.gupta 32562 
          (_ktype778, _vtype779, _size777 ) = iprot.readMapBegin()
32563 
          for _i781 in xrange(_size777):
32564 
            _key782 = iprot.readI64();
32565 
            _val783 = iprot.readDouble();
32566 
            self.statevat[_key782] = _val783
12567 amit.gupta 32567 
          iprot.readMapEnd()
32568 
        else:
32569 
          iprot.skip(ftype)
32570 
      else:
32571 
        iprot.skip(ftype)
32572 
      iprot.readFieldEnd()
32573 
    iprot.readStructEnd()
32574 
 
32575 
  def write(self, oprot):
32576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32578 
      return
32579 
    oprot.writeStructBegin('updateItemStateVat_args')
32580 
    if self.itemId is not None:
32581 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
32582 
      oprot.writeI64(self.itemId)
32583 
      oprot.writeFieldEnd()
32584 
    if self.statevat is not None:
32585 
      oprot.writeFieldBegin('statevat', TType.MAP, 2)
32586 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.statevat))
13493 amit.gupta 32587 
      for kiter784,viter785 in self.statevat.items():
32588 
        oprot.writeI64(kiter784)
32589 
        oprot.writeDouble(viter785)
12567 amit.gupta 32590 
      oprot.writeMapEnd()
32591 
      oprot.writeFieldEnd()
32592 
    oprot.writeFieldStop()
32593 
    oprot.writeStructEnd()
32594 
 
32595 
  def validate(self):
32596 
    return
32597 
 
32598 
 
32599 
  def __repr__(self):
32600 
    L = ['%s=%r' % (key, value)
32601 
      for key, value in self.__dict__.iteritems()]
32602 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32603 
 
32604 
  def __eq__(self, other):
32605 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32606 
 
32607 
  def __ne__(self, other):
32608 
    return not (self == other)
32609 
 
32610 
class updateItemStateVat_result:
32611 
  """
32612 
  Attributes:
32613 
   - success
32614 
  """
32615 
 
32616 
  thrift_spec = (
32617 
    (0, TType.BOOL, 'success', None, None, ), # 0
32618 
  )
32619 
 
32620 
  def __init__(self, success=None,):
32621 
    self.success = success
32622 
 
32623 
  def read(self, iprot):
32624 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32625 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32626 
      return
32627 
    iprot.readStructBegin()
32628 
    while True:
32629 
      (fname, ftype, fid) = iprot.readFieldBegin()
32630 
      if ftype == TType.STOP:
32631 
        break
32632 
      if fid == 0:
32633 
        if ftype == TType.BOOL:
32634 
          self.success = iprot.readBool();
32635 
        else:
32636 
          iprot.skip(ftype)
32637 
      else:
32638 
        iprot.skip(ftype)
32639 
      iprot.readFieldEnd()
32640 
    iprot.readStructEnd()
32641 
 
32642 
  def write(self, oprot):
32643 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32644 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32645 
      return
32646 
    oprot.writeStructBegin('updateItemStateVat_result')
32647 
    if self.success is not None:
32648 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
32649 
      oprot.writeBool(self.success)
32650 
      oprot.writeFieldEnd()
32651 
    oprot.writeFieldStop()
32652 
    oprot.writeStructEnd()
32653 
 
32654 
  def validate(self):
32655 
    return
32656 
 
32657 
 
32658 
  def __repr__(self):
32659 
    L = ['%s=%r' % (key, value)
32660 
      for key, value in self.__dict__.iteritems()]
32661 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32662 
 
32663 
  def __eq__(self, other):
32664 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32665 
 
32666 
  def __ne__(self, other):
32667 
    return not (self == other)
12620 amit.gupta 32668 
 
32669 
class getExAffiliateItemInfo_args:
32670 
 
32671 
  thrift_spec = (
32672 
  )
32673 
 
32674 
  def read(self, iprot):
32675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32677 
      return
32678 
    iprot.readStructBegin()
32679 
    while True:
32680 
      (fname, ftype, fid) = iprot.readFieldBegin()
32681 
      if ftype == TType.STOP:
32682 
        break
32683 
      else:
32684 
        iprot.skip(ftype)
32685 
      iprot.readFieldEnd()
32686 
    iprot.readStructEnd()
32687 
 
32688 
  def write(self, oprot):
32689 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32690 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32691 
      return
32692 
    oprot.writeStructBegin('getExAffiliateItemInfo_args')
32693 
    oprot.writeFieldStop()
32694 
    oprot.writeStructEnd()
32695 
 
32696 
  def validate(self):
32697 
    return
32698 
 
32699 
 
32700 
  def __repr__(self):
32701 
    L = ['%s=%r' % (key, value)
32702 
      for key, value in self.__dict__.iteritems()]
32703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32704 
 
32705 
  def __eq__(self, other):
32706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32707 
 
32708 
  def __ne__(self, other):
32709 
    return not (self == other)
32710 
 
32711 
class getExAffiliateItemInfo_result:
32712 
  """
32713 
  Attributes:
32714 
   - success
32715 
  """
32716 
 
32717 
  thrift_spec = (
32718 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRUCT,(ExclusiveAffiliateItemInfo, ExclusiveAffiliateItemInfo.thrift_spec)), None, ), # 0
32719 
  )
32720 
 
32721 
  def __init__(self, success=None,):
32722 
    self.success = success
32723 
 
32724 
  def read(self, iprot):
32725 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32726 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32727 
      return
32728 
    iprot.readStructBegin()
32729 
    while True:
32730 
      (fname, ftype, fid) = iprot.readFieldBegin()
32731 
      if ftype == TType.STOP:
32732 
        break
32733 
      if fid == 0:
32734 
        if ftype == TType.MAP:
32735 
          self.success = {}
13493 amit.gupta 32736 
          (_ktype787, _vtype788, _size786 ) = iprot.readMapBegin()
32737 
          for _i790 in xrange(_size786):
32738 
            _key791 = iprot.readI64();
32739 
            _val792 = ExclusiveAffiliateItemInfo()
32740 
            _val792.read(iprot)
32741 
            self.success[_key791] = _val792
12620 amit.gupta 32742 
          iprot.readMapEnd()
32743 
        else:
32744 
          iprot.skip(ftype)
32745 
      else:
32746 
        iprot.skip(ftype)
32747 
      iprot.readFieldEnd()
32748 
    iprot.readStructEnd()
32749 
 
32750 
  def write(self, oprot):
32751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32753 
      return
32754 
    oprot.writeStructBegin('getExAffiliateItemInfo_result')
32755 
    if self.success is not None:
32756 
      oprot.writeFieldBegin('success', TType.MAP, 0)
32757 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.success))
13493 amit.gupta 32758 
      for kiter793,viter794 in self.success.items():
32759 
        oprot.writeI64(kiter793)
32760 
        viter794.write(oprot)
12620 amit.gupta 32761 
      oprot.writeMapEnd()
32762 
      oprot.writeFieldEnd()
32763 
    oprot.writeFieldStop()
32764 
    oprot.writeStructEnd()
32765 
 
32766 
  def validate(self):
32767 
    return
32768 
 
32769 
 
32770 
  def __repr__(self):
32771 
    L = ['%s=%r' % (key, value)
32772 
      for key, value in self.__dict__.iteritems()]
32773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32774 
 
32775 
  def __eq__(self, other):
32776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32777 
 
32778 
  def __ne__(self, other):
32779 
    return not (self == other)
12888 kshitij.so 32780 
 
32781 
class getAllItemstoListOnFbg_args:
32782 
 
32783 
  thrift_spec = (
32784 
  )
32785 
 
32786 
  def read(self, iprot):
32787 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32788 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32789 
      return
32790 
    iprot.readStructBegin()
32791 
    while True:
32792 
      (fname, ftype, fid) = iprot.readFieldBegin()
32793 
      if ftype == TType.STOP:
32794 
        break
32795 
      else:
32796 
        iprot.skip(ftype)
32797 
      iprot.readFieldEnd()
32798 
    iprot.readStructEnd()
32799 
 
32800 
  def write(self, oprot):
32801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32803 
      return
32804 
    oprot.writeStructBegin('getAllItemstoListOnFbg_args')
32805 
    oprot.writeFieldStop()
32806 
    oprot.writeStructEnd()
32807 
 
32808 
  def validate(self):
32809 
    return
32810 
 
32811 
 
32812 
  def __repr__(self):
32813 
    L = ['%s=%r' % (key, value)
32814 
      for key, value in self.__dict__.iteritems()]
32815 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32816 
 
32817 
  def __eq__(self, other):
32818 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32819 
 
32820 
  def __ne__(self, other):
32821 
    return not (self == other)
32822 
 
32823 
class getAllItemstoListOnFbg_result:
32824 
  """
32825 
  Attributes:
32826 
   - success
32827 
  """
32828 
 
32829 
  thrift_spec = (
32830 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
32831 
  )
32832 
 
32833 
  def __init__(self, success=None,):
32834 
    self.success = success
32835 
 
32836 
  def read(self, iprot):
32837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32839 
      return
32840 
    iprot.readStructBegin()
32841 
    while True:
32842 
      (fname, ftype, fid) = iprot.readFieldBegin()
32843 
      if ftype == TType.STOP:
32844 
        break
32845 
      if fid == 0:
32846 
        if ftype == TType.LIST:
32847 
          self.success = []
13493 amit.gupta 32848 
          (_etype798, _size795) = iprot.readListBegin()
32849 
          for _i799 in xrange(_size795):
32850 
            _elem800 = Amazonlisted()
32851 
            _elem800.read(iprot)
32852 
            self.success.append(_elem800)
12888 kshitij.so 32853 
          iprot.readListEnd()
32854 
        else:
32855 
          iprot.skip(ftype)
32856 
      else:
32857 
        iprot.skip(ftype)
32858 
      iprot.readFieldEnd()
32859 
    iprot.readStructEnd()
32860 
 
32861 
  def write(self, oprot):
32862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32864 
      return
32865 
    oprot.writeStructBegin('getAllItemstoListOnFbg_result')
32866 
    if self.success is not None:
32867 
      oprot.writeFieldBegin('success', TType.LIST, 0)
32868 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 32869 
      for iter801 in self.success:
32870 
        iter801.write(oprot)
12888 kshitij.so 32871 
      oprot.writeListEnd()
32872 
      oprot.writeFieldEnd()
32873 
    oprot.writeFieldStop()
32874 
    oprot.writeStructEnd()
32875 
 
32876 
  def validate(self):
32877 
    return
32878 
 
32879 
 
32880 
  def __repr__(self):
32881 
    L = ['%s=%r' % (key, value)
32882 
      for key, value in self.__dict__.iteritems()]
32883 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32884 
 
32885 
  def __eq__(self, other):
32886 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32887 
 
32888 
  def __ne__(self, other):
32889 
    return not (self == other)
12892 kshitij.so 32890 
 
32891 
class getAllFbgListedItems_args:
32892 
 
32893 
  thrift_spec = (
32894 
  )
32895 
 
32896 
  def read(self, iprot):
32897 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32898 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32899 
      return
32900 
    iprot.readStructBegin()
32901 
    while True:
32902 
      (fname, ftype, fid) = iprot.readFieldBegin()
32903 
      if ftype == TType.STOP:
32904 
        break
32905 
      else:
32906 
        iprot.skip(ftype)
32907 
      iprot.readFieldEnd()
32908 
    iprot.readStructEnd()
32909 
 
32910 
  def write(self, oprot):
32911 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32912 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32913 
      return
32914 
    oprot.writeStructBegin('getAllFbgListedItems_args')
32915 
    oprot.writeFieldStop()
32916 
    oprot.writeStructEnd()
32917 
 
32918 
  def validate(self):
32919 
    return
32920 
 
32921 
 
32922 
  def __repr__(self):
32923 
    L = ['%s=%r' % (key, value)
32924 
      for key, value in self.__dict__.iteritems()]
32925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32926 
 
32927 
  def __eq__(self, other):
32928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32929 
 
32930 
  def __ne__(self, other):
32931 
    return not (self == other)
32932 
 
32933 
class getAllFbgListedItems_result:
32934 
  """
32935 
  Attributes:
32936 
   - success
32937 
  """
32938 
 
32939 
  thrift_spec = (
32940 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
32941 
  )
32942 
 
32943 
  def __init__(self, success=None,):
32944 
    self.success = success
32945 
 
32946 
  def read(self, iprot):
32947 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32948 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32949 
      return
32950 
    iprot.readStructBegin()
32951 
    while True:
32952 
      (fname, ftype, fid) = iprot.readFieldBegin()
32953 
      if ftype == TType.STOP:
32954 
        break
32955 
      if fid == 0:
32956 
        if ftype == TType.LIST:
32957 
          self.success = []
13493 amit.gupta 32958 
          (_etype805, _size802) = iprot.readListBegin()
32959 
          for _i806 in xrange(_size802):
32960 
            _elem807 = Amazonlisted()
32961 
            _elem807.read(iprot)
32962 
            self.success.append(_elem807)
12892 kshitij.so 32963 
          iprot.readListEnd()
32964 
        else:
32965 
          iprot.skip(ftype)
32966 
      else:
32967 
        iprot.skip(ftype)
32968 
      iprot.readFieldEnd()
32969 
    iprot.readStructEnd()
32970 
 
32971 
  def write(self, oprot):
32972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32974 
      return
32975 
    oprot.writeStructBegin('getAllFbgListedItems_result')
32976 
    if self.success is not None:
32977 
      oprot.writeFieldBegin('success', TType.LIST, 0)
32978 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13493 amit.gupta 32979 
      for iter808 in self.success:
32980 
        iter808.write(oprot)
12892 kshitij.so 32981 
      oprot.writeListEnd()
32982 
      oprot.writeFieldEnd()
32983 
    oprot.writeFieldStop()
32984 
    oprot.writeStructEnd()
32985 
 
32986 
  def validate(self):
32987 
    return
32988 
 
32989 
 
32990 
  def __repr__(self):
32991 
    L = ['%s=%r' % (key, value)
32992 
      for key, value in self.__dict__.iteritems()]
32993 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32994 
 
32995 
  def __eq__(self, other):
32996 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32997 
 
32998 
  def __ne__(self, other):
32999 
    return not (self == other)
13136 amit.gupta 33000 
 
33001 
class checkServices_args:
33002 
  """
33003 
  Attributes:
33004 
   - lines
33005 
  """
33006 
 
33007 
  thrift_spec = (
33008 
    None, # 0
33009 
    (1, TType.MAP, 'lines', (TType.I64,None,TType.MAP,(TType.STRING,None,TType.I64,None)), None, ), # 1
33010 
  )
33011 
 
33012 
  def __init__(self, lines=None,):
33013 
    self.lines = lines
33014 
 
33015 
  def read(self, iprot):
33016 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33017 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33018 
      return
33019 
    iprot.readStructBegin()
33020 
    while True:
33021 
      (fname, ftype, fid) = iprot.readFieldBegin()
33022 
      if ftype == TType.STOP:
33023 
        break
33024 
      if fid == 1:
33025 
        if ftype == TType.MAP:
33026 
          self.lines = {}
13493 amit.gupta 33027 
          (_ktype810, _vtype811, _size809 ) = iprot.readMapBegin()
33028 
          for _i813 in xrange(_size809):
33029 
            _key814 = iprot.readI64();
33030 
            _val815 = {}
33031 
            (_ktype817, _vtype818, _size816 ) = iprot.readMapBegin()
33032 
            for _i820 in xrange(_size816):
33033 
              _key821 = iprot.readString();
33034 
              _val822 = iprot.readI64();
33035 
              _val815[_key821] = _val822
13136 amit.gupta 33036 
            iprot.readMapEnd()
13493 amit.gupta 33037 
            self.lines[_key814] = _val815
13136 amit.gupta 33038 
          iprot.readMapEnd()
33039 
        else:
33040 
          iprot.skip(ftype)
33041 
      else:
33042 
        iprot.skip(ftype)
33043 
      iprot.readFieldEnd()
33044 
    iprot.readStructEnd()
33045 
 
33046 
  def write(self, oprot):
33047 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33048 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33049 
      return
33050 
    oprot.writeStructBegin('checkServices_args')
33051 
    if self.lines is not None:
33052 
      oprot.writeFieldBegin('lines', TType.MAP, 1)
33053 
      oprot.writeMapBegin(TType.I64, TType.MAP, len(self.lines))
13493 amit.gupta 33054 
      for kiter823,viter824 in self.lines.items():
33055 
        oprot.writeI64(kiter823)
33056 
        oprot.writeMapBegin(TType.STRING, TType.I64, len(viter824))
33057 
        for kiter825,viter826 in viter824.items():
33058 
          oprot.writeString(kiter825)
33059 
          oprot.writeI64(viter826)
13136 amit.gupta 33060 
        oprot.writeMapEnd()
33061 
      oprot.writeMapEnd()
33062 
      oprot.writeFieldEnd()
33063 
    oprot.writeFieldStop()
33064 
    oprot.writeStructEnd()
33065 
 
33066 
  def validate(self):
33067 
    return
33068 
 
33069 
 
33070 
  def __repr__(self):
33071 
    L = ['%s=%r' % (key, value)
33072 
      for key, value in self.__dict__.iteritems()]
33073 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33074 
 
33075 
  def __eq__(self, other):
33076 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33077 
 
33078 
  def __ne__(self, other):
33079 
    return not (self == other)
33080 
 
33081 
class checkServices_result:
33082 
  """
33083 
  Attributes:
33084 
   - success
33085 
   - cex
33086 
  """
33087 
 
33088 
  thrift_spec = (
33089 
    (0, TType.MAP, 'success', (TType.I64,None,TType.MAP,(TType.STRING,None,TType.I64,None)), None, ), # 0
33090 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
33091 
  )
33092 
 
33093 
  def __init__(self, success=None, cex=None,):
33094 
    self.success = success
33095 
    self.cex = cex
33096 
 
33097 
  def read(self, iprot):
33098 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33099 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33100 
      return
33101 
    iprot.readStructBegin()
33102 
    while True:
33103 
      (fname, ftype, fid) = iprot.readFieldBegin()
33104 
      if ftype == TType.STOP:
33105 
        break
33106 
      if fid == 0:
33107 
        if ftype == TType.MAP:
33108 
          self.success = {}
13493 amit.gupta 33109 
          (_ktype828, _vtype829, _size827 ) = iprot.readMapBegin()
33110 
          for _i831 in xrange(_size827):
33111 
            _key832 = iprot.readI64();
33112 
            _val833 = {}
33113 
            (_ktype835, _vtype836, _size834 ) = iprot.readMapBegin()
33114 
            for _i838 in xrange(_size834):
33115 
              _key839 = iprot.readString();
33116 
              _val840 = iprot.readI64();
33117 
              _val833[_key839] = _val840
13136 amit.gupta 33118 
            iprot.readMapEnd()
13493 amit.gupta 33119 
            self.success[_key832] = _val833
13136 amit.gupta 33120 
          iprot.readMapEnd()
33121 
        else:
33122 
          iprot.skip(ftype)
33123 
      elif fid == 1:
33124 
        if ftype == TType.STRUCT:
33125 
          self.cex = CatalogServiceException()
33126 
          self.cex.read(iprot)
33127 
        else:
33128 
          iprot.skip(ftype)
33129 
      else:
33130 
        iprot.skip(ftype)
33131 
      iprot.readFieldEnd()
33132 
    iprot.readStructEnd()
33133 
 
33134 
  def write(self, oprot):
33135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33137 
      return
33138 
    oprot.writeStructBegin('checkServices_result')
33139 
    if self.success is not None:
33140 
      oprot.writeFieldBegin('success', TType.MAP, 0)
33141 
      oprot.writeMapBegin(TType.I64, TType.MAP, len(self.success))
13493 amit.gupta 33142 
      for kiter841,viter842 in self.success.items():
33143 
        oprot.writeI64(kiter841)
33144 
        oprot.writeMapBegin(TType.STRING, TType.I64, len(viter842))
33145 
        for kiter843,viter844 in viter842.items():
33146 
          oprot.writeString(kiter843)
33147 
          oprot.writeI64(viter844)
13136 amit.gupta 33148 
        oprot.writeMapEnd()
33149 
      oprot.writeMapEnd()
33150 
      oprot.writeFieldEnd()
33151 
    if self.cex is not None:
33152 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
33153 
      self.cex.write(oprot)
33154 
      oprot.writeFieldEnd()
33155 
    oprot.writeFieldStop()
33156 
    oprot.writeStructEnd()
33157 
 
33158 
  def validate(self):
33159 
    return
33160 
 
33161 
 
33162 
  def __repr__(self):
33163 
    L = ['%s=%r' % (key, value)
33164 
      for key, value in self.__dict__.iteritems()]
33165 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33166 
 
33167 
  def __eq__(self, other):
33168 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33169 
 
33170 
  def __ne__(self, other):
33171 
    return not (self == other)
13709 manish.sha 33172 
 
33173 
class addHsItem_args:
33174 
  """
33175 
  Attributes:
33176 
   - hsItems
33177 
  """
33178 
 
33179 
  thrift_spec = (
33180 
    None, # 0
33181 
    (1, TType.LIST, 'hsItems', (TType.STRUCT,(HsItem, HsItem.thrift_spec)), None, ), # 1
33182 
  )
33183 
 
33184 
  def __init__(self, hsItems=None,):
33185 
    self.hsItems = hsItems
33186 
 
33187 
  def read(self, iprot):
33188 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33189 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33190 
      return
33191 
    iprot.readStructBegin()
33192 
    while True:
33193 
      (fname, ftype, fid) = iprot.readFieldBegin()
33194 
      if ftype == TType.STOP:
33195 
        break
33196 
      if fid == 1:
33197 
        if ftype == TType.LIST:
33198 
          self.hsItems = []
33199 
          (_etype848, _size845) = iprot.readListBegin()
33200 
          for _i849 in xrange(_size845):
33201 
            _elem850 = HsItem()
33202 
            _elem850.read(iprot)
33203 
            self.hsItems.append(_elem850)
33204 
          iprot.readListEnd()
33205 
        else:
33206 
          iprot.skip(ftype)
33207 
      else:
33208 
        iprot.skip(ftype)
33209 
      iprot.readFieldEnd()
33210 
    iprot.readStructEnd()
33211 
 
33212 
  def write(self, oprot):
33213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33215 
      return
33216 
    oprot.writeStructBegin('addHsItem_args')
33217 
    if self.hsItems is not None:
33218 
      oprot.writeFieldBegin('hsItems', TType.LIST, 1)
33219 
      oprot.writeListBegin(TType.STRUCT, len(self.hsItems))
33220 
      for iter851 in self.hsItems:
33221 
        iter851.write(oprot)
33222 
      oprot.writeListEnd()
33223 
      oprot.writeFieldEnd()
33224 
    oprot.writeFieldStop()
33225 
    oprot.writeStructEnd()
33226 
 
33227 
  def validate(self):
33228 
    return
33229 
 
33230 
 
33231 
  def __repr__(self):
33232 
    L = ['%s=%r' % (key, value)
33233 
      for key, value in self.__dict__.iteritems()]
33234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33235 
 
33236 
  def __eq__(self, other):
33237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33238 
 
33239 
  def __ne__(self, other):
33240 
    return not (self == other)
33241 
 
33242 
class addHsItem_result:
33243 
 
33244 
  thrift_spec = (
33245 
  )
33246 
 
33247 
  def read(self, iprot):
33248 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33249 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33250 
      return
33251 
    iprot.readStructBegin()
33252 
    while True:
33253 
      (fname, ftype, fid) = iprot.readFieldBegin()
33254 
      if ftype == TType.STOP:
33255 
        break
33256 
      else:
33257 
        iprot.skip(ftype)
33258 
      iprot.readFieldEnd()
33259 
    iprot.readStructEnd()
33260 
 
33261 
  def write(self, oprot):
33262 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33263 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33264 
      return
33265 
    oprot.writeStructBegin('addHsItem_result')
33266 
    oprot.writeFieldStop()
33267 
    oprot.writeStructEnd()
33268 
 
33269 
  def validate(self):
33270 
    return
33271 
 
33272 
 
33273 
  def __repr__(self):
33274 
    L = ['%s=%r' % (key, value)
33275 
      for key, value in self.__dict__.iteritems()]
33276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33277 
 
33278 
  def __eq__(self, other):
33279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33280 
 
33281 
  def __ne__(self, other):
33282 
    return not (self == other)
33283 
 
33284 
class getHsItem_args:
33285 
  """
33286 
  Attributes:
33287 
   - hsItemId
33288 
  """
33289 
 
33290 
  thrift_spec = (
33291 
    None, # 0
33292 
    (1, TType.STRING, 'hsItemId', None, None, ), # 1
33293 
  )
33294 
 
33295 
  def __init__(self, hsItemId=None,):
33296 
    self.hsItemId = hsItemId
33297 
 
33298 
  def read(self, iprot):
33299 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33300 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33301 
      return
33302 
    iprot.readStructBegin()
33303 
    while True:
33304 
      (fname, ftype, fid) = iprot.readFieldBegin()
33305 
      if ftype == TType.STOP:
33306 
        break
33307 
      if fid == 1:
33308 
        if ftype == TType.STRING:
33309 
          self.hsItemId = iprot.readString();
33310 
        else:
33311 
          iprot.skip(ftype)
33312 
      else:
33313 
        iprot.skip(ftype)
33314 
      iprot.readFieldEnd()
33315 
    iprot.readStructEnd()
33316 
 
33317 
  def write(self, oprot):
33318 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33319 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33320 
      return
33321 
    oprot.writeStructBegin('getHsItem_args')
33322 
    if self.hsItemId is not None:
33323 
      oprot.writeFieldBegin('hsItemId', TType.STRING, 1)
33324 
      oprot.writeString(self.hsItemId)
33325 
      oprot.writeFieldEnd()
33326 
    oprot.writeFieldStop()
33327 
    oprot.writeStructEnd()
33328 
 
33329 
  def validate(self):
33330 
    return
33331 
 
33332 
 
33333 
  def __repr__(self):
33334 
    L = ['%s=%r' % (key, value)
33335 
      for key, value in self.__dict__.iteritems()]
33336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33337 
 
33338 
  def __eq__(self, other):
33339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33340 
 
33341 
  def __ne__(self, other):
33342 
    return not (self == other)
33343 
 
33344 
class getHsItem_result:
33345 
  """
33346 
  Attributes:
33347 
   - success
33348 
  """
33349 
 
33350 
  thrift_spec = (
33351 
    (0, TType.STRUCT, 'success', (HsItem, HsItem.thrift_spec), None, ), # 0
33352 
  )
33353 
 
33354 
  def __init__(self, success=None,):
33355 
    self.success = success
33356 
 
33357 
  def read(self, iprot):
33358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33360 
      return
33361 
    iprot.readStructBegin()
33362 
    while True:
33363 
      (fname, ftype, fid) = iprot.readFieldBegin()
33364 
      if ftype == TType.STOP:
33365 
        break
33366 
      if fid == 0:
33367 
        if ftype == TType.STRUCT:
33368 
          self.success = HsItem()
33369 
          self.success.read(iprot)
33370 
        else:
33371 
          iprot.skip(ftype)
33372 
      else:
33373 
        iprot.skip(ftype)
33374 
      iprot.readFieldEnd()
33375 
    iprot.readStructEnd()
33376 
 
33377 
  def write(self, oprot):
33378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33380 
      return
33381 
    oprot.writeStructBegin('getHsItem_result')
33382 
    if self.success is not None:
33383 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
33384 
      self.success.write(oprot)
33385 
      oprot.writeFieldEnd()
33386 
    oprot.writeFieldStop()
33387 
    oprot.writeStructEnd()
33388 
 
33389 
  def validate(self):
33390 
    return
33391 
 
33392 
 
33393 
  def __repr__(self):
33394 
    L = ['%s=%r' % (key, value)
33395 
      for key, value in self.__dict__.iteritems()]
33396 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33397 
 
33398 
  def __eq__(self, other):
33399 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33400 
 
33401 
  def __ne__(self, other):
33402 
    return not (self == other)
33403 
 
33404 
class updateHsItem_args:
33405 
  """
33406 
  Attributes:
33407 
   - hsItem
33408 
  """
33409 
 
33410 
  thrift_spec = (
33411 
    None, # 0
33412 
    (1, TType.STRUCT, 'hsItem', (HsItem, HsItem.thrift_spec), None, ), # 1
33413 
  )
33414 
 
33415 
  def __init__(self, hsItem=None,):
33416 
    self.hsItem = hsItem
33417 
 
33418 
  def read(self, iprot):
33419 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33420 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33421 
      return
33422 
    iprot.readStructBegin()
33423 
    while True:
33424 
      (fname, ftype, fid) = iprot.readFieldBegin()
33425 
      if ftype == TType.STOP:
33426 
        break
33427 
      if fid == 1:
33428 
        if ftype == TType.STRUCT:
33429 
          self.hsItem = HsItem()
33430 
          self.hsItem.read(iprot)
33431 
        else:
33432 
          iprot.skip(ftype)
33433 
      else:
33434 
        iprot.skip(ftype)
33435 
      iprot.readFieldEnd()
33436 
    iprot.readStructEnd()
33437 
 
33438 
  def write(self, oprot):
33439 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33440 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33441 
      return
33442 
    oprot.writeStructBegin('updateHsItem_args')
33443 
    if self.hsItem is not None:
33444 
      oprot.writeFieldBegin('hsItem', TType.STRUCT, 1)
33445 
      self.hsItem.write(oprot)
33446 
      oprot.writeFieldEnd()
33447 
    oprot.writeFieldStop()
33448 
    oprot.writeStructEnd()
33449 
 
33450 
  def validate(self):
33451 
    return
33452 
 
33453 
 
33454 
  def __repr__(self):
33455 
    L = ['%s=%r' % (key, value)
33456 
      for key, value in self.__dict__.iteritems()]
33457 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33458 
 
33459 
  def __eq__(self, other):
33460 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33461 
 
33462 
  def __ne__(self, other):
33463 
    return not (self == other)
33464 
 
33465 
class updateHsItem_result:
33466 
 
33467 
  thrift_spec = (
33468 
  )
33469 
 
33470 
  def read(self, iprot):
33471 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33472 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33473 
      return
33474 
    iprot.readStructBegin()
33475 
    while True:
33476 
      (fname, ftype, fid) = iprot.readFieldBegin()
33477 
      if ftype == TType.STOP:
33478 
        break
33479 
      else:
33480 
        iprot.skip(ftype)
33481 
      iprot.readFieldEnd()
33482 
    iprot.readStructEnd()
33483 
 
33484 
  def write(self, oprot):
33485 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33486 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33487 
      return
33488 
    oprot.writeStructBegin('updateHsItem_result')
33489 
    oprot.writeFieldStop()
33490 
    oprot.writeStructEnd()
33491 
 
33492 
  def validate(self):
33493 
    return
33494 
 
33495 
 
33496 
  def __repr__(self):
33497 
    L = ['%s=%r' % (key, value)
33498 
      for key, value in self.__dict__.iteritems()]
33499 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33500 
 
33501 
  def __eq__(self, other):
33502 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33503 
 
33504 
  def __ne__(self, other):
33505 
    return not (self == other)
14182 kshitij.so 33506 
 
33507 
class getPricingForDtr_args:
33508 
  """
33509 
  Attributes:
33510 
   - catalogItemId
33511 
  """
33512 
 
33513 
  thrift_spec = (
33514 
    None, # 0
33515 
    (1, TType.I64, 'catalogItemId', None, None, ), # 1
33516 
  )
33517 
 
33518 
  def __init__(self, catalogItemId=None,):
33519 
    self.catalogItemId = catalogItemId
33520 
 
33521 
  def read(self, iprot):
33522 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33523 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33524 
      return
33525 
    iprot.readStructBegin()
33526 
    while True:
33527 
      (fname, ftype, fid) = iprot.readFieldBegin()
33528 
      if ftype == TType.STOP:
33529 
        break
33530 
      if fid == 1:
33531 
        if ftype == TType.I64:
33532 
          self.catalogItemId = iprot.readI64();
33533 
        else:
33534 
          iprot.skip(ftype)
33535 
      else:
33536 
        iprot.skip(ftype)
33537 
      iprot.readFieldEnd()
33538 
    iprot.readStructEnd()
33539 
 
33540 
  def write(self, oprot):
33541 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33542 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33543 
      return
33544 
    oprot.writeStructBegin('getPricingForDtr_args')
33545 
    if self.catalogItemId is not None:
33546 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 1)
33547 
      oprot.writeI64(self.catalogItemId)
33548 
      oprot.writeFieldEnd()
33549 
    oprot.writeFieldStop()
33550 
    oprot.writeStructEnd()
33551 
 
33552 
  def validate(self):
33553 
    return
33554 
 
33555 
 
33556 
  def __repr__(self):
33557 
    L = ['%s=%r' % (key, value)
33558 
      for key, value in self.__dict__.iteritems()]
33559 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33560 
 
33561 
  def __eq__(self, other):
33562 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33563 
 
33564 
  def __ne__(self, other):
33565 
    return not (self == other)
33566 
 
33567 
class getPricingForDtr_result:
33568 
  """
33569 
  Attributes:
33570 
   - success
33571 
  """
33572 
 
33573 
  thrift_spec = (
33574 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
33575 
  )
33576 
 
33577 
  def __init__(self, success=None,):
33578 
    self.success = success
33579 
 
33580 
  def read(self, iprot):
33581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33583 
      return
33584 
    iprot.readStructBegin()
33585 
    while True:
33586 
      (fname, ftype, fid) = iprot.readFieldBegin()
33587 
      if ftype == TType.STOP:
33588 
        break
33589 
      if fid == 0:
33590 
        if ftype == TType.STRUCT:
33591 
          self.success = Item()
33592 
          self.success.read(iprot)
33593 
        else:
33594 
          iprot.skip(ftype)
33595 
      else:
33596 
        iprot.skip(ftype)
33597 
      iprot.readFieldEnd()
33598 
    iprot.readStructEnd()
33599 
 
33600 
  def write(self, oprot):
33601 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33602 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33603 
      return
33604 
    oprot.writeStructBegin('getPricingForDtr_result')
33605 
    if self.success is not None:
33606 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
33607 
      self.success.write(oprot)
33608 
      oprot.writeFieldEnd()
33609 
    oprot.writeFieldStop()
33610 
    oprot.writeStructEnd()
33611 
 
33612 
  def validate(self):
33613 
    return
33614 
 
33615 
 
33616 
  def __repr__(self):
33617 
    L = ['%s=%r' % (key, value)
33618 
      for key, value in self.__dict__.iteritems()]
33619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33620 
 
33621 
  def __eq__(self, other):
33622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33623 
 
33624 
  def __ne__(self, other):
33625 
    return not (self == other)
15702 kshitij.so 33626 
 
33627 
class getAllItemstoListOnFbd_args:
33628 
 
33629 
  thrift_spec = (
33630 
  )
33631 
 
33632 
  def read(self, iprot):
33633 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33634 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33635 
      return
33636 
    iprot.readStructBegin()
33637 
    while True:
33638 
      (fname, ftype, fid) = iprot.readFieldBegin()
33639 
      if ftype == TType.STOP:
33640 
        break
33641 
      else:
33642 
        iprot.skip(ftype)
33643 
      iprot.readFieldEnd()
33644 
    iprot.readStructEnd()
33645 
 
33646 
  def write(self, oprot):
33647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33649 
      return
33650 
    oprot.writeStructBegin('getAllItemstoListOnFbd_args')
33651 
    oprot.writeFieldStop()
33652 
    oprot.writeStructEnd()
33653 
 
33654 
  def validate(self):
33655 
    return
33656 
 
33657 
 
33658 
  def __repr__(self):
33659 
    L = ['%s=%r' % (key, value)
33660 
      for key, value in self.__dict__.iteritems()]
33661 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33662 
 
33663 
  def __eq__(self, other):
33664 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33665 
 
33666 
  def __ne__(self, other):
33667 
    return not (self == other)
33668 
 
33669 
class getAllItemstoListOnFbd_result:
33670 
  """
33671 
  Attributes:
33672 
   - success
33673 
  """
33674 
 
33675 
  thrift_spec = (
33676 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
33677 
  )
33678 
 
33679 
  def __init__(self, success=None,):
33680 
    self.success = success
33681 
 
33682 
  def read(self, iprot):
33683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33685 
      return
33686 
    iprot.readStructBegin()
33687 
    while True:
33688 
      (fname, ftype, fid) = iprot.readFieldBegin()
33689 
      if ftype == TType.STOP:
33690 
        break
33691 
      if fid == 0:
33692 
        if ftype == TType.LIST:
33693 
          self.success = []
33694 
          (_etype855, _size852) = iprot.readListBegin()
33695 
          for _i856 in xrange(_size852):
33696 
            _elem857 = Amazonlisted()
33697 
            _elem857.read(iprot)
33698 
            self.success.append(_elem857)
33699 
          iprot.readListEnd()
33700 
        else:
33701 
          iprot.skip(ftype)
33702 
      else:
33703 
        iprot.skip(ftype)
33704 
      iprot.readFieldEnd()
33705 
    iprot.readStructEnd()
33706 
 
33707 
  def write(self, oprot):
33708 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33709 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33710 
      return
33711 
    oprot.writeStructBegin('getAllItemstoListOnFbd_result')
33712 
    if self.success is not None:
33713 
      oprot.writeFieldBegin('success', TType.LIST, 0)
33714 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
33715 
      for iter858 in self.success:
33716 
        iter858.write(oprot)
33717 
      oprot.writeListEnd()
33718 
      oprot.writeFieldEnd()
33719 
    oprot.writeFieldStop()
33720 
    oprot.writeStructEnd()
33721 
 
33722 
  def validate(self):
33723 
    return
33724 
 
33725 
 
33726 
  def __repr__(self):
33727 
    L = ['%s=%r' % (key, value)
33728 
      for key, value in self.__dict__.iteritems()]
33729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33730 
 
33731 
  def __eq__(self, other):
33732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33733 
 
33734 
  def __ne__(self, other):
33735 
    return not (self == other)
15706 kshitij.so 33736 
 
33737 
class getAllFbdListedItems_args:
33738 
 
33739 
  thrift_spec = (
33740 
  )
33741 
 
33742 
  def read(self, iprot):
33743 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33744 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33745 
      return
33746 
    iprot.readStructBegin()
33747 
    while True:
33748 
      (fname, ftype, fid) = iprot.readFieldBegin()
33749 
      if ftype == TType.STOP:
33750 
        break
33751 
      else:
33752 
        iprot.skip(ftype)
33753 
      iprot.readFieldEnd()
33754 
    iprot.readStructEnd()
33755 
 
33756 
  def write(self, oprot):
33757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33759 
      return
33760 
    oprot.writeStructBegin('getAllFbdListedItems_args')
33761 
    oprot.writeFieldStop()
33762 
    oprot.writeStructEnd()
33763 
 
33764 
  def validate(self):
33765 
    return
33766 
 
33767 
 
33768 
  def __repr__(self):
33769 
    L = ['%s=%r' % (key, value)
33770 
      for key, value in self.__dict__.iteritems()]
33771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33772 
 
33773 
  def __eq__(self, other):
33774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33775 
 
33776 
  def __ne__(self, other):
33777 
    return not (self == other)
33778 
 
33779 
class getAllFbdListedItems_result:
33780 
  """
33781 
  Attributes:
33782 
   - success
33783 
  """
33784 
 
33785 
  thrift_spec = (
33786 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
33787 
  )
33788 
 
33789 
  def __init__(self, success=None,):
33790 
    self.success = success
33791 
 
33792 
  def read(self, iprot):
33793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33795 
      return
33796 
    iprot.readStructBegin()
33797 
    while True:
33798 
      (fname, ftype, fid) = iprot.readFieldBegin()
33799 
      if ftype == TType.STOP:
33800 
        break
33801 
      if fid == 0:
33802 
        if ftype == TType.LIST:
33803 
          self.success = []
33804 
          (_etype862, _size859) = iprot.readListBegin()
33805 
          for _i863 in xrange(_size859):
33806 
            _elem864 = Amazonlisted()
33807 
            _elem864.read(iprot)
33808 
            self.success.append(_elem864)
33809 
          iprot.readListEnd()
33810 
        else:
33811 
          iprot.skip(ftype)
33812 
      else:
33813 
        iprot.skip(ftype)
33814 
      iprot.readFieldEnd()
33815 
    iprot.readStructEnd()
33816 
 
33817 
  def write(self, oprot):
33818 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33819 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33820 
      return
33821 
    oprot.writeStructBegin('getAllFbdListedItems_result')
33822 
    if self.success is not None:
33823 
      oprot.writeFieldBegin('success', TType.LIST, 0)
33824 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
33825 
      for iter865 in self.success:
33826 
        iter865.write(oprot)
33827 
      oprot.writeListEnd()
33828 
      oprot.writeFieldEnd()
33829 
    oprot.writeFieldStop()
33830 
    oprot.writeStructEnd()
33831 
 
33832 
  def validate(self):
33833 
    return
33834 
 
33835 
 
33836 
  def __repr__(self):
33837 
    L = ['%s=%r' % (key, value)
33838 
      for key, value in self.__dict__.iteritems()]
33839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33840 
 
33841 
  def __eq__(self, other):
33842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33843 
 
33844 
  def __ne__(self, other):
33845 
    return not (self == other)
18150 kshitij.so 33846 
 
33847 
class getBulkPricingForItems_args:
33848 
  """
33849 
  Attributes:
33850 
   - itemIds
33851 
  """
33852 
 
33853 
  thrift_spec = (
33854 
    None, # 0
33855 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
33856 
  )
33857 
 
33858 
  def __init__(self, itemIds=None,):
33859 
    self.itemIds = itemIds
33860 
 
33861 
  def read(self, iprot):
33862 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33863 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33864 
      return
33865 
    iprot.readStructBegin()
33866 
    while True:
33867 
      (fname, ftype, fid) = iprot.readFieldBegin()
33868 
      if ftype == TType.STOP:
33869 
        break
33870 
      if fid == 1:
33871 
        if ftype == TType.LIST:
33872 
          self.itemIds = []
33873 
          (_etype869, _size866) = iprot.readListBegin()
33874 
          for _i870 in xrange(_size866):
33875 
            _elem871 = iprot.readI64();
33876 
            self.itemIds.append(_elem871)
33877 
          iprot.readListEnd()
33878 
        else:
33879 
          iprot.skip(ftype)
33880 
      else:
33881 
        iprot.skip(ftype)
33882 
      iprot.readFieldEnd()
33883 
    iprot.readStructEnd()
33884 
 
33885 
  def write(self, oprot):
33886 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33887 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33888 
      return
33889 
    oprot.writeStructBegin('getBulkPricingForItems_args')
33890 
    if self.itemIds is not None:
33891 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
33892 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
33893 
      for iter872 in self.itemIds:
33894 
        oprot.writeI64(iter872)
33895 
      oprot.writeListEnd()
33896 
      oprot.writeFieldEnd()
33897 
    oprot.writeFieldStop()
33898 
    oprot.writeStructEnd()
33899 
 
33900 
  def validate(self):
33901 
    return
33902 
 
33903 
 
33904 
  def __repr__(self):
33905 
    L = ['%s=%r' % (key, value)
33906 
      for key, value in self.__dict__.iteritems()]
33907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33908 
 
33909 
  def __eq__(self, other):
33910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33911 
 
33912 
  def __ne__(self, other):
33913 
    return not (self == other)
33914 
 
33915 
class getBulkPricingForItems_result:
33916 
  """
33917 
  Attributes:
33918 
   - success
33919 
  """
33920 
 
33921 
  thrift_spec = (
33922 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRUCT,(BulkItemPricing, BulkItemPricing.thrift_spec))), None, ), # 0
33923 
  )
33924 
 
33925 
  def __init__(self, success=None,):
33926 
    self.success = success
33927 
 
33928 
  def read(self, iprot):
33929 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33930 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33931 
      return
33932 
    iprot.readStructBegin()
33933 
    while True:
33934 
      (fname, ftype, fid) = iprot.readFieldBegin()
33935 
      if ftype == TType.STOP:
33936 
        break
33937 
      if fid == 0:
33938 
        if ftype == TType.MAP:
33939 
          self.success = {}
33940 
          (_ktype874, _vtype875, _size873 ) = iprot.readMapBegin()
33941 
          for _i877 in xrange(_size873):
33942 
            _key878 = iprot.readI64();
33943 
            _val879 = []
33944 
            (_etype883, _size880) = iprot.readListBegin()
33945 
            for _i884 in xrange(_size880):
33946 
              _elem885 = BulkItemPricing()
33947 
              _elem885.read(iprot)
33948 
              _val879.append(_elem885)
33949 
            iprot.readListEnd()
33950 
            self.success[_key878] = _val879
33951 
          iprot.readMapEnd()
33952 
        else:
33953 
          iprot.skip(ftype)
33954 
      else:
33955 
        iprot.skip(ftype)
33956 
      iprot.readFieldEnd()
33957 
    iprot.readStructEnd()
33958 
 
33959 
  def write(self, oprot):
33960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33962 
      return
33963 
    oprot.writeStructBegin('getBulkPricingForItems_result')
33964 
    if self.success is not None:
33965 
      oprot.writeFieldBegin('success', TType.MAP, 0)
33966 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
33967 
      for kiter886,viter887 in self.success.items():
33968 
        oprot.writeI64(kiter886)
33969 
        oprot.writeListBegin(TType.STRUCT, len(viter887))
33970 
        for iter888 in viter887:
33971 
          iter888.write(oprot)
33972 
        oprot.writeListEnd()
33973 
      oprot.writeMapEnd()
33974 
      oprot.writeFieldEnd()
33975 
    oprot.writeFieldStop()
33976 
    oprot.writeStructEnd()
33977 
 
33978 
  def validate(self):
33979 
    return
33980 
 
33981 
 
33982 
  def __repr__(self):
33983 
    L = ['%s=%r' % (key, value)
33984 
      for key, value in self.__dict__.iteritems()]
33985 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33986 
 
33987 
  def __eq__(self, other):
33988 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33989 
 
33990 
  def __ne__(self, other):
33991 
    return not (self == other)
33992 
 
33993 
class addBulkPricingForItem_args:
33994 
  """
33995 
  Attributes:
33996 
   - bulkItemPricing
33997 
  """
33998 
 
33999 
  thrift_spec = (
34000 
    None, # 0
34001 
    (1, TType.STRUCT, 'bulkItemPricing', (BulkItemPricing, BulkItemPricing.thrift_spec), None, ), # 1
34002 
  )
34003 
 
34004 
  def __init__(self, bulkItemPricing=None,):
34005 
    self.bulkItemPricing = bulkItemPricing
34006 
 
34007 
  def read(self, iprot):
34008 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34009 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34010 
      return
34011 
    iprot.readStructBegin()
34012 
    while True:
34013 
      (fname, ftype, fid) = iprot.readFieldBegin()
34014 
      if ftype == TType.STOP:
34015 
        break
34016 
      if fid == 1:
34017 
        if ftype == TType.STRUCT:
34018 
          self.bulkItemPricing = BulkItemPricing()
34019 
          self.bulkItemPricing.read(iprot)
34020 
        else:
34021 
          iprot.skip(ftype)
34022 
      else:
34023 
        iprot.skip(ftype)
34024 
      iprot.readFieldEnd()
34025 
    iprot.readStructEnd()
34026 
 
34027 
  def write(self, oprot):
34028 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34029 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34030 
      return
34031 
    oprot.writeStructBegin('addBulkPricingForItem_args')
34032 
    if self.bulkItemPricing is not None:
34033 
      oprot.writeFieldBegin('bulkItemPricing', TType.STRUCT, 1)
34034 
      self.bulkItemPricing.write(oprot)
34035 
      oprot.writeFieldEnd()
34036 
    oprot.writeFieldStop()
34037 
    oprot.writeStructEnd()
34038 
 
34039 
  def validate(self):
34040 
    return
34041 
 
34042 
 
34043 
  def __repr__(self):
34044 
    L = ['%s=%r' % (key, value)
34045 
      for key, value in self.__dict__.iteritems()]
34046 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34047 
 
34048 
  def __eq__(self, other):
34049 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34050 
 
34051 
  def __ne__(self, other):
34052 
    return not (self == other)
34053 
 
34054 
class addBulkPricingForItem_result:
34055 
  """
34056 
  Attributes:
34057 
   - success
34058 
  """
34059 
 
34060 
  thrift_spec = (
34061 
    (0, TType.STRUCT, 'success', (BulkItemPricing, BulkItemPricing.thrift_spec), None, ), # 0
34062 
  )
34063 
 
34064 
  def __init__(self, success=None,):
34065 
    self.success = success
34066 
 
34067 
  def read(self, iprot):
34068 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34069 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34070 
      return
34071 
    iprot.readStructBegin()
34072 
    while True:
34073 
      (fname, ftype, fid) = iprot.readFieldBegin()
34074 
      if ftype == TType.STOP:
34075 
        break
34076 
      if fid == 0:
34077 
        if ftype == TType.STRUCT:
34078 
          self.success = BulkItemPricing()
34079 
          self.success.read(iprot)
34080 
        else:
34081 
          iprot.skip(ftype)
34082 
      else:
34083 
        iprot.skip(ftype)
34084 
      iprot.readFieldEnd()
34085 
    iprot.readStructEnd()
34086 
 
34087 
  def write(self, oprot):
34088 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34089 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34090 
      return
34091 
    oprot.writeStructBegin('addBulkPricingForItem_result')
34092 
    if self.success is not None:
34093 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
34094 
      self.success.write(oprot)
34095 
      oprot.writeFieldEnd()
34096 
    oprot.writeFieldStop()
34097 
    oprot.writeStructEnd()
34098 
 
34099 
  def validate(self):
34100 
    return
34101 
 
34102 
 
34103 
  def __repr__(self):
34104 
    L = ['%s=%r' % (key, value)
34105 
      for key, value in self.__dict__.iteritems()]
34106 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34107 
 
34108 
  def __eq__(self, other):
34109 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34110 
 
34111 
  def __ne__(self, other):
34112 
    return not (self == other)
34113 
 
34114 
class deleteBulkPricingForItemById_args:
34115 
  """
34116 
  Attributes:
34117 
   - id
34118 
  """
34119 
 
34120 
  thrift_spec = (
34121 
    None, # 0
34122 
    (1, TType.I64, 'id', None, None, ), # 1
34123 
  )
34124 
 
34125 
  def __init__(self, id=None,):
34126 
    self.id = id
34127 
 
34128 
  def read(self, iprot):
34129 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34130 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34131 
      return
34132 
    iprot.readStructBegin()
34133 
    while True:
34134 
      (fname, ftype, fid) = iprot.readFieldBegin()
34135 
      if ftype == TType.STOP:
34136 
        break
34137 
      if fid == 1:
34138 
        if ftype == TType.I64:
34139 
          self.id = iprot.readI64();
34140 
        else:
34141 
          iprot.skip(ftype)
34142 
      else:
34143 
        iprot.skip(ftype)
34144 
      iprot.readFieldEnd()
34145 
    iprot.readStructEnd()
34146 
 
34147 
  def write(self, oprot):
34148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34150 
      return
34151 
    oprot.writeStructBegin('deleteBulkPricingForItemById_args')
34152 
    if self.id is not None:
34153 
      oprot.writeFieldBegin('id', TType.I64, 1)
34154 
      oprot.writeI64(self.id)
34155 
      oprot.writeFieldEnd()
34156 
    oprot.writeFieldStop()
34157 
    oprot.writeStructEnd()
34158 
 
34159 
  def validate(self):
34160 
    return
34161 
 
34162 
 
34163 
  def __repr__(self):
34164 
    L = ['%s=%r' % (key, value)
34165 
      for key, value in self.__dict__.iteritems()]
34166 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34167 
 
34168 
  def __eq__(self, other):
34169 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34170 
 
34171 
  def __ne__(self, other):
34172 
    return not (self == other)
34173 
 
34174 
class deleteBulkPricingForItemById_result:
34175 
  """
34176 
  Attributes:
34177 
   - success
34178 
  """
34179 
 
34180 
  thrift_spec = (
34181 
    (0, TType.BOOL, 'success', None, None, ), # 0
34182 
  )
34183 
 
34184 
  def __init__(self, success=None,):
34185 
    self.success = success
34186 
 
34187 
  def read(self, iprot):
34188 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34189 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34190 
      return
34191 
    iprot.readStructBegin()
34192 
    while True:
34193 
      (fname, ftype, fid) = iprot.readFieldBegin()
34194 
      if ftype == TType.STOP:
34195 
        break
34196 
      if fid == 0:
34197 
        if ftype == TType.BOOL:
34198 
          self.success = iprot.readBool();
34199 
        else:
34200 
          iprot.skip(ftype)
34201 
      else:
34202 
        iprot.skip(ftype)
34203 
      iprot.readFieldEnd()
34204 
    iprot.readStructEnd()
34205 
 
34206 
  def write(self, oprot):
34207 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34208 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34209 
      return
34210 
    oprot.writeStructBegin('deleteBulkPricingForItemById_result')
34211 
    if self.success is not None:
34212 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
34213 
      oprot.writeBool(self.success)
34214 
      oprot.writeFieldEnd()
34215 
    oprot.writeFieldStop()
34216 
    oprot.writeStructEnd()
34217 
 
34218 
  def validate(self):
34219 
    return
34220 
 
34221 
 
34222 
  def __repr__(self):
34223 
    L = ['%s=%r' % (key, value)
34224 
      for key, value in self.__dict__.iteritems()]
34225 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34226 
 
34227 
  def __eq__(self, other):
34228 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34229 
 
34230 
  def __ne__(self, other):
34231 
    return not (self == other)
34232 
 
34233 
class deleteBulkPricingForItem_args:
34234 
  """
34235 
  Attributes:
34236 
   - item_id
34237 
  """
34238 
 
34239 
  thrift_spec = (
34240 
    None, # 0
34241 
    (1, TType.I64, 'item_id', None, None, ), # 1
34242 
  )
34243 
 
34244 
  def __init__(self, item_id=None,):
34245 
    self.item_id = item_id
34246 
 
34247 
  def read(self, iprot):
34248 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34249 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34250 
      return
34251 
    iprot.readStructBegin()
34252 
    while True:
34253 
      (fname, ftype, fid) = iprot.readFieldBegin()
34254 
      if ftype == TType.STOP:
34255 
        break
34256 
      if fid == 1:
34257 
        if ftype == TType.I64:
34258 
          self.item_id = iprot.readI64();
34259 
        else:
34260 
          iprot.skip(ftype)
34261 
      else:
34262 
        iprot.skip(ftype)
34263 
      iprot.readFieldEnd()
34264 
    iprot.readStructEnd()
34265 
 
34266 
  def write(self, oprot):
34267 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34268 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34269 
      return
34270 
    oprot.writeStructBegin('deleteBulkPricingForItem_args')
34271 
    if self.item_id is not None:
34272 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
34273 
      oprot.writeI64(self.item_id)
34274 
      oprot.writeFieldEnd()
34275 
    oprot.writeFieldStop()
34276 
    oprot.writeStructEnd()
34277 
 
34278 
  def validate(self):
34279 
    return
34280 
 
34281 
 
34282 
  def __repr__(self):
34283 
    L = ['%s=%r' % (key, value)
34284 
      for key, value in self.__dict__.iteritems()]
34285 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34286 
 
34287 
  def __eq__(self, other):
34288 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34289 
 
34290 
  def __ne__(self, other):
34291 
    return not (self == other)
34292 
 
34293 
class deleteBulkPricingForItem_result:
34294 
  """
34295 
  Attributes:
34296 
   - success
34297 
  """
34298 
 
34299 
  thrift_spec = (
34300 
    (0, TType.BOOL, 'success', None, None, ), # 0
34301 
  )
34302 
 
34303 
  def __init__(self, success=None,):
34304 
    self.success = success
34305 
 
34306 
  def read(self, iprot):
34307 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34308 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34309 
      return
34310 
    iprot.readStructBegin()
34311 
    while True:
34312 
      (fname, ftype, fid) = iprot.readFieldBegin()
34313 
      if ftype == TType.STOP:
34314 
        break
34315 
      if fid == 0:
34316 
        if ftype == TType.BOOL:
34317 
          self.success = iprot.readBool();
34318 
        else:
34319 
          iprot.skip(ftype)
34320 
      else:
34321 
        iprot.skip(ftype)
34322 
      iprot.readFieldEnd()
34323 
    iprot.readStructEnd()
34324 
 
34325 
  def write(self, oprot):
34326 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34327 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34328 
      return
34329 
    oprot.writeStructBegin('deleteBulkPricingForItem_result')
34330 
    if self.success is not None:
34331 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
34332 
      oprot.writeBool(self.success)
34333 
      oprot.writeFieldEnd()
34334 
    oprot.writeFieldStop()
34335 
    oprot.writeStructEnd()
34336 
 
34337 
  def validate(self):
34338 
    return
34339 
 
34340 
 
34341 
  def __repr__(self):
34342 
    L = ['%s=%r' % (key, value)
34343 
      for key, value in self.__dict__.iteritems()]
34344 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34345 
 
34346 
  def __eq__(self, other):
34347 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34348 
 
34349 
  def __ne__(self, other):
34350 
    return not (self == other)
34351 
 
34352 
class getBulkPricingByItemId_args:
34353 
  """
34354 
  Attributes:
34355 
   - item_id
34356 
  """
34357 
 
34358 
  thrift_spec = (
34359 
    None, # 0
34360 
    (1, TType.I64, 'item_id', None, None, ), # 1
34361 
  )
34362 
 
34363 
  def __init__(self, item_id=None,):
34364 
    self.item_id = item_id
34365 
 
34366 
  def read(self, iprot):
34367 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34368 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34369 
      return
34370 
    iprot.readStructBegin()
34371 
    while True:
34372 
      (fname, ftype, fid) = iprot.readFieldBegin()
34373 
      if ftype == TType.STOP:
34374 
        break
34375 
      if fid == 1:
34376 
        if ftype == TType.I64:
34377 
          self.item_id = iprot.readI64();
34378 
        else:
34379 
          iprot.skip(ftype)
34380 
      else:
34381 
        iprot.skip(ftype)
34382 
      iprot.readFieldEnd()
34383 
    iprot.readStructEnd()
34384 
 
34385 
  def write(self, oprot):
34386 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34387 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34388 
      return
34389 
    oprot.writeStructBegin('getBulkPricingByItemId_args')
34390 
    if self.item_id is not None:
34391 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
34392 
      oprot.writeI64(self.item_id)
34393 
      oprot.writeFieldEnd()
34394 
    oprot.writeFieldStop()
34395 
    oprot.writeStructEnd()
34396 
 
34397 
  def validate(self):
34398 
    return
34399 
 
34400 
 
34401 
  def __repr__(self):
34402 
    L = ['%s=%r' % (key, value)
34403 
      for key, value in self.__dict__.iteritems()]
34404 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34405 
 
34406 
  def __eq__(self, other):
34407 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34408 
 
34409 
  def __ne__(self, other):
34410 
    return not (self == other)
34411 
 
34412 
class getBulkPricingByItemId_result:
34413 
  """
34414 
  Attributes:
34415 
   - success
34416 
  """
34417 
 
34418 
  thrift_spec = (
34419 
    (0, TType.LIST, 'success', (TType.STRUCT,(BulkItemPricing, BulkItemPricing.thrift_spec)), None, ), # 0
34420 
  )
34421 
 
34422 
  def __init__(self, success=None,):
34423 
    self.success = success
34424 
 
34425 
  def read(self, iprot):
34426 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34427 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34428 
      return
34429 
    iprot.readStructBegin()
34430 
    while True:
34431 
      (fname, ftype, fid) = iprot.readFieldBegin()
34432 
      if ftype == TType.STOP:
34433 
        break
34434 
      if fid == 0:
34435 
        if ftype == TType.LIST:
34436 
          self.success = []
34437 
          (_etype892, _size889) = iprot.readListBegin()
34438 
          for _i893 in xrange(_size889):
34439 
            _elem894 = BulkItemPricing()
34440 
            _elem894.read(iprot)
34441 
            self.success.append(_elem894)
34442 
          iprot.readListEnd()
34443 
        else:
34444 
          iprot.skip(ftype)
34445 
      else:
34446 
        iprot.skip(ftype)
34447 
      iprot.readFieldEnd()
34448 
    iprot.readStructEnd()
34449 
 
34450 
  def write(self, oprot):
34451 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34452 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34453 
      return
34454 
    oprot.writeStructBegin('getBulkPricingByItemId_result')
34455 
    if self.success is not None:
34456 
      oprot.writeFieldBegin('success', TType.LIST, 0)
34457 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
34458 
      for iter895 in self.success:
34459 
        iter895.write(oprot)
34460 
      oprot.writeListEnd()
34461 
      oprot.writeFieldEnd()
34462 
    oprot.writeFieldStop()
34463 
    oprot.writeStructEnd()
34464 
 
34465 
  def validate(self):
34466 
    return
34467 
 
34468 
 
34469 
  def __repr__(self):
34470 
    L = ['%s=%r' % (key, value)
34471 
      for key, value in self.__dict__.iteritems()]
34472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34473 
 
34474 
  def __eq__(self, other):
34475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34476 
 
34477 
  def __ne__(self, other):
34478 
    return not (self == other)
18602 kshitij.so 34479 
 
34480 
class updateBulkPricesOnProduction_args:
34481 
  """
34482 
  Attributes:
34483 
   - item_id
34484 
   - bulkItemPricingList
34485 
  """
34486 
 
34487 
  thrift_spec = (
34488 
    None, # 0
34489 
    (1, TType.I64, 'item_id', None, None, ), # 1
34490 
    (2, TType.LIST, 'bulkItemPricingList', (TType.STRUCT,(BulkItemPricing, BulkItemPricing.thrift_spec)), None, ), # 2
34491 
  )
34492 
 
34493 
  def __init__(self, item_id=None, bulkItemPricingList=None,):
34494 
    self.item_id = item_id
34495 
    self.bulkItemPricingList = bulkItemPricingList
34496 
 
34497 
  def read(self, iprot):
34498 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34499 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34500 
      return
34501 
    iprot.readStructBegin()
34502 
    while True:
34503 
      (fname, ftype, fid) = iprot.readFieldBegin()
34504 
      if ftype == TType.STOP:
34505 
        break
34506 
      if fid == 1:
34507 
        if ftype == TType.I64:
34508 
          self.item_id = iprot.readI64();
34509 
        else:
34510 
          iprot.skip(ftype)
34511 
      elif fid == 2:
34512 
        if ftype == TType.LIST:
34513 
          self.bulkItemPricingList = []
34514 
          (_etype899, _size896) = iprot.readListBegin()
34515 
          for _i900 in xrange(_size896):
34516 
            _elem901 = BulkItemPricing()
34517 
            _elem901.read(iprot)
34518 
            self.bulkItemPricingList.append(_elem901)
34519 
          iprot.readListEnd()
34520 
        else:
34521 
          iprot.skip(ftype)
34522 
      else:
34523 
        iprot.skip(ftype)
34524 
      iprot.readFieldEnd()
34525 
    iprot.readStructEnd()
34526 
 
34527 
  def write(self, oprot):
34528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34530 
      return
34531 
    oprot.writeStructBegin('updateBulkPricesOnProduction_args')
34532 
    if self.item_id is not None:
34533 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
34534 
      oprot.writeI64(self.item_id)
34535 
      oprot.writeFieldEnd()
34536 
    if self.bulkItemPricingList is not None:
34537 
      oprot.writeFieldBegin('bulkItemPricingList', TType.LIST, 2)
34538 
      oprot.writeListBegin(TType.STRUCT, len(self.bulkItemPricingList))
34539 
      for iter902 in self.bulkItemPricingList:
34540 
        iter902.write(oprot)
34541 
      oprot.writeListEnd()
34542 
      oprot.writeFieldEnd()
34543 
    oprot.writeFieldStop()
34544 
    oprot.writeStructEnd()
34545 
 
34546 
  def validate(self):
34547 
    return
34548 
 
34549 
 
34550 
  def __repr__(self):
34551 
    L = ['%s=%r' % (key, value)
34552 
      for key, value in self.__dict__.iteritems()]
34553 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34554 
 
34555 
  def __eq__(self, other):
34556 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34557 
 
34558 
  def __ne__(self, other):
34559 
    return not (self == other)
34560 
 
34561 
class updateBulkPricesOnProduction_result:
34562 
  """
34563 
  Attributes:
34564 
   - success
34565 
  """
34566 
 
34567 
  thrift_spec = (
34568 
    (0, TType.BOOL, 'success', None, None, ), # 0
34569 
  )
34570 
 
34571 
  def __init__(self, success=None,):
34572 
    self.success = success
34573 
 
34574 
  def read(self, iprot):
34575 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34576 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34577 
      return
34578 
    iprot.readStructBegin()
34579 
    while True:
34580 
      (fname, ftype, fid) = iprot.readFieldBegin()
34581 
      if ftype == TType.STOP:
34582 
        break
34583 
      if fid == 0:
34584 
        if ftype == TType.BOOL:
34585 
          self.success = iprot.readBool();
34586 
        else:
34587 
          iprot.skip(ftype)
34588 
      else:
34589 
        iprot.skip(ftype)
34590 
      iprot.readFieldEnd()
34591 
    iprot.readStructEnd()
34592 
 
34593 
  def write(self, oprot):
34594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34596 
      return
34597 
    oprot.writeStructBegin('updateBulkPricesOnProduction_result')
34598 
    if self.success is not None:
34599 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
34600 
      oprot.writeBool(self.success)
34601 
      oprot.writeFieldEnd()
34602 
    oprot.writeFieldStop()
34603 
    oprot.writeStructEnd()
34604 
 
34605 
  def validate(self):
34606 
    return
34607 
 
34608 
 
34609 
  def __repr__(self):
34610 
    L = ['%s=%r' % (key, value)
34611 
      for key, value in self.__dict__.iteritems()]
34612 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34613 
 
34614 
  def __eq__(self, other):
34615 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34616 
 
34617 
  def __ne__(self, other):
34618 
    return not (self == other)