Subversion Repositories SmartDukaan

Rev

Rev 18719 | Rev 19247 | 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 
 
18764 kshitij.so 1373 
  def getCartByValue(self, cartIds):
1374 
    """
1375 
    Parameters:
1376 
     - cartIds
1377 
    """
1378 
    pass
18602 kshitij.so 1379 
 
18764 kshitij.so 1380 
 
5944 mandeep.dh 1381 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
1382 
  def __init__(self, iprot, oprot=None):
1383 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
1384 
 
1385 
  def addItem(self, item):
1386 
    """
1387 
    Availability and inventory attributes
1388 
 
1389 
    Parameters:
1390 
     - item
1391 
    """
1392 
    self.send_addItem(item)
1393 
    return self.recv_addItem()
1394 
 
1395 
  def send_addItem(self, item):
1396 
    self._oprot.writeMessageBegin('addItem', TMessageType.CALL, self._seqid)
1397 
    args = addItem_args()
1398 
    args.item = item
1399 
    args.write(self._oprot)
1400 
    self._oprot.writeMessageEnd()
1401 
    self._oprot.trans.flush()
1402 
 
1403 
  def recv_addItem(self, ):
1404 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1405 
    if mtype == TMessageType.EXCEPTION:
1406 
      x = TApplicationException()
1407 
      x.read(self._iprot)
1408 
      self._iprot.readMessageEnd()
1409 
      raise x
1410 
    result = addItem_result()
1411 
    result.read(self._iprot)
1412 
    self._iprot.readMessageEnd()
1413 
    if result.success is not None:
1414 
      return result.success
1415 
    if result.cex is not None:
1416 
      raise result.cex
1417 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItem failed: unknown result");
1418 
 
1419 
  def updateItem(self, item):
1420 
    """
1421 
    Parameters:
1422 
     - item
1423 
    """
1424 
    self.send_updateItem(item)
1425 
    return self.recv_updateItem()
1426 
 
1427 
  def send_updateItem(self, item):
1428 
    self._oprot.writeMessageBegin('updateItem', TMessageType.CALL, self._seqid)
1429 
    args = updateItem_args()
1430 
    args.item = item
1431 
    args.write(self._oprot)
1432 
    self._oprot.writeMessageEnd()
1433 
    self._oprot.trans.flush()
1434 
 
1435 
  def recv_updateItem(self, ):
1436 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1437 
    if mtype == TMessageType.EXCEPTION:
1438 
      x = TApplicationException()
1439 
      x.read(self._iprot)
1440 
      self._iprot.readMessageEnd()
1441 
      raise x
1442 
    result = updateItem_result()
1443 
    result.read(self._iprot)
1444 
    self._iprot.readMessageEnd()
1445 
    if result.success is not None:
1446 
      return result.success
1447 
    if result.cex is not None:
1448 
      raise result.cex
1449 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItem failed: unknown result");
1450 
 
1451 
  def isActive(self, itemId):
1452 
    """
1453 
    Checks if the item given to the corresponding itemId is active. If it's active,
1454 
    whether it's risky and if it's risky, its inventory position.
1455 
 
1456 
    Parameters:
1457 
     - itemId
1458 
    """
1459 
    self.send_isActive(itemId)
1460 
    return self.recv_isActive()
1461 
 
1462 
  def send_isActive(self, itemId):
1463 
    self._oprot.writeMessageBegin('isActive', TMessageType.CALL, self._seqid)
1464 
    args = isActive_args()
1465 
    args.itemId = itemId
1466 
    args.write(self._oprot)
1467 
    self._oprot.writeMessageEnd()
1468 
    self._oprot.trans.flush()
1469 
 
1470 
  def recv_isActive(self, ):
1471 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1472 
    if mtype == TMessageType.EXCEPTION:
1473 
      x = TApplicationException()
1474 
      x.read(self._iprot)
1475 
      self._iprot.readMessageEnd()
1476 
      raise x
1477 
    result = isActive_result()
1478 
    result.read(self._iprot)
1479 
    self._iprot.readMessageEnd()
1480 
    if result.success is not None:
1481 
      return result.success
1482 
    if result.isex is not None:
1483 
      raise result.isex
1484 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isActive failed: unknown result");
1485 
 
7438 amit.gupta 1486 
  def getItemsStatus(self, itemIds):
1487 
    """
1488 
    Parameters:
1489 
     - itemIds
1490 
    """
1491 
    self.send_getItemsStatus(itemIds)
1492 
    return self.recv_getItemsStatus()
1493 
 
1494 
  def send_getItemsStatus(self, itemIds):
1495 
    self._oprot.writeMessageBegin('getItemsStatus', TMessageType.CALL, self._seqid)
1496 
    args = getItemsStatus_args()
1497 
    args.itemIds = itemIds
1498 
    args.write(self._oprot)
1499 
    self._oprot.writeMessageEnd()
1500 
    self._oprot.trans.flush()
1501 
 
1502 
  def recv_getItemsStatus(self, ):
1503 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1504 
    if mtype == TMessageType.EXCEPTION:
1505 
      x = TApplicationException()
1506 
      x.read(self._iprot)
1507 
      self._iprot.readMessageEnd()
1508 
      raise x
1509 
    result = getItemsStatus_result()
1510 
    result.read(self._iprot)
1511 
    self._iprot.readMessageEnd()
1512 
    if result.success is not None:
1513 
      return result.success
1514 
    if result.isex is not None:
1515 
      raise result.isex
1516 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsStatus failed: unknown result");
1517 
 
5944 mandeep.dh 1518 
  def getItemStatusDescription(self, itemId):
1519 
    """
1520 
    Parameters:
1521 
     - itemId
1522 
    """
1523 
    self.send_getItemStatusDescription(itemId)
1524 
    return self.recv_getItemStatusDescription()
1525 
 
1526 
  def send_getItemStatusDescription(self, itemId):
1527 
    self._oprot.writeMessageBegin('getItemStatusDescription', TMessageType.CALL, self._seqid)
1528 
    args = getItemStatusDescription_args()
1529 
    args.itemId = itemId
1530 
    args.write(self._oprot)
1531 
    self._oprot.writeMessageEnd()
1532 
    self._oprot.trans.flush()
1533 
 
1534 
  def recv_getItemStatusDescription(self, ):
1535 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1536 
    if mtype == TMessageType.EXCEPTION:
1537 
      x = TApplicationException()
1538 
      x.read(self._iprot)
1539 
      self._iprot.readMessageEnd()
1540 
      raise x
1541 
    result = getItemStatusDescription_result()
1542 
    result.read(self._iprot)
1543 
    self._iprot.readMessageEnd()
1544 
    if result.success is not None:
1545 
      return result.success
1546 
    if result.isex is not None:
1547 
      raise result.isex
1548 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStatusDescription failed: unknown result");
1549 
 
1550 
  def startItemOn(self, item_id, timestamp):
1551 
    """
1552 
    Parameters:
1553 
     - item_id
1554 
     - timestamp
1555 
    """
1556 
    self.send_startItemOn(item_id, timestamp)
1557 
    self.recv_startItemOn()
1558 
 
1559 
  def send_startItemOn(self, item_id, timestamp):
1560 
    self._oprot.writeMessageBegin('startItemOn', TMessageType.CALL, self._seqid)
1561 
    args = startItemOn_args()
1562 
    args.item_id = item_id
1563 
    args.timestamp = timestamp
1564 
    args.write(self._oprot)
1565 
    self._oprot.writeMessageEnd()
1566 
    self._oprot.trans.flush()
1567 
 
1568 
  def recv_startItemOn(self, ):
1569 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1570 
    if mtype == TMessageType.EXCEPTION:
1571 
      x = TApplicationException()
1572 
      x.read(self._iprot)
1573 
      self._iprot.readMessageEnd()
1574 
      raise x
1575 
    result = startItemOn_result()
1576 
    result.read(self._iprot)
1577 
    self._iprot.readMessageEnd()
1578 
    if result.cex is not None:
1579 
      raise result.cex
1580 
    return
1581 
 
1582 
  def retireItemOn(self, item_id, timestamp):
1583 
    """
1584 
    Parameters:
1585 
     - item_id
1586 
     - timestamp
1587 
    """
1588 
    self.send_retireItemOn(item_id, timestamp)
1589 
    self.recv_retireItemOn()
1590 
 
1591 
  def send_retireItemOn(self, item_id, timestamp):
1592 
    self._oprot.writeMessageBegin('retireItemOn', TMessageType.CALL, self._seqid)
1593 
    args = retireItemOn_args()
1594 
    args.item_id = item_id
1595 
    args.timestamp = timestamp
1596 
    args.write(self._oprot)
1597 
    self._oprot.writeMessageEnd()
1598 
    self._oprot.trans.flush()
1599 
 
1600 
  def recv_retireItemOn(self, ):
1601 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1602 
    if mtype == TMessageType.EXCEPTION:
1603 
      x = TApplicationException()
1604 
      x.read(self._iprot)
1605 
      self._iprot.readMessageEnd()
1606 
      raise x
1607 
    result = retireItemOn_result()
1608 
    result.read(self._iprot)
1609 
    self._iprot.readMessageEnd()
1610 
    if result.cex is not None:
1611 
      raise result.cex
1612 
    return
1613 
 
1614 
  def changeItemStatus(self, item_id, timestamp, newstatus):
1615 
    """
1616 
    Parameters:
1617 
     - item_id
1618 
     - timestamp
1619 
     - newstatus
1620 
    """
1621 
    self.send_changeItemStatus(item_id, timestamp, newstatus)
1622 
    self.recv_changeItemStatus()
1623 
 
1624 
  def send_changeItemStatus(self, item_id, timestamp, newstatus):
1625 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
1626 
    args = changeItemStatus_args()
1627 
    args.item_id = item_id
1628 
    args.timestamp = timestamp
1629 
    args.newstatus = newstatus
1630 
    args.write(self._oprot)
1631 
    self._oprot.writeMessageEnd()
1632 
    self._oprot.trans.flush()
1633 
 
1634 
  def recv_changeItemStatus(self, ):
1635 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1636 
    if mtype == TMessageType.EXCEPTION:
1637 
      x = TApplicationException()
1638 
      x.read(self._iprot)
1639 
      self._iprot.readMessageEnd()
1640 
      raise x
1641 
    result = changeItemStatus_result()
1642 
    result.read(self._iprot)
1643 
    self._iprot.readMessageEnd()
1644 
    if result.cex is not None:
1645 
      raise result.cex
1646 
    return
1647 
 
1648 
  def getItem(self, item_id):
1649 
    """
1650 
    Parameters:
1651 
     - item_id
1652 
    """
1653 
    self.send_getItem(item_id)
1654 
    return self.recv_getItem()
1655 
 
1656 
  def send_getItem(self, item_id):
1657 
    self._oprot.writeMessageBegin('getItem', TMessageType.CALL, self._seqid)
1658 
    args = getItem_args()
1659 
    args.item_id = item_id
1660 
    args.write(self._oprot)
1661 
    self._oprot.writeMessageEnd()
1662 
    self._oprot.trans.flush()
1663 
 
1664 
  def recv_getItem(self, ):
1665 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1666 
    if mtype == TMessageType.EXCEPTION:
1667 
      x = TApplicationException()
1668 
      x.read(self._iprot)
1669 
      self._iprot.readMessageEnd()
1670 
      raise x
1671 
    result = getItem_result()
1672 
    result.read(self._iprot)
1673 
    self._iprot.readMessageEnd()
1674 
    if result.success is not None:
1675 
      return result.success
1676 
    if result.cex is not None:
1677 
      raise result.cex
1678 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItem failed: unknown result");
1679 
 
13493 amit.gupta 1680 
  def getItems(self, item_ids):
1681 
    """
1682 
    Parameters:
1683 
     - item_ids
1684 
    """
1685 
    self.send_getItems(item_ids)
1686 
    return self.recv_getItems()
1687 
 
1688 
  def send_getItems(self, item_ids):
1689 
    self._oprot.writeMessageBegin('getItems', TMessageType.CALL, self._seqid)
1690 
    args = getItems_args()
1691 
    args.item_ids = item_ids
1692 
    args.write(self._oprot)
1693 
    self._oprot.writeMessageEnd()
1694 
    self._oprot.trans.flush()
1695 
 
1696 
  def recv_getItems(self, ):
1697 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1698 
    if mtype == TMessageType.EXCEPTION:
1699 
      x = TApplicationException()
1700 
      x.read(self._iprot)
1701 
      self._iprot.readMessageEnd()
1702 
      raise x
1703 
    result = getItems_result()
1704 
    result.read(self._iprot)
1705 
    self._iprot.readMessageEnd()
1706 
    if result.success is not None:
1707 
      return result.success
1708 
    if result.cex is not None:
1709 
      raise result.cex
1710 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItems failed: unknown result");
1711 
 
5944 mandeep.dh 1712 
  def getItemsByCatalogId(self, catalog_item_id):
1713 
    """
1714 
    Parameters:
1715 
     - catalog_item_id
1716 
    """
1717 
    self.send_getItemsByCatalogId(catalog_item_id)
1718 
    return self.recv_getItemsByCatalogId()
1719 
 
1720 
  def send_getItemsByCatalogId(self, catalog_item_id):
1721 
    self._oprot.writeMessageBegin('getItemsByCatalogId', TMessageType.CALL, self._seqid)
1722 
    args = getItemsByCatalogId_args()
1723 
    args.catalog_item_id = catalog_item_id
1724 
    args.write(self._oprot)
1725 
    self._oprot.writeMessageEnd()
1726 
    self._oprot.trans.flush()
1727 
 
1728 
  def recv_getItemsByCatalogId(self, ):
1729 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1730 
    if mtype == TMessageType.EXCEPTION:
1731 
      x = TApplicationException()
1732 
      x.read(self._iprot)
1733 
      self._iprot.readMessageEnd()
1734 
      raise x
1735 
    result = getItemsByCatalogId_result()
1736 
    result.read(self._iprot)
1737 
    self._iprot.readMessageEnd()
1738 
    if result.success is not None:
1739 
      return result.success
1740 
    if result.cex is not None:
1741 
      raise result.cex
1742 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByCatalogId failed: unknown result");
1743 
 
1744 
  def getValidItemsByCatalogId(self, catalog_item_id):
1745 
    """
1746 
    Parameters:
1747 
     - catalog_item_id
1748 
    """
1749 
    self.send_getValidItemsByCatalogId(catalog_item_id)
1750 
    return self.recv_getValidItemsByCatalogId()
1751 
 
1752 
  def send_getValidItemsByCatalogId(self, catalog_item_id):
1753 
    self._oprot.writeMessageBegin('getValidItemsByCatalogId', TMessageType.CALL, self._seqid)
1754 
    args = getValidItemsByCatalogId_args()
1755 
    args.catalog_item_id = catalog_item_id
1756 
    args.write(self._oprot)
1757 
    self._oprot.writeMessageEnd()
1758 
    self._oprot.trans.flush()
1759 
 
1760 
  def recv_getValidItemsByCatalogId(self, ):
1761 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1762 
    if mtype == TMessageType.EXCEPTION:
1763 
      x = TApplicationException()
1764 
      x.read(self._iprot)
1765 
      self._iprot.readMessageEnd()
1766 
      raise x
1767 
    result = getValidItemsByCatalogId_result()
1768 
    result.read(self._iprot)
1769 
    self._iprot.readMessageEnd()
1770 
    if result.success is not None:
1771 
      return result.success
1772 
    if result.cex is not None:
1773 
      raise result.cex
1774 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidItemsByCatalogId failed: unknown result");
1775 
 
1776 
  def getAllItems(self, isActive):
1777 
    """
1778 
    Parameters:
1779 
     - isActive
1780 
    """
1781 
    self.send_getAllItems(isActive)
1782 
    return self.recv_getAllItems()
1783 
 
1784 
  def send_getAllItems(self, isActive):
1785 
    self._oprot.writeMessageBegin('getAllItems', TMessageType.CALL, self._seqid)
1786 
    args = getAllItems_args()
1787 
    args.isActive = isActive
1788 
    args.write(self._oprot)
1789 
    self._oprot.writeMessageEnd()
1790 
    self._oprot.trans.flush()
1791 
 
1792 
  def recv_getAllItems(self, ):
1793 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1794 
    if mtype == TMessageType.EXCEPTION:
1795 
      x = TApplicationException()
1796 
      x.read(self._iprot)
1797 
      self._iprot.readMessageEnd()
1798 
      raise x
1799 
    result = getAllItems_result()
1800 
    result.read(self._iprot)
1801 
    self._iprot.readMessageEnd()
1802 
    if result.success is not None:
1803 
      return result.success
1804 
    if result.cex is not None:
1805 
      raise result.cex
1806 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItems failed: unknown result");
1807 
 
1808 
  def getAllItemsByStatus(self, itemStatus):
1809 
    """
1810 
    Parameters:
1811 
     - itemStatus
1812 
    """
1813 
    self.send_getAllItemsByStatus(itemStatus)
1814 
    return self.recv_getAllItemsByStatus()
1815 
 
1816 
  def send_getAllItemsByStatus(self, itemStatus):
1817 
    self._oprot.writeMessageBegin('getAllItemsByStatus', TMessageType.CALL, self._seqid)
1818 
    args = getAllItemsByStatus_args()
1819 
    args.itemStatus = itemStatus
1820 
    args.write(self._oprot)
1821 
    self._oprot.writeMessageEnd()
1822 
    self._oprot.trans.flush()
1823 
 
1824 
  def recv_getAllItemsByStatus(self, ):
1825 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1826 
    if mtype == TMessageType.EXCEPTION:
1827 
      x = TApplicationException()
1828 
      x.read(self._iprot)
1829 
      self._iprot.readMessageEnd()
1830 
      raise x
1831 
    result = getAllItemsByStatus_result()
1832 
    result.read(self._iprot)
1833 
    self._iprot.readMessageEnd()
1834 
    if result.success is not None:
1835 
      return result.success
1836 
    if result.cex is not None:
1837 
      raise result.cex
1838 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatus failed: unknown result");
1839 
 
9253 rajveer 1840 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber, isAndroid):
5944 mandeep.dh 1841 
    """
1842 
    Parameters:
1843 
     - entityId
1844 
     - category
1845 
     - brand
1846 
     - modelName
1847 
     - modelNumber
9253 rajveer 1848 
     - isAndroid
5944 mandeep.dh 1849 
    """
9253 rajveer 1850 
    self.send_markItemAsContentComplete(entityId, category, brand, modelName, modelNumber, isAndroid)
5944 mandeep.dh 1851 
    return self.recv_markItemAsContentComplete()
1852 
 
9253 rajveer 1853 
  def send_markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber, isAndroid):
5944 mandeep.dh 1854 
    self._oprot.writeMessageBegin('markItemAsContentComplete', TMessageType.CALL, self._seqid)
1855 
    args = markItemAsContentComplete_args()
1856 
    args.entityId = entityId
1857 
    args.category = category
1858 
    args.brand = brand
1859 
    args.modelName = modelName
1860 
    args.modelNumber = modelNumber
9253 rajveer 1861 
    args.isAndroid = isAndroid
5944 mandeep.dh 1862 
    args.write(self._oprot)
1863 
    self._oprot.writeMessageEnd()
1864 
    self._oprot.trans.flush()
1865 
 
1866 
  def recv_markItemAsContentComplete(self, ):
1867 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1868 
    if mtype == TMessageType.EXCEPTION:
1869 
      x = TApplicationException()
1870 
      x.read(self._iprot)
1871 
      self._iprot.readMessageEnd()
1872 
      raise x
1873 
    result = markItemAsContentComplete_result()
1874 
    result.read(self._iprot)
1875 
    self._iprot.readMessageEnd()
1876 
    if result.success is not None:
1877 
      return result.success
1878 
    if result.cex is not None:
1879 
      raise result.cex
1880 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markItemAsContentComplete failed: unknown result");
1881 
 
12567 amit.gupta 1882 
  def getVatRates(self, itemId, categoryId):
1883 
    """
1884 
    Parameters:
1885 
     - itemId
1886 
     - categoryId
1887 
    """
1888 
    self.send_getVatRates(itemId, categoryId)
1889 
    return self.recv_getVatRates()
1890 
 
1891 
  def send_getVatRates(self, itemId, categoryId):
1892 
    self._oprot.writeMessageBegin('getVatRates', TMessageType.CALL, self._seqid)
1893 
    args = getVatRates_args()
1894 
    args.itemId = itemId
1895 
    args.categoryId = categoryId
1896 
    args.write(self._oprot)
1897 
    self._oprot.writeMessageEnd()
1898 
    self._oprot.trans.flush()
1899 
 
1900 
  def recv_getVatRates(self, ):
1901 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1902 
    if mtype == TMessageType.EXCEPTION:
1903 
      x = TApplicationException()
1904 
      x.read(self._iprot)
1905 
      self._iprot.readMessageEnd()
1906 
      raise x
1907 
    result = getVatRates_result()
1908 
    result.read(self._iprot)
1909 
    self._iprot.readMessageEnd()
1910 
    if result.success is not None:
1911 
      return result.success
1912 
    if result.cex is not None:
1913 
      raise result.cex
1914 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatRates failed: unknown result");
1915 
 
5944 mandeep.dh 1916 
  def getAllItemsInRange(self, offset, limit):
1917 
    """
1918 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
1919 
 
1920 
    Parameters:
1921 
     - offset
1922 
     - limit
1923 
    """
1924 
    self.send_getAllItemsInRange(offset, limit)
1925 
    return self.recv_getAllItemsInRange()
1926 
 
1927 
  def send_getAllItemsInRange(self, offset, limit):
1928 
    self._oprot.writeMessageBegin('getAllItemsInRange', TMessageType.CALL, self._seqid)
1929 
    args = getAllItemsInRange_args()
1930 
    args.offset = offset
1931 
    args.limit = limit
1932 
    args.write(self._oprot)
1933 
    self._oprot.writeMessageEnd()
1934 
    self._oprot.trans.flush()
1935 
 
1936 
  def recv_getAllItemsInRange(self, ):
1937 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1938 
    if mtype == TMessageType.EXCEPTION:
1939 
      x = TApplicationException()
1940 
      x.read(self._iprot)
1941 
      self._iprot.readMessageEnd()
1942 
      raise x
1943 
    result = getAllItemsInRange_result()
1944 
    result.read(self._iprot)
1945 
    self._iprot.readMessageEnd()
1946 
    if result.success is not None:
1947 
      return result.success
1948 
    if result.cex is not None:
1949 
      raise result.cex
1950 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsInRange failed: unknown result");
1951 
 
1952 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1953 
    """
1954 
    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.
1955 
 
1956 
    Parameters:
1957 
     - itemStatus
1958 
     - offset
1959 
     - limit
1960 
    """
1961 
    self.send_getAllItemsByStatusInRange(itemStatus, offset, limit)
1962 
    return self.recv_getAllItemsByStatusInRange()
1963 
 
1964 
  def send_getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1965 
    self._oprot.writeMessageBegin('getAllItemsByStatusInRange', TMessageType.CALL, self._seqid)
1966 
    args = getAllItemsByStatusInRange_args()
1967 
    args.itemStatus = itemStatus
1968 
    args.offset = offset
1969 
    args.limit = limit
1970 
    args.write(self._oprot)
1971 
    self._oprot.writeMessageEnd()
1972 
    self._oprot.trans.flush()
1973 
 
1974 
  def recv_getAllItemsByStatusInRange(self, ):
1975 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1976 
    if mtype == TMessageType.EXCEPTION:
1977 
      x = TApplicationException()
1978 
      x.read(self._iprot)
1979 
      self._iprot.readMessageEnd()
1980 
      raise x
1981 
    result = getAllItemsByStatusInRange_result()
1982 
    result.read(self._iprot)
1983 
    self._iprot.readMessageEnd()
1984 
    if result.success is not None:
1985 
      return result.success
1986 
    if result.cex is not None:
1987 
      raise result.cex
1988 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatusInRange failed: unknown result");
1989 
 
1990 
  def getItemCountByStatus(self, useStatus, itemStatus):
1991 
    """
1992 
    Gets a count of all items by status
1993 
 
1994 
    Parameters:
1995 
     - useStatus
1996 
     - itemStatus
1997 
    """
1998 
    self.send_getItemCountByStatus(useStatus, itemStatus)
1999 
    return self.recv_getItemCountByStatus()
2000 
 
2001 
  def send_getItemCountByStatus(self, useStatus, itemStatus):
2002 
    self._oprot.writeMessageBegin('getItemCountByStatus', TMessageType.CALL, self._seqid)
2003 
    args = getItemCountByStatus_args()
2004 
    args.useStatus = useStatus
2005 
    args.itemStatus = itemStatus
2006 
    args.write(self._oprot)
2007 
    self._oprot.writeMessageEnd()
2008 
    self._oprot.trans.flush()
2009 
 
2010 
  def recv_getItemCountByStatus(self, ):
2011 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2012 
    if mtype == TMessageType.EXCEPTION:
2013 
      x = TApplicationException()
2014 
      x.read(self._iprot)
2015 
      self._iprot.readMessageEnd()
2016 
      raise x
2017 
    result = getItemCountByStatus_result()
2018 
    result.read(self._iprot)
2019 
    self._iprot.readMessageEnd()
2020 
    if result.success is not None:
2021 
      return result.success
2022 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemCountByStatus failed: unknown result");
2023 
 
2024 
  def getBestSellers(self, ):
2025 
    self.send_getBestSellers()
2026 
    return self.recv_getBestSellers()
2027 
 
2028 
  def send_getBestSellers(self, ):
2029 
    self._oprot.writeMessageBegin('getBestSellers', TMessageType.CALL, self._seqid)
2030 
    args = getBestSellers_args()
2031 
    args.write(self._oprot)
2032 
    self._oprot.writeMessageEnd()
2033 
    self._oprot.trans.flush()
2034 
 
2035 
  def recv_getBestSellers(self, ):
2036 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2037 
    if mtype == TMessageType.EXCEPTION:
2038 
      x = TApplicationException()
2039 
      x.read(self._iprot)
2040 
      self._iprot.readMessageEnd()
2041 
      raise x
2042 
    result = getBestSellers_result()
2043 
    result.read(self._iprot)
2044 
    self._iprot.readMessageEnd()
2045 
    if result.success is not None:
2046 
      return result.success
2047 
    if result.isex is not None:
2048 
      raise result.isex
2049 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellers failed: unknown result");
2050 
 
2051 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
2052 
    """
2053 
    Parameters:
2054 
     - beginIndex
2055 
     - totalItems
2056 
     - brand
2057 
     - category
2058 
    """
2059 
    self.send_getBestSellersCatalogIds(beginIndex, totalItems, brand, category)
2060 
    return self.recv_getBestSellersCatalogIds()
2061 
 
2062 
  def send_getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
2063 
    self._oprot.writeMessageBegin('getBestSellersCatalogIds', TMessageType.CALL, self._seqid)
2064 
    args = getBestSellersCatalogIds_args()
2065 
    args.beginIndex = beginIndex
2066 
    args.totalItems = totalItems
2067 
    args.brand = brand
2068 
    args.category = category
2069 
    args.write(self._oprot)
2070 
    self._oprot.writeMessageEnd()
2071 
    self._oprot.trans.flush()
2072 
 
2073 
  def recv_getBestSellersCatalogIds(self, ):
2074 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2075 
    if mtype == TMessageType.EXCEPTION:
2076 
      x = TApplicationException()
2077 
      x.read(self._iprot)
2078 
      self._iprot.readMessageEnd()
2079 
      raise x
2080 
    result = getBestSellersCatalogIds_result()
2081 
    result.read(self._iprot)
2082 
    self._iprot.readMessageEnd()
2083 
    if result.success is not None:
2084 
      return result.success
2085 
    if result.cex is not None:
2086 
      raise result.cex
2087 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCatalogIds failed: unknown result");
2088 
 
2089 
  def getBestSellersCount(self, ):
2090 
    self.send_getBestSellersCount()
2091 
    return self.recv_getBestSellersCount()
2092 
 
2093 
  def send_getBestSellersCount(self, ):
2094 
    self._oprot.writeMessageBegin('getBestSellersCount', TMessageType.CALL, self._seqid)
2095 
    args = getBestSellersCount_args()
2096 
    args.write(self._oprot)
2097 
    self._oprot.writeMessageEnd()
2098 
    self._oprot.trans.flush()
2099 
 
2100 
  def recv_getBestSellersCount(self, ):
2101 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2102 
    if mtype == TMessageType.EXCEPTION:
2103 
      x = TApplicationException()
2104 
      x.read(self._iprot)
2105 
      self._iprot.readMessageEnd()
2106 
      raise x
2107 
    result = getBestSellersCount_result()
2108 
    result.read(self._iprot)
2109 
    self._iprot.readMessageEnd()
2110 
    if result.success is not None:
2111 
      return result.success
2112 
    if result.cex is not None:
2113 
      raise result.cex
2114 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCount failed: unknown result");
2115 
 
2116 
  def getBestDeals(self, ):
2117 
    self.send_getBestDeals()
2118 
    return self.recv_getBestDeals()
2119 
 
2120 
  def send_getBestDeals(self, ):
2121 
    self._oprot.writeMessageBegin('getBestDeals', TMessageType.CALL, self._seqid)
2122 
    args = getBestDeals_args()
2123 
    args.write(self._oprot)
2124 
    self._oprot.writeMessageEnd()
2125 
    self._oprot.trans.flush()
2126 
 
2127 
  def recv_getBestDeals(self, ):
2128 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2129 
    if mtype == TMessageType.EXCEPTION:
2130 
      x = TApplicationException()
2131 
      x.read(self._iprot)
2132 
      self._iprot.readMessageEnd()
2133 
      raise x
2134 
    result = getBestDeals_result()
2135 
    result.read(self._iprot)
2136 
    self._iprot.readMessageEnd()
2137 
    if result.success is not None:
2138 
      return result.success
2139 
    if result.isex is not None:
2140 
      raise result.isex
2141 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDeals failed: unknown result");
2142 
 
2143 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
2144 
    """
2145 
    Parameters:
2146 
     - beginIndex
2147 
     - totalItems
2148 
     - brand
2149 
     - category
2150 
    """
2151 
    self.send_getBestDealsCatalogIds(beginIndex, totalItems, brand, category)
2152 
    return self.recv_getBestDealsCatalogIds()
2153 
 
2154 
  def send_getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
2155 
    self._oprot.writeMessageBegin('getBestDealsCatalogIds', TMessageType.CALL, self._seqid)
2156 
    args = getBestDealsCatalogIds_args()
2157 
    args.beginIndex = beginIndex
2158 
    args.totalItems = totalItems
2159 
    args.brand = brand
2160 
    args.category = category
2161 
    args.write(self._oprot)
2162 
    self._oprot.writeMessageEnd()
2163 
    self._oprot.trans.flush()
2164 
 
2165 
  def recv_getBestDealsCatalogIds(self, ):
2166 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2167 
    if mtype == TMessageType.EXCEPTION:
2168 
      x = TApplicationException()
2169 
      x.read(self._iprot)
2170 
      self._iprot.readMessageEnd()
2171 
      raise x
2172 
    result = getBestDealsCatalogIds_result()
2173 
    result.read(self._iprot)
2174 
    self._iprot.readMessageEnd()
2175 
    if result.success is not None:
2176 
      return result.success
2177 
    if result.cex is not None:
2178 
      raise result.cex
2179 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCatalogIds failed: unknown result");
2180 
 
2181 
  def getBestDealsCount(self, ):
2182 
    self.send_getBestDealsCount()
2183 
    return self.recv_getBestDealsCount()
2184 
 
2185 
  def send_getBestDealsCount(self, ):
2186 
    self._oprot.writeMessageBegin('getBestDealsCount', TMessageType.CALL, self._seqid)
2187 
    args = getBestDealsCount_args()
2188 
    args.write(self._oprot)
2189 
    self._oprot.writeMessageEnd()
2190 
    self._oprot.trans.flush()
2191 
 
2192 
  def recv_getBestDealsCount(self, ):
2193 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2194 
    if mtype == TMessageType.EXCEPTION:
2195 
      x = TApplicationException()
2196 
      x.read(self._iprot)
2197 
      self._iprot.readMessageEnd()
2198 
      raise x
2199 
    result = getBestDealsCount_result()
2200 
    result.read(self._iprot)
2201 
    self._iprot.readMessageEnd()
2202 
    if result.success is not None:
2203 
      return result.success
2204 
    if result.cex is not None:
2205 
      raise result.cex
2206 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCount failed: unknown result");
2207 
 
2208 
  def getComingSoon(self, ):
2209 
    self.send_getComingSoon()
2210 
    return self.recv_getComingSoon()
2211 
 
2212 
  def send_getComingSoon(self, ):
2213 
    self._oprot.writeMessageBegin('getComingSoon', TMessageType.CALL, self._seqid)
2214 
    args = getComingSoon_args()
2215 
    args.write(self._oprot)
2216 
    self._oprot.writeMessageEnd()
2217 
    self._oprot.trans.flush()
2218 
 
2219 
  def recv_getComingSoon(self, ):
2220 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2221 
    if mtype == TMessageType.EXCEPTION:
2222 
      x = TApplicationException()
2223 
      x.read(self._iprot)
2224 
      self._iprot.readMessageEnd()
2225 
      raise x
2226 
    result = getComingSoon_result()
2227 
    result.read(self._iprot)
2228 
    self._iprot.readMessageEnd()
2229 
    if result.success is not None:
2230 
      return result.success
2231 
    if result.isex is not None:
2232 
      raise result.isex
2233 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoon failed: unknown result");
2234 
 
2235 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
2236 
    """
2237 
    Parameters:
2238 
     - beginIndex
2239 
     - totalItems
2240 
     - brand
2241 
     - category
2242 
    """
2243 
    self.send_getComingSoonCatalogIds(beginIndex, totalItems, brand, category)
2244 
    return self.recv_getComingSoonCatalogIds()
2245 
 
2246 
  def send_getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
2247 
    self._oprot.writeMessageBegin('getComingSoonCatalogIds', TMessageType.CALL, self._seqid)
2248 
    args = getComingSoonCatalogIds_args()
2249 
    args.beginIndex = beginIndex
2250 
    args.totalItems = totalItems
2251 
    args.brand = brand
2252 
    args.category = category
2253 
    args.write(self._oprot)
2254 
    self._oprot.writeMessageEnd()
2255 
    self._oprot.trans.flush()
2256 
 
2257 
  def recv_getComingSoonCatalogIds(self, ):
2258 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2259 
    if mtype == TMessageType.EXCEPTION:
2260 
      x = TApplicationException()
2261 
      x.read(self._iprot)
2262 
      self._iprot.readMessageEnd()
2263 
      raise x
2264 
    result = getComingSoonCatalogIds_result()
2265 
    result.read(self._iprot)
2266 
    self._iprot.readMessageEnd()
2267 
    if result.success is not None:
2268 
      return result.success
2269 
    if result.cex is not None:
2270 
      raise result.cex
2271 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCatalogIds failed: unknown result");
2272 
 
2273 
  def getComingSoonCount(self, ):
2274 
    self.send_getComingSoonCount()
2275 
    return self.recv_getComingSoonCount()
2276 
 
2277 
  def send_getComingSoonCount(self, ):
2278 
    self._oprot.writeMessageBegin('getComingSoonCount', TMessageType.CALL, self._seqid)
2279 
    args = getComingSoonCount_args()
2280 
    args.write(self._oprot)
2281 
    self._oprot.writeMessageEnd()
2282 
    self._oprot.trans.flush()
2283 
 
2284 
  def recv_getComingSoonCount(self, ):
2285 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2286 
    if mtype == TMessageType.EXCEPTION:
2287 
      x = TApplicationException()
2288 
      x.read(self._iprot)
2289 
      self._iprot.readMessageEnd()
2290 
      raise x
2291 
    result = getComingSoonCount_result()
2292 
    result.read(self._iprot)
2293 
    self._iprot.readMessageEnd()
2294 
    if result.success is not None:
2295 
      return result.success
2296 
    if result.cex is not None:
2297 
      raise result.cex
2298 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCount failed: unknown result");
2299 
 
2300 
  def getLatestArrivals(self, ):
2301 
    """
2302 
    Returns a list of items sorted in the descending order by start date.
2303 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
2304 
    """
2305 
    self.send_getLatestArrivals()
2306 
    return self.recv_getLatestArrivals()
2307 
 
2308 
  def send_getLatestArrivals(self, ):
2309 
    self._oprot.writeMessageBegin('getLatestArrivals', TMessageType.CALL, self._seqid)
2310 
    args = getLatestArrivals_args()
2311 
    args.write(self._oprot)
2312 
    self._oprot.writeMessageEnd()
2313 
    self._oprot.trans.flush()
2314 
 
2315 
  def recv_getLatestArrivals(self, ):
2316 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2317 
    if mtype == TMessageType.EXCEPTION:
2318 
      x = TApplicationException()
2319 
      x.read(self._iprot)
2320 
      self._iprot.readMessageEnd()
2321 
      raise x
2322 
    result = getLatestArrivals_result()
2323 
    result.read(self._iprot)
2324 
    self._iprot.readMessageEnd()
2325 
    if result.success is not None:
2326 
      return result.success
2327 
    if result.isex is not None:
2328 
      raise result.isex
2329 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivals failed: unknown result");
2330 
 
2331 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
2332 
    """
2333 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
2334 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
2335 
 
2336 
    Parameters:
2337 
     - beginIndex
2338 
     - totalItems
2339 
     - brand
2340 
     - categories
2341 
    """
2342 
    self.send_getLatestArrivalsCatalogIds(beginIndex, totalItems, brand, categories)
2343 
    return self.recv_getLatestArrivalsCatalogIds()
2344 
 
2345 
  def send_getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
2346 
    self._oprot.writeMessageBegin('getLatestArrivalsCatalogIds', TMessageType.CALL, self._seqid)
2347 
    args = getLatestArrivalsCatalogIds_args()
2348 
    args.beginIndex = beginIndex
2349 
    args.totalItems = totalItems
2350 
    args.brand = brand
2351 
    args.categories = categories
2352 
    args.write(self._oprot)
2353 
    self._oprot.writeMessageEnd()
2354 
    self._oprot.trans.flush()
2355 
 
2356 
  def recv_getLatestArrivalsCatalogIds(self, ):
2357 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2358 
    if mtype == TMessageType.EXCEPTION:
2359 
      x = TApplicationException()
2360 
      x.read(self._iprot)
2361 
      self._iprot.readMessageEnd()
2362 
      raise x
2363 
    result = getLatestArrivalsCatalogIds_result()
2364 
    result.read(self._iprot)
2365 
    self._iprot.readMessageEnd()
2366 
    if result.success is not None:
2367 
      return result.success
2368 
    if result.cex is not None:
2369 
      raise result.cex
2370 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCatalogIds failed: unknown result");
2371 
 
2372 
  def getLatestArrivalsCount(self, ):
2373 
    """
2374 
    Get the total number of latest arrivals we are willing to show.
2375 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
2376 
    """
2377 
    self.send_getLatestArrivalsCount()
2378 
    return self.recv_getLatestArrivalsCount()
2379 
 
2380 
  def send_getLatestArrivalsCount(self, ):
2381 
    self._oprot.writeMessageBegin('getLatestArrivalsCount', TMessageType.CALL, self._seqid)
2382 
    args = getLatestArrivalsCount_args()
2383 
    args.write(self._oprot)
2384 
    self._oprot.writeMessageEnd()
2385 
    self._oprot.trans.flush()
2386 
 
2387 
  def recv_getLatestArrivalsCount(self, ):
2388 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2389 
    if mtype == TMessageType.EXCEPTION:
2390 
      x = TApplicationException()
2391 
      x.read(self._iprot)
2392 
      self._iprot.readMessageEnd()
2393 
      raise x
2394 
    result = getLatestArrivalsCount_result()
2395 
    result.read(self._iprot)
2396 
    self._iprot.readMessageEnd()
2397 
    if result.success is not None:
2398 
      return result.success
2399 
    if result.cex is not None:
2400 
      raise result.cex
2401 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCount failed: unknown result");
2402 
 
2403 
  def generateNewEntityID(self, ):
2404 
    self.send_generateNewEntityID()
2405 
    return self.recv_generateNewEntityID()
2406 
 
2407 
  def send_generateNewEntityID(self, ):
2408 
    self._oprot.writeMessageBegin('generateNewEntityID', TMessageType.CALL, self._seqid)
2409 
    args = generateNewEntityID_args()
2410 
    args.write(self._oprot)
2411 
    self._oprot.writeMessageEnd()
2412 
    self._oprot.trans.flush()
2413 
 
2414 
  def recv_generateNewEntityID(self, ):
2415 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2416 
    if mtype == TMessageType.EXCEPTION:
2417 
      x = TApplicationException()
2418 
      x.read(self._iprot)
2419 
      self._iprot.readMessageEnd()
2420 
      raise x
2421 
    result = generateNewEntityID_result()
2422 
    result.read(self._iprot)
2423 
    self._iprot.readMessageEnd()
2424 
    if result.success is not None:
2425 
      return result.success
2426 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateNewEntityID failed: unknown result");
2427 
 
2428 
  def addCategory(self, category):
2429 
    """
2430 
    All category related functions
2431 
 
2432 
    Parameters:
2433 
     - category
2434 
    """
2435 
    self.send_addCategory(category)
2436 
    return self.recv_addCategory()
2437 
 
2438 
  def send_addCategory(self, category):
2439 
    self._oprot.writeMessageBegin('addCategory', TMessageType.CALL, self._seqid)
2440 
    args = addCategory_args()
2441 
    args.category = category
2442 
    args.write(self._oprot)
2443 
    self._oprot.writeMessageEnd()
2444 
    self._oprot.trans.flush()
2445 
 
2446 
  def recv_addCategory(self, ):
2447 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2448 
    if mtype == TMessageType.EXCEPTION:
2449 
      x = TApplicationException()
2450 
      x.read(self._iprot)
2451 
      self._iprot.readMessageEnd()
2452 
      raise x
2453 
    result = addCategory_result()
2454 
    result.read(self._iprot)
2455 
    self._iprot.readMessageEnd()
2456 
    if result.success is not None:
2457 
      return result.success
2458 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addCategory failed: unknown result");
2459 
 
2460 
  def getCategory(self, id):
2461 
    """
2462 
    Parameters:
2463 
     - id
2464 
    """
2465 
    self.send_getCategory(id)
2466 
    return self.recv_getCategory()
2467 
 
2468 
  def send_getCategory(self, id):
2469 
    self._oprot.writeMessageBegin('getCategory', TMessageType.CALL, self._seqid)
2470 
    args = getCategory_args()
2471 
    args.id = id
2472 
    args.write(self._oprot)
2473 
    self._oprot.writeMessageEnd()
2474 
    self._oprot.trans.flush()
2475 
 
2476 
  def recv_getCategory(self, ):
2477 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2478 
    if mtype == TMessageType.EXCEPTION:
2479 
      x = TApplicationException()
2480 
      x.read(self._iprot)
2481 
      self._iprot.readMessageEnd()
2482 
      raise x
2483 
    result = getCategory_result()
2484 
    result.read(self._iprot)
2485 
    self._iprot.readMessageEnd()
2486 
    if result.success is not None:
2487 
      return result.success
2488 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCategory failed: unknown result");
2489 
 
2490 
  def getAllCategories(self, ):
2491 
    self.send_getAllCategories()
2492 
    return self.recv_getAllCategories()
2493 
 
2494 
  def send_getAllCategories(self, ):
2495 
    self._oprot.writeMessageBegin('getAllCategories', TMessageType.CALL, self._seqid)
2496 
    args = getAllCategories_args()
2497 
    args.write(self._oprot)
2498 
    self._oprot.writeMessageEnd()
2499 
    self._oprot.trans.flush()
2500 
 
2501 
  def recv_getAllCategories(self, ):
2502 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2503 
    if mtype == TMessageType.EXCEPTION:
2504 
      x = TApplicationException()
2505 
      x.read(self._iprot)
2506 
      self._iprot.readMessageEnd()
2507 
      raise x
2508 
    result = getAllCategories_result()
2509 
    result.read(self._iprot)
2510 
    self._iprot.readMessageEnd()
2511 
    if result.success is not None:
2512 
      return result.success
2513 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCategories failed: unknown result");
2514 
 
2515 
  def getAllSimilarItems(self, itemId):
2516 
    """
2517 
    Returns the list of similar items.
2518 
 
2519 
    Parameters:
2520 
     - itemId
2521 
    """
2522 
    self.send_getAllSimilarItems(itemId)
2523 
    return self.recv_getAllSimilarItems()
2524 
 
2525 
  def send_getAllSimilarItems(self, itemId):
2526 
    self._oprot.writeMessageBegin('getAllSimilarItems', TMessageType.CALL, self._seqid)
2527 
    args = getAllSimilarItems_args()
2528 
    args.itemId = itemId
2529 
    args.write(self._oprot)
2530 
    self._oprot.writeMessageEnd()
2531 
    self._oprot.trans.flush()
2532 
 
2533 
  def recv_getAllSimilarItems(self, ):
2534 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2535 
    if mtype == TMessageType.EXCEPTION:
2536 
      x = TApplicationException()
2537 
      x.read(self._iprot)
2538 
      self._iprot.readMessageEnd()
2539 
      raise x
2540 
    result = getAllSimilarItems_result()
2541 
    result.read(self._iprot)
2542 
    self._iprot.readMessageEnd()
2543 
    if result.success is not None:
2544 
      return result.success
2545 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSimilarItems failed: unknown result");
2546 
 
2547 
  def addSimilarItem(self, itemId, catalogItemId):
2548 
    """
2549 
    Adds similar item.
2550 
 
2551 
    Parameters:
2552 
     - itemId
2553 
     - catalogItemId
2554 
    """
2555 
    self.send_addSimilarItem(itemId, catalogItemId)
2556 
    return self.recv_addSimilarItem()
2557 
 
2558 
  def send_addSimilarItem(self, itemId, catalogItemId):
2559 
    self._oprot.writeMessageBegin('addSimilarItem', TMessageType.CALL, self._seqid)
2560 
    args = addSimilarItem_args()
2561 
    args.itemId = itemId
2562 
    args.catalogItemId = catalogItemId
2563 
    args.write(self._oprot)
2564 
    self._oprot.writeMessageEnd()
2565 
    self._oprot.trans.flush()
2566 
 
2567 
  def recv_addSimilarItem(self, ):
2568 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2569 
    if mtype == TMessageType.EXCEPTION:
2570 
      x = TApplicationException()
2571 
      x.read(self._iprot)
2572 
      self._iprot.readMessageEnd()
2573 
      raise x
2574 
    result = addSimilarItem_result()
2575 
    result.read(self._iprot)
2576 
    self._iprot.readMessageEnd()
2577 
    if result.success is not None:
2578 
      return result.success
2579 
    if result.cex is not None:
2580 
      raise result.cex
2581 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSimilarItem failed: unknown result");
2582 
 
6512 kshitij.so 2583 
  def addTag(self, displayName, itemId):
2584 
    """
2585 
    Tag Related
2586 
 
2587 
    Parameters:
2588 
     - displayName
2589 
     - itemId
2590 
    """
2591 
    self.send_addTag(displayName, itemId)
2592 
    return self.recv_addTag()
2593 
 
2594 
  def send_addTag(self, displayName, itemId):
2595 
    self._oprot.writeMessageBegin('addTag', TMessageType.CALL, self._seqid)
2596 
    args = addTag_args()
2597 
    args.displayName = displayName
2598 
    args.itemId = itemId
2599 
    args.write(self._oprot)
2600 
    self._oprot.writeMessageEnd()
2601 
    self._oprot.trans.flush()
2602 
 
2603 
  def recv_addTag(self, ):
2604 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2605 
    if mtype == TMessageType.EXCEPTION:
2606 
      x = TApplicationException()
2607 
      x.read(self._iprot)
2608 
      self._iprot.readMessageEnd()
2609 
      raise x
2610 
    result = addTag_result()
2611 
    result.read(self._iprot)
2612 
    self._iprot.readMessageEnd()
2613 
    if result.success is not None:
2614 
      return result.success
2615 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTag failed: unknown result");
2616 
 
2617 
  def deleteEntityTag(self, displayName, itemId):
2618 
    """
2619 
    Parameters:
2620 
     - displayName
2621 
     - itemId
2622 
    """
2623 
    self.send_deleteEntityTag(displayName, itemId)
2624 
    return self.recv_deleteEntityTag()
2625 
 
2626 
  def send_deleteEntityTag(self, displayName, itemId):
2627 
    self._oprot.writeMessageBegin('deleteEntityTag', TMessageType.CALL, self._seqid)
2628 
    args = deleteEntityTag_args()
2629 
    args.displayName = displayName
2630 
    args.itemId = itemId
2631 
    args.write(self._oprot)
2632 
    self._oprot.writeMessageEnd()
2633 
    self._oprot.trans.flush()
2634 
 
2635 
  def recv_deleteEntityTag(self, ):
2636 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2637 
    if mtype == TMessageType.EXCEPTION:
2638 
      x = TApplicationException()
2639 
      x.read(self._iprot)
2640 
      self._iprot.readMessageEnd()
2641 
      raise x
2642 
    result = deleteEntityTag_result()
2643 
    result.read(self._iprot)
2644 
    self._iprot.readMessageEnd()
2645 
    if result.success is not None:
2646 
      return result.success
2647 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteEntityTag failed: unknown result");
2648 
 
2649 
  def deleteTag(self, displayName):
2650 
    """
2651 
    Parameters:
2652 
     - displayName
2653 
    """
2654 
    self.send_deleteTag(displayName)
2655 
    return self.recv_deleteTag()
2656 
 
2657 
  def send_deleteTag(self, displayName):
2658 
    self._oprot.writeMessageBegin('deleteTag', TMessageType.CALL, self._seqid)
2659 
    args = deleteTag_args()
2660 
    args.displayName = displayName
2661 
    args.write(self._oprot)
2662 
    self._oprot.writeMessageEnd()
2663 
    self._oprot.trans.flush()
2664 
 
2665 
  def recv_deleteTag(self, ):
2666 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2667 
    if mtype == TMessageType.EXCEPTION:
2668 
      x = TApplicationException()
2669 
      x.read(self._iprot)
2670 
      self._iprot.readMessageEnd()
2671 
      raise x
2672 
    result = deleteTag_result()
2673 
    result.read(self._iprot)
2674 
    self._iprot.readMessageEnd()
2675 
    if result.success is not None:
2676 
      return result.success
2677 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteTag failed: unknown result");
2678 
 
2679 
  def getAllTags(self, ):
2680 
    self.send_getAllTags()
2681 
    return self.recv_getAllTags()
2682 
 
2683 
  def send_getAllTags(self, ):
2684 
    self._oprot.writeMessageBegin('getAllTags', TMessageType.CALL, self._seqid)
2685 
    args = getAllTags_args()
2686 
    args.write(self._oprot)
2687 
    self._oprot.writeMessageEnd()
2688 
    self._oprot.trans.flush()
2689 
 
2690 
  def recv_getAllTags(self, ):
2691 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2692 
    if mtype == TMessageType.EXCEPTION:
2693 
      x = TApplicationException()
2694 
      x.read(self._iprot)
2695 
      self._iprot.readMessageEnd()
2696 
      raise x
2697 
    result = getAllTags_result()
2698 
    result.read(self._iprot)
2699 
    self._iprot.readMessageEnd()
2700 
    if result.success is not None:
2701 
      return result.success
2702 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllTags failed: unknown result");
2703 
 
2704 
  def getAllEntitiesByTagName(self, displayName):
2705 
    """
2706 
    Parameters:
2707 
     - displayName
2708 
    """
2709 
    self.send_getAllEntitiesByTagName(displayName)
2710 
    return self.recv_getAllEntitiesByTagName()
2711 
 
2712 
  def send_getAllEntitiesByTagName(self, displayName):
2713 
    self._oprot.writeMessageBegin('getAllEntitiesByTagName', TMessageType.CALL, self._seqid)
2714 
    args = getAllEntitiesByTagName_args()
2715 
    args.displayName = displayName
2716 
    args.write(self._oprot)
2717 
    self._oprot.writeMessageEnd()
2718 
    self._oprot.trans.flush()
2719 
 
2720 
  def recv_getAllEntitiesByTagName(self, ):
2721 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2722 
    if mtype == TMessageType.EXCEPTION:
2723 
      x = TApplicationException()
2724 
      x.read(self._iprot)
2725 
      self._iprot.readMessageEnd()
2726 
      raise x
2727 
    result = getAllEntitiesByTagName_result()
2728 
    result.read(self._iprot)
2729 
    self._iprot.readMessageEnd()
2730 
    if result.success is not None:
2731 
      return result.success
2732 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntitiesByTagName failed: unknown result");
2733 
 
6845 amit.gupta 2734 
  def getAllEntityTags(self, ):
2735 
    self.send_getAllEntityTags()
2736 
    return self.recv_getAllEntityTags()
2737 
 
2738 
  def send_getAllEntityTags(self, ):
2739 
    self._oprot.writeMessageBegin('getAllEntityTags', TMessageType.CALL, self._seqid)
2740 
    args = getAllEntityTags_args()
2741 
    args.write(self._oprot)
2742 
    self._oprot.writeMessageEnd()
2743 
    self._oprot.trans.flush()
2744 
 
2745 
  def recv_getAllEntityTags(self, ):
2746 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2747 
    if mtype == TMessageType.EXCEPTION:
2748 
      x = TApplicationException()
2749 
      x.read(self._iprot)
2750 
      self._iprot.readMessageEnd()
2751 
      raise x
2752 
    result = getAllEntityTags_result()
2753 
    result.read(self._iprot)
2754 
    self._iprot.readMessageEnd()
2755 
    if result.success is not None:
2756 
      return result.success
2757 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntityTags failed: unknown result");
2758 
 
8590 kshitij.so 2759 
  def addBanner(self, bannerCongregate):
6850 kshitij.so 2760 
    """
8579 kshitij.so 2761 
    Banner Related
2762 
 
6850 kshitij.so 2763 
    Parameters:
8590 kshitij.so 2764 
     - bannerCongregate
6850 kshitij.so 2765 
    """
8590 kshitij.so 2766 
    self.send_addBanner(bannerCongregate)
10097 kshitij.so 2767 
    return self.recv_addBanner()
6850 kshitij.so 2768 
 
8590 kshitij.so 2769 
  def send_addBanner(self, bannerCongregate):
6850 kshitij.so 2770 
    self._oprot.writeMessageBegin('addBanner', TMessageType.CALL, self._seqid)
2771 
    args = addBanner_args()
8590 kshitij.so 2772 
    args.bannerCongregate = bannerCongregate
6850 kshitij.so 2773 
    args.write(self._oprot)
2774 
    self._oprot.writeMessageEnd()
2775 
    self._oprot.trans.flush()
2776 
 
2777 
  def recv_addBanner(self, ):
2778 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2779 
    if mtype == TMessageType.EXCEPTION:
2780 
      x = TApplicationException()
2781 
      x.read(self._iprot)
2782 
      self._iprot.readMessageEnd()
2783 
      raise x
2784 
    result = addBanner_result()
2785 
    result.read(self._iprot)
2786 
    self._iprot.readMessageEnd()
10097 kshitij.so 2787 
    if result.success is not None:
2788 
      return result.success
2789 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBanner failed: unknown result");
6850 kshitij.so 2790 
 
8579 kshitij.so 2791 
  def updateBanner(self, banner):
2792 
    """
2793 
    Parameters:
2794 
     - banner
2795 
    """
2796 
    self.send_updateBanner(banner)
2797 
    return self.recv_updateBanner()
2798 
 
2799 
  def send_updateBanner(self, banner):
2800 
    self._oprot.writeMessageBegin('updateBanner', TMessageType.CALL, self._seqid)
2801 
    args = updateBanner_args()
2802 
    args.banner = banner
2803 
    args.write(self._oprot)
2804 
    self._oprot.writeMessageEnd()
2805 
    self._oprot.trans.flush()
2806 
 
2807 
  def recv_updateBanner(self, ):
2808 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2809 
    if mtype == TMessageType.EXCEPTION:
2810 
      x = TApplicationException()
2811 
      x.read(self._iprot)
2812 
      self._iprot.readMessageEnd()
2813 
      raise x
2814 
    result = updateBanner_result()
2815 
    result.read(self._iprot)
2816 
    self._iprot.readMessageEnd()
2817 
    if result.success is not None:
2818 
      return result.success
2819 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBanner failed: unknown result");
2820 
 
6850 kshitij.so 2821 
  def getAllBanners(self, ):
2822 
    self.send_getAllBanners()
2823 
    return self.recv_getAllBanners()
2824 
 
2825 
  def send_getAllBanners(self, ):
2826 
    self._oprot.writeMessageBegin('getAllBanners', TMessageType.CALL, self._seqid)
2827 
    args = getAllBanners_args()
2828 
    args.write(self._oprot)
2829 
    self._oprot.writeMessageEnd()
2830 
    self._oprot.trans.flush()
2831 
 
2832 
  def recv_getAllBanners(self, ):
2833 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2834 
    if mtype == TMessageType.EXCEPTION:
2835 
      x = TApplicationException()
2836 
      x.read(self._iprot)
2837 
      self._iprot.readMessageEnd()
2838 
      raise x
2839 
    result = getAllBanners_result()
2840 
    result.read(self._iprot)
2841 
    self._iprot.readMessageEnd()
2842 
    if result.success is not None:
2843 
      return result.success
2844 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBanners failed: unknown result");
2845 
 
9155 kshitij.so 2846 
  def deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 2847 
    """
2848 
    Parameters:
2849 
     - bannerName
9155 kshitij.so 2850 
     - bannerType
6850 kshitij.so 2851 
    """
9155 kshitij.so 2852 
    self.send_deleteBanner(bannerName, bannerType)
6850 kshitij.so 2853 
    return self.recv_deleteBanner()
2854 
 
9155 kshitij.so 2855 
  def send_deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 2856 
    self._oprot.writeMessageBegin('deleteBanner', TMessageType.CALL, self._seqid)
2857 
    args = deleteBanner_args()
2858 
    args.bannerName = bannerName
9155 kshitij.so 2859 
    args.bannerType = bannerType
6850 kshitij.so 2860 
    args.write(self._oprot)
2861 
    self._oprot.writeMessageEnd()
2862 
    self._oprot.trans.flush()
2863 
 
2864 
  def recv_deleteBanner(self, ):
2865 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2866 
    if mtype == TMessageType.EXCEPTION:
2867 
      x = TApplicationException()
2868 
      x.read(self._iprot)
2869 
      self._iprot.readMessageEnd()
2870 
      raise x
2871 
    result = deleteBanner_result()
2872 
    result.read(self._iprot)
2873 
    self._iprot.readMessageEnd()
2874 
    if result.success is not None:
2875 
      return result.success
2876 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBanner failed: unknown result");
2877 
 
9155 kshitij.so 2878 
  def getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 2879 
    """
2880 
    Parameters:
2881 
     - bannerName
9155 kshitij.so 2882 
     - bannerType
6850 kshitij.so 2883 
    """
9155 kshitij.so 2884 
    self.send_getBannerDetails(bannerName, bannerType)
6850 kshitij.so 2885 
    return self.recv_getBannerDetails()
2886 
 
9155 kshitij.so 2887 
  def send_getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 2888 
    self._oprot.writeMessageBegin('getBannerDetails', TMessageType.CALL, self._seqid)
2889 
    args = getBannerDetails_args()
2890 
    args.bannerName = bannerName
9155 kshitij.so 2891 
    args.bannerType = bannerType
6850 kshitij.so 2892 
    args.write(self._oprot)
2893 
    self._oprot.writeMessageEnd()
2894 
    self._oprot.trans.flush()
2895 
 
2896 
  def recv_getBannerDetails(self, ):
2897 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2898 
    if mtype == TMessageType.EXCEPTION:
2899 
      x = TApplicationException()
2900 
      x.read(self._iprot)
2901 
      self._iprot.readMessageEnd()
2902 
      raise x
2903 
    result = getBannerDetails_result()
2904 
    result.read(self._iprot)
2905 
    self._iprot.readMessageEnd()
2906 
    if result.success is not None:
2907 
      return result.success
2908 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerDetails failed: unknown result");
2909 
 
2910 
  def getActiveBanners(self, ):
2911 
    self.send_getActiveBanners()
2912 
    return self.recv_getActiveBanners()
2913 
 
2914 
  def send_getActiveBanners(self, ):
2915 
    self._oprot.writeMessageBegin('getActiveBanners', TMessageType.CALL, self._seqid)
2916 
    args = getActiveBanners_args()
2917 
    args.write(self._oprot)
2918 
    self._oprot.writeMessageEnd()
2919 
    self._oprot.trans.flush()
2920 
 
2921 
  def recv_getActiveBanners(self, ):
2922 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2923 
    if mtype == TMessageType.EXCEPTION:
2924 
      x = TApplicationException()
2925 
      x.read(self._iprot)
2926 
      self._iprot.readMessageEnd()
2927 
      raise x
2928 
    result = getActiveBanners_result()
2929 
    result.read(self._iprot)
2930 
    self._iprot.readMessageEnd()
2931 
    if result.success is not None:
2932 
      return result.success
2933 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBanners failed: unknown result");
2934 
 
8579 kshitij.so 2935 
  def addBannerMap(self, bannerMaps):
6849 kshitij.so 2936 
    """
2937 
    Parameters:
8579 kshitij.so 2938 
     - bannerMaps
6849 kshitij.so 2939 
    """
8579 kshitij.so 2940 
    self.send_addBannerMap(bannerMaps)
6849 kshitij.so 2941 
    return self.recv_addBannerMap()
2942 
 
8579 kshitij.so 2943 
  def send_addBannerMap(self, bannerMaps):
6849 kshitij.so 2944 
    self._oprot.writeMessageBegin('addBannerMap', TMessageType.CALL, self._seqid)
2945 
    args = addBannerMap_args()
8579 kshitij.so 2946 
    args.bannerMaps = bannerMaps
6849 kshitij.so 2947 
    args.write(self._oprot)
2948 
    self._oprot.writeMessageEnd()
2949 
    self._oprot.trans.flush()
2950 
 
2951 
  def recv_addBannerMap(self, ):
2952 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2953 
    if mtype == TMessageType.EXCEPTION:
2954 
      x = TApplicationException()
2955 
      x.read(self._iprot)
2956 
      self._iprot.readMessageEnd()
2957 
      raise x
2958 
    result = addBannerMap_result()
2959 
    result.read(self._iprot)
2960 
    self._iprot.readMessageEnd()
2961 
    if result.success is not None:
2962 
      return result.success
2963 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBannerMap failed: unknown result");
2964 
 
8579 kshitij.so 2965 
  def updateBannerMap(self, bannerMap):
2966 
    """
2967 
    Parameters:
2968 
     - bannerMap
2969 
    """
2970 
    self.send_updateBannerMap(bannerMap)
2971 
    return self.recv_updateBannerMap()
2972 
 
2973 
  def send_updateBannerMap(self, bannerMap):
2974 
    self._oprot.writeMessageBegin('updateBannerMap', TMessageType.CALL, self._seqid)
2975 
    args = updateBannerMap_args()
2976 
    args.bannerMap = bannerMap
2977 
    args.write(self._oprot)
2978 
    self._oprot.writeMessageEnd()
2979 
    self._oprot.trans.flush()
2980 
 
2981 
  def recv_updateBannerMap(self, ):
2982 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2983 
    if mtype == TMessageType.EXCEPTION:
2984 
      x = TApplicationException()
2985 
      x.read(self._iprot)
2986 
      self._iprot.readMessageEnd()
2987 
      raise x
2988 
    result = updateBannerMap_result()
2989 
    result.read(self._iprot)
2990 
    self._iprot.readMessageEnd()
2991 
    if result.success is not None:
2992 
      return result.success
2993 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBannerMap failed: unknown result");
2994 
 
6849 kshitij.so 2995 
  def deleteBannerMap(self, bannerName):
2996 
    """
2997 
    Parameters:
2998 
     - bannerName
2999 
    """
3000 
    self.send_deleteBannerMap(bannerName)
3001 
    return self.recv_deleteBannerMap()
3002 
 
3003 
  def send_deleteBannerMap(self, bannerName):
3004 
    self._oprot.writeMessageBegin('deleteBannerMap', TMessageType.CALL, self._seqid)
3005 
    args = deleteBannerMap_args()
3006 
    args.bannerName = bannerName
3007 
    args.write(self._oprot)
3008 
    self._oprot.writeMessageEnd()
3009 
    self._oprot.trans.flush()
3010 
 
3011 
  def recv_deleteBannerMap(self, ):
3012 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3013 
    if mtype == TMessageType.EXCEPTION:
3014 
      x = TApplicationException()
3015 
      x.read(self._iprot)
3016 
      self._iprot.readMessageEnd()
3017 
      raise x
3018 
    result = deleteBannerMap_result()
3019 
    result.read(self._iprot)
3020 
    self._iprot.readMessageEnd()
3021 
    if result.success is not None:
3022 
      return result.success
3023 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBannerMap failed: unknown result");
3024 
 
9155 kshitij.so 3025 
  def getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 3026 
    """
3027 
    Parameters:
3028 
     - bannerName
9155 kshitij.so 3029 
     - bannerType
6849 kshitij.so 3030 
    """
9155 kshitij.so 3031 
    self.send_getBannerMapDetails(bannerName, bannerType)
6849 kshitij.so 3032 
    return self.recv_getBannerMapDetails()
3033 
 
9155 kshitij.so 3034 
  def send_getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 3035 
    self._oprot.writeMessageBegin('getBannerMapDetails', TMessageType.CALL, self._seqid)
3036 
    args = getBannerMapDetails_args()
3037 
    args.bannerName = bannerName
9155 kshitij.so 3038 
    args.bannerType = bannerType
6849 kshitij.so 3039 
    args.write(self._oprot)
3040 
    self._oprot.writeMessageEnd()
3041 
    self._oprot.trans.flush()
3042 
 
3043 
  def recv_getBannerMapDetails(self, ):
3044 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3045 
    if mtype == TMessageType.EXCEPTION:
3046 
      x = TApplicationException()
3047 
      x.read(self._iprot)
3048 
      self._iprot.readMessageEnd()
3049 
      raise x
3050 
    result = getBannerMapDetails_result()
3051 
    result.read(self._iprot)
3052 
    self._iprot.readMessageEnd()
3053 
    if result.success is not None:
3054 
      return result.success
3055 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerMapDetails failed: unknown result");
3056 
 
8579 kshitij.so 3057 
  def addBannerUri(self, bannerUriMappings):
3058 
    """
3059 
    Parameters:
3060 
     - bannerUriMappings
3061 
    """
3062 
    self.send_addBannerUri(bannerUriMappings)
3063 
    self.recv_addBannerUri()
3064 
 
3065 
  def send_addBannerUri(self, bannerUriMappings):
3066 
    self._oprot.writeMessageBegin('addBannerUri', TMessageType.CALL, self._seqid)
3067 
    args = addBannerUri_args()
3068 
    args.bannerUriMappings = bannerUriMappings
3069 
    args.write(self._oprot)
3070 
    self._oprot.writeMessageEnd()
3071 
    self._oprot.trans.flush()
3072 
 
3073 
  def recv_addBannerUri(self, ):
3074 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3075 
    if mtype == TMessageType.EXCEPTION:
3076 
      x = TApplicationException()
3077 
      x.read(self._iprot)
3078 
      self._iprot.readMessageEnd()
3079 
      raise x
3080 
    result = addBannerUri_result()
3081 
    result.read(self._iprot)
3082 
    self._iprot.readMessageEnd()
3083 
    return
3084 
 
9155 kshitij.so 3085 
  def getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 3086 
    """
3087 
    Parameters:
3088 
     - bannerName
9155 kshitij.so 3089 
     - bannerType
8579 kshitij.so 3090 
    """
9155 kshitij.so 3091 
    self.send_getUriMapping(bannerName, bannerType)
8579 kshitij.so 3092 
    return self.recv_getUriMapping()
3093 
 
9155 kshitij.so 3094 
  def send_getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 3095 
    self._oprot.writeMessageBegin('getUriMapping', TMessageType.CALL, self._seqid)
3096 
    args = getUriMapping_args()
3097 
    args.bannerName = bannerName
9155 kshitij.so 3098 
    args.bannerType = bannerType
8579 kshitij.so 3099 
    args.write(self._oprot)
3100 
    self._oprot.writeMessageEnd()
3101 
    self._oprot.trans.flush()
3102 
 
3103 
  def recv_getUriMapping(self, ):
3104 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3105 
    if mtype == TMessageType.EXCEPTION:
3106 
      x = TApplicationException()
3107 
      x.read(self._iprot)
3108 
      self._iprot.readMessageEnd()
3109 
      raise x
3110 
    result = getUriMapping_result()
3111 
    result.read(self._iprot)
3112 
    self._iprot.readMessageEnd()
3113 
    if result.success is not None:
3114 
      return result.success
3115 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUriMapping failed: unknown result");
3116 
 
3117 
  def addCampaign(self, campaign):
3118 
    """
3119 
    Parameters:
3120 
     - campaign
3121 
    """
3122 
    self.send_addCampaign(campaign)
3123 
    self.recv_addCampaign()
3124 
 
3125 
  def send_addCampaign(self, campaign):
3126 
    self._oprot.writeMessageBegin('addCampaign', TMessageType.CALL, self._seqid)
3127 
    args = addCampaign_args()
3128 
    args.campaign = campaign
3129 
    args.write(self._oprot)
3130 
    self._oprot.writeMessageEnd()
3131 
    self._oprot.trans.flush()
3132 
 
3133 
  def recv_addCampaign(self, ):
3134 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3135 
    if mtype == TMessageType.EXCEPTION:
3136 
      x = TApplicationException()
3137 
      x.read(self._iprot)
3138 
      self._iprot.readMessageEnd()
3139 
      raise x
3140 
    result = addCampaign_result()
3141 
    result.read(self._iprot)
3142 
    self._iprot.readMessageEnd()
3143 
    return
3144 
 
3145 
  def getCampaigns(self, campaignName):
3146 
    """
3147 
    Parameters:
3148 
     - campaignName
3149 
    """
3150 
    self.send_getCampaigns(campaignName)
3151 
    return self.recv_getCampaigns()
3152 
 
3153 
  def send_getCampaigns(self, campaignName):
3154 
    self._oprot.writeMessageBegin('getCampaigns', TMessageType.CALL, self._seqid)
3155 
    args = getCampaigns_args()
3156 
    args.campaignName = campaignName
3157 
    args.write(self._oprot)
3158 
    self._oprot.writeMessageEnd()
3159 
    self._oprot.trans.flush()
3160 
 
3161 
  def recv_getCampaigns(self, ):
3162 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3163 
    if mtype == TMessageType.EXCEPTION:
3164 
      x = TApplicationException()
3165 
      x.read(self._iprot)
3166 
      self._iprot.readMessageEnd()
3167 
      raise x
3168 
    result = getCampaigns_result()
3169 
    result.read(self._iprot)
3170 
    self._iprot.readMessageEnd()
3171 
    if result.success is not None:
3172 
      return result.success
3173 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCampaigns failed: unknown result");
3174 
 
3175 
  def deleteCampaign(self, campaignId):
3176 
    """
3177 
    Parameters:
3178 
     - campaignId
3179 
    """
3180 
    self.send_deleteCampaign(campaignId)
3181 
    self.recv_deleteCampaign()
3182 
 
3183 
  def send_deleteCampaign(self, campaignId):
3184 
    self._oprot.writeMessageBegin('deleteCampaign', TMessageType.CALL, self._seqid)
3185 
    args = deleteCampaign_args()
3186 
    args.campaignId = campaignId
3187 
    args.write(self._oprot)
3188 
    self._oprot.writeMessageEnd()
3189 
    self._oprot.trans.flush()
3190 
 
3191 
  def recv_deleteCampaign(self, ):
3192 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3193 
    if mtype == TMessageType.EXCEPTION:
3194 
      x = TApplicationException()
3195 
      x.read(self._iprot)
3196 
      self._iprot.readMessageEnd()
3197 
      raise x
3198 
    result = deleteCampaign_result()
3199 
    result.read(self._iprot)
3200 
    self._iprot.readMessageEnd()
3201 
    return
3202 
 
3203 
  def getAllCampaigns(self, ):
3204 
    self.send_getAllCampaigns()
3205 
    return self.recv_getAllCampaigns()
3206 
 
3207 
  def send_getAllCampaigns(self, ):
3208 
    self._oprot.writeMessageBegin('getAllCampaigns', TMessageType.CALL, self._seqid)
3209 
    args = getAllCampaigns_args()
3210 
    args.write(self._oprot)
3211 
    self._oprot.writeMessageEnd()
3212 
    self._oprot.trans.flush()
3213 
 
3214 
  def recv_getAllCampaigns(self, ):
3215 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3216 
    if mtype == TMessageType.EXCEPTION:
3217 
      x = TApplicationException()
3218 
      x.read(self._iprot)
3219 
      self._iprot.readMessageEnd()
3220 
      raise x
3221 
    result = getAllCampaigns_result()
3222 
    result.read(self._iprot)
3223 
    self._iprot.readMessageEnd()
3224 
    if result.success is not None:
3225 
      return result.success
3226 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCampaigns failed: unknown result");
3227 
 
9155 kshitij.so 3228 
  def getActiveBannersForMobileSite(self, ):
3229 
    self.send_getActiveBannersForMobileSite()
3230 
    return self.recv_getActiveBannersForMobileSite()
3231 
 
3232 
  def send_getActiveBannersForMobileSite(self, ):
3233 
    self._oprot.writeMessageBegin('getActiveBannersForMobileSite', TMessageType.CALL, self._seqid)
3234 
    args = getActiveBannersForMobileSite_args()
3235 
    args.write(self._oprot)
3236 
    self._oprot.writeMessageEnd()
3237 
    self._oprot.trans.flush()
3238 
 
3239 
  def recv_getActiveBannersForMobileSite(self, ):
3240 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3241 
    if mtype == TMessageType.EXCEPTION:
3242 
      x = TApplicationException()
3243 
      x.read(self._iprot)
3244 
      self._iprot.readMessageEnd()
3245 
      raise x
3246 
    result = getActiveBannersForMobileSite_result()
3247 
    result.read(self._iprot)
3248 
    self._iprot.readMessageEnd()
3249 
    if result.success is not None:
3250 
      return result.success
3251 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBannersForMobileSite failed: unknown result");
3252 
 
5944 mandeep.dh 3253 
  def deleteSimilarItem(self, itemId, catalogItemId):
3254 
    """
3255 
    Delete similar item.
3256 
 
3257 
    Parameters:
3258 
     - itemId
3259 
     - catalogItemId
3260 
    """
3261 
    self.send_deleteSimilarItem(itemId, catalogItemId)
3262 
    return self.recv_deleteSimilarItem()
3263 
 
3264 
  def send_deleteSimilarItem(self, itemId, catalogItemId):
3265 
    self._oprot.writeMessageBegin('deleteSimilarItem', TMessageType.CALL, self._seqid)
3266 
    args = deleteSimilarItem_args()
3267 
    args.itemId = itemId
3268 
    args.catalogItemId = catalogItemId
3269 
    args.write(self._oprot)
3270 
    self._oprot.writeMessageEnd()
3271 
    self._oprot.trans.flush()
3272 
 
3273 
  def recv_deleteSimilarItem(self, ):
3274 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3275 
    if mtype == TMessageType.EXCEPTION:
3276 
      x = TApplicationException()
3277 
      x.read(self._iprot)
3278 
      self._iprot.readMessageEnd()
3279 
      raise x
3280 
    result = deleteSimilarItem_result()
3281 
    result.read(self._iprot)
3282 
    self._iprot.readMessageEnd()
3283 
    if result.success is not None:
3284 
      return result.success
3285 
    if result.cex is not None:
3286 
      raise result.cex
3287 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteSimilarItem failed: unknown result");
3288 
 
3289 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
3290 
    """
3291 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
3292 
    If yes, returns the itemId else returns 0
3293 
 
3294 
    Parameters:
3295 
     - brand
3296 
     - modelNumber
3297 
     - modelName
3298 
     - color
3299 
    """
3300 
    self.send_checkSimilarItem(brand, modelNumber, modelName, color)
3301 
    return self.recv_checkSimilarItem()
3302 
 
3303 
  def send_checkSimilarItem(self, brand, modelNumber, modelName, color):
3304 
    self._oprot.writeMessageBegin('checkSimilarItem', TMessageType.CALL, self._seqid)
3305 
    args = checkSimilarItem_args()
3306 
    args.brand = brand
3307 
    args.modelNumber = modelNumber
3308 
    args.modelName = modelName
3309 
    args.color = color
3310 
    args.write(self._oprot)
3311 
    self._oprot.writeMessageEnd()
3312 
    self._oprot.trans.flush()
3313 
 
3314 
  def recv_checkSimilarItem(self, ):
3315 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3316 
    if mtype == TMessageType.EXCEPTION:
3317 
      x = TApplicationException()
3318 
      x.read(self._iprot)
3319 
      self._iprot.readMessageEnd()
3320 
      raise x
3321 
    result = checkSimilarItem_result()
3322 
    result.read(self._iprot)
3323 
    self._iprot.readMessageEnd()
3324 
    if result.success is not None:
3325 
      return result.success
3326 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkSimilarItem failed: unknown result");
3327 
 
3328 
  def validateRiskyStatus(self, itemId):
3329 
    """
3330 
    Check wether item is risky and change status if inventory is not available for risky items
3331 
 
3332 
    Parameters:
3333 
     - itemId
3334 
    """
3335 
    self.send_validateRiskyStatus(itemId)
3336 
    self.recv_validateRiskyStatus()
3337 
 
3338 
  def send_validateRiskyStatus(self, itemId):
3339 
    self._oprot.writeMessageBegin('validateRiskyStatus', TMessageType.CALL, self._seqid)
3340 
    args = validateRiskyStatus_args()
3341 
    args.itemId = itemId
3342 
    args.write(self._oprot)
3343 
    self._oprot.writeMessageEnd()
3344 
    self._oprot.trans.flush()
3345 
 
3346 
  def recv_validateRiskyStatus(self, ):
3347 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3348 
    if mtype == TMessageType.EXCEPTION:
3349 
      x = TApplicationException()
3350 
      x.read(self._iprot)
3351 
      self._iprot.readMessageEnd()
3352 
      raise x
3353 
    result = validateRiskyStatus_result()
3354 
    result.read(self._iprot)
3355 
    self._iprot.readMessageEnd()
3356 
    return
3357 
 
3358 
  def changeItemRiskyFlag(self, itemId, risky):
3359 
    """
3360 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
3361 
 
3362 
    Parameters:
3363 
     - itemId
3364 
     - risky
3365 
    """
3366 
    self.send_changeItemRiskyFlag(itemId, risky)
3367 
    self.recv_changeItemRiskyFlag()
3368 
 
3369 
  def send_changeItemRiskyFlag(self, itemId, risky):
3370 
    self._oprot.writeMessageBegin('changeItemRiskyFlag', TMessageType.CALL, self._seqid)
3371 
    args = changeItemRiskyFlag_args()
3372 
    args.itemId = itemId
3373 
    args.risky = risky
3374 
    args.write(self._oprot)
3375 
    self._oprot.writeMessageEnd()
3376 
    self._oprot.trans.flush()
3377 
 
3378 
  def recv_changeItemRiskyFlag(self, ):
3379 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3380 
    if mtype == TMessageType.EXCEPTION:
3381 
      x = TApplicationException()
3382 
      x.read(self._iprot)
3383 
      self._iprot.readMessageEnd()
3384 
      raise x
3385 
    result = changeItemRiskyFlag_result()
3386 
    result.read(self._iprot)
3387 
    self._iprot.readMessageEnd()
3388 
    return
3389 
 
3390 
  def getItemsByRiskyFlag(self, ):
3391 
    """
3392 
    Returns list of items marked as risky.
3393 
    """
3394 
    self.send_getItemsByRiskyFlag()
3395 
    return self.recv_getItemsByRiskyFlag()
3396 
 
3397 
  def send_getItemsByRiskyFlag(self, ):
3398 
    self._oprot.writeMessageBegin('getItemsByRiskyFlag', TMessageType.CALL, self._seqid)
3399 
    args = getItemsByRiskyFlag_args()
3400 
    args.write(self._oprot)
3401 
    self._oprot.writeMessageEnd()
3402 
    self._oprot.trans.flush()
3403 
 
3404 
  def recv_getItemsByRiskyFlag(self, ):
3405 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3406 
    if mtype == TMessageType.EXCEPTION:
3407 
      x = TApplicationException()
3408 
      x.read(self._iprot)
3409 
      self._iprot.readMessageEnd()
3410 
      raise x
3411 
    result = getItemsByRiskyFlag_result()
3412 
    result.read(self._iprot)
3413 
    self._iprot.readMessageEnd()
3414 
    if result.success is not None:
3415 
      return result.success
3416 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByRiskyFlag failed: unknown result");
3417 
 
3418 
  def getItemsForMasterSheet(self, category, brand):
3419 
    """
3420 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
3421 
 
3422 
    Parameters:
3423 
     - category
3424 
     - brand
3425 
    """
3426 
    self.send_getItemsForMasterSheet(category, brand)
3427 
    return self.recv_getItemsForMasterSheet()
3428 
 
3429 
  def send_getItemsForMasterSheet(self, category, brand):
3430 
    self._oprot.writeMessageBegin('getItemsForMasterSheet', TMessageType.CALL, self._seqid)
3431 
    args = getItemsForMasterSheet_args()
3432 
    args.category = category
3433 
    args.brand = brand
3434 
    args.write(self._oprot)
3435 
    self._oprot.writeMessageEnd()
3436 
    self._oprot.trans.flush()
3437 
 
3438 
  def recv_getItemsForMasterSheet(self, ):
3439 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3440 
    if mtype == TMessageType.EXCEPTION:
3441 
      x = TApplicationException()
3442 
      x.read(self._iprot)
3443 
      self._iprot.readMessageEnd()
3444 
      raise x
3445 
    result = getItemsForMasterSheet_result()
3446 
    result.read(self._iprot)
3447 
    self._iprot.readMessageEnd()
3448 
    if result.success is not None:
3449 
      return result.success
3450 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsForMasterSheet failed: unknown result");
3451 
 
3452 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
3453 
    """
3454 
    Returns list of catalog ids of items with same similarity index as of the given itemId
3455 
 
3456 
    Parameters:
3457 
     - beginIndex
3458 
     - totalItems
3459 
     - itemId
3460 
    """
3461 
    self.send_getSimilarItemsCatalogIds(beginIndex, totalItems, itemId)
3462 
    return self.recv_getSimilarItemsCatalogIds()
3463 
 
3464 
  def send_getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
3465 
    self._oprot.writeMessageBegin('getSimilarItemsCatalogIds', TMessageType.CALL, self._seqid)
3466 
    args = getSimilarItemsCatalogIds_args()
3467 
    args.beginIndex = beginIndex
3468 
    args.totalItems = totalItems
3469 
    args.itemId = itemId
3470 
    args.write(self._oprot)
3471 
    self._oprot.writeMessageEnd()
3472 
    self._oprot.trans.flush()
3473 
 
3474 
  def recv_getSimilarItemsCatalogIds(self, ):
3475 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3476 
    if mtype == TMessageType.EXCEPTION:
3477 
      x = TApplicationException()
3478 
      x.read(self._iprot)
3479 
      self._iprot.readMessageEnd()
3480 
      raise x
3481 
    result = getSimilarItemsCatalogIds_result()
3482 
    result.read(self._iprot)
3483 
    self._iprot.readMessageEnd()
3484 
    if result.success is not None:
3485 
      return result.success
3486 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSimilarItemsCatalogIds failed: unknown result");
3487 
 
3488 
  def addProductNotification(self, itemId, email):
3489 
    """
3490 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
3491 
 
3492 
    Parameters:
3493 
     - itemId
3494 
     - email
3495 
    """
3496 
    self.send_addProductNotification(itemId, email)
3497 
    return self.recv_addProductNotification()
3498 
 
3499 
  def send_addProductNotification(self, itemId, email):
3500 
    self._oprot.writeMessageBegin('addProductNotification', TMessageType.CALL, self._seqid)
3501 
    args = addProductNotification_args()
3502 
    args.itemId = itemId
3503 
    args.email = email
3504 
    args.write(self._oprot)
3505 
    self._oprot.writeMessageEnd()
3506 
    self._oprot.trans.flush()
3507 
 
3508 
  def recv_addProductNotification(self, ):
3509 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3510 
    if mtype == TMessageType.EXCEPTION:
3511 
      x = TApplicationException()
3512 
      x.read(self._iprot)
3513 
      self._iprot.readMessageEnd()
3514 
      raise x
3515 
    result = addProductNotification_result()
3516 
    result.read(self._iprot)
3517 
    self._iprot.readMessageEnd()
3518 
    if result.success is not None:
3519 
      return result.success
3520 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductNotification failed: unknown result");
3521 
 
3522 
  def sendProductNotifications(self, ):
3523 
    """
3524 
    Send the product notifications to the users for items which has stock.
3525 
    """
3526 
    self.send_sendProductNotifications()
3527 
    return self.recv_sendProductNotifications()
3528 
 
3529 
  def send_sendProductNotifications(self, ):
3530 
    self._oprot.writeMessageBegin('sendProductNotifications', TMessageType.CALL, self._seqid)
3531 
    args = sendProductNotifications_args()
3532 
    args.write(self._oprot)
3533 
    self._oprot.writeMessageEnd()
3534 
    self._oprot.trans.flush()
3535 
 
3536 
  def recv_sendProductNotifications(self, ):
3537 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3538 
    if mtype == TMessageType.EXCEPTION:
3539 
      x = TApplicationException()
3540 
      x.read(self._iprot)
3541 
      self._iprot.readMessageEnd()
3542 
      raise x
3543 
    result = sendProductNotifications_result()
3544 
    result.read(self._iprot)
3545 
    self._iprot.readMessageEnd()
3546 
    if result.success is not None:
3547 
      return result.success
3548 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendProductNotifications failed: unknown result");
3549 
 
3550 
  def getAllBrandsByCategory(self, categoryId):
3551 
    """
3552 
    Returns list of brand names for a given category Id
3553 
 
3554 
    Parameters:
3555 
     - categoryId
3556 
    """
3557 
    self.send_getAllBrandsByCategory(categoryId)
3558 
    return self.recv_getAllBrandsByCategory()
3559 
 
3560 
  def send_getAllBrandsByCategory(self, categoryId):
3561 
    self._oprot.writeMessageBegin('getAllBrandsByCategory', TMessageType.CALL, self._seqid)
3562 
    args = getAllBrandsByCategory_args()
3563 
    args.categoryId = categoryId
3564 
    args.write(self._oprot)
3565 
    self._oprot.writeMessageEnd()
3566 
    self._oprot.trans.flush()
3567 
 
3568 
  def recv_getAllBrandsByCategory(self, ):
3569 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3570 
    if mtype == TMessageType.EXCEPTION:
3571 
      x = TApplicationException()
3572 
      x.read(self._iprot)
3573 
      self._iprot.readMessageEnd()
3574 
      raise x
3575 
    result = getAllBrandsByCategory_result()
3576 
    result.read(self._iprot)
3577 
    self._iprot.readMessageEnd()
3578 
    if result.success is not None:
3579 
      return result.success
3580 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrandsByCategory failed: unknown result");
3581 
 
3582 
  def getAllBrands(self, ):
3583 
    """
3584 
    Returns list of brand names
3585 
    """
3586 
    self.send_getAllBrands()
3587 
    return self.recv_getAllBrands()
3588 
 
3589 
  def send_getAllBrands(self, ):
3590 
    self._oprot.writeMessageBegin('getAllBrands', TMessageType.CALL, self._seqid)
3591 
    args = getAllBrands_args()
3592 
    args.write(self._oprot)
3593 
    self._oprot.writeMessageEnd()
3594 
    self._oprot.trans.flush()
3595 
 
3596 
  def recv_getAllBrands(self, ):
3597 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3598 
    if mtype == TMessageType.EXCEPTION:
3599 
      x = TApplicationException()
3600 
      x.read(self._iprot)
3601 
      self._iprot.readMessageEnd()
3602 
      raise x
3603 
    result = getAllBrands_result()
3604 
    result.read(self._iprot)
3605 
    self._iprot.readMessageEnd()
3606 
    if result.success is not None:
3607 
      return result.success
3608 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrands failed: unknown result");
3609 
 
3610 
  def getAllSources(self, ):
3611 
    """
3612 
    Return list of all sources
3613 
    """
3614 
    self.send_getAllSources()
3615 
    return self.recv_getAllSources()
3616 
 
3617 
  def send_getAllSources(self, ):
3618 
    self._oprot.writeMessageBegin('getAllSources', TMessageType.CALL, self._seqid)
3619 
    args = getAllSources_args()
3620 
    args.write(self._oprot)
3621 
    self._oprot.writeMessageEnd()
3622 
    self._oprot.trans.flush()
3623 
 
3624 
  def recv_getAllSources(self, ):
3625 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3626 
    if mtype == TMessageType.EXCEPTION:
3627 
      x = TApplicationException()
3628 
      x.read(self._iprot)
3629 
      self._iprot.readMessageEnd()
3630 
      raise x
3631 
    result = getAllSources_result()
3632 
    result.read(self._iprot)
3633 
    self._iprot.readMessageEnd()
3634 
    if result.success is not None:
3635 
      return result.success
3636 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSources failed: unknown result");
3637 
 
3638 
  def getItemPricingBySource(self, itemId, sourceId):
3639 
    """
3640 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
3641 
 
3642 
    Parameters:
3643 
     - itemId
3644 
     - sourceId
3645 
    """
3646 
    self.send_getItemPricingBySource(itemId, sourceId)
3647 
    return self.recv_getItemPricingBySource()
3648 
 
3649 
  def send_getItemPricingBySource(self, itemId, sourceId):
3650 
    self._oprot.writeMessageBegin('getItemPricingBySource', TMessageType.CALL, self._seqid)
3651 
    args = getItemPricingBySource_args()
3652 
    args.itemId = itemId
3653 
    args.sourceId = sourceId
3654 
    args.write(self._oprot)
3655 
    self._oprot.writeMessageEnd()
3656 
    self._oprot.trans.flush()
3657 
 
3658 
  def recv_getItemPricingBySource(self, ):
3659 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3660 
    if mtype == TMessageType.EXCEPTION:
3661 
      x = TApplicationException()
3662 
      x.read(self._iprot)
3663 
      self._iprot.readMessageEnd()
3664 
      raise x
3665 
    result = getItemPricingBySource_result()
3666 
    result.read(self._iprot)
3667 
    self._iprot.readMessageEnd()
3668 
    if result.success is not None:
3669 
      return result.success
3670 
    if result.cex is not None:
3671 
      raise result.cex
3672 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricingBySource failed: unknown result");
3673 
 
3674 
  def addSourceItemPricing(self, sourceItemPricing):
3675 
    """
3676 
    Adds prices to be displayed corresponding to the item if user comes from a source.
3677 
    If item is not found or source is not found, it will throw exception.
3678 
 
3679 
    Parameters:
3680 
     - sourceItemPricing
3681 
    """
3682 
    self.send_addSourceItemPricing(sourceItemPricing)
3683 
    self.recv_addSourceItemPricing()
3684 
 
3685 
  def send_addSourceItemPricing(self, sourceItemPricing):
3686 
    self._oprot.writeMessageBegin('addSourceItemPricing', TMessageType.CALL, self._seqid)
3687 
    args = addSourceItemPricing_args()
3688 
    args.sourceItemPricing = sourceItemPricing
3689 
    args.write(self._oprot)
3690 
    self._oprot.writeMessageEnd()
3691 
    self._oprot.trans.flush()
3692 
 
3693 
  def recv_addSourceItemPricing(self, ):
3694 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3695 
    if mtype == TMessageType.EXCEPTION:
3696 
      x = TApplicationException()
3697 
      x.read(self._iprot)
3698 
      self._iprot.readMessageEnd()
3699 
      raise x
3700 
    result = addSourceItemPricing_result()
3701 
    result.read(self._iprot)
3702 
    self._iprot.readMessageEnd()
3703 
    if result.cex is not None:
3704 
      raise result.cex
3705 
    return
3706 
 
3707 
  def getAllSourcePricing(self, itemId):
3708 
    """
3709 
    Returns the list of source pricing information of an item.
3710 
    Raises an exception if item not found corresponding to itemId
3711 
 
3712 
    Parameters:
3713 
     - itemId
3714 
    """
3715 
    self.send_getAllSourcePricing(itemId)
3716 
    return self.recv_getAllSourcePricing()
3717 
 
3718 
  def send_getAllSourcePricing(self, itemId):
3719 
    self._oprot.writeMessageBegin('getAllSourcePricing', TMessageType.CALL, self._seqid)
3720 
    args = getAllSourcePricing_args()
3721 
    args.itemId = itemId
3722 
    args.write(self._oprot)
3723 
    self._oprot.writeMessageEnd()
3724 
    self._oprot.trans.flush()
3725 
 
3726 
  def recv_getAllSourcePricing(self, ):
3727 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3728 
    if mtype == TMessageType.EXCEPTION:
3729 
      x = TApplicationException()
3730 
      x.read(self._iprot)
3731 
      self._iprot.readMessageEnd()
3732 
      raise x
3733 
    result = getAllSourcePricing_result()
3734 
    result.read(self._iprot)
3735 
    self._iprot.readMessageEnd()
3736 
    if result.success is not None:
3737 
      return result.success
3738 
    if result.cex is not None:
3739 
      raise result.cex
3740 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSourcePricing failed: unknown result");
3741 
 
3742 
  def getItemForSource(self, item_id, sourceId):
3743 
    """
3744 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
3745 
 
3746 
    Parameters:
3747 
     - item_id
3748 
     - sourceId
3749 
    """
3750 
    self.send_getItemForSource(item_id, sourceId)
3751 
    return self.recv_getItemForSource()
3752 
 
3753 
  def send_getItemForSource(self, item_id, sourceId):
3754 
    self._oprot.writeMessageBegin('getItemForSource', TMessageType.CALL, self._seqid)
3755 
    args = getItemForSource_args()
3756 
    args.item_id = item_id
3757 
    args.sourceId = sourceId
3758 
    args.write(self._oprot)
3759 
    self._oprot.writeMessageEnd()
3760 
    self._oprot.trans.flush()
3761 
 
3762 
  def recv_getItemForSource(self, ):
3763 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3764 
    if mtype == TMessageType.EXCEPTION:
3765 
      x = TApplicationException()
3766 
      x.read(self._iprot)
3767 
      self._iprot.readMessageEnd()
3768 
      raise x
3769 
    result = getItemForSource_result()
3770 
    result.read(self._iprot)
3771 
    self._iprot.readMessageEnd()
3772 
    if result.success is not None:
3773 
      return result.success
3774 
    if result.cex is not None:
3775 
      raise result.cex
3776 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemForSource failed: unknown result");
3777 
 
3778 
  def searchItemsInRange(self, searchTerms, offset, limit):
3779 
    """
3780 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
3781 
 
3782 
    Parameters:
3783 
     - searchTerms
3784 
     - offset
3785 
     - limit
3786 
    """
3787 
    self.send_searchItemsInRange(searchTerms, offset, limit)
3788 
    return self.recv_searchItemsInRange()
3789 
 
3790 
  def send_searchItemsInRange(self, searchTerms, offset, limit):
3791 
    self._oprot.writeMessageBegin('searchItemsInRange', TMessageType.CALL, self._seqid)
3792 
    args = searchItemsInRange_args()
3793 
    args.searchTerms = searchTerms
3794 
    args.offset = offset
3795 
    args.limit = limit
3796 
    args.write(self._oprot)
3797 
    self._oprot.writeMessageEnd()
3798 
    self._oprot.trans.flush()
3799 
 
3800 
  def recv_searchItemsInRange(self, ):
3801 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3802 
    if mtype == TMessageType.EXCEPTION:
3803 
      x = TApplicationException()
3804 
      x.read(self._iprot)
3805 
      self._iprot.readMessageEnd()
3806 
      raise x
3807 
    result = searchItemsInRange_result()
3808 
    result.read(self._iprot)
3809 
    self._iprot.readMessageEnd()
3810 
    if result.success is not None:
3811 
      return result.success
3812 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchItemsInRange failed: unknown result");
3813 
 
3814 
  def getSearchResultCount(self, searchTerms):
3815 
    """
3816 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
3817 
 
3818 
    Parameters:
3819 
     - searchTerms
3820 
    """
3821 
    self.send_getSearchResultCount(searchTerms)
3822 
    return self.recv_getSearchResultCount()
3823 
 
3824 
  def send_getSearchResultCount(self, searchTerms):
3825 
    self._oprot.writeMessageBegin('getSearchResultCount', TMessageType.CALL, self._seqid)
3826 
    args = getSearchResultCount_args()
3827 
    args.searchTerms = searchTerms
3828 
    args.write(self._oprot)
3829 
    self._oprot.writeMessageEnd()
3830 
    self._oprot.trans.flush()
3831 
 
3832 
  def recv_getSearchResultCount(self, ):
3833 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3834 
    if mtype == TMessageType.EXCEPTION:
3835 
      x = TApplicationException()
3836 
      x.read(self._iprot)
3837 
      self._iprot.readMessageEnd()
3838 
      raise x
3839 
    result = getSearchResultCount_result()
3840 
    result.read(self._iprot)
3841 
    self._iprot.readMessageEnd()
3842 
    if result.success is not None:
3843 
      return result.success
3844 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSearchResultCount failed: unknown result");
3845 
 
3846 
  def getProductNotifications(self, startDateTime):
3847 
    """
3848 
    Returns a list of product notifications added after a supplied datetime
3849 
 
3850 
    Parameters:
3851 
     - startDateTime
3852 
    """
3853 
    self.send_getProductNotifications(startDateTime)
3854 
    return self.recv_getProductNotifications()
3855 
 
3856 
  def send_getProductNotifications(self, startDateTime):
3857 
    self._oprot.writeMessageBegin('getProductNotifications', TMessageType.CALL, self._seqid)
3858 
    args = getProductNotifications_args()
3859 
    args.startDateTime = startDateTime
3860 
    args.write(self._oprot)
3861 
    self._oprot.writeMessageEnd()
3862 
    self._oprot.trans.flush()
3863 
 
3864 
  def recv_getProductNotifications(self, ):
3865 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3866 
    if mtype == TMessageType.EXCEPTION:
3867 
      x = TApplicationException()
3868 
      x.read(self._iprot)
3869 
      self._iprot.readMessageEnd()
3870 
      raise x
3871 
    result = getProductNotifications_result()
3872 
    result.read(self._iprot)
3873 
    self._iprot.readMessageEnd()
3874 
    if result.success is not None:
3875 
      return result.success
3876 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotifications failed: unknown result");
3877 
 
7897 amar.kumar 3878 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3879 
    """
3880 
    Returns a list of count of requests for product notification against each item
3881 
 
3882 
    Parameters:
3883 
     - startDateTime
7897 amar.kumar 3884 
     - categoryId
5944 mandeep.dh 3885 
    """
7897 amar.kumar 3886 
    self.send_getProductNotificationRequestCount(startDateTime, categoryId)
5944 mandeep.dh 3887 
    return self.recv_getProductNotificationRequestCount()
3888 
 
7897 amar.kumar 3889 
  def send_getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3890 
    self._oprot.writeMessageBegin('getProductNotificationRequestCount', TMessageType.CALL, self._seqid)
3891 
    args = getProductNotificationRequestCount_args()
3892 
    args.startDateTime = startDateTime
7897 amar.kumar 3893 
    args.categoryId = categoryId
5944 mandeep.dh 3894 
    args.write(self._oprot)
3895 
    self._oprot.writeMessageEnd()
3896 
    self._oprot.trans.flush()
3897 
 
3898 
  def recv_getProductNotificationRequestCount(self, ):
3899 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3900 
    if mtype == TMessageType.EXCEPTION:
3901 
      x = TApplicationException()
3902 
      x.read(self._iprot)
3903 
      self._iprot.readMessageEnd()
3904 
      raise x
3905 
    result = getProductNotificationRequestCount_result()
3906 
    result.read(self._iprot)
3907 
    self._iprot.readMessageEnd()
3908 
    if result.success is not None:
3909 
      return result.success
3910 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotificationRequestCount failed: unknown result");
3911 
 
3912 
  def addAuthorizationLog(self, itemId, username, reason):
3913 
    """
3914 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
3915 
 
3916 
    Parameters:
3917 
     - itemId
3918 
     - username
3919 
     - reason
3920 
    """
3921 
    self.send_addAuthorizationLog(itemId, username, reason)
3922 
    return self.recv_addAuthorizationLog()
3923 
 
3924 
  def send_addAuthorizationLog(self, itemId, username, reason):
3925 
    self._oprot.writeMessageBegin('addAuthorizationLog', TMessageType.CALL, self._seqid)
3926 
    args = addAuthorizationLog_args()
3927 
    args.itemId = itemId
3928 
    args.username = username
3929 
    args.reason = reason
3930 
    args.write(self._oprot)
3931 
    self._oprot.writeMessageEnd()
3932 
    self._oprot.trans.flush()
3933 
 
3934 
  def recv_addAuthorizationLog(self, ):
3935 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3936 
    if mtype == TMessageType.EXCEPTION:
3937 
      x = TApplicationException()
3938 
      x.read(self._iprot)
3939 
      self._iprot.readMessageEnd()
3940 
      raise x
3941 
    result = addAuthorizationLog_result()
3942 
    result.read(self._iprot)
3943 
    self._iprot.readMessageEnd()
3944 
    if result.success is not None:
3945 
      return result.success
3946 
    if result.cex is not None:
3947 
      raise result.cex
3948 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAuthorizationLog failed: unknown result");
3949 
 
3950 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3951 
    """
3952 
    Parameters:
3953 
     - catalog_item_id
3954 
     - voucherType
3955 
     - voucherAmount
3956 
    """
3957 
    self.send_addupdateVoucherForItem(catalog_item_id, voucherType, voucherAmount)
3958 
    return self.recv_addupdateVoucherForItem()
3959 
 
3960 
  def send_addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3961 
    self._oprot.writeMessageBegin('addupdateVoucherForItem', TMessageType.CALL, self._seqid)
3962 
    args = addupdateVoucherForItem_args()
3963 
    args.catalog_item_id = catalog_item_id
3964 
    args.voucherType = voucherType
3965 
    args.voucherAmount = voucherAmount
3966 
    args.write(self._oprot)
3967 
    self._oprot.writeMessageEnd()
3968 
    self._oprot.trans.flush()
3969 
 
3970 
  def recv_addupdateVoucherForItem(self, ):
3971 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3972 
    if mtype == TMessageType.EXCEPTION:
3973 
      x = TApplicationException()
3974 
      x.read(self._iprot)
3975 
      self._iprot.readMessageEnd()
3976 
      raise x
3977 
    result = addupdateVoucherForItem_result()
3978 
    result.read(self._iprot)
3979 
    self._iprot.readMessageEnd()
3980 
    if result.success is not None:
3981 
      return result.success
3982 
    if result.cex is not None:
3983 
      raise result.cex
3984 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addupdateVoucherForItem failed: unknown result");
3985 
 
3986 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
3987 
    """
3988 
    Parameters:
3989 
     - catalog_item_id
3990 
     - voucherType
3991 
    """
3992 
    self.send_deleteVoucherForItem(catalog_item_id, voucherType)
3993 
    return self.recv_deleteVoucherForItem()
3994 
 
3995 
  def send_deleteVoucherForItem(self, catalog_item_id, voucherType):
3996 
    self._oprot.writeMessageBegin('deleteVoucherForItem', TMessageType.CALL, self._seqid)
3997 
    args = deleteVoucherForItem_args()
3998 
    args.catalog_item_id = catalog_item_id
3999 
    args.voucherType = voucherType
4000 
    args.write(self._oprot)
4001 
    self._oprot.writeMessageEnd()
4002 
    self._oprot.trans.flush()
4003 
 
4004 
  def recv_deleteVoucherForItem(self, ):
4005 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4006 
    if mtype == TMessageType.EXCEPTION:
4007 
      x = TApplicationException()
4008 
      x.read(self._iprot)
4009 
      self._iprot.readMessageEnd()
4010 
      raise x
4011 
    result = deleteVoucherForItem_result()
4012 
    result.read(self._iprot)
4013 
    self._iprot.readMessageEnd()
4014 
    if result.success is not None:
4015 
      return result.success
4016 
    if result.cex is not None:
4017 
      raise result.cex
4018 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteVoucherForItem failed: unknown result");
4019 
 
4020 
  def getVoucherAmount(self, itemId, voucherType):
4021 
    """
4022 
    Parameters:
4023 
     - itemId
4024 
     - voucherType
4025 
    """
4026 
    self.send_getVoucherAmount(itemId, voucherType)
4027 
    return self.recv_getVoucherAmount()
4028 
 
4029 
  def send_getVoucherAmount(self, itemId, voucherType):
4030 
    self._oprot.writeMessageBegin('getVoucherAmount', TMessageType.CALL, self._seqid)
4031 
    args = getVoucherAmount_args()
4032 
    args.itemId = itemId
4033 
    args.voucherType = voucherType
4034 
    args.write(self._oprot)
4035 
    self._oprot.writeMessageEnd()
4036 
    self._oprot.trans.flush()
4037 
 
4038 
  def recv_getVoucherAmount(self, ):
4039 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4040 
    if mtype == TMessageType.EXCEPTION:
4041 
      x = TApplicationException()
4042 
      x.read(self._iprot)
4043 
      self._iprot.readMessageEnd()
4044 
      raise x
4045 
    result = getVoucherAmount_result()
4046 
    result.read(self._iprot)
4047 
    self._iprot.readMessageEnd()
4048 
    if result.success is not None:
4049 
      return result.success
4050 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVoucherAmount failed: unknown result");
4051 
 
4052 
  def getAllItemVouchers(self, itemId):
4053 
    """
4054 
    Parameters:
4055 
     - itemId
4056 
    """
4057 
    self.send_getAllItemVouchers(itemId)
4058 
    return self.recv_getAllItemVouchers()
4059 
 
4060 
  def send_getAllItemVouchers(self, itemId):
4061 
    self._oprot.writeMessageBegin('getAllItemVouchers', TMessageType.CALL, self._seqid)
4062 
    args = getAllItemVouchers_args()
4063 
    args.itemId = itemId
4064 
    args.write(self._oprot)
4065 
    self._oprot.writeMessageEnd()
4066 
    self._oprot.trans.flush()
4067 
 
4068 
  def recv_getAllItemVouchers(self, ):
4069 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4070 
    if mtype == TMessageType.EXCEPTION:
4071 
      x = TApplicationException()
4072 
      x.read(self._iprot)
4073 
      self._iprot.readMessageEnd()
4074 
      raise x
4075 
    result = getAllItemVouchers_result()
4076 
    result.read(self._iprot)
4077 
    self._iprot.readMessageEnd()
4078 
    if result.success is not None:
4079 
      return result.success
4080 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemVouchers failed: unknown result");
4081 
 
4082 
  def isValidCatalogItemId(self, catalog_item_id):
4083 
    """
4084 
    Parameters:
4085 
     - catalog_item_id
4086 
    """
4087 
    self.send_isValidCatalogItemId(catalog_item_id)
4088 
    return self.recv_isValidCatalogItemId()
4089 
 
4090 
  def send_isValidCatalogItemId(self, catalog_item_id):
4091 
    self._oprot.writeMessageBegin('isValidCatalogItemId', TMessageType.CALL, self._seqid)
4092 
    args = isValidCatalogItemId_args()
4093 
    args.catalog_item_id = catalog_item_id
4094 
    args.write(self._oprot)
4095 
    self._oprot.writeMessageEnd()
4096 
    self._oprot.trans.flush()
4097 
 
4098 
  def recv_isValidCatalogItemId(self, ):
4099 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4100 
    if mtype == TMessageType.EXCEPTION:
4101 
      x = TApplicationException()
4102 
      x.read(self._iprot)
4103 
      self._iprot.readMessageEnd()
4104 
      raise x
4105 
    result = isValidCatalogItemId_result()
4106 
    result.read(self._iprot)
4107 
    self._iprot.readMessageEnd()
4108 
    if result.success is not None:
4109 
      return result.success
4110 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isValidCatalogItemId failed: unknown result");
4111 
 
7330 amit.gupta 4112 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 4113 
    """
4114 
    Parameters:
4115 
     - itemId
7330 amit.gupta 4116 
     - stateId
6039 amit.gupta 4117 
     - price
4118 
    """
7330 amit.gupta 4119 
    self.send_getVatPercentageForItem(itemId, stateId, price)
6039 amit.gupta 4120 
    return self.recv_getVatPercentageForItem()
5944 mandeep.dh 4121 
 
7330 amit.gupta 4122 
  def send_getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 4123 
    self._oprot.writeMessageBegin('getVatPercentageForItem', TMessageType.CALL, self._seqid)
4124 
    args = getVatPercentageForItem_args()
4125 
    args.itemId = itemId
7330 amit.gupta 4126 
    args.stateId = stateId
6039 amit.gupta 4127 
    args.price = price
4128 
    args.write(self._oprot)
4129 
    self._oprot.writeMessageEnd()
4130 
    self._oprot.trans.flush()
4131 
 
4132 
  def recv_getVatPercentageForItem(self, ):
4133 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4134 
    if mtype == TMessageType.EXCEPTION:
4135 
      x = TApplicationException()
4136 
      x.read(self._iprot)
4137 
      self._iprot.readMessageEnd()
4138 
      raise x
4139 
    result = getVatPercentageForItem_result()
4140 
    result.read(self._iprot)
4141 
    self._iprot.readMessageEnd()
4142 
    if result.success is not None:
4143 
      return result.success
7340 amit.gupta 4144 
    if result.cex is not None:
4145 
      raise result.cex
6039 amit.gupta 4146 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatPercentageForItem failed: unknown result");
4147 
 
4148 
  def getVatAmountForItem(self, itemId, price):
4149 
    """
4150 
    Parameters:
4151 
     - itemId
4152 
     - price
4153 
    """
4154 
    self.send_getVatAmountForItem(itemId, price)
4155 
    return self.recv_getVatAmountForItem()
4156 
 
4157 
  def send_getVatAmountForItem(self, itemId, price):
4158 
    self._oprot.writeMessageBegin('getVatAmountForItem', TMessageType.CALL, self._seqid)
4159 
    args = getVatAmountForItem_args()
4160 
    args.itemId = itemId
4161 
    args.price = price
4162 
    args.write(self._oprot)
4163 
    self._oprot.writeMessageEnd()
4164 
    self._oprot.trans.flush()
4165 
 
4166 
  def recv_getVatAmountForItem(self, ):
4167 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4168 
    if mtype == TMessageType.EXCEPTION:
4169 
      x = TApplicationException()
4170 
      x.read(self._iprot)
4171 
      self._iprot.readMessageEnd()
4172 
      raise x
4173 
    result = getVatAmountForItem_result()
4174 
    result.read(self._iprot)
4175 
    self._iprot.readMessageEnd()
4176 
    if result.success is not None:
4177 
      return result.success
4178 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatAmountForItem failed: unknown result");
4179 
 
6531 vikram.rag 4180 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
4181 
    """
4182 
    Parameters:
4183 
     - offset
4184 
     - limit
4185 
    """
4186 
    self.send_getAllIgnoredInventoryUpdateItemsList(offset, limit)
4187 
    return self.recv_getAllIgnoredInventoryUpdateItemsList()
6039 amit.gupta 4188 
 
6531 vikram.rag 4189 
  def send_getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
4190 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryUpdateItemsList', TMessageType.CALL, self._seqid)
4191 
    args = getAllIgnoredInventoryUpdateItemsList_args()
4192 
    args.offset = offset
4193 
    args.limit = limit
4194 
    args.write(self._oprot)
4195 
    self._oprot.writeMessageEnd()
4196 
    self._oprot.trans.flush()
4197 
 
4198 
  def recv_getAllIgnoredInventoryUpdateItemsList(self, ):
4199 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4200 
    if mtype == TMessageType.EXCEPTION:
4201 
      x = TApplicationException()
4202 
      x.read(self._iprot)
4203 
      self._iprot.readMessageEnd()
4204 
      raise x
4205 
    result = getAllIgnoredInventoryUpdateItemsList_result()
4206 
    result.read(self._iprot)
4207 
    self._iprot.readMessageEnd()
4208 
    if result.success is not None:
4209 
      return result.success
4210 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryUpdateItemsList failed: unknown result");
4211 
 
6821 amar.kumar 4212 
  def getAllAliveItems(self, ):
4213 
    self.send_getAllAliveItems()
4214 
    return self.recv_getAllAliveItems()
4215 
 
4216 
  def send_getAllAliveItems(self, ):
4217 
    self._oprot.writeMessageBegin('getAllAliveItems', TMessageType.CALL, self._seqid)
4218 
    args = getAllAliveItems_args()
4219 
    args.write(self._oprot)
4220 
    self._oprot.writeMessageEnd()
4221 
    self._oprot.trans.flush()
4222 
 
4223 
  def recv_getAllAliveItems(self, ):
4224 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4225 
    if mtype == TMessageType.EXCEPTION:
4226 
      x = TApplicationException()
4227 
      x.read(self._iprot)
4228 
      self._iprot.readMessageEnd()
4229 
      raise x
4230 
    result = getAllAliveItems_result()
4231 
    result.read(self._iprot)
4232 
    self._iprot.readMessageEnd()
4233 
    if result.success is not None:
4234 
      return result.success
4235 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAliveItems failed: unknown result");
4236 
 
6921 anupam.sin 4237 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 4238 
    """
4239 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 4240 
 
6805 anupam.sin 4241 
    Parameters:
4242 
     - itemId
6921 anupam.sin 4243 
     - price
6805 anupam.sin 4244 
     - insurerId
4245 
     - quantity
4246 
    """
6921 anupam.sin 4247 
    self.send_getInsuranceAmount(itemId, price, insurerId, quantity)
6805 anupam.sin 4248 
    return self.recv_getInsuranceAmount()
4249 
 
6921 anupam.sin 4250 
  def send_getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 4251 
    self._oprot.writeMessageBegin('getInsuranceAmount', TMessageType.CALL, self._seqid)
4252 
    args = getInsuranceAmount_args()
4253 
    args.itemId = itemId
6921 anupam.sin 4254 
    args.price = price
6805 anupam.sin 4255 
    args.insurerId = insurerId
4256 
    args.quantity = quantity
4257 
    args.write(self._oprot)
4258 
    self._oprot.writeMessageEnd()
4259 
    self._oprot.trans.flush()
4260 
 
4261 
  def recv_getInsuranceAmount(self, ):
4262 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4263 
    if mtype == TMessageType.EXCEPTION:
4264 
      x = TApplicationException()
4265 
      x.read(self._iprot)
4266 
      self._iprot.readMessageEnd()
4267 
      raise x
4268 
    result = getInsuranceAmount_result()
4269 
    result.read(self._iprot)
4270 
    self._iprot.readMessageEnd()
4271 
    if result.success is not None:
4272 
      return result.success
4273 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsuranceAmount failed: unknown result");
4274 
 
4275 
  def getInsurer(self, insurerId):
4276 
    """
4277 
    Parameters:
4278 
     - insurerId
4279 
    """
4280 
    self.send_getInsurer(insurerId)
4281 
    return self.recv_getInsurer()
4282 
 
4283 
  def send_getInsurer(self, insurerId):
4284 
    self._oprot.writeMessageBegin('getInsurer', TMessageType.CALL, self._seqid)
4285 
    args = getInsurer_args()
4286 
    args.insurerId = insurerId
4287 
    args.write(self._oprot)
4288 
    self._oprot.writeMessageEnd()
4289 
    self._oprot.trans.flush()
4290 
 
4291 
  def recv_getInsurer(self, ):
4292 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4293 
    if mtype == TMessageType.EXCEPTION:
4294 
      x = TApplicationException()
4295 
      x.read(self._iprot)
4296 
      self._iprot.readMessageEnd()
4297 
      raise x
4298 
    result = getInsurer_result()
4299 
    result.read(self._iprot)
4300 
    self._iprot.readMessageEnd()
4301 
    if result.success is not None:
4302 
      return result.success
4303 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsurer failed: unknown result");
4304 
 
6838 vikram.rag 4305 
  def getAllInsurers(self, ):
4306 
    self.send_getAllInsurers()
4307 
    return self.recv_getAllInsurers()
6805 anupam.sin 4308 
 
6838 vikram.rag 4309 
  def send_getAllInsurers(self, ):
4310 
    self._oprot.writeMessageBegin('getAllInsurers', TMessageType.CALL, self._seqid)
4311 
    args = getAllInsurers_args()
4312 
    args.write(self._oprot)
4313 
    self._oprot.writeMessageEnd()
4314 
    self._oprot.trans.flush()
4315 
 
4316 
  def recv_getAllInsurers(self, ):
4317 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4318 
    if mtype == TMessageType.EXCEPTION:
4319 
      x = TApplicationException()
4320 
      x.read(self._iprot)
4321 
      self._iprot.readMessageEnd()
4322 
      raise x
4323 
    result = getAllInsurers_result()
4324 
    result.read(self._iprot)
4325 
    self._iprot.readMessageEnd()
4326 
    if result.success is not None:
4327 
      return result.success
4328 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllInsurers failed: unknown result");
4329 
 
6962 rajveer 4330 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
4331 
    """
4332 
    Parameters:
4333 
     - insurerId
4334 
     - amount
4335 
    """
4336 
    self.send_updateInsuranceDeclaredAmount(insurerId, amount)
4337 
    self.recv_updateInsuranceDeclaredAmount()
6838 vikram.rag 4338 
 
6962 rajveer 4339 
  def send_updateInsuranceDeclaredAmount(self, insurerId, amount):
4340 
    self._oprot.writeMessageBegin('updateInsuranceDeclaredAmount', TMessageType.CALL, self._seqid)
4341 
    args = updateInsuranceDeclaredAmount_args()
4342 
    args.insurerId = insurerId
4343 
    args.amount = amount
4344 
    args.write(self._oprot)
4345 
    self._oprot.writeMessageEnd()
4346 
    self._oprot.trans.flush()
4347 
 
4348 
  def recv_updateInsuranceDeclaredAmount(self, ):
4349 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4350 
    if mtype == TMessageType.EXCEPTION:
4351 
      x = TApplicationException()
4352 
      x.read(self._iprot)
4353 
      self._iprot.readMessageEnd()
4354 
      raise x
4355 
    result = updateInsuranceDeclaredAmount_result()
4356 
    result.read(self._iprot)
4357 
    self._iprot.readMessageEnd()
4358 
    return
4359 
 
7190 amar.kumar 4360 
  def getFreebieForItem(self, itemId):
4361 
    """
4362 
    Parameters:
4363 
     - itemId
4364 
    """
4365 
    self.send_getFreebieForItem(itemId)
4366 
    return self.recv_getFreebieForItem()
6962 rajveer 4367 
 
7190 amar.kumar 4368 
  def send_getFreebieForItem(self, itemId):
4369 
    self._oprot.writeMessageBegin('getFreebieForItem', TMessageType.CALL, self._seqid)
4370 
    args = getFreebieForItem_args()
4371 
    args.itemId = itemId
4372 
    args.write(self._oprot)
4373 
    self._oprot.writeMessageEnd()
4374 
    self._oprot.trans.flush()
4375 
 
4376 
  def recv_getFreebieForItem(self, ):
4377 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4378 
    if mtype == TMessageType.EXCEPTION:
4379 
      x = TApplicationException()
4380 
      x.read(self._iprot)
4381 
      self._iprot.readMessageEnd()
4382 
      raise x
4383 
    result = getFreebieForItem_result()
4384 
    result.read(self._iprot)
4385 
    self._iprot.readMessageEnd()
4386 
    if result.success is not None:
4387 
      return result.success
4388 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFreebieForItem failed: unknown result");
4389 
 
4390 
  def addOrUpdateFreebieForItem(self, freebieItem):
4391 
    """
4392 
    Parameters:
4393 
     - freebieItem
4394 
    """
4395 
    self.send_addOrUpdateFreebieForItem(freebieItem)
4396 
    self.recv_addOrUpdateFreebieForItem()
4397 
 
4398 
  def send_addOrUpdateFreebieForItem(self, freebieItem):
4399 
    self._oprot.writeMessageBegin('addOrUpdateFreebieForItem', TMessageType.CALL, self._seqid)
4400 
    args = addOrUpdateFreebieForItem_args()
4401 
    args.freebieItem = freebieItem
4402 
    args.write(self._oprot)
4403 
    self._oprot.writeMessageEnd()
4404 
    self._oprot.trans.flush()
4405 
 
4406 
  def recv_addOrUpdateFreebieForItem(self, ):
4407 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4408 
    if mtype == TMessageType.EXCEPTION:
4409 
      x = TApplicationException()
4410 
      x.read(self._iprot)
4411 
      self._iprot.readMessageEnd()
4412 
      raise x
4413 
    result = addOrUpdateFreebieForItem_result()
4414 
    result.read(self._iprot)
4415 
    self._iprot.readMessageEnd()
4416 
    return
4417 
 
7272 amit.gupta 4418 
  def addOrUpdateBrandInfo(self, brandInfo):
4419 
    """
4420 
    Parameters:
4421 
     - brandInfo
4422 
    """
4423 
    self.send_addOrUpdateBrandInfo(brandInfo)
4424 
    self.recv_addOrUpdateBrandInfo()
4425 
 
4426 
  def send_addOrUpdateBrandInfo(self, brandInfo):
4427 
    self._oprot.writeMessageBegin('addOrUpdateBrandInfo', TMessageType.CALL, self._seqid)
4428 
    args = addOrUpdateBrandInfo_args()
4429 
    args.brandInfo = brandInfo
4430 
    args.write(self._oprot)
4431 
    self._oprot.writeMessageEnd()
4432 
    self._oprot.trans.flush()
4433 
 
4434 
  def recv_addOrUpdateBrandInfo(self, ):
4435 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4436 
    if mtype == TMessageType.EXCEPTION:
4437 
      x = TApplicationException()
4438 
      x.read(self._iprot)
4439 
      self._iprot.readMessageEnd()
4440 
      raise x
4441 
    result = addOrUpdateBrandInfo_result()
4442 
    result.read(self._iprot)
4443 
    self._iprot.readMessageEnd()
4444 
    return
4445 
 
4446 
  def getBrandInfo(self, ):
4447 
    self.send_getBrandInfo()
4448 
    return self.recv_getBrandInfo()
4449 
 
4450 
  def send_getBrandInfo(self, ):
4451 
    self._oprot.writeMessageBegin('getBrandInfo', TMessageType.CALL, self._seqid)
4452 
    args = getBrandInfo_args()
4453 
    args.write(self._oprot)
4454 
    self._oprot.writeMessageEnd()
4455 
    self._oprot.trans.flush()
4456 
 
4457 
  def recv_getBrandInfo(self, ):
4458 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4459 
    if mtype == TMessageType.EXCEPTION:
4460 
      x = TApplicationException()
4461 
      x.read(self._iprot)
4462 
      self._iprot.readMessageEnd()
4463 
      raise x
4464 
    result = getBrandInfo_result()
4465 
    result.read(self._iprot)
4466 
    self._iprot.readMessageEnd()
4467 
    if result.success is not None:
4468 
      return result.success
4469 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrandInfo failed: unknown result");
4470 
 
7256 rajveer 4471 
  def getStorePricing(self, itemId):
4472 
    """
4473 
    Parameters:
4474 
     - itemId
4475 
    """
4476 
    self.send_getStorePricing(itemId)
4477 
    return self.recv_getStorePricing()
7190 amar.kumar 4478 
 
7256 rajveer 4479 
  def send_getStorePricing(self, itemId):
4480 
    self._oprot.writeMessageBegin('getStorePricing', TMessageType.CALL, self._seqid)
4481 
    args = getStorePricing_args()
4482 
    args.itemId = itemId
4483 
    args.write(self._oprot)
4484 
    self._oprot.writeMessageEnd()
4485 
    self._oprot.trans.flush()
4486 
 
4487 
  def recv_getStorePricing(self, ):
4488 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4489 
    if mtype == TMessageType.EXCEPTION:
4490 
      x = TApplicationException()
4491 
      x.read(self._iprot)
4492 
      self._iprot.readMessageEnd()
4493 
      raise x
4494 
    result = getStorePricing_result()
4495 
    result.read(self._iprot)
4496 
    self._iprot.readMessageEnd()
4497 
    if result.success is not None:
4498 
      return result.success
4499 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricing failed: unknown result");
4500 
 
7306 rajveer 4501 
  def getStorePricings(self, itemIds):
4502 
    """
4503 
    Parameters:
4504 
     - itemIds
4505 
    """
4506 
    self.send_getStorePricings(itemIds)
4507 
    return self.recv_getStorePricings()
4508 
 
4509 
  def send_getStorePricings(self, itemIds):
4510 
    self._oprot.writeMessageBegin('getStorePricings', TMessageType.CALL, self._seqid)
4511 
    args = getStorePricings_args()
4512 
    args.itemIds = itemIds
4513 
    args.write(self._oprot)
4514 
    self._oprot.writeMessageEnd()
4515 
    self._oprot.trans.flush()
4516 
 
4517 
  def recv_getStorePricings(self, ):
4518 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4519 
    if mtype == TMessageType.EXCEPTION:
4520 
      x = TApplicationException()
4521 
      x.read(self._iprot)
4522 
      self._iprot.readMessageEnd()
4523 
      raise x
4524 
    result = getStorePricings_result()
4525 
    result.read(self._iprot)
4526 
    self._iprot.readMessageEnd()
4527 
    if result.success is not None:
4528 
      return result.success
4529 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricings failed: unknown result");
4530 
 
7382 rajveer 4531 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 4532 
    """
4533 
    Parameters:
4534 
     - sp
7382 rajveer 4535 
     - allColors
7265 rajveer 4536 
    """
7382 rajveer 4537 
    self.send_updateStorePricing(sp, allColors)
7265 rajveer 4538 
    self.recv_updateStorePricing()
7256 rajveer 4539 
 
7382 rajveer 4540 
  def send_updateStorePricing(self, sp, allColors):
7265 rajveer 4541 
    self._oprot.writeMessageBegin('updateStorePricing', TMessageType.CALL, self._seqid)
4542 
    args = updateStorePricing_args()
4543 
    args.sp = sp
7382 rajveer 4544 
    args.allColors = allColors
7265 rajveer 4545 
    args.write(self._oprot)
4546 
    self._oprot.writeMessageEnd()
4547 
    self._oprot.trans.flush()
4548 
 
4549 
  def recv_updateStorePricing(self, ):
4550 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4551 
    if mtype == TMessageType.EXCEPTION:
4552 
      x = TApplicationException()
4553 
      x.read(self._iprot)
4554 
      self._iprot.readMessageEnd()
4555 
      raise x
4556 
    result = updateStorePricing_result()
4557 
    result.read(self._iprot)
4558 
    self._iprot.readMessageEnd()
4559 
    return
4560 
 
7281 kshitij.so 4561 
  def getAllAmazonListedItems(self, ):
4562 
    self.send_getAllAmazonListedItems()
4563 
    return self.recv_getAllAmazonListedItems()
7265 rajveer 4564 
 
7281 kshitij.so 4565 
  def send_getAllAmazonListedItems(self, ):
4566 
    self._oprot.writeMessageBegin('getAllAmazonListedItems', TMessageType.CALL, self._seqid)
4567 
    args = getAllAmazonListedItems_args()
4568 
    args.write(self._oprot)
4569 
    self._oprot.writeMessageEnd()
4570 
    self._oprot.trans.flush()
4571 
 
4572 
  def recv_getAllAmazonListedItems(self, ):
4573 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4574 
    if mtype == TMessageType.EXCEPTION:
4575 
      x = TApplicationException()
4576 
      x.read(self._iprot)
4577 
      self._iprot.readMessageEnd()
4578 
      raise x
4579 
    result = getAllAmazonListedItems_result()
4580 
    result.read(self._iprot)
4581 
    self._iprot.readMessageEnd()
4582 
    if result.success is not None:
4583 
      return result.success
4584 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonListedItems failed: unknown result");
4585 
 
8619 kshitij.so 4586 
  def searchAmazonItems(self, searchTerm, offset, limit):
4587 
    """
4588 
    Parameters:
4589 
     - searchTerm
4590 
     - offset
4591 
     - limit
4592 
    """
4593 
    self.send_searchAmazonItems(searchTerm, offset, limit)
4594 
    return self.recv_searchAmazonItems()
4595 
 
4596 
  def send_searchAmazonItems(self, searchTerm, offset, limit):
4597 
    self._oprot.writeMessageBegin('searchAmazonItems', TMessageType.CALL, self._seqid)
4598 
    args = searchAmazonItems_args()
4599 
    args.searchTerm = searchTerm
4600 
    args.offset = offset
4601 
    args.limit = limit
4602 
    args.write(self._oprot)
4603 
    self._oprot.writeMessageEnd()
4604 
    self._oprot.trans.flush()
4605 
 
4606 
  def recv_searchAmazonItems(self, ):
4607 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4608 
    if mtype == TMessageType.EXCEPTION:
4609 
      x = TApplicationException()
4610 
      x.read(self._iprot)
4611 
      self._iprot.readMessageEnd()
4612 
      raise x
4613 
    result = searchAmazonItems_result()
4614 
    result.read(self._iprot)
4615 
    self._iprot.readMessageEnd()
4616 
    if result.success is not None:
4617 
      return result.success
4618 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchAmazonItems failed: unknown result");
4619 
 
4620 
  def getAmazonSearchResultCount(self, searchTerm):
4621 
    """
4622 
    Parameters:
4623 
     - searchTerm
4624 
    """
4625 
    self.send_getAmazonSearchResultCount(searchTerm)
4626 
    return self.recv_getAmazonSearchResultCount()
4627 
 
4628 
  def send_getAmazonSearchResultCount(self, searchTerm):
4629 
    self._oprot.writeMessageBegin('getAmazonSearchResultCount', TMessageType.CALL, self._seqid)
4630 
    args = getAmazonSearchResultCount_args()
4631 
    args.searchTerm = searchTerm
4632 
    args.write(self._oprot)
4633 
    self._oprot.writeMessageEnd()
4634 
    self._oprot.trans.flush()
4635 
 
4636 
  def recv_getAmazonSearchResultCount(self, ):
4637 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4638 
    if mtype == TMessageType.EXCEPTION:
4639 
      x = TApplicationException()
4640 
      x.read(self._iprot)
4641 
      self._iprot.readMessageEnd()
4642 
      raise x
4643 
    result = getAmazonSearchResultCount_result()
4644 
    result.read(self._iprot)
4645 
    self._iprot.readMessageEnd()
4646 
    if result.success is not None:
4647 
      return result.success
4648 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonSearchResultCount failed: unknown result");
4649 
 
4650 
  def getCountForAmazonlistedItems(self, ):
4651 
    self.send_getCountForAmazonlistedItems()
4652 
    return self.recv_getCountForAmazonlistedItems()
4653 
 
4654 
  def send_getCountForAmazonlistedItems(self, ):
4655 
    self._oprot.writeMessageBegin('getCountForAmazonlistedItems', TMessageType.CALL, self._seqid)
4656 
    args = getCountForAmazonlistedItems_args()
4657 
    args.write(self._oprot)
4658 
    self._oprot.writeMessageEnd()
4659 
    self._oprot.trans.flush()
4660 
 
4661 
  def recv_getCountForAmazonlistedItems(self, ):
4662 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4663 
    if mtype == TMessageType.EXCEPTION:
4664 
      x = TApplicationException()
4665 
      x.read(self._iprot)
4666 
      self._iprot.readMessageEnd()
4667 
      raise x
4668 
    result = getCountForAmazonlistedItems_result()
4669 
    result.read(self._iprot)
4670 
    self._iprot.readMessageEnd()
4671 
    if result.success is not None:
4672 
      return result.success
4673 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForAmazonlistedItems failed: unknown result");
4674 
 
7281 kshitij.so 4675 
  def getAmazonItemDetails(self, itemId):
4676 
    """
4677 
    Parameters:
4678 
     - itemId
4679 
    """
4680 
    self.send_getAmazonItemDetails(itemId)
4681 
    return self.recv_getAmazonItemDetails()
4682 
 
4683 
  def send_getAmazonItemDetails(self, itemId):
4684 
    self._oprot.writeMessageBegin('getAmazonItemDetails', TMessageType.CALL, self._seqid)
4685 
    args = getAmazonItemDetails_args()
4686 
    args.itemId = itemId
4687 
    args.write(self._oprot)
4688 
    self._oprot.writeMessageEnd()
4689 
    self._oprot.trans.flush()
4690 
 
4691 
  def recv_getAmazonItemDetails(self, ):
4692 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4693 
    if mtype == TMessageType.EXCEPTION:
4694 
      x = TApplicationException()
4695 
      x.read(self._iprot)
4696 
      self._iprot.readMessageEnd()
4697 
      raise x
4698 
    result = getAmazonItemDetails_result()
4699 
    result.read(self._iprot)
4700 
    self._iprot.readMessageEnd()
4701 
    if result.success is not None:
4702 
      return result.success
4703 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonItemDetails failed: unknown result");
4704 
 
8168 kshitij.so 4705 
  def updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4706 
    """
4707 
    Parameters:
8168 kshitij.so 4708 
     - amazonlisted
7281 kshitij.so 4709 
    """
8168 kshitij.so 4710 
    self.send_updateAmazonItemDetails(amazonlisted)
7281 kshitij.so 4711 
    self.recv_updateAmazonItemDetails()
4712 
 
8168 kshitij.so 4713 
  def send_updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4714 
    self._oprot.writeMessageBegin('updateAmazonItemDetails', TMessageType.CALL, self._seqid)
4715 
    args = updateAmazonItemDetails_args()
8168 kshitij.so 4716 
    args.amazonlisted = amazonlisted
7281 kshitij.so 4717 
    args.write(self._oprot)
4718 
    self._oprot.writeMessageEnd()
4719 
    self._oprot.trans.flush()
4720 
 
4721 
  def recv_updateAmazonItemDetails(self, ):
4722 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4723 
    if mtype == TMessageType.EXCEPTION:
4724 
      x = TApplicationException()
4725 
      x.read(self._iprot)
4726 
      self._iprot.readMessageEnd()
4727 
      raise x
4728 
    result = updateAmazonItemDetails_result()
4729 
    result.read(self._iprot)
4730 
    self._iprot.readMessageEnd()
4731 
    return
4732 
 
4733 
  def addAmazonItem(self, amazonlisted):
4734 
    """
4735 
    Parameters:
4736 
     - amazonlisted
4737 
    """
4738 
    self.send_addAmazonItem(amazonlisted)
4739 
    self.recv_addAmazonItem()
4740 
 
4741 
  def send_addAmazonItem(self, amazonlisted):
4742 
    self._oprot.writeMessageBegin('addAmazonItem', TMessageType.CALL, self._seqid)
4743 
    args = addAmazonItem_args()
4744 
    args.amazonlisted = amazonlisted
4745 
    args.write(self._oprot)
4746 
    self._oprot.writeMessageEnd()
4747 
    self._oprot.trans.flush()
4748 
 
4749 
  def recv_addAmazonItem(self, ):
4750 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4751 
    if mtype == TMessageType.EXCEPTION:
4752 
      x = TApplicationException()
4753 
      x.read(self._iprot)
4754 
      self._iprot.readMessageEnd()
4755 
      raise x
4756 
    result = addAmazonItem_result()
4757 
    result.read(self._iprot)
4758 
    self._iprot.readMessageEnd()
4759 
    return
4760 
 
7291 vikram.rag 4761 
  def getAsinItems(self, ):
4762 
    self.send_getAsinItems()
4763 
    return self.recv_getAsinItems()
7281 kshitij.so 4764 
 
7291 vikram.rag 4765 
  def send_getAsinItems(self, ):
4766 
    self._oprot.writeMessageBegin('getAsinItems', TMessageType.CALL, self._seqid)
4767 
    args = getAsinItems_args()
4768 
    args.write(self._oprot)
4769 
    self._oprot.writeMessageEnd()
4770 
    self._oprot.trans.flush()
4771 
 
4772 
  def recv_getAsinItems(self, ):
4773 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4774 
    if mtype == TMessageType.EXCEPTION:
4775 
      x = TApplicationException()
4776 
      x.read(self._iprot)
4777 
      self._iprot.readMessageEnd()
4778 
      raise x
4779 
    result = getAsinItems_result()
4780 
    result.read(self._iprot)
4781 
    self._iprot.readMessageEnd()
4782 
    if result.success is not None:
4783 
      return result.success
4784 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAsinItems failed: unknown result");
4785 
 
4786 
  def getAllFbaListedItems(self, ):
4787 
    self.send_getAllFbaListedItems()
4788 
    return self.recv_getAllFbaListedItems()
4789 
 
4790 
  def send_getAllFbaListedItems(self, ):
4791 
    self._oprot.writeMessageBegin('getAllFbaListedItems', TMessageType.CALL, self._seqid)
4792 
    args = getAllFbaListedItems_args()
4793 
    args.write(self._oprot)
4794 
    self._oprot.writeMessageEnd()
4795 
    self._oprot.trans.flush()
4796 
 
4797 
  def recv_getAllFbaListedItems(self, ):
4798 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4799 
    if mtype == TMessageType.EXCEPTION:
4800 
      x = TApplicationException()
4801 
      x.read(self._iprot)
4802 
      self._iprot.readMessageEnd()
4803 
      raise x
4804 
    result = getAllFbaListedItems_result()
4805 
    result.read(self._iprot)
4806 
    self._iprot.readMessageEnd()
4807 
    if result.success is not None:
4808 
      return result.success
4809 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbaListedItems failed: unknown result");
4810 
 
4811 
  def getAllNonFbaListedItems(self, ):
4812 
    self.send_getAllNonFbaListedItems()
4813 
    return self.recv_getAllNonFbaListedItems()
4814 
 
4815 
  def send_getAllNonFbaListedItems(self, ):
4816 
    self._oprot.writeMessageBegin('getAllNonFbaListedItems', TMessageType.CALL, self._seqid)
4817 
    args = getAllNonFbaListedItems_args()
4818 
    args.write(self._oprot)
4819 
    self._oprot.writeMessageEnd()
4820 
    self._oprot.trans.flush()
4821 
 
4822 
  def recv_getAllNonFbaListedItems(self, ):
4823 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4824 
    if mtype == TMessageType.EXCEPTION:
4825 
      x = TApplicationException()
4826 
      x.read(self._iprot)
4827 
      self._iprot.readMessageEnd()
4828 
      raise x
4829 
    result = getAllNonFbaListedItems_result()
4830 
    result.read(self._iprot)
4831 
    self._iprot.readMessageEnd()
4832 
    if result.success is not None:
4833 
      return result.success
4834 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllNonFbaListedItems failed: unknown result");
4835 
 
7460 kshitij.so 4836 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
4837 
    """
4838 
    Parameters:
4839 
     - itemId
4840 
     - holdInventory
4841 
     - defaultInventory
4842 
    """
4843 
    self.send_updateItemInventory(itemId, holdInventory, defaultInventory)
4844 
    return self.recv_updateItemInventory()
7291 vikram.rag 4845 
 
7460 kshitij.so 4846 
  def send_updateItemInventory(self, itemId, holdInventory, defaultInventory):
4847 
    self._oprot.writeMessageBegin('updateItemInventory', TMessageType.CALL, self._seqid)
4848 
    args = updateItemInventory_args()
4849 
    args.itemId = itemId
4850 
    args.holdInventory = holdInventory
4851 
    args.defaultInventory = defaultInventory
4852 
    args.write(self._oprot)
4853 
    self._oprot.writeMessageEnd()
4854 
    self._oprot.trans.flush()
4855 
 
4856 
  def recv_updateItemInventory(self, ):
4857 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4858 
    if mtype == TMessageType.EXCEPTION:
4859 
      x = TApplicationException()
4860 
      x.read(self._iprot)
4861 
      self._iprot.readMessageEnd()
4862 
      raise x
4863 
    result = updateItemInventory_result()
4864 
    result.read(self._iprot)
4865 
    self._iprot.readMessageEnd()
4866 
    if result.success is not None:
4867 
      return result.success
4868 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItemInventory failed: unknown result");
4869 
 
7770 kshitij.so 4870 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4871 
    """
4872 
    Parameters:
4873 
     - type
4874 
     - sku
4875 
     - timestamp
4876 
    """
4877 
    self.send_updateTimestampForAmazonFeeds(type, sku, timestamp)
4878 
    return self.recv_updateTimestampForAmazonFeeds()
7460 kshitij.so 4879 
 
7770 kshitij.so 4880 
  def send_updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4881 
    self._oprot.writeMessageBegin('updateTimestampForAmazonFeeds', TMessageType.CALL, self._seqid)
4882 
    args = updateTimestampForAmazonFeeds_args()
4883 
    args.type = type
4884 
    args.sku = sku
4885 
    args.timestamp = timestamp
4886 
    args.write(self._oprot)
4887 
    self._oprot.writeMessageEnd()
4888 
    self._oprot.trans.flush()
4889 
 
4890 
  def recv_updateTimestampForAmazonFeeds(self, ):
4891 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4892 
    if mtype == TMessageType.EXCEPTION:
4893 
      x = TApplicationException()
4894 
      x.read(self._iprot)
4895 
      self._iprot.readMessageEnd()
4896 
      raise x
4897 
    result = updateTimestampForAmazonFeeds_result()
4898 
    result.read(self._iprot)
4899 
    self._iprot.readMessageEnd()
4900 
    if result.success is not None:
4901 
      return result.success
4902 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateTimestampForAmazonFeeds failed: unknown result");
4903 
 
7897 amar.kumar 4904 
  def getAllParentCategories(self, ):
4905 
    self.send_getAllParentCategories()
4906 
    return self.recv_getAllParentCategories()
7770 kshitij.so 4907 
 
7897 amar.kumar 4908 
  def send_getAllParentCategories(self, ):
4909 
    self._oprot.writeMessageBegin('getAllParentCategories', TMessageType.CALL, self._seqid)
4910 
    args = getAllParentCategories_args()
4911 
    args.write(self._oprot)
4912 
    self._oprot.writeMessageEnd()
4913 
    self._oprot.trans.flush()
4914 
 
4915 
  def recv_getAllParentCategories(self, ):
4916 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4917 
    if mtype == TMessageType.EXCEPTION:
4918 
      x = TApplicationException()
4919 
      x.read(self._iprot)
4920 
      self._iprot.readMessageEnd()
4921 
      raise x
4922 
    result = getAllParentCategories_result()
4923 
    result.read(self._iprot)
4924 
    self._iprot.readMessageEnd()
4925 
    if result.success is not None:
4926 
      return result.success
4927 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllParentCategories failed: unknown result");
4928 
 
7977 kshitij.so 4929 
  def addPageViewEvent(self, pageViewEvents):
4930 
    """
4931 
    Parameters:
4932 
     - pageViewEvents
4933 
    """
4934 
    self.send_addPageViewEvent(pageViewEvents)
4935 
    self.recv_addPageViewEvent()
7897 amar.kumar 4936 
 
7977 kshitij.so 4937 
  def send_addPageViewEvent(self, pageViewEvents):
4938 
    self._oprot.writeMessageBegin('addPageViewEvent', TMessageType.CALL, self._seqid)
4939 
    args = addPageViewEvent_args()
4940 
    args.pageViewEvents = pageViewEvents
4941 
    args.write(self._oprot)
4942 
    self._oprot.writeMessageEnd()
4943 
    self._oprot.trans.flush()
4944 
 
4945 
  def recv_addPageViewEvent(self, ):
4946 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4947 
    if mtype == TMessageType.EXCEPTION:
4948 
      x = TApplicationException()
4949 
      x.read(self._iprot)
4950 
      self._iprot.readMessageEnd()
4951 
      raise x
4952 
    result = addPageViewEvent_result()
4953 
    result.read(self._iprot)
4954 
    self._iprot.readMessageEnd()
4955 
    return
4956 
 
4957 
  def addCartEvent(self, cartEvents):
4958 
    """
4959 
    Parameters:
4960 
     - cartEvents
4961 
    """
4962 
    self.send_addCartEvent(cartEvents)
4963 
    self.recv_addCartEvent()
4964 
 
4965 
  def send_addCartEvent(self, cartEvents):
4966 
    self._oprot.writeMessageBegin('addCartEvent', TMessageType.CALL, self._seqid)
4967 
    args = addCartEvent_args()
4968 
    args.cartEvents = cartEvents
4969 
    args.write(self._oprot)
4970 
    self._oprot.writeMessageEnd()
4971 
    self._oprot.trans.flush()
4972 
 
4973 
  def recv_addCartEvent(self, ):
4974 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4975 
    if mtype == TMessageType.EXCEPTION:
4976 
      x = TApplicationException()
4977 
      x.read(self._iprot)
4978 
      self._iprot.readMessageEnd()
4979 
      raise x
4980 
    result = addCartEvent_result()
4981 
    result.read(self._iprot)
4982 
    self._iprot.readMessageEnd()
4983 
    return
4984 
 
8182 amar.kumar 4985 
  def addEbayItem(self, ebayItem):
4986 
    """
4987 
    Parameters:
4988 
     - ebayItem
4989 
    """
4990 
    self.send_addEbayItem(ebayItem)
4991 
    self.recv_addEbayItem()
4992 
 
4993 
  def send_addEbayItem(self, ebayItem):
4994 
    self._oprot.writeMessageBegin('addEbayItem', TMessageType.CALL, self._seqid)
4995 
    args = addEbayItem_args()
4996 
    args.ebayItem = ebayItem
4997 
    args.write(self._oprot)
4998 
    self._oprot.writeMessageEnd()
4999 
    self._oprot.trans.flush()
5000 
 
5001 
  def recv_addEbayItem(self, ):
5002 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5003 
    if mtype == TMessageType.EXCEPTION:
5004 
      x = TApplicationException()
5005 
      x.read(self._iprot)
5006 
      self._iprot.readMessageEnd()
5007 
      raise x
5008 
    result = addEbayItem_result()
5009 
    result.read(self._iprot)
5010 
    self._iprot.readMessageEnd()
5011 
    return
5012 
 
5013 
  def getEbayItem(self, listingId):
5014 
    """
5015 
    Parameters:
5016 
     - listingId
5017 
    """
5018 
    self.send_getEbayItem(listingId)
5019 
    return self.recv_getEbayItem()
5020 
 
5021 
  def send_getEbayItem(self, listingId):
5022 
    self._oprot.writeMessageBegin('getEbayItem', TMessageType.CALL, self._seqid)
5023 
    args = getEbayItem_args()
5024 
    args.listingId = listingId
5025 
    args.write(self._oprot)
5026 
    self._oprot.writeMessageEnd()
5027 
    self._oprot.trans.flush()
5028 
 
5029 
  def recv_getEbayItem(self, ):
5030 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5031 
    if mtype == TMessageType.EXCEPTION:
5032 
      x = TApplicationException()
5033 
      x.read(self._iprot)
5034 
      self._iprot.readMessageEnd()
5035 
      raise x
5036 
    result = getEbayItem_result()
5037 
    result.read(self._iprot)
5038 
    self._iprot.readMessageEnd()
5039 
    if result.success is not None:
5040 
      return result.success
5041 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEbayItem failed: unknown result");
5042 
 
5043 
  def updateEbayItem(self, ebayItem):
5044 
    """
5045 
    Parameters:
5046 
     - ebayItem
5047 
    """
5048 
    self.send_updateEbayItem(ebayItem)
5049 
    self.recv_updateEbayItem()
5050 
 
5051 
  def send_updateEbayItem(self, ebayItem):
5052 
    self._oprot.writeMessageBegin('updateEbayItem', TMessageType.CALL, self._seqid)
5053 
    args = updateEbayItem_args()
5054 
    args.ebayItem = ebayItem
5055 
    args.write(self._oprot)
5056 
    self._oprot.writeMessageEnd()
5057 
    self._oprot.trans.flush()
5058 
 
5059 
  def recv_updateEbayItem(self, ):
5060 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5061 
    if mtype == TMessageType.EXCEPTION:
5062 
      x = TApplicationException()
5063 
      x.read(self._iprot)
5064 
      self._iprot.readMessageEnd()
5065 
      raise x
5066 
    result = updateEbayItem_result()
5067 
    result.read(self._iprot)
5068 
    self._iprot.readMessageEnd()
5069 
    return
5070 
 
8139 kshitij.so 5071 
  def getAmazonListedItems(self, offset, limit):
5072 
    """
5073 
    Parameters:
5074 
     - offset
5075 
     - limit
5076 
    """
5077 
    self.send_getAmazonListedItems(offset, limit)
5078 
    return self.recv_getAmazonListedItems()
7977 kshitij.so 5079 
 
8139 kshitij.so 5080 
  def send_getAmazonListedItems(self, offset, limit):
5081 
    self._oprot.writeMessageBegin('getAmazonListedItems', TMessageType.CALL, self._seqid)
5082 
    args = getAmazonListedItems_args()
5083 
    args.offset = offset
5084 
    args.limit = limit
5085 
    args.write(self._oprot)
5086 
    self._oprot.writeMessageEnd()
5087 
    self._oprot.trans.flush()
5088 
 
5089 
  def recv_getAmazonListedItems(self, ):
5090 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5091 
    if mtype == TMessageType.EXCEPTION:
5092 
      x = TApplicationException()
5093 
      x.read(self._iprot)
5094 
      self._iprot.readMessageEnd()
5095 
      raise x
5096 
    result = getAmazonListedItems_result()
5097 
    result.read(self._iprot)
5098 
    self._iprot.readMessageEnd()
5099 
    if result.success is not None:
5100 
      return result.success
5101 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonListedItems failed: unknown result");
5102 
 
8168 kshitij.so 5103 
  def updateAmazonAttributesInBulk(self, amazonlisted):
5104 
    """
5105 
    Parameters:
5106 
     - amazonlisted
5107 
    """
5108 
    self.send_updateAmazonAttributesInBulk(amazonlisted)
5109 
    return self.recv_updateAmazonAttributesInBulk()
8139 kshitij.so 5110 
 
8168 kshitij.so 5111 
  def send_updateAmazonAttributesInBulk(self, amazonlisted):
5112 
    self._oprot.writeMessageBegin('updateAmazonAttributesInBulk', TMessageType.CALL, self._seqid)
5113 
    args = updateAmazonAttributesInBulk_args()
5114 
    args.amazonlisted = amazonlisted
5115 
    args.write(self._oprot)
5116 
    self._oprot.writeMessageEnd()
5117 
    self._oprot.trans.flush()
5118 
 
5119 
  def recv_updateAmazonAttributesInBulk(self, ):
5120 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5121 
    if mtype == TMessageType.EXCEPTION:
5122 
      x = TApplicationException()
5123 
      x.read(self._iprot)
5124 
      self._iprot.readMessageEnd()
5125 
      raise x
5126 
    result = updateAmazonAttributesInBulk_result()
5127 
    result.read(self._iprot)
5128 
    self._iprot.readMessageEnd()
5129 
    if result.success is not None:
5130 
      return result.success
5131 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateAmazonAttributesInBulk failed: unknown result");
5132 
 
8379 vikram.rag 5133 
  def getAllItemstoListOnFba(self, ):
5134 
    self.send_getAllItemstoListOnFba()
5135 
    return self.recv_getAllItemstoListOnFba()
8168 kshitij.so 5136 
 
8379 vikram.rag 5137 
  def send_getAllItemstoListOnFba(self, ):
5138 
    self._oprot.writeMessageBegin('getAllItemstoListOnFba', TMessageType.CALL, self._seqid)
5139 
    args = getAllItemstoListOnFba_args()
5140 
    args.write(self._oprot)
5141 
    self._oprot.writeMessageEnd()
5142 
    self._oprot.trans.flush()
5143 
 
5144 
  def recv_getAllItemstoListOnFba(self, ):
5145 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5146 
    if mtype == TMessageType.EXCEPTION:
5147 
      x = TApplicationException()
5148 
      x.read(self._iprot)
5149 
      self._iprot.readMessageEnd()
5150 
      raise x
5151 
    result = getAllItemstoListOnFba_result()
5152 
    result.read(self._iprot)
5153 
    self._iprot.readMessageEnd()
5154 
    if result.success is not None:
5155 
      return result.success
5156 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnFba failed: unknown result");
5157 
 
5158 
  def getAllItemstoListOnNonFba(self, ):
5159 
    self.send_getAllItemstoListOnNonFba()
5160 
    return self.recv_getAllItemstoListOnNonFba()
5161 
 
5162 
  def send_getAllItemstoListOnNonFba(self, ):
5163 
    self._oprot.writeMessageBegin('getAllItemstoListOnNonFba', TMessageType.CALL, self._seqid)
5164 
    args = getAllItemstoListOnNonFba_args()
5165 
    args.write(self._oprot)
5166 
    self._oprot.writeMessageEnd()
5167 
    self._oprot.trans.flush()
5168 
 
5169 
  def recv_getAllItemstoListOnNonFba(self, ):
5170 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5171 
    if mtype == TMessageType.EXCEPTION:
5172 
      x = TApplicationException()
5173 
      x.read(self._iprot)
5174 
      self._iprot.readMessageEnd()
5175 
      raise x
5176 
    result = getAllItemstoListOnNonFba_result()
5177 
    result.read(self._iprot)
5178 
    self._iprot.readMessageEnd()
5179 
    if result.success is not None:
5180 
      return result.success
5181 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnNonFba failed: unknown result");
5182 
 
8619 kshitij.so 5183 
  def updateAsin(self, item):
5184 
    """
5185 
    Parameters:
5186 
     - item
5187 
    """
5188 
    self.send_updateAsin(item)
5189 
    self.recv_updateAsin()
8616 vikram.rag 5190 
 
8619 kshitij.so 5191 
  def send_updateAsin(self, item):
5192 
    self._oprot.writeMessageBegin('updateAsin', TMessageType.CALL, self._seqid)
5193 
    args = updateAsin_args()
5194 
    args.item = item
5195 
    args.write(self._oprot)
5196 
    self._oprot.writeMessageEnd()
5197 
    self._oprot.trans.flush()
5198 
 
5199 
  def recv_updateAsin(self, ):
5200 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5201 
    if mtype == TMessageType.EXCEPTION:
5202 
      x = TApplicationException()
5203 
      x.read(self._iprot)
5204 
      self._iprot.readMessageEnd()
5205 
      raise x
5206 
    result = updateAsin_result()
5207 
    result.read(self._iprot)
5208 
    self._iprot.readMessageEnd()
5209 
    return
5210 
 
8739 vikram.rag 5211 
  def addOrUpdateSnapdealItem(self, snapdealitem):
5212 
    """
5213 
    Parameters:
5214 
     - snapdealitem
5215 
    """
5216 
    self.send_addOrUpdateSnapdealItem(snapdealitem)
5217 
    return self.recv_addOrUpdateSnapdealItem()
8619 kshitij.so 5218 
 
8739 vikram.rag 5219 
  def send_addOrUpdateSnapdealItem(self, snapdealitem):
5220 
    self._oprot.writeMessageBegin('addOrUpdateSnapdealItem', TMessageType.CALL, self._seqid)
5221 
    args = addOrUpdateSnapdealItem_args()
5222 
    args.snapdealitem = snapdealitem
5223 
    args.write(self._oprot)
5224 
    self._oprot.writeMessageEnd()
5225 
    self._oprot.trans.flush()
5226 
 
5227 
  def recv_addOrUpdateSnapdealItem(self, ):
5228 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5229 
    if mtype == TMessageType.EXCEPTION:
5230 
      x = TApplicationException()
5231 
      x.read(self._iprot)
5232 
      self._iprot.readMessageEnd()
5233 
      raise x
5234 
    result = addOrUpdateSnapdealItem_result()
5235 
    result.read(self._iprot)
5236 
    self._iprot.readMessageEnd()
5237 
    if result.success is not None:
5238 
      return result.success
5239 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addOrUpdateSnapdealItem failed: unknown result");
5240 
 
5241 
  def getSnapdealItem(self, item_id):
5242 
    """
5243 
    Parameters:
5244 
     - item_id
5245 
    """
5246 
    self.send_getSnapdealItem(item_id)
5247 
    return self.recv_getSnapdealItem()
5248 
 
5249 
  def send_getSnapdealItem(self, item_id):
5250 
    self._oprot.writeMessageBegin('getSnapdealItem', TMessageType.CALL, self._seqid)
5251 
    args = getSnapdealItem_args()
5252 
    args.item_id = item_id
5253 
    args.write(self._oprot)
5254 
    self._oprot.writeMessageEnd()
5255 
    self._oprot.trans.flush()
5256 
 
5257 
  def recv_getSnapdealItem(self, ):
5258 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5259 
    if mtype == TMessageType.EXCEPTION:
5260 
      x = TApplicationException()
5261 
      x.read(self._iprot)
5262 
      self._iprot.readMessageEnd()
5263 
      raise x
5264 
    result = getSnapdealItem_result()
5265 
    result.read(self._iprot)
5266 
    self._iprot.readMessageEnd()
5267 
    if result.success is not None:
5268 
      return result.success
5269 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItem failed: unknown result");
5270 
 
9242 kshitij.so 5271 
  def getSnapdealItemDetails(self, item_id):
5272 
    """
5273 
    Parameters:
5274 
     - item_id
5275 
    """
5276 
    self.send_getSnapdealItemDetails(item_id)
5277 
    return self.recv_getSnapdealItemDetails()
5278 
 
5279 
  def send_getSnapdealItemDetails(self, item_id):
5280 
    self._oprot.writeMessageBegin('getSnapdealItemDetails', TMessageType.CALL, self._seqid)
5281 
    args = getSnapdealItemDetails_args()
5282 
    args.item_id = item_id
5283 
    args.write(self._oprot)
5284 
    self._oprot.writeMessageEnd()
5285 
    self._oprot.trans.flush()
5286 
 
5287 
  def recv_getSnapdealItemDetails(self, ):
5288 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5289 
    if mtype == TMessageType.EXCEPTION:
5290 
      x = TApplicationException()
5291 
      x.read(self._iprot)
5292 
      self._iprot.readMessageEnd()
5293 
      raise x
5294 
    result = getSnapdealItemDetails_result()
5295 
    result.read(self._iprot)
5296 
    self._iprot.readMessageEnd()
5297 
    if result.success is not None:
5298 
      return result.success
5299 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItemDetails failed: unknown result");
5300 
 
8739 vikram.rag 5301 
  def getAllSnapdealItems(self, ):
5302 
    self.send_getAllSnapdealItems()
5303 
    return self.recv_getAllSnapdealItems()
5304 
 
5305 
  def send_getAllSnapdealItems(self, ):
5306 
    self._oprot.writeMessageBegin('getAllSnapdealItems', TMessageType.CALL, self._seqid)
5307 
    args = getAllSnapdealItems_args()
5308 
    args.write(self._oprot)
5309 
    self._oprot.writeMessageEnd()
5310 
    self._oprot.trans.flush()
5311 
 
5312 
  def recv_getAllSnapdealItems(self, ):
5313 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5314 
    if mtype == TMessageType.EXCEPTION:
5315 
      x = TApplicationException()
5316 
      x.read(self._iprot)
5317 
      self._iprot.readMessageEnd()
5318 
      raise x
5319 
    result = getAllSnapdealItems_result()
5320 
    result.read(self._iprot)
5321 
    self._iprot.readMessageEnd()
5322 
    if result.success is not None:
5323 
      return result.success
5324 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSnapdealItems failed: unknown result");
5325 
 
9242 kshitij.so 5326 
  def getSnapdealItems(self, offset, limit):
5327 
    """
5328 
    Parameters:
5329 
     - offset
5330 
     - limit
5331 
    """
5332 
    self.send_getSnapdealItems(offset, limit)
5333 
    return self.recv_getSnapdealItems()
8739 vikram.rag 5334 
 
9242 kshitij.so 5335 
  def send_getSnapdealItems(self, offset, limit):
5336 
    self._oprot.writeMessageBegin('getSnapdealItems', TMessageType.CALL, self._seqid)
5337 
    args = getSnapdealItems_args()
5338 
    args.offset = offset
5339 
    args.limit = limit
5340 
    args.write(self._oprot)
5341 
    self._oprot.writeMessageEnd()
5342 
    self._oprot.trans.flush()
5343 
 
5344 
  def recv_getSnapdealItems(self, ):
5345 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5346 
    if mtype == TMessageType.EXCEPTION:
5347 
      x = TApplicationException()
5348 
      x.read(self._iprot)
5349 
      self._iprot.readMessageEnd()
5350 
      raise x
5351 
    result = getSnapdealItems_result()
5352 
    result.read(self._iprot)
5353 
    self._iprot.readMessageEnd()
5354 
    if result.success is not None:
5355 
      return result.success
5356 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItems failed: unknown result");
5357 
 
5358 
  def searchSnapdealItems(self, searchTerm, offset, limit):
5359 
    """
5360 
    Parameters:
5361 
     - searchTerm
5362 
     - offset
5363 
     - limit
5364 
    """
5365 
    self.send_searchSnapdealItems(searchTerm, offset, limit)
5366 
    return self.recv_searchSnapdealItems()
5367 
 
5368 
  def send_searchSnapdealItems(self, searchTerm, offset, limit):
5369 
    self._oprot.writeMessageBegin('searchSnapdealItems', TMessageType.CALL, self._seqid)
5370 
    args = searchSnapdealItems_args()
5371 
    args.searchTerm = searchTerm
5372 
    args.offset = offset
5373 
    args.limit = limit
5374 
    args.write(self._oprot)
5375 
    self._oprot.writeMessageEnd()
5376 
    self._oprot.trans.flush()
5377 
 
5378 
  def recv_searchSnapdealItems(self, ):
5379 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5380 
    if mtype == TMessageType.EXCEPTION:
5381 
      x = TApplicationException()
5382 
      x.read(self._iprot)
5383 
      self._iprot.readMessageEnd()
5384 
      raise x
5385 
    result = searchSnapdealItems_result()
5386 
    result.read(self._iprot)
5387 
    self._iprot.readMessageEnd()
5388 
    if result.success is not None:
5389 
      return result.success
5390 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchSnapdealItems failed: unknown result");
5391 
 
5392 
  def getCountForSnapdealItems(self, ):
5393 
    self.send_getCountForSnapdealItems()
5394 
    return self.recv_getCountForSnapdealItems()
5395 
 
5396 
  def send_getCountForSnapdealItems(self, ):
5397 
    self._oprot.writeMessageBegin('getCountForSnapdealItems', TMessageType.CALL, self._seqid)
5398 
    args = getCountForSnapdealItems_args()
5399 
    args.write(self._oprot)
5400 
    self._oprot.writeMessageEnd()
5401 
    self._oprot.trans.flush()
5402 
 
5403 
  def recv_getCountForSnapdealItems(self, ):
5404 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5405 
    if mtype == TMessageType.EXCEPTION:
5406 
      x = TApplicationException()
5407 
      x.read(self._iprot)
5408 
      self._iprot.readMessageEnd()
5409 
      raise x
5410 
    result = getCountForSnapdealItems_result()
5411 
    result.read(self._iprot)
5412 
    self._iprot.readMessageEnd()
5413 
    if result.success is not None:
5414 
      return result.success
5415 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForSnapdealItems failed: unknown result");
5416 
 
5417 
  def getSnapdealSearchResultCount(self, searchTerm):
5418 
    """
5419 
    Parameters:
5420 
     - searchTerm
5421 
    """
5422 
    self.send_getSnapdealSearchResultCount(searchTerm)
5423 
    return self.recv_getSnapdealSearchResultCount()
5424 
 
5425 
  def send_getSnapdealSearchResultCount(self, searchTerm):
5426 
    self._oprot.writeMessageBegin('getSnapdealSearchResultCount', TMessageType.CALL, self._seqid)
5427 
    args = getSnapdealSearchResultCount_args()
5428 
    args.searchTerm = searchTerm
5429 
    args.write(self._oprot)
5430 
    self._oprot.writeMessageEnd()
5431 
    self._oprot.trans.flush()
5432 
 
5433 
  def recv_getSnapdealSearchResultCount(self, ):
5434 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5435 
    if mtype == TMessageType.EXCEPTION:
5436 
      x = TApplicationException()
5437 
      x.read(self._iprot)
5438 
      self._iprot.readMessageEnd()
5439 
      raise x
5440 
    result = getSnapdealSearchResultCount_result()
5441 
    result.read(self._iprot)
5442 
    self._iprot.readMessageEnd()
5443 
    if result.success is not None:
5444 
      return result.success
5445 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealSearchResultCount failed: unknown result");
5446 
 
9299 kshitij.so 5447 
  def getPrefferedInsurerForItem(self, itemId, insurerType):
5448 
    """
5449 
    Parameters:
5450 
     - itemId
5451 
     - insurerType
5452 
    """
5453 
    self.send_getPrefferedInsurerForItem(itemId, insurerType)
5454 
    return self.recv_getPrefferedInsurerForItem()
9242 kshitij.so 5455 
 
9299 kshitij.so 5456 
  def send_getPrefferedInsurerForItem(self, itemId, insurerType):
5457 
    self._oprot.writeMessageBegin('getPrefferedInsurerForItem', TMessageType.CALL, self._seqid)
5458 
    args = getPrefferedInsurerForItem_args()
5459 
    args.itemId = itemId
5460 
    args.insurerType = insurerType
5461 
    args.write(self._oprot)
5462 
    self._oprot.writeMessageEnd()
5463 
    self._oprot.trans.flush()
5464 
 
5465 
  def recv_getPrefferedInsurerForItem(self, ):
5466 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5467 
    if mtype == TMessageType.EXCEPTION:
5468 
      x = TApplicationException()
5469 
      x.read(self._iprot)
5470 
      self._iprot.readMessageEnd()
5471 
      raise x
5472 
    result = getPrefferedInsurerForItem_result()
5473 
    result.read(self._iprot)
5474 
    self._iprot.readMessageEnd()
5475 
    if result.success is not None:
5476 
      return result.success
5477 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrefferedInsurerForItem failed: unknown result");
5478 
 
9456 vikram.rag 5479 
  def getSnapdealItembySkuAtSnapdeal(self, skuAtSnapdeal):
5480 
    """
5481 
    Parameters:
5482 
     - skuAtSnapdeal
5483 
    """
5484 
    self.send_getSnapdealItembySkuAtSnapdeal(skuAtSnapdeal)
5485 
    return self.recv_getSnapdealItembySkuAtSnapdeal()
9299 kshitij.so 5486 
 
9456 vikram.rag 5487 
  def send_getSnapdealItembySkuAtSnapdeal(self, skuAtSnapdeal):
5488 
    self._oprot.writeMessageBegin('getSnapdealItembySkuAtSnapdeal', TMessageType.CALL, self._seqid)
5489 
    args = getSnapdealItembySkuAtSnapdeal_args()
5490 
    args.skuAtSnapdeal = skuAtSnapdeal
5491 
    args.write(self._oprot)
5492 
    self._oprot.writeMessageEnd()
5493 
    self._oprot.trans.flush()
5494 
 
5495 
  def recv_getSnapdealItembySkuAtSnapdeal(self, ):
5496 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5497 
    if mtype == TMessageType.EXCEPTION:
5498 
      x = TApplicationException()
5499 
      x.read(self._iprot)
5500 
      self._iprot.readMessageEnd()
5501 
      raise x
5502 
    result = getSnapdealItembySkuAtSnapdeal_result()
5503 
    result.read(self._iprot)
5504 
    self._iprot.readMessageEnd()
5505 
    if result.success is not None:
5506 
      return result.success
5507 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItembySkuAtSnapdeal failed: unknown result");
5508 
 
9621 manish.sha 5509 
  def getProductFeedSubmit(self, catalogItemId):
5510 
    """
5511 
    Parameters:
5512 
     - catalogItemId
5513 
    """
5514 
    self.send_getProductFeedSubmit(catalogItemId)
5515 
    return self.recv_getProductFeedSubmit()
9456 vikram.rag 5516 
 
9621 manish.sha 5517 
  def send_getProductFeedSubmit(self, catalogItemId):
5518 
    self._oprot.writeMessageBegin('getProductFeedSubmit', TMessageType.CALL, self._seqid)
5519 
    args = getProductFeedSubmit_args()
5520 
    args.catalogItemId = catalogItemId
5521 
    args.write(self._oprot)
5522 
    self._oprot.writeMessageEnd()
5523 
    self._oprot.trans.flush()
5524 
 
5525 
  def recv_getProductFeedSubmit(self, ):
5526 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5527 
    if mtype == TMessageType.EXCEPTION:
5528 
      x = TApplicationException()
5529 
      x.read(self._iprot)
5530 
      self._iprot.readMessageEnd()
5531 
      raise x
5532 
    result = getProductFeedSubmit_result()
5533 
    result.read(self._iprot)
5534 
    self._iprot.readMessageEnd()
5535 
    if result.success is not None:
5536 
      return result.success
5537 
    if result.cex is not None:
5538 
      raise result.cex
5539 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductFeedSubmit failed: unknown result");
5540 
 
5541 
  def addProductFeedSubmit(self, productFeedSubmit):
5542 
    """
5543 
    Parameters:
5544 
     - productFeedSubmit
5545 
    """
5546 
    self.send_addProductFeedSubmit(productFeedSubmit)
5547 
    return self.recv_addProductFeedSubmit()
5548 
 
5549 
  def send_addProductFeedSubmit(self, productFeedSubmit):
5550 
    self._oprot.writeMessageBegin('addProductFeedSubmit', TMessageType.CALL, self._seqid)
5551 
    args = addProductFeedSubmit_args()
5552 
    args.productFeedSubmit = productFeedSubmit
5553 
    args.write(self._oprot)
5554 
    self._oprot.writeMessageEnd()
5555 
    self._oprot.trans.flush()
5556 
 
5557 
  def recv_addProductFeedSubmit(self, ):
5558 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5559 
    if mtype == TMessageType.EXCEPTION:
5560 
      x = TApplicationException()
5561 
      x.read(self._iprot)
5562 
      self._iprot.readMessageEnd()
5563 
      raise x
5564 
    result = addProductFeedSubmit_result()
5565 
    result.read(self._iprot)
5566 
    self._iprot.readMessageEnd()
5567 
    if result.success is not None:
5568 
      return result.success
5569 
    if result.cex is not None:
5570 
      raise result.cex
5571 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductFeedSubmit failed: unknown result");
5572 
 
5573 
  def updateProductFeedSubmit(self, productFeedSubmit):
5574 
    """
5575 
    Parameters:
5576 
     - productFeedSubmit
5577 
    """
5578 
    self.send_updateProductFeedSubmit(productFeedSubmit)
5579 
    return self.recv_updateProductFeedSubmit()
5580 
 
5581 
  def send_updateProductFeedSubmit(self, productFeedSubmit):
5582 
    self._oprot.writeMessageBegin('updateProductFeedSubmit', TMessageType.CALL, self._seqid)
5583 
    args = updateProductFeedSubmit_args()
5584 
    args.productFeedSubmit = productFeedSubmit
5585 
    args.write(self._oprot)
5586 
    self._oprot.writeMessageEnd()
5587 
    self._oprot.trans.flush()
5588 
 
5589 
  def recv_updateProductFeedSubmit(self, ):
5590 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5591 
    if mtype == TMessageType.EXCEPTION:
5592 
      x = TApplicationException()
5593 
      x.read(self._iprot)
5594 
      self._iprot.readMessageEnd()
5595 
      raise x
5596 
    result = updateProductFeedSubmit_result()
5597 
    result.read(self._iprot)
5598 
    self._iprot.readMessageEnd()
5599 
    if result.success is not None:
5600 
      return result.success
5601 
    if result.cex is not None:
5602 
      raise result.cex
5603 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateProductFeedSubmit failed: unknown result");
5604 
 
5605 
  def deleteProductFeedSubmit(self, catalogItemId):
5606 
    """
5607 
    Parameters:
5608 
     - catalogItemId
5609 
    """
5610 
    self.send_deleteProductFeedSubmit(catalogItemId)
5611 
    return self.recv_deleteProductFeedSubmit()
5612 
 
5613 
  def send_deleteProductFeedSubmit(self, catalogItemId):
5614 
    self._oprot.writeMessageBegin('deleteProductFeedSubmit', TMessageType.CALL, self._seqid)
5615 
    args = deleteProductFeedSubmit_args()
5616 
    args.catalogItemId = catalogItemId
5617 
    args.write(self._oprot)
5618 
    self._oprot.writeMessageEnd()
5619 
    self._oprot.trans.flush()
5620 
 
5621 
  def recv_deleteProductFeedSubmit(self, ):
5622 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5623 
    if mtype == TMessageType.EXCEPTION:
5624 
      x = TApplicationException()
5625 
      x.read(self._iprot)
5626 
      self._iprot.readMessageEnd()
5627 
      raise x
5628 
    result = deleteProductFeedSubmit_result()
5629 
    result.read(self._iprot)
5630 
    self._iprot.readMessageEnd()
5631 
    if result.success is not None:
5632 
      return result.success
5633 
    if result.cex is not None:
5634 
      raise result.cex
5635 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteProductFeedSubmit failed: unknown result");
5636 
 
5637 
  def getAllProductFeedSubmit(self, ):
5638 
    self.send_getAllProductFeedSubmit()
5639 
    return self.recv_getAllProductFeedSubmit()
5640 
 
5641 
  def send_getAllProductFeedSubmit(self, ):
5642 
    self._oprot.writeMessageBegin('getAllProductFeedSubmit', TMessageType.CALL, self._seqid)
5643 
    args = getAllProductFeedSubmit_args()
5644 
    args.write(self._oprot)
5645 
    self._oprot.writeMessageEnd()
5646 
    self._oprot.trans.flush()
5647 
 
5648 
  def recv_getAllProductFeedSubmit(self, ):
5649 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5650 
    if mtype == TMessageType.EXCEPTION:
5651 
      x = TApplicationException()
5652 
      x.read(self._iprot)
5653 
      self._iprot.readMessageEnd()
5654 
      raise x
5655 
    result = getAllProductFeedSubmit_result()
5656 
    result.read(self._iprot)
5657 
    self._iprot.readMessageEnd()
5658 
    if result.success is not None:
5659 
      return result.success
5660 
    if result.cex is not None:
5661 
      raise result.cex
5662 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllProductFeedSubmit failed: unknown result");
5663 
 
9724 kshitij.so 5664 
  def getMarketplacedetailsForItem(self, itemId, sourceId):
5665 
    """
5666 
    Parameters:
5667 
     - itemId
5668 
     - sourceId
5669 
    """
5670 
    self.send_getMarketplacedetailsForItem(itemId, sourceId)
5671 
    return self.recv_getMarketplacedetailsForItem()
9621 manish.sha 5672 
 
9724 kshitij.so 5673 
  def send_getMarketplacedetailsForItem(self, itemId, sourceId):
5674 
    self._oprot.writeMessageBegin('getMarketplacedetailsForItem', TMessageType.CALL, self._seqid)
5675 
    args = getMarketplacedetailsForItem_args()
5676 
    args.itemId = itemId
5677 
    args.sourceId = sourceId
5678 
    args.write(self._oprot)
5679 
    self._oprot.writeMessageEnd()
5680 
    self._oprot.trans.flush()
5681 
 
5682 
  def recv_getMarketplacedetailsForItem(self, ):
5683 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5684 
    if mtype == TMessageType.EXCEPTION:
5685 
      x = TApplicationException()
5686 
      x.read(self._iprot)
5687 
      self._iprot.readMessageEnd()
5688 
      raise x
5689 
    result = getMarketplacedetailsForItem_result()
5690 
    result.read(self._iprot)
5691 
    self._iprot.readMessageEnd()
5692 
    if result.success is not None:
5693 
      return result.success
5694 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMarketplacedetailsForItem failed: unknown result");
5695 
 
5696 
  def updateMarketplaceAttributesForItem(self, marketPlaceItem):
5697 
    """
5698 
    Parameters:
5699 
     - marketPlaceItem
5700 
    """
5701 
    self.send_updateMarketplaceAttributesForItem(marketPlaceItem)
5702 
    return self.recv_updateMarketplaceAttributesForItem()
5703 
 
5704 
  def send_updateMarketplaceAttributesForItem(self, marketPlaceItem):
5705 
    self._oprot.writeMessageBegin('updateMarketplaceAttributesForItem', TMessageType.CALL, self._seqid)
5706 
    args = updateMarketplaceAttributesForItem_args()
5707 
    args.marketPlaceItem = marketPlaceItem
5708 
    args.write(self._oprot)
5709 
    self._oprot.writeMessageEnd()
5710 
    self._oprot.trans.flush()
5711 
 
5712 
  def recv_updateMarketplaceAttributesForItem(self, ):
5713 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5714 
    if mtype == TMessageType.EXCEPTION:
5715 
      x = TApplicationException()
5716 
      x.read(self._iprot)
5717 
      self._iprot.readMessageEnd()
5718 
      raise x
5719 
    result = updateMarketplaceAttributesForItem_result()
5720 
    result.read(self._iprot)
5721 
    self._iprot.readMessageEnd()
5722 
    if result.success is not None:
5723 
      return result.success
5724 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMarketplaceAttributesForItem failed: unknown result");
5725 
 
9779 kshitij.so 5726 
  def getCostingForMarketplace(self, source, item_id):
5727 
    """
5728 
    Parameters:
5729 
     - source
5730 
     - item_id
5731 
    """
5732 
    self.send_getCostingForMarketplace(source, item_id)
5733 
    return self.recv_getCostingForMarketplace()
5734 
 
5735 
  def send_getCostingForMarketplace(self, source, item_id):
5736 
    self._oprot.writeMessageBegin('getCostingForMarketplace', TMessageType.CALL, self._seqid)
5737 
    args = getCostingForMarketplace_args()
5738 
    args.source = source
5739 
    args.item_id = item_id
5740 
    args.write(self._oprot)
5741 
    self._oprot.writeMessageEnd()
5742 
    self._oprot.trans.flush()
5743 
 
5744 
  def recv_getCostingForMarketplace(self, ):
5745 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5746 
    if mtype == TMessageType.EXCEPTION:
5747 
      x = TApplicationException()
5748 
      x.read(self._iprot)
5749 
      self._iprot.readMessageEnd()
5750 
      raise x
5751 
    result = getCostingForMarketplace_result()
5752 
    result.read(self._iprot)
5753 
    self._iprot.readMessageEnd()
5754 
    if result.success is not None:
5755 
      return result.success
5756 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCostingForMarketplace failed: unknown result");
5757 
 
9776 vikram.rag 5758 
  def getMarketPlaceItemsForPriceUpdate(self, source):
5759 
    """
5760 
    Parameters:
5761 
     - source
5762 
    """
5763 
    self.send_getMarketPlaceItemsForPriceUpdate(source)
5764 
    return self.recv_getMarketPlaceItemsForPriceUpdate()
9724 kshitij.so 5765 
 
9776 vikram.rag 5766 
  def send_getMarketPlaceItemsForPriceUpdate(self, source):
5767 
    self._oprot.writeMessageBegin('getMarketPlaceItemsForPriceUpdate', TMessageType.CALL, self._seqid)
5768 
    args = getMarketPlaceItemsForPriceUpdate_args()
5769 
    args.source = source
5770 
    args.write(self._oprot)
5771 
    self._oprot.writeMessageEnd()
5772 
    self._oprot.trans.flush()
5773 
 
5774 
  def recv_getMarketPlaceItemsForPriceUpdate(self, ):
5775 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5776 
    if mtype == TMessageType.EXCEPTION:
5777 
      x = TApplicationException()
5778 
      x.read(self._iprot)
5779 
      self._iprot.readMessageEnd()
5780 
      raise x
5781 
    result = getMarketPlaceItemsForPriceUpdate_result()
5782 
    result.read(self._iprot)
5783 
    self._iprot.readMessageEnd()
5784 
    if result.success is not None:
5785 
      return result.success
5786 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMarketPlaceItemsForPriceUpdate failed: unknown result");
5787 
 
9816 kshitij.so 5788 
  def updateMarketPlacePriceUpdateStatus(self, skulist, timestamp, source):
9776 vikram.rag 5789 
    """
5790 
    Parameters:
5791 
     - skulist
5792 
     - timestamp
9816 kshitij.so 5793 
     - source
9776 vikram.rag 5794 
    """
9816 kshitij.so 5795 
    self.send_updateMarketPlacePriceUpdateStatus(skulist, timestamp, source)
9776 vikram.rag 5796 
    self.recv_updateMarketPlacePriceUpdateStatus()
5797 
 
9816 kshitij.so 5798 
  def send_updateMarketPlacePriceUpdateStatus(self, skulist, timestamp, source):
9776 vikram.rag 5799 
    self._oprot.writeMessageBegin('updateMarketPlacePriceUpdateStatus', TMessageType.CALL, self._seqid)
5800 
    args = updateMarketPlacePriceUpdateStatus_args()
5801 
    args.skulist = skulist
5802 
    args.timestamp = timestamp
9816 kshitij.so 5803 
    args.source = source
9776 vikram.rag 5804 
    args.write(self._oprot)
5805 
    self._oprot.writeMessageEnd()
5806 
    self._oprot.trans.flush()
5807 
 
5808 
  def recv_updateMarketPlacePriceUpdateStatus(self, ):
5809 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5810 
    if mtype == TMessageType.EXCEPTION:
5811 
      x = TApplicationException()
5812 
      x.read(self._iprot)
5813 
      self._iprot.readMessageEnd()
5814 
      raise x
5815 
    result = updateMarketPlacePriceUpdateStatus_result()
5816 
    result.read(self._iprot)
5817 
    self._iprot.readMessageEnd()
5818 
    return
5819 
 
9861 rajveer 5820 
  def updateItemHoldInventory(self, itemHoldMap):
5821 
    """
5822 
    Parameters:
5823 
     - itemHoldMap
5824 
    """
5825 
    self.send_updateItemHoldInventory(itemHoldMap)
5826 
    self.recv_updateItemHoldInventory()
9776 vikram.rag 5827 
 
9861 rajveer 5828 
  def send_updateItemHoldInventory(self, itemHoldMap):
5829 
    self._oprot.writeMessageBegin('updateItemHoldInventory', TMessageType.CALL, self._seqid)
5830 
    args = updateItemHoldInventory_args()
5831 
    args.itemHoldMap = itemHoldMap
5832 
    args.write(self._oprot)
5833 
    self._oprot.writeMessageEnd()
5834 
    self._oprot.trans.flush()
5835 
 
5836 
  def recv_updateItemHoldInventory(self, ):
5837 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5838 
    if mtype == TMessageType.EXCEPTION:
5839 
      x = TApplicationException()
5840 
      x.read(self._iprot)
5841 
      self._iprot.readMessageEnd()
5842 
      raise x
5843 
    result = updateItemHoldInventory_result()
5844 
    result.read(self._iprot)
5845 
    self._iprot.readMessageEnd()
5846 
    return
5847 
 
9895 vikram.rag 5848 
  def updateNlcAtMarketplaces(self, item_id, vendor_id, nlc):
5849 
    """
5850 
    Parameters:
5851 
     - item_id
5852 
     - vendor_id
5853 
     - nlc
5854 
    """
5855 
    self.send_updateNlcAtMarketplaces(item_id, vendor_id, nlc)
5856 
    self.recv_updateNlcAtMarketplaces()
9861 rajveer 5857 
 
9895 vikram.rag 5858 
  def send_updateNlcAtMarketplaces(self, item_id, vendor_id, nlc):
5859 
    self._oprot.writeMessageBegin('updateNlcAtMarketplaces', TMessageType.CALL, self._seqid)
5860 
    args = updateNlcAtMarketplaces_args()
5861 
    args.item_id = item_id
5862 
    args.vendor_id = vendor_id
5863 
    args.nlc = nlc
5864 
    args.write(self._oprot)
5865 
    self._oprot.writeMessageEnd()
5866 
    self._oprot.trans.flush()
5867 
 
5868 
  def recv_updateNlcAtMarketplaces(self, ):
5869 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5870 
    if mtype == TMessageType.EXCEPTION:
5871 
      x = TApplicationException()
5872 
      x.read(self._iprot)
5873 
      self._iprot.readMessageEnd()
5874 
      raise x
5875 
    result = updateNlcAtMarketplaces_result()
5876 
    result.read(self._iprot)
5877 
    self._iprot.readMessageEnd()
5878 
    return
5879 
 
9945 vikram.rag 5880 
  def getAllFlipkartItems(self, ):
5881 
    self.send_getAllFlipkartItems()
5882 
    return self.recv_getAllFlipkartItems()
9895 vikram.rag 5883 
 
9945 vikram.rag 5884 
  def send_getAllFlipkartItems(self, ):
5885 
    self._oprot.writeMessageBegin('getAllFlipkartItems', TMessageType.CALL, self._seqid)
5886 
    args = getAllFlipkartItems_args()
5887 
    args.write(self._oprot)
5888 
    self._oprot.writeMessageEnd()
5889 
    self._oprot.trans.flush()
5890 
 
5891 
  def recv_getAllFlipkartItems(self, ):
5892 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5893 
    if mtype == TMessageType.EXCEPTION:
5894 
      x = TApplicationException()
5895 
      x.read(self._iprot)
5896 
      self._iprot.readMessageEnd()
5897 
      raise x
5898 
    result = getAllFlipkartItems_result()
5899 
    result.read(self._iprot)
5900 
    self._iprot.readMessageEnd()
5901 
    if result.success is not None:
5902 
      return result.success
5903 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFlipkartItems failed: unknown result");
5904 
 
10097 kshitij.so 5905 
  def addOrUpdateFlipkartItem(self, flipkartitem):
5906 
    """
5907 
    Parameters:
5908 
     - flipkartitem
5909 
    """
5910 
    self.send_addOrUpdateFlipkartItem(flipkartitem)
5911 
    return self.recv_addOrUpdateFlipkartItem()
9945 vikram.rag 5912 
 
10097 kshitij.so 5913 
  def send_addOrUpdateFlipkartItem(self, flipkartitem):
5914 
    self._oprot.writeMessageBegin('addOrUpdateFlipkartItem', TMessageType.CALL, self._seqid)
5915 
    args = addOrUpdateFlipkartItem_args()
5916 
    args.flipkartitem = flipkartitem
5917 
    args.write(self._oprot)
5918 
    self._oprot.writeMessageEnd()
5919 
    self._oprot.trans.flush()
5920 
 
5921 
  def recv_addOrUpdateFlipkartItem(self, ):
5922 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5923 
    if mtype == TMessageType.EXCEPTION:
5924 
      x = TApplicationException()
5925 
      x.read(self._iprot)
5926 
      self._iprot.readMessageEnd()
5927 
      raise x
5928 
    result = addOrUpdateFlipkartItem_result()
5929 
    result.read(self._iprot)
5930 
    self._iprot.readMessageEnd()
5931 
    if result.success is not None:
5932 
      return result.success
5933 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addOrUpdateFlipkartItem failed: unknown result");
5934 
 
5935 
  def getFlipkartItem(self, item_id):
5936 
    """
5937 
    Parameters:
5938 
     - item_id
5939 
    """
5940 
    self.send_getFlipkartItem(item_id)
5941 
    return self.recv_getFlipkartItem()
5942 
 
5943 
  def send_getFlipkartItem(self, item_id):
5944 
    self._oprot.writeMessageBegin('getFlipkartItem', TMessageType.CALL, self._seqid)
5945 
    args = getFlipkartItem_args()
5946 
    args.item_id = item_id
5947 
    args.write(self._oprot)
5948 
    self._oprot.writeMessageEnd()
5949 
    self._oprot.trans.flush()
5950 
 
5951 
  def recv_getFlipkartItem(self, ):
5952 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5953 
    if mtype == TMessageType.EXCEPTION:
5954 
      x = TApplicationException()
5955 
      x.read(self._iprot)
5956 
      self._iprot.readMessageEnd()
5957 
      raise x
5958 
    result = getFlipkartItem_result()
5959 
    result.read(self._iprot)
5960 
    self._iprot.readMessageEnd()
5961 
    if result.success is not None:
5962 
      return result.success
5963 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartItem failed: unknown result");
5964 
 
5965 
  def getFlipkartItemDetails(self, item_id):
5966 
    """
5967 
    Parameters:
5968 
     - item_id
5969 
    """
5970 
    self.send_getFlipkartItemDetails(item_id)
5971 
    return self.recv_getFlipkartItemDetails()
5972 
 
5973 
  def send_getFlipkartItemDetails(self, item_id):
5974 
    self._oprot.writeMessageBegin('getFlipkartItemDetails', TMessageType.CALL, self._seqid)
5975 
    args = getFlipkartItemDetails_args()
5976 
    args.item_id = item_id
5977 
    args.write(self._oprot)
5978 
    self._oprot.writeMessageEnd()
5979 
    self._oprot.trans.flush()
5980 
 
5981 
  def recv_getFlipkartItemDetails(self, ):
5982 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5983 
    if mtype == TMessageType.EXCEPTION:
5984 
      x = TApplicationException()
5985 
      x.read(self._iprot)
5986 
      self._iprot.readMessageEnd()
5987 
      raise x
5988 
    result = getFlipkartItemDetails_result()
5989 
    result.read(self._iprot)
5990 
    self._iprot.readMessageEnd()
5991 
    if result.success is not None:
5992 
      return result.success
5993 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartItemDetails failed: unknown result");
5994 
 
5995 
  def getFlipkartItems(self, offset, limit):
5996 
    """
5997 
    Parameters:
5998 
     - offset
5999 
     - limit
6000 
    """
6001 
    self.send_getFlipkartItems(offset, limit)
6002 
    return self.recv_getFlipkartItems()
6003 
 
6004 
  def send_getFlipkartItems(self, offset, limit):
6005 
    self._oprot.writeMessageBegin('getFlipkartItems', TMessageType.CALL, self._seqid)
6006 
    args = getFlipkartItems_args()
6007 
    args.offset = offset
6008 
    args.limit = limit
6009 
    args.write(self._oprot)
6010 
    self._oprot.writeMessageEnd()
6011 
    self._oprot.trans.flush()
6012 
 
6013 
  def recv_getFlipkartItems(self, ):
6014 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6015 
    if mtype == TMessageType.EXCEPTION:
6016 
      x = TApplicationException()
6017 
      x.read(self._iprot)
6018 
      self._iprot.readMessageEnd()
6019 
      raise x
6020 
    result = getFlipkartItems_result()
6021 
    result.read(self._iprot)
6022 
    self._iprot.readMessageEnd()
6023 
    if result.success is not None:
6024 
      return result.success
6025 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartItems failed: unknown result");
6026 
 
6027 
  def searchFlipkartItems(self, searchTerm, offset, limit):
6028 
    """
6029 
    Parameters:
6030 
     - searchTerm
6031 
     - offset
6032 
     - limit
6033 
    """
6034 
    self.send_searchFlipkartItems(searchTerm, offset, limit)
6035 
    return self.recv_searchFlipkartItems()
6036 
 
6037 
  def send_searchFlipkartItems(self, searchTerm, offset, limit):
6038 
    self._oprot.writeMessageBegin('searchFlipkartItems', TMessageType.CALL, self._seqid)
6039 
    args = searchFlipkartItems_args()
6040 
    args.searchTerm = searchTerm
6041 
    args.offset = offset
6042 
    args.limit = limit
6043 
    args.write(self._oprot)
6044 
    self._oprot.writeMessageEnd()
6045 
    self._oprot.trans.flush()
6046 
 
6047 
  def recv_searchFlipkartItems(self, ):
6048 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6049 
    if mtype == TMessageType.EXCEPTION:
6050 
      x = TApplicationException()
6051 
      x.read(self._iprot)
6052 
      self._iprot.readMessageEnd()
6053 
      raise x
6054 
    result = searchFlipkartItems_result()
6055 
    result.read(self._iprot)
6056 
    self._iprot.readMessageEnd()
6057 
    if result.success is not None:
6058 
      return result.success
6059 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchFlipkartItems failed: unknown result");
6060 
 
6061 
  def getCountForFlipkartItems(self, ):
6062 
    self.send_getCountForFlipkartItems()
6063 
    return self.recv_getCountForFlipkartItems()
6064 
 
6065 
  def send_getCountForFlipkartItems(self, ):
6066 
    self._oprot.writeMessageBegin('getCountForFlipkartItems', TMessageType.CALL, self._seqid)
6067 
    args = getCountForFlipkartItems_args()
6068 
    args.write(self._oprot)
6069 
    self._oprot.writeMessageEnd()
6070 
    self._oprot.trans.flush()
6071 
 
6072 
  def recv_getCountForFlipkartItems(self, ):
6073 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6074 
    if mtype == TMessageType.EXCEPTION:
6075 
      x = TApplicationException()
6076 
      x.read(self._iprot)
6077 
      self._iprot.readMessageEnd()
6078 
      raise x
6079 
    result = getCountForFlipkartItems_result()
6080 
    result.read(self._iprot)
6081 
    self._iprot.readMessageEnd()
6082 
    if result.success is not None:
6083 
      return result.success
6084 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForFlipkartItems failed: unknown result");
6085 
 
6086 
  def getFlipkartSearchResultCount(self, searchTerm):
6087 
    """
6088 
    Parameters:
6089 
     - searchTerm
6090 
    """
6091 
    self.send_getFlipkartSearchResultCount(searchTerm)
6092 
    return self.recv_getFlipkartSearchResultCount()
6093 
 
6094 
  def send_getFlipkartSearchResultCount(self, searchTerm):
6095 
    self._oprot.writeMessageBegin('getFlipkartSearchResultCount', TMessageType.CALL, self._seqid)
6096 
    args = getFlipkartSearchResultCount_args()
6097 
    args.searchTerm = searchTerm
6098 
    args.write(self._oprot)
6099 
    self._oprot.writeMessageEnd()
6100 
    self._oprot.trans.flush()
6101 
 
6102 
  def recv_getFlipkartSearchResultCount(self, ):
6103 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6104 
    if mtype == TMessageType.EXCEPTION:
6105 
      x = TApplicationException()
6106 
      x.read(self._iprot)
6107 
      self._iprot.readMessageEnd()
6108 
      raise x
6109 
    result = getFlipkartSearchResultCount_result()
6110 
    result.read(self._iprot)
6111 
    self._iprot.readMessageEnd()
6112 
    if result.success is not None:
6113 
      return result.success
6114 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartSearchResultCount failed: unknown result");
6115 
 
6116 
  def getAllFkItems(self, ):
6117 
    self.send_getAllFkItems()
6118 
    return self.recv_getAllFkItems()
6119 
 
6120 
  def send_getAllFkItems(self, ):
6121 
    self._oprot.writeMessageBegin('getAllFkItems', TMessageType.CALL, self._seqid)
6122 
    args = getAllFkItems_args()
6123 
    args.write(self._oprot)
6124 
    self._oprot.writeMessageEnd()
6125 
    self._oprot.trans.flush()
6126 
 
6127 
  def recv_getAllFkItems(self, ):
6128 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6129 
    if mtype == TMessageType.EXCEPTION:
6130 
      x = TApplicationException()
6131 
      x.read(self._iprot)
6132 
      self._iprot.readMessageEnd()
6133 
      raise x
6134 
    result = getAllFkItems_result()
6135 
    result.read(self._iprot)
6136 
    self._iprot.readMessageEnd()
6137 
    if result.success is not None:
6138 
      return result.success
6139 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFkItems failed: unknown result");
6140 
 
10140 vikram.rag 6141 
  def getFlipkartItemBySkyAtFlipkart(self, sku):
6142 
    """
6143 
    Parameters:
6144 
     - sku
6145 
    """
6146 
    self.send_getFlipkartItemBySkyAtFlipkart(sku)
6147 
    return self.recv_getFlipkartItemBySkyAtFlipkart()
10097 kshitij.so 6148 
 
10140 vikram.rag 6149 
  def send_getFlipkartItemBySkyAtFlipkart(self, sku):
6150 
    self._oprot.writeMessageBegin('getFlipkartItemBySkyAtFlipkart', TMessageType.CALL, self._seqid)
6151 
    args = getFlipkartItemBySkyAtFlipkart_args()
6152 
    args.sku = sku
6153 
    args.write(self._oprot)
6154 
    self._oprot.writeMessageEnd()
6155 
    self._oprot.trans.flush()
6156 
 
6157 
  def recv_getFlipkartItemBySkyAtFlipkart(self, ):
6158 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6159 
    if mtype == TMessageType.EXCEPTION:
6160 
      x = TApplicationException()
6161 
      x.read(self._iprot)
6162 
      self._iprot.readMessageEnd()
6163 
      raise x
6164 
    result = getFlipkartItemBySkyAtFlipkart_result()
6165 
    result.read(self._iprot)
6166 
    self._iprot.readMessageEnd()
6167 
    if result.success is not None:
6168 
      return result.success
6169 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartItemBySkyAtFlipkart failed: unknown result");
6170 
 
11015 kshitij.so 6171 
  def getMarketplaceHistory(self, source, offset, itemId):
6172 
    """
6173 
    Parameters:
6174 
     - source
6175 
     - offset
6176 
     - itemId
6177 
    """
6178 
    self.send_getMarketplaceHistory(source, offset, itemId)
6179 
    return self.recv_getMarketplaceHistory()
6180 
 
6181 
  def send_getMarketplaceHistory(self, source, offset, itemId):
6182 
    self._oprot.writeMessageBegin('getMarketplaceHistory', TMessageType.CALL, self._seqid)
6183 
    args = getMarketplaceHistory_args()
6184 
    args.source = source
6185 
    args.offset = offset
6186 
    args.itemId = itemId
6187 
    args.write(self._oprot)
6188 
    self._oprot.writeMessageEnd()
6189 
    self._oprot.trans.flush()
6190 
 
6191 
  def recv_getMarketplaceHistory(self, ):
6192 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6193 
    if mtype == TMessageType.EXCEPTION:
6194 
      x = TApplicationException()
6195 
      x.read(self._iprot)
6196 
      self._iprot.readMessageEnd()
6197 
      raise x
6198 
    result = getMarketplaceHistory_result()
6199 
    result.read(self._iprot)
6200 
    self._iprot.readMessageEnd()
6201 
    if result.success is not None:
6202 
      return result.success
6203 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMarketplaceHistory failed: unknown result");
6204 
 
10909 vikram.rag 6205 
  def getAllFbbListedItems(self, ):
6206 
    self.send_getAllFbbListedItems()
6207 
    return self.recv_getAllFbbListedItems()
10140 vikram.rag 6208 
 
10909 vikram.rag 6209 
  def send_getAllFbbListedItems(self, ):
6210 
    self._oprot.writeMessageBegin('getAllFbbListedItems', TMessageType.CALL, self._seqid)
6211 
    args = getAllFbbListedItems_args()
6212 
    args.write(self._oprot)
6213 
    self._oprot.writeMessageEnd()
6214 
    self._oprot.trans.flush()
6215 
 
6216 
  def recv_getAllFbbListedItems(self, ):
6217 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6218 
    if mtype == TMessageType.EXCEPTION:
6219 
      x = TApplicationException()
6220 
      x.read(self._iprot)
6221 
      self._iprot.readMessageEnd()
6222 
      raise x
6223 
    result = getAllFbbListedItems_result()
6224 
    result.read(self._iprot)
6225 
    self._iprot.readMessageEnd()
6226 
    if result.success is not None:
6227 
      return result.success
6228 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbbListedItems failed: unknown result");
6229 
 
10924 vikram.rag 6230 
  def getAllFbbPricingItems(self, ):
6231 
    self.send_getAllFbbPricingItems()
6232 
    return self.recv_getAllFbbPricingItems()
10909 vikram.rag 6233 
 
10924 vikram.rag 6234 
  def send_getAllFbbPricingItems(self, ):
6235 
    self._oprot.writeMessageBegin('getAllFbbPricingItems', TMessageType.CALL, self._seqid)
6236 
    args = getAllFbbPricingItems_args()
6237 
    args.write(self._oprot)
6238 
    self._oprot.writeMessageEnd()
6239 
    self._oprot.trans.flush()
6240 
 
6241 
  def recv_getAllFbbPricingItems(self, ):
6242 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6243 
    if mtype == TMessageType.EXCEPTION:
6244 
      x = TApplicationException()
6245 
      x.read(self._iprot)
6246 
      self._iprot.readMessageEnd()
6247 
      raise x
6248 
    result = getAllFbbPricingItems_result()
6249 
    result.read(self._iprot)
6250 
    self._iprot.readMessageEnd()
6251 
    if result.success is not None:
6252 
      return result.success
6253 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbbPricingItems failed: unknown result");
6254 
 
11015 kshitij.so 6255 
  def getCountForMarketplaceHistory(self, source, itemId):
6256 
    """
6257 
    Parameters:
6258 
     - source
6259 
     - itemId
6260 
    """
6261 
    self.send_getCountForMarketplaceHistory(source, itemId)
6262 
    return self.recv_getCountForMarketplaceHistory()
10924 vikram.rag 6263 
 
11015 kshitij.so 6264 
  def send_getCountForMarketplaceHistory(self, source, itemId):
6265 
    self._oprot.writeMessageBegin('getCountForMarketplaceHistory', TMessageType.CALL, self._seqid)
6266 
    args = getCountForMarketplaceHistory_args()
6267 
    args.source = source
6268 
    args.itemId = itemId
6269 
    args.write(self._oprot)
6270 
    self._oprot.writeMessageEnd()
6271 
    self._oprot.trans.flush()
6272 
 
6273 
  def recv_getCountForMarketplaceHistory(self, ):
6274 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6275 
    if mtype == TMessageType.EXCEPTION:
6276 
      x = TApplicationException()
6277 
      x.read(self._iprot)
6278 
      self._iprot.readMessageEnd()
6279 
      raise x
6280 
    result = getCountForMarketplaceHistory_result()
6281 
    result.read(self._iprot)
6282 
    self._iprot.readMessageEnd()
6283 
    if result.success is not None:
6284 
      return result.success
6285 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForMarketplaceHistory failed: unknown result");
6286 
 
6287 
  def getMarketplaceHistoryByDate(self, source, startDate, endDate, offset, limit, itemId):
6288 
    """
6289 
    Parameters:
6290 
     - source
6291 
     - startDate
6292 
     - endDate
6293 
     - offset
6294 
     - limit
6295 
     - itemId
6296 
    """
6297 
    self.send_getMarketplaceHistoryByDate(source, startDate, endDate, offset, limit, itemId)
6298 
    return self.recv_getMarketplaceHistoryByDate()
6299 
 
6300 
  def send_getMarketplaceHistoryByDate(self, source, startDate, endDate, offset, limit, itemId):
6301 
    self._oprot.writeMessageBegin('getMarketplaceHistoryByDate', TMessageType.CALL, self._seqid)
6302 
    args = getMarketplaceHistoryByDate_args()
6303 
    args.source = source
6304 
    args.startDate = startDate
6305 
    args.endDate = endDate
6306 
    args.offset = offset
6307 
    args.limit = limit
6308 
    args.itemId = itemId
6309 
    args.write(self._oprot)
6310 
    self._oprot.writeMessageEnd()
6311 
    self._oprot.trans.flush()
6312 
 
6313 
  def recv_getMarketplaceHistoryByDate(self, ):
6314 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6315 
    if mtype == TMessageType.EXCEPTION:
6316 
      x = TApplicationException()
6317 
      x.read(self._iprot)
6318 
      self._iprot.readMessageEnd()
6319 
      raise x
6320 
    result = getMarketplaceHistoryByDate_result()
6321 
    result.read(self._iprot)
6322 
    self._iprot.readMessageEnd()
6323 
    if result.success is not None:
6324 
      return result.success
6325 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMarketplaceHistoryByDate failed: unknown result");
6326 
 
11531 vikram.rag 6327 
  def getPrivateDealDetails(self, item_id):
6328 
    """
6329 
    Parameters:
6330 
     - item_id
6331 
    """
6332 
    self.send_getPrivateDealDetails(item_id)
6333 
    return self.recv_getPrivateDealDetails()
11015 kshitij.so 6334 
 
11531 vikram.rag 6335 
  def send_getPrivateDealDetails(self, item_id):
6336 
    self._oprot.writeMessageBegin('getPrivateDealDetails', TMessageType.CALL, self._seqid)
6337 
    args = getPrivateDealDetails_args()
6338 
    args.item_id = item_id
6339 
    args.write(self._oprot)
6340 
    self._oprot.writeMessageEnd()
6341 
    self._oprot.trans.flush()
6342 
 
6343 
  def recv_getPrivateDealDetails(self, ):
6344 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6345 
    if mtype == TMessageType.EXCEPTION:
6346 
      x = TApplicationException()
6347 
      x.read(self._iprot)
6348 
      self._iprot.readMessageEnd()
6349 
      raise x
6350 
    result = getPrivateDealDetails_result()
6351 
    result.read(self._iprot)
6352 
    self._iprot.readMessageEnd()
6353 
    if result.success is not None:
6354 
      return result.success
6355 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrivateDealDetails failed: unknown result");
6356 
 
6357 
  def getPrivateDealItems(self, offset, limit):
6358 
    """
6359 
    Parameters:
6360 
     - offset
6361 
     - limit
6362 
    """
6363 
    self.send_getPrivateDealItems(offset, limit)
6364 
    return self.recv_getPrivateDealItems()
6365 
 
6366 
  def send_getPrivateDealItems(self, offset, limit):
6367 
    self._oprot.writeMessageBegin('getPrivateDealItems', TMessageType.CALL, self._seqid)
6368 
    args = getPrivateDealItems_args()
6369 
    args.offset = offset
6370 
    args.limit = limit
6371 
    args.write(self._oprot)
6372 
    self._oprot.writeMessageEnd()
6373 
    self._oprot.trans.flush()
6374 
 
6375 
  def recv_getPrivateDealItems(self, ):
6376 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6377 
    if mtype == TMessageType.EXCEPTION:
6378 
      x = TApplicationException()
6379 
      x.read(self._iprot)
6380 
      self._iprot.readMessageEnd()
6381 
      raise x
6382 
    result = getPrivateDealItems_result()
6383 
    result.read(self._iprot)
6384 
    self._iprot.readMessageEnd()
6385 
    if result.success is not None:
6386 
      return result.success
6387 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrivateDealItems failed: unknown result");
6388 
 
11653 amit.gupta 6389 
  def getAllActivePrivateDeals(self, itemIds, daysDelta):
6390 
    """
6391 
    Parameters:
6392 
     - itemIds
6393 
     - daysDelta
6394 
    """
6395 
    self.send_getAllActivePrivateDeals(itemIds, daysDelta)
11592 amit.gupta 6396 
    return self.recv_getAllActivePrivateDeals()
6397 
 
11653 amit.gupta 6398 
  def send_getAllActivePrivateDeals(self, itemIds, daysDelta):
11592 amit.gupta 6399 
    self._oprot.writeMessageBegin('getAllActivePrivateDeals', TMessageType.CALL, self._seqid)
6400 
    args = getAllActivePrivateDeals_args()
11653 amit.gupta 6401 
    args.itemIds = itemIds
6402 
    args.daysDelta = daysDelta
11592 amit.gupta 6403 
    args.write(self._oprot)
6404 
    self._oprot.writeMessageEnd()
6405 
    self._oprot.trans.flush()
6406 
 
6407 
  def recv_getAllActivePrivateDeals(self, ):
6408 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6409 
    if mtype == TMessageType.EXCEPTION:
6410 
      x = TApplicationException()
6411 
      x.read(self._iprot)
6412 
      self._iprot.readMessageEnd()
6413 
      raise x
6414 
    result = getAllActivePrivateDeals_result()
6415 
    result.read(self._iprot)
6416 
    self._iprot.readMessageEnd()
6417 
    if result.success is not None:
6418 
      return result.success
6419 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllActivePrivateDeals failed: unknown result");
6420 
 
11531 vikram.rag 6421 
  def addOrUpdatePrivateDeal(self, privateDeal):
6422 
    """
6423 
    Parameters:
6424 
     - privateDeal
6425 
    """
6426 
    self.send_addOrUpdatePrivateDeal(privateDeal)
6427 
    return self.recv_addOrUpdatePrivateDeal()
6428 
 
6429 
  def send_addOrUpdatePrivateDeal(self, privateDeal):
6430 
    self._oprot.writeMessageBegin('addOrUpdatePrivateDeal', TMessageType.CALL, self._seqid)
6431 
    args = addOrUpdatePrivateDeal_args()
6432 
    args.privateDeal = privateDeal
6433 
    args.write(self._oprot)
6434 
    self._oprot.writeMessageEnd()
6435 
    self._oprot.trans.flush()
6436 
 
6437 
  def recv_addOrUpdatePrivateDeal(self, ):
6438 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6439 
    if mtype == TMessageType.EXCEPTION:
6440 
      x = TApplicationException()
6441 
      x.read(self._iprot)
6442 
      self._iprot.readMessageEnd()
6443 
      raise x
6444 
    result = addOrUpdatePrivateDeal_result()
6445 
    result.read(self._iprot)
6446 
    self._iprot.readMessageEnd()
6447 
    if result.success is not None:
6448 
      return result.success
6449 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addOrUpdatePrivateDeal failed: unknown result");
6450 
 
11635 vikram.rag 6451 
  def getPrivateDealsCatalogIds(self, beginIndex, totalItems):
6452 
    """
6453 
    Parameters:
6454 
     - beginIndex
6455 
     - totalItems
6456 
    """
6457 
    self.send_getPrivateDealsCatalogIds(beginIndex, totalItems)
6458 
    return self.recv_getPrivateDealsCatalogIds()
11531 vikram.rag 6459 
 
11635 vikram.rag 6460 
  def send_getPrivateDealsCatalogIds(self, beginIndex, totalItems):
6461 
    self._oprot.writeMessageBegin('getPrivateDealsCatalogIds', TMessageType.CALL, self._seqid)
6462 
    args = getPrivateDealsCatalogIds_args()
6463 
    args.beginIndex = beginIndex
6464 
    args.totalItems = totalItems
6465 
    args.write(self._oprot)
6466 
    self._oprot.writeMessageEnd()
6467 
    self._oprot.trans.flush()
6468 
 
6469 
  def recv_getPrivateDealsCatalogIds(self, ):
6470 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6471 
    if mtype == TMessageType.EXCEPTION:
6472 
      x = TApplicationException()
6473 
      x.read(self._iprot)
6474 
      self._iprot.readMessageEnd()
6475 
      raise x
6476 
    result = getPrivateDealsCatalogIds_result()
6477 
    result.read(self._iprot)
6478 
    self._iprot.readMessageEnd()
6479 
    if result.success is not None:
6480 
      return result.success
6481 
    if result.cex is not None:
6482 
      raise result.cex
6483 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrivateDealsCatalogIds failed: unknown result");
6484 
 
11645 amit.gupta 6485 
  def getPrivateDealsCount(self, ):
6486 
    self.send_getPrivateDealsCount()
6487 
    return self.recv_getPrivateDealsCount()
11635 vikram.rag 6488 
 
11645 amit.gupta 6489 
  def send_getPrivateDealsCount(self, ):
6490 
    self._oprot.writeMessageBegin('getPrivateDealsCount', TMessageType.CALL, self._seqid)
6491 
    args = getPrivateDealsCount_args()
6492 
    args.write(self._oprot)
6493 
    self._oprot.writeMessageEnd()
6494 
    self._oprot.trans.flush()
6495 
 
6496 
  def recv_getPrivateDealsCount(self, ):
6497 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6498 
    if mtype == TMessageType.EXCEPTION:
6499 
      x = TApplicationException()
6500 
      x.read(self._iprot)
6501 
      self._iprot.readMessageEnd()
6502 
      raise x
6503 
    result = getPrivateDealsCount_result()
6504 
    result.read(self._iprot)
6505 
    self._iprot.readMessageEnd()
6506 
    if result.success is not None:
6507 
      return result.success
6508 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrivateDealsCount failed: unknown result");
6509 
 
11905 kshitij.so 6510 
  def getAmazonOutSyncItems(self, item_id):
6511 
    """
6512 
    Parameters:
6513 
     - item_id
6514 
    """
6515 
    self.send_getAmazonOutSyncItems(item_id)
6516 
    return self.recv_getAmazonOutSyncItems()
11645 amit.gupta 6517 
 
11905 kshitij.so 6518 
  def send_getAmazonOutSyncItems(self, item_id):
6519 
    self._oprot.writeMessageBegin('getAmazonOutSyncItems', TMessageType.CALL, self._seqid)
6520 
    args = getAmazonOutSyncItems_args()
6521 
    args.item_id = item_id
6522 
    args.write(self._oprot)
6523 
    self._oprot.writeMessageEnd()
6524 
    self._oprot.trans.flush()
6525 
 
6526 
  def recv_getAmazonOutSyncItems(self, ):
6527 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6528 
    if mtype == TMessageType.EXCEPTION:
6529 
      x = TApplicationException()
6530 
      x.read(self._iprot)
6531 
      self._iprot.readMessageEnd()
6532 
      raise x
6533 
    result = getAmazonOutSyncItems_result()
6534 
    result.read(self._iprot)
6535 
    self._iprot.readMessageEnd()
6536 
    if result.success is not None:
6537 
      return result.success
6538 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonOutSyncItems failed: unknown result");
6539 
 
6540 
  def getAllPrivateDealsComparison(self, ):
6541 
    self.send_getAllPrivateDealsComparison()
6542 
    return self.recv_getAllPrivateDealsComparison()
6543 
 
6544 
  def send_getAllPrivateDealsComparison(self, ):
6545 
    self._oprot.writeMessageBegin('getAllPrivateDealsComparison', TMessageType.CALL, self._seqid)
6546 
    args = getAllPrivateDealsComparison_args()
6547 
    args.write(self._oprot)
6548 
    self._oprot.writeMessageEnd()
6549 
    self._oprot.trans.flush()
6550 
 
6551 
  def recv_getAllPrivateDealsComparison(self, ):
6552 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6553 
    if mtype == TMessageType.EXCEPTION:
6554 
      x = TApplicationException()
6555 
      x.read(self._iprot)
6556 
      self._iprot.readMessageEnd()
6557 
      raise x
6558 
    result = getAllPrivateDealsComparison_result()
6559 
    result.read(self._iprot)
6560 
    self._iprot.readMessageEnd()
6561 
    if result.success is not None:
6562 
      return result.success
6563 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllPrivateDealsComparison failed: unknown result");
6564 
 
12133 kshitij.so 6565 
  def getAllSnapdealMarketplaceItem(self, ):
6566 
    self.send_getAllSnapdealMarketplaceItem()
6567 
    return self.recv_getAllSnapdealMarketplaceItem()
11905 kshitij.so 6568 
 
12133 kshitij.so 6569 
  def send_getAllSnapdealMarketplaceItem(self, ):
6570 
    self._oprot.writeMessageBegin('getAllSnapdealMarketplaceItem', TMessageType.CALL, self._seqid)
6571 
    args = getAllSnapdealMarketplaceItem_args()
6572 
    args.write(self._oprot)
6573 
    self._oprot.writeMessageEnd()
6574 
    self._oprot.trans.flush()
6575 
 
6576 
  def recv_getAllSnapdealMarketplaceItem(self, ):
6577 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6578 
    if mtype == TMessageType.EXCEPTION:
6579 
      x = TApplicationException()
6580 
      x.read(self._iprot)
6581 
      self._iprot.readMessageEnd()
6582 
      raise x
6583 
    result = getAllSnapdealMarketplaceItem_result()
6584 
    result.read(self._iprot)
6585 
    self._iprot.readMessageEnd()
6586 
    if result.success is not None:
6587 
      return result.success
6588 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSnapdealMarketplaceItem failed: unknown result");
6589 
 
6590 
  def getAllFlipkartMarketplaceItem(self, ):
6591 
    self.send_getAllFlipkartMarketplaceItem()
6592 
    return self.recv_getAllFlipkartMarketplaceItem()
6593 
 
6594 
  def send_getAllFlipkartMarketplaceItem(self, ):
6595 
    self._oprot.writeMessageBegin('getAllFlipkartMarketplaceItem', TMessageType.CALL, self._seqid)
6596 
    args = getAllFlipkartMarketplaceItem_args()
6597 
    args.write(self._oprot)
6598 
    self._oprot.writeMessageEnd()
6599 
    self._oprot.trans.flush()
6600 
 
6601 
  def recv_getAllFlipkartMarketplaceItem(self, ):
6602 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6603 
    if mtype == TMessageType.EXCEPTION:
6604 
      x = TApplicationException()
6605 
      x.read(self._iprot)
6606 
      self._iprot.readMessageEnd()
6607 
      raise x
6608 
    result = getAllFlipkartMarketplaceItem_result()
6609 
    result.read(self._iprot)
6610 
    self._iprot.readMessageEnd()
6611 
    if result.success is not None:
6612 
      return result.success
6613 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFlipkartMarketplaceItem failed: unknown result");
6614 
 
12243 kshitij.so 6615 
  def addCompetitorScraping(self, competitorPricingMap):
6616 
    """
6617 
    Parameters:
6618 
     - competitorPricingMap
6619 
    """
6620 
    self.send_addCompetitorScraping(competitorPricingMap)
6621 
    self.recv_addCompetitorScraping()
12133 kshitij.so 6622 
 
12243 kshitij.so 6623 
  def send_addCompetitorScraping(self, competitorPricingMap):
6624 
    self._oprot.writeMessageBegin('addCompetitorScraping', TMessageType.CALL, self._seqid)
6625 
    args = addCompetitorScraping_args()
6626 
    args.competitorPricingMap = competitorPricingMap
6627 
    args.write(self._oprot)
6628 
    self._oprot.writeMessageEnd()
6629 
    self._oprot.trans.flush()
6630 
 
6631 
  def recv_addCompetitorScraping(self, ):
6632 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6633 
    if mtype == TMessageType.EXCEPTION:
6634 
      x = TApplicationException()
6635 
      x.read(self._iprot)
6636 
      self._iprot.readMessageEnd()
6637 
      raise x
6638 
    result = addCompetitorScraping_result()
6639 
    result.read(self._iprot)
6640 
    self._iprot.readMessageEnd()
6641 
    return
6642 
 
6643 
  def getPreviousCompetitorScraping(self, delta):
6644 
    """
6645 
    Parameters:
6646 
     - delta
6647 
    """
6648 
    self.send_getPreviousCompetitorScraping(delta)
6649 
    return self.recv_getPreviousCompetitorScraping()
6650 
 
6651 
  def send_getPreviousCompetitorScraping(self, delta):
6652 
    self._oprot.writeMessageBegin('getPreviousCompetitorScraping', TMessageType.CALL, self._seqid)
6653 
    args = getPreviousCompetitorScraping_args()
6654 
    args.delta = delta
6655 
    args.write(self._oprot)
6656 
    self._oprot.writeMessageEnd()
6657 
    self._oprot.trans.flush()
6658 
 
6659 
  def recv_getPreviousCompetitorScraping(self, ):
6660 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6661 
    if mtype == TMessageType.EXCEPTION:
6662 
      x = TApplicationException()
6663 
      x.read(self._iprot)
6664 
      self._iprot.readMessageEnd()
6665 
      raise x
6666 
    result = getPreviousCompetitorScraping_result()
6667 
    result.read(self._iprot)
6668 
    self._iprot.readMessageEnd()
6669 
    if result.success is not None:
6670 
      return result.success
6671 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPreviousCompetitorScraping failed: unknown result");
6672 
 
12256 kshitij.so 6673 
  def getUploadResultById(self, uploadId):
6674 
    """
6675 
    Parameters:
6676 
     - uploadId
6677 
    """
6678 
    self.send_getUploadResultById(uploadId)
6679 
    return self.recv_getUploadResultById()
12243 kshitij.so 6680 
 
12256 kshitij.so 6681 
  def send_getUploadResultById(self, uploadId):
6682 
    self._oprot.writeMessageBegin('getUploadResultById', TMessageType.CALL, self._seqid)
6683 
    args = getUploadResultById_args()
6684 
    args.uploadId = uploadId
6685 
    args.write(self._oprot)
6686 
    self._oprot.writeMessageEnd()
6687 
    self._oprot.trans.flush()
6688 
 
6689 
  def recv_getUploadResultById(self, ):
6690 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6691 
    if mtype == TMessageType.EXCEPTION:
6692 
      x = TApplicationException()
6693 
      x.read(self._iprot)
6694 
      self._iprot.readMessageEnd()
6695 
      raise x
6696 
    result = getUploadResultById_result()
6697 
    result.read(self._iprot)
6698 
    self._iprot.readMessageEnd()
6699 
    if result.success is not None:
6700 
      return result.success
6701 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUploadResultById failed: unknown result");
6702 
 
12363 kshitij.so 6703 
  def addAmazonPromotion(self, amazonPromotions):
6704 
    """
6705 
    Parameters:
6706 
     - amazonPromotions
6707 
    """
6708 
    self.send_addAmazonPromotion(amazonPromotions)
6709 
    return self.recv_addAmazonPromotion()
12256 kshitij.so 6710 
 
12363 kshitij.so 6711 
  def send_addAmazonPromotion(self, amazonPromotions):
6712 
    self._oprot.writeMessageBegin('addAmazonPromotion', TMessageType.CALL, self._seqid)
6713 
    args = addAmazonPromotion_args()
6714 
    args.amazonPromotions = amazonPromotions
6715 
    args.write(self._oprot)
6716 
    self._oprot.writeMessageEnd()
6717 
    self._oprot.trans.flush()
6718 
 
6719 
  def recv_addAmazonPromotion(self, ):
6720 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6721 
    if mtype == TMessageType.EXCEPTION:
6722 
      x = TApplicationException()
6723 
      x.read(self._iprot)
6724 
      self._iprot.readMessageEnd()
6725 
      raise x
6726 
    result = addAmazonPromotion_result()
6727 
    result.read(self._iprot)
6728 
    self._iprot.readMessageEnd()
6729 
    if result.success is not None:
6730 
      return result.success
12947 kshitij.so 6731 
    if result.cex is not None:
6732 
      raise result.cex
12363 kshitij.so 6733 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAmazonPromotion failed: unknown result");
6734 
 
6735 
  def getAmazonPromotion(self, startDate, endDate):
6736 
    """
6737 
    Parameters:
6738 
     - startDate
6739 
     - endDate
6740 
    """
6741 
    self.send_getAmazonPromotion(startDate, endDate)
6742 
    return self.recv_getAmazonPromotion()
6743 
 
6744 
  def send_getAmazonPromotion(self, startDate, endDate):
6745 
    self._oprot.writeMessageBegin('getAmazonPromotion', TMessageType.CALL, self._seqid)
6746 
    args = getAmazonPromotion_args()
6747 
    args.startDate = startDate
6748 
    args.endDate = endDate
6749 
    args.write(self._oprot)
6750 
    self._oprot.writeMessageEnd()
6751 
    self._oprot.trans.flush()
6752 
 
6753 
  def recv_getAmazonPromotion(self, ):
6754 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6755 
    if mtype == TMessageType.EXCEPTION:
6756 
      x = TApplicationException()
6757 
      x.read(self._iprot)
6758 
      self._iprot.readMessageEnd()
6759 
      raise x
6760 
    result = getAmazonPromotion_result()
6761 
    result.read(self._iprot)
6762 
    self._iprot.readMessageEnd()
6763 
    if result.success is not None:
6764 
      return result.success
6765 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonPromotion failed: unknown result");
6766 
 
6767 
  def updateAmazonPromotion(self, amazonPromotions):
6768 
    """
6769 
    Parameters:
6770 
     - amazonPromotions
6771 
    """
6772 
    self.send_updateAmazonPromotion(amazonPromotions)
6773 
    return self.recv_updateAmazonPromotion()
6774 
 
6775 
  def send_updateAmazonPromotion(self, amazonPromotions):
6776 
    self._oprot.writeMessageBegin('updateAmazonPromotion', TMessageType.CALL, self._seqid)
6777 
    args = updateAmazonPromotion_args()
6778 
    args.amazonPromotions = amazonPromotions
6779 
    args.write(self._oprot)
6780 
    self._oprot.writeMessageEnd()
6781 
    self._oprot.trans.flush()
6782 
 
6783 
  def recv_updateAmazonPromotion(self, ):
6784 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6785 
    if mtype == TMessageType.EXCEPTION:
6786 
      x = TApplicationException()
6787 
      x.read(self._iprot)
6788 
      self._iprot.readMessageEnd()
6789 
      raise x
6790 
    result = updateAmazonPromotion_result()
6791 
    result.read(self._iprot)
6792 
    self._iprot.readMessageEnd()
6793 
    if result.success is not None:
6794 
      return result.success
6795 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateAmazonPromotion failed: unknown result");
6796 
 
12567 amit.gupta 6797 
  def markPartiallyActive(self, itemId, categoryId):
6798 
    """
6799 
    Parameters:
6800 
     - itemId
6801 
     - categoryId
6802 
    """
6803 
    self.send_markPartiallyActive(itemId, categoryId)
6804 
    return self.recv_markPartiallyActive()
12363 kshitij.so 6805 
 
12567 amit.gupta 6806 
  def send_markPartiallyActive(self, itemId, categoryId):
6807 
    self._oprot.writeMessageBegin('markPartiallyActive', TMessageType.CALL, self._seqid)
6808 
    args = markPartiallyActive_args()
6809 
    args.itemId = itemId
6810 
    args.categoryId = categoryId
6811 
    args.write(self._oprot)
6812 
    self._oprot.writeMessageEnd()
6813 
    self._oprot.trans.flush()
6814 
 
6815 
  def recv_markPartiallyActive(self, ):
6816 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6817 
    if mtype == TMessageType.EXCEPTION:
6818 
      x = TApplicationException()
6819 
      x.read(self._iprot)
6820 
      self._iprot.readMessageEnd()
6821 
      raise x
6822 
    result = markPartiallyActive_result()
6823 
    result.read(self._iprot)
6824 
    self._iprot.readMessageEnd()
6825 
    if result.success is not None:
6826 
      return result.success
6827 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markPartiallyActive failed: unknown result");
6828 
 
6829 
  def updateItemStateVat(self, itemId, statevat):
6830 
    """
6831 
    Parameters:
6832 
     - itemId
6833 
     - statevat
6834 
    """
6835 
    self.send_updateItemStateVat(itemId, statevat)
6836 
    return self.recv_updateItemStateVat()
6837 
 
6838 
  def send_updateItemStateVat(self, itemId, statevat):
6839 
    self._oprot.writeMessageBegin('updateItemStateVat', TMessageType.CALL, self._seqid)
6840 
    args = updateItemStateVat_args()
6841 
    args.itemId = itemId
6842 
    args.statevat = statevat
6843 
    args.write(self._oprot)
6844 
    self._oprot.writeMessageEnd()
6845 
    self._oprot.trans.flush()
6846 
 
6847 
  def recv_updateItemStateVat(self, ):
6848 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6849 
    if mtype == TMessageType.EXCEPTION:
6850 
      x = TApplicationException()
6851 
      x.read(self._iprot)
6852 
      self._iprot.readMessageEnd()
6853 
      raise x
6854 
    result = updateItemStateVat_result()
6855 
    result.read(self._iprot)
6856 
    self._iprot.readMessageEnd()
6857 
    if result.success is not None:
6858 
      return result.success
6859 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItemStateVat failed: unknown result");
6860 
 
12620 amit.gupta 6861 
  def getExAffiliateItemInfo(self, ):
6862 
    self.send_getExAffiliateItemInfo()
6863 
    return self.recv_getExAffiliateItemInfo()
12567 amit.gupta 6864 
 
12620 amit.gupta 6865 
  def send_getExAffiliateItemInfo(self, ):
6866 
    self._oprot.writeMessageBegin('getExAffiliateItemInfo', TMessageType.CALL, self._seqid)
6867 
    args = getExAffiliateItemInfo_args()
6868 
    args.write(self._oprot)
6869 
    self._oprot.writeMessageEnd()
6870 
    self._oprot.trans.flush()
6871 
 
6872 
  def recv_getExAffiliateItemInfo(self, ):
6873 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6874 
    if mtype == TMessageType.EXCEPTION:
6875 
      x = TApplicationException()
6876 
      x.read(self._iprot)
6877 
      self._iprot.readMessageEnd()
6878 
      raise x
6879 
    result = getExAffiliateItemInfo_result()
6880 
    result.read(self._iprot)
6881 
    self._iprot.readMessageEnd()
6882 
    if result.success is not None:
6883 
      return result.success
6884 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getExAffiliateItemInfo failed: unknown result");
6885 
 
12888 kshitij.so 6886 
  def getAllItemstoListOnFbg(self, ):
6887 
    self.send_getAllItemstoListOnFbg()
6888 
    return self.recv_getAllItemstoListOnFbg()
12620 amit.gupta 6889 
 
12888 kshitij.so 6890 
  def send_getAllItemstoListOnFbg(self, ):
6891 
    self._oprot.writeMessageBegin('getAllItemstoListOnFbg', TMessageType.CALL, self._seqid)
6892 
    args = getAllItemstoListOnFbg_args()
6893 
    args.write(self._oprot)
6894 
    self._oprot.writeMessageEnd()
6895 
    self._oprot.trans.flush()
6896 
 
6897 
  def recv_getAllItemstoListOnFbg(self, ):
6898 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6899 
    if mtype == TMessageType.EXCEPTION:
6900 
      x = TApplicationException()
6901 
      x.read(self._iprot)
6902 
      self._iprot.readMessageEnd()
6903 
      raise x
6904 
    result = getAllItemstoListOnFbg_result()
6905 
    result.read(self._iprot)
6906 
    self._iprot.readMessageEnd()
6907 
    if result.success is not None:
6908 
      return result.success
6909 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnFbg failed: unknown result");
6910 
 
12892 kshitij.so 6911 
  def getAllFbgListedItems(self, ):
6912 
    self.send_getAllFbgListedItems()
6913 
    return self.recv_getAllFbgListedItems()
12888 kshitij.so 6914 
 
12892 kshitij.so 6915 
  def send_getAllFbgListedItems(self, ):
6916 
    self._oprot.writeMessageBegin('getAllFbgListedItems', TMessageType.CALL, self._seqid)
6917 
    args = getAllFbgListedItems_args()
6918 
    args.write(self._oprot)
6919 
    self._oprot.writeMessageEnd()
6920 
    self._oprot.trans.flush()
6921 
 
6922 
  def recv_getAllFbgListedItems(self, ):
6923 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6924 
    if mtype == TMessageType.EXCEPTION:
6925 
      x = TApplicationException()
6926 
      x.read(self._iprot)
6927 
      self._iprot.readMessageEnd()
6928 
      raise x
6929 
    result = getAllFbgListedItems_result()
6930 
    result.read(self._iprot)
6931 
    self._iprot.readMessageEnd()
6932 
    if result.success is not None:
6933 
      return result.success
6934 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbgListedItems failed: unknown result");
6935 
 
13136 amit.gupta 6936 
  def checkServices(self, lines):
6937 
    """
6938 
    Parameters:
6939 
     - lines
6940 
    """
6941 
    self.send_checkServices(lines)
6942 
    return self.recv_checkServices()
12892 kshitij.so 6943 
 
13136 amit.gupta 6944 
  def send_checkServices(self, lines):
6945 
    self._oprot.writeMessageBegin('checkServices', TMessageType.CALL, self._seqid)
6946 
    args = checkServices_args()
6947 
    args.lines = lines
6948 
    args.write(self._oprot)
6949 
    self._oprot.writeMessageEnd()
6950 
    self._oprot.trans.flush()
6951 
 
6952 
  def recv_checkServices(self, ):
6953 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6954 
    if mtype == TMessageType.EXCEPTION:
6955 
      x = TApplicationException()
6956 
      x.read(self._iprot)
6957 
      self._iprot.readMessageEnd()
6958 
      raise x
6959 
    result = checkServices_result()
6960 
    result.read(self._iprot)
6961 
    self._iprot.readMessageEnd()
6962 
    if result.success is not None:
6963 
      return result.success
6964 
    if result.cex is not None:
6965 
      raise result.cex
6966 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkServices failed: unknown result");
6967 
 
13709 manish.sha 6968 
  def addHsItem(self, hsItems):
6969 
    """
6970 
    Parameters:
6971 
     - hsItems
6972 
    """
6973 
    self.send_addHsItem(hsItems)
6974 
    self.recv_addHsItem()
13136 amit.gupta 6975 
 
13709 manish.sha 6976 
  def send_addHsItem(self, hsItems):
6977 
    self._oprot.writeMessageBegin('addHsItem', TMessageType.CALL, self._seqid)
6978 
    args = addHsItem_args()
6979 
    args.hsItems = hsItems
6980 
    args.write(self._oprot)
6981 
    self._oprot.writeMessageEnd()
6982 
    self._oprot.trans.flush()
6983 
 
6984 
  def recv_addHsItem(self, ):
6985 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6986 
    if mtype == TMessageType.EXCEPTION:
6987 
      x = TApplicationException()
6988 
      x.read(self._iprot)
6989 
      self._iprot.readMessageEnd()
6990 
      raise x
6991 
    result = addHsItem_result()
6992 
    result.read(self._iprot)
6993 
    self._iprot.readMessageEnd()
6994 
    return
6995 
 
6996 
  def getHsItem(self, hsItemId):
6997 
    """
6998 
    Parameters:
6999 
     - hsItemId
7000 
    """
7001 
    self.send_getHsItem(hsItemId)
7002 
    return self.recv_getHsItem()
7003 
 
7004 
  def send_getHsItem(self, hsItemId):
7005 
    self._oprot.writeMessageBegin('getHsItem', TMessageType.CALL, self._seqid)
7006 
    args = getHsItem_args()
7007 
    args.hsItemId = hsItemId
7008 
    args.write(self._oprot)
7009 
    self._oprot.writeMessageEnd()
7010 
    self._oprot.trans.flush()
7011 
 
7012 
  def recv_getHsItem(self, ):
7013 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7014 
    if mtype == TMessageType.EXCEPTION:
7015 
      x = TApplicationException()
7016 
      x.read(self._iprot)
7017 
      self._iprot.readMessageEnd()
7018 
      raise x
7019 
    result = getHsItem_result()
7020 
    result.read(self._iprot)
7021 
    self._iprot.readMessageEnd()
7022 
    if result.success is not None:
7023 
      return result.success
7024 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getHsItem failed: unknown result");
7025 
 
7026 
  def updateHsItem(self, hsItem):
7027 
    """
7028 
    Parameters:
7029 
     - hsItem
7030 
    """
7031 
    self.send_updateHsItem(hsItem)
7032 
    self.recv_updateHsItem()
7033 
 
7034 
  def send_updateHsItem(self, hsItem):
7035 
    self._oprot.writeMessageBegin('updateHsItem', TMessageType.CALL, self._seqid)
7036 
    args = updateHsItem_args()
7037 
    args.hsItem = hsItem
7038 
    args.write(self._oprot)
7039 
    self._oprot.writeMessageEnd()
7040 
    self._oprot.trans.flush()
7041 
 
7042 
  def recv_updateHsItem(self, ):
7043 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7044 
    if mtype == TMessageType.EXCEPTION:
7045 
      x = TApplicationException()
7046 
      x.read(self._iprot)
7047 
      self._iprot.readMessageEnd()
7048 
      raise x
7049 
    result = updateHsItem_result()
7050 
    result.read(self._iprot)
7051 
    self._iprot.readMessageEnd()
7052 
    return
7053 
 
14182 kshitij.so 7054 
  def getPricingForDtr(self, catalogItemId):
7055 
    """
7056 
    Parameters:
7057 
     - catalogItemId
7058 
    """
7059 
    self.send_getPricingForDtr(catalogItemId)
7060 
    return self.recv_getPricingForDtr()
13709 manish.sha 7061 
 
14182 kshitij.so 7062 
  def send_getPricingForDtr(self, catalogItemId):
7063 
    self._oprot.writeMessageBegin('getPricingForDtr', TMessageType.CALL, self._seqid)
7064 
    args = getPricingForDtr_args()
7065 
    args.catalogItemId = catalogItemId
7066 
    args.write(self._oprot)
7067 
    self._oprot.writeMessageEnd()
7068 
    self._oprot.trans.flush()
7069 
 
7070 
  def recv_getPricingForDtr(self, ):
7071 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7072 
    if mtype == TMessageType.EXCEPTION:
7073 
      x = TApplicationException()
7074 
      x.read(self._iprot)
7075 
      self._iprot.readMessageEnd()
7076 
      raise x
7077 
    result = getPricingForDtr_result()
7078 
    result.read(self._iprot)
7079 
    self._iprot.readMessageEnd()
7080 
    if result.success is not None:
7081 
      return result.success
7082 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPricingForDtr failed: unknown result");
7083 
 
15702 kshitij.so 7084 
  def getAllItemstoListOnFbd(self, ):
7085 
    self.send_getAllItemstoListOnFbd()
7086 
    return self.recv_getAllItemstoListOnFbd()
14182 kshitij.so 7087 
 
15702 kshitij.so 7088 
  def send_getAllItemstoListOnFbd(self, ):
7089 
    self._oprot.writeMessageBegin('getAllItemstoListOnFbd', TMessageType.CALL, self._seqid)
7090 
    args = getAllItemstoListOnFbd_args()
7091 
    args.write(self._oprot)
7092 
    self._oprot.writeMessageEnd()
7093 
    self._oprot.trans.flush()
7094 
 
7095 
  def recv_getAllItemstoListOnFbd(self, ):
7096 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7097 
    if mtype == TMessageType.EXCEPTION:
7098 
      x = TApplicationException()
7099 
      x.read(self._iprot)
7100 
      self._iprot.readMessageEnd()
7101 
      raise x
7102 
    result = getAllItemstoListOnFbd_result()
7103 
    result.read(self._iprot)
7104 
    self._iprot.readMessageEnd()
7105 
    if result.success is not None:
7106 
      return result.success
7107 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnFbd failed: unknown result");
7108 
 
15706 kshitij.so 7109 
  def getAllFbdListedItems(self, ):
7110 
    self.send_getAllFbdListedItems()
7111 
    return self.recv_getAllFbdListedItems()
15702 kshitij.so 7112 
 
15706 kshitij.so 7113 
  def send_getAllFbdListedItems(self, ):
7114 
    self._oprot.writeMessageBegin('getAllFbdListedItems', TMessageType.CALL, self._seqid)
7115 
    args = getAllFbdListedItems_args()
7116 
    args.write(self._oprot)
7117 
    self._oprot.writeMessageEnd()
7118 
    self._oprot.trans.flush()
7119 
 
7120 
  def recv_getAllFbdListedItems(self, ):
7121 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7122 
    if mtype == TMessageType.EXCEPTION:
7123 
      x = TApplicationException()
7124 
      x.read(self._iprot)
7125 
      self._iprot.readMessageEnd()
7126 
      raise x
7127 
    result = getAllFbdListedItems_result()
7128 
    result.read(self._iprot)
7129 
    self._iprot.readMessageEnd()
7130 
    if result.success is not None:
7131 
      return result.success
7132 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbdListedItems failed: unknown result");
7133 
 
18150 kshitij.so 7134 
  def getBulkPricingForItems(self, itemIds):
7135 
    """
7136 
    Parameters:
7137 
     - itemIds
7138 
    """
7139 
    self.send_getBulkPricingForItems(itemIds)
7140 
    return self.recv_getBulkPricingForItems()
15706 kshitij.so 7141 
 
18150 kshitij.so 7142 
  def send_getBulkPricingForItems(self, itemIds):
7143 
    self._oprot.writeMessageBegin('getBulkPricingForItems', TMessageType.CALL, self._seqid)
7144 
    args = getBulkPricingForItems_args()
7145 
    args.itemIds = itemIds
7146 
    args.write(self._oprot)
7147 
    self._oprot.writeMessageEnd()
7148 
    self._oprot.trans.flush()
7149 
 
7150 
  def recv_getBulkPricingForItems(self, ):
7151 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7152 
    if mtype == TMessageType.EXCEPTION:
7153 
      x = TApplicationException()
7154 
      x.read(self._iprot)
7155 
      self._iprot.readMessageEnd()
7156 
      raise x
7157 
    result = getBulkPricingForItems_result()
7158 
    result.read(self._iprot)
7159 
    self._iprot.readMessageEnd()
7160 
    if result.success is not None:
7161 
      return result.success
7162 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBulkPricingForItems failed: unknown result");
7163 
 
7164 
  def addBulkPricingForItem(self, bulkItemPricing):
7165 
    """
7166 
    Parameters:
7167 
     - bulkItemPricing
7168 
    """
7169 
    self.send_addBulkPricingForItem(bulkItemPricing)
7170 
    return self.recv_addBulkPricingForItem()
7171 
 
7172 
  def send_addBulkPricingForItem(self, bulkItemPricing):
7173 
    self._oprot.writeMessageBegin('addBulkPricingForItem', TMessageType.CALL, self._seqid)
7174 
    args = addBulkPricingForItem_args()
7175 
    args.bulkItemPricing = bulkItemPricing
7176 
    args.write(self._oprot)
7177 
    self._oprot.writeMessageEnd()
7178 
    self._oprot.trans.flush()
7179 
 
7180 
  def recv_addBulkPricingForItem(self, ):
7181 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7182 
    if mtype == TMessageType.EXCEPTION:
7183 
      x = TApplicationException()
7184 
      x.read(self._iprot)
7185 
      self._iprot.readMessageEnd()
7186 
      raise x
7187 
    result = addBulkPricingForItem_result()
7188 
    result.read(self._iprot)
7189 
    self._iprot.readMessageEnd()
7190 
    if result.success is not None:
7191 
      return result.success
7192 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBulkPricingForItem failed: unknown result");
7193 
 
7194 
  def deleteBulkPricingForItemById(self, id):
7195 
    """
7196 
    Parameters:
7197 
     - id
7198 
    """
7199 
    self.send_deleteBulkPricingForItemById(id)
7200 
    return self.recv_deleteBulkPricingForItemById()
7201 
 
7202 
  def send_deleteBulkPricingForItemById(self, id):
7203 
    self._oprot.writeMessageBegin('deleteBulkPricingForItemById', TMessageType.CALL, self._seqid)
7204 
    args = deleteBulkPricingForItemById_args()
7205 
    args.id = id
7206 
    args.write(self._oprot)
7207 
    self._oprot.writeMessageEnd()
7208 
    self._oprot.trans.flush()
7209 
 
7210 
  def recv_deleteBulkPricingForItemById(self, ):
7211 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7212 
    if mtype == TMessageType.EXCEPTION:
7213 
      x = TApplicationException()
7214 
      x.read(self._iprot)
7215 
      self._iprot.readMessageEnd()
7216 
      raise x
7217 
    result = deleteBulkPricingForItemById_result()
7218 
    result.read(self._iprot)
7219 
    self._iprot.readMessageEnd()
7220 
    if result.success is not None:
7221 
      return result.success
7222 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBulkPricingForItemById failed: unknown result");
7223 
 
7224 
  def deleteBulkPricingForItem(self, item_id):
7225 
    """
7226 
    Parameters:
7227 
     - item_id
7228 
    """
7229 
    self.send_deleteBulkPricingForItem(item_id)
7230 
    return self.recv_deleteBulkPricingForItem()
7231 
 
7232 
  def send_deleteBulkPricingForItem(self, item_id):
7233 
    self._oprot.writeMessageBegin('deleteBulkPricingForItem', TMessageType.CALL, self._seqid)
7234 
    args = deleteBulkPricingForItem_args()
7235 
    args.item_id = item_id
7236 
    args.write(self._oprot)
7237 
    self._oprot.writeMessageEnd()
7238 
    self._oprot.trans.flush()
7239 
 
7240 
  def recv_deleteBulkPricingForItem(self, ):
7241 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7242 
    if mtype == TMessageType.EXCEPTION:
7243 
      x = TApplicationException()
7244 
      x.read(self._iprot)
7245 
      self._iprot.readMessageEnd()
7246 
      raise x
7247 
    result = deleteBulkPricingForItem_result()
7248 
    result.read(self._iprot)
7249 
    self._iprot.readMessageEnd()
7250 
    if result.success is not None:
7251 
      return result.success
7252 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBulkPricingForItem failed: unknown result");
7253 
 
7254 
  def getBulkPricingByItemId(self, item_id):
7255 
    """
7256 
    Parameters:
7257 
     - item_id
7258 
    """
7259 
    self.send_getBulkPricingByItemId(item_id)
7260 
    return self.recv_getBulkPricingByItemId()
7261 
 
7262 
  def send_getBulkPricingByItemId(self, item_id):
7263 
    self._oprot.writeMessageBegin('getBulkPricingByItemId', TMessageType.CALL, self._seqid)
7264 
    args = getBulkPricingByItemId_args()
7265 
    args.item_id = item_id
7266 
    args.write(self._oprot)
7267 
    self._oprot.writeMessageEnd()
7268 
    self._oprot.trans.flush()
7269 
 
7270 
  def recv_getBulkPricingByItemId(self, ):
7271 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7272 
    if mtype == TMessageType.EXCEPTION:
7273 
      x = TApplicationException()
7274 
      x.read(self._iprot)
7275 
      self._iprot.readMessageEnd()
7276 
      raise x
7277 
    result = getBulkPricingByItemId_result()
7278 
    result.read(self._iprot)
7279 
    self._iprot.readMessageEnd()
7280 
    if result.success is not None:
7281 
      return result.success
7282 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBulkPricingByItemId failed: unknown result");
7283 
 
18602 kshitij.so 7284 
  def updateBulkPricesOnProduction(self, item_id, bulkItemPricingList):
7285 
    """
7286 
    Parameters:
7287 
     - item_id
7288 
     - bulkItemPricingList
7289 
    """
7290 
    self.send_updateBulkPricesOnProduction(item_id, bulkItemPricingList)
7291 
    return self.recv_updateBulkPricesOnProduction()
18150 kshitij.so 7292 
 
18602 kshitij.so 7293 
  def send_updateBulkPricesOnProduction(self, item_id, bulkItemPricingList):
7294 
    self._oprot.writeMessageBegin('updateBulkPricesOnProduction', TMessageType.CALL, self._seqid)
7295 
    args = updateBulkPricesOnProduction_args()
7296 
    args.item_id = item_id
7297 
    args.bulkItemPricingList = bulkItemPricingList
7298 
    args.write(self._oprot)
7299 
    self._oprot.writeMessageEnd()
7300 
    self._oprot.trans.flush()
7301 
 
7302 
  def recv_updateBulkPricesOnProduction(self, ):
7303 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7304 
    if mtype == TMessageType.EXCEPTION:
7305 
      x = TApplicationException()
7306 
      x.read(self._iprot)
7307 
      self._iprot.readMessageEnd()
7308 
      raise x
7309 
    result = updateBulkPricesOnProduction_result()
7310 
    result.read(self._iprot)
7311 
    self._iprot.readMessageEnd()
7312 
    if result.success is not None:
7313 
      return result.success
7314 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBulkPricesOnProduction failed: unknown result");
7315 
 
18764 kshitij.so 7316 
  def getCartByValue(self, cartIds):
7317 
    """
7318 
    Parameters:
7319 
     - cartIds
7320 
    """
7321 
    self.send_getCartByValue(cartIds)
7322 
    return self.recv_getCartByValue()
18602 kshitij.so 7323 
 
18764 kshitij.so 7324 
  def send_getCartByValue(self, cartIds):
7325 
    self._oprot.writeMessageBegin('getCartByValue', TMessageType.CALL, self._seqid)
7326 
    args = getCartByValue_args()
7327 
    args.cartIds = cartIds
7328 
    args.write(self._oprot)
7329 
    self._oprot.writeMessageEnd()
7330 
    self._oprot.trans.flush()
7331 
 
7332 
  def recv_getCartByValue(self, ):
7333 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7334 
    if mtype == TMessageType.EXCEPTION:
7335 
      x = TApplicationException()
7336 
      x.read(self._iprot)
7337 
      self._iprot.readMessageEnd()
7338 
      raise x
7339 
    result = getCartByValue_result()
7340 
    result.read(self._iprot)
7341 
    self._iprot.readMessageEnd()
7342 
    if result.success is not None:
7343 
      return result.success
7344 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartByValue failed: unknown result");
7345 
 
7346 
 
5944 mandeep.dh 7347 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
7348 
  def __init__(self, handler):
7349 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
7350 
    self._processMap["addItem"] = Processor.process_addItem
7351 
    self._processMap["updateItem"] = Processor.process_updateItem
7352 
    self._processMap["isActive"] = Processor.process_isActive
7438 amit.gupta 7353 
    self._processMap["getItemsStatus"] = Processor.process_getItemsStatus
5944 mandeep.dh 7354 
    self._processMap["getItemStatusDescription"] = Processor.process_getItemStatusDescription
7355 
    self._processMap["startItemOn"] = Processor.process_startItemOn
7356 
    self._processMap["retireItemOn"] = Processor.process_retireItemOn
7357 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
7358 
    self._processMap["getItem"] = Processor.process_getItem
13493 amit.gupta 7359 
    self._processMap["getItems"] = Processor.process_getItems
5944 mandeep.dh 7360 
    self._processMap["getItemsByCatalogId"] = Processor.process_getItemsByCatalogId
7361 
    self._processMap["getValidItemsByCatalogId"] = Processor.process_getValidItemsByCatalogId
7362 
    self._processMap["getAllItems"] = Processor.process_getAllItems
7363 
    self._processMap["getAllItemsByStatus"] = Processor.process_getAllItemsByStatus
7364 
    self._processMap["markItemAsContentComplete"] = Processor.process_markItemAsContentComplete
12567 amit.gupta 7365 
    self._processMap["getVatRates"] = Processor.process_getVatRates
5944 mandeep.dh 7366 
    self._processMap["getAllItemsInRange"] = Processor.process_getAllItemsInRange
7367 
    self._processMap["getAllItemsByStatusInRange"] = Processor.process_getAllItemsByStatusInRange
7368 
    self._processMap["getItemCountByStatus"] = Processor.process_getItemCountByStatus
7369 
    self._processMap["getBestSellers"] = Processor.process_getBestSellers
7370 
    self._processMap["getBestSellersCatalogIds"] = Processor.process_getBestSellersCatalogIds
7371 
    self._processMap["getBestSellersCount"] = Processor.process_getBestSellersCount
7372 
    self._processMap["getBestDeals"] = Processor.process_getBestDeals
7373 
    self._processMap["getBestDealsCatalogIds"] = Processor.process_getBestDealsCatalogIds
7374 
    self._processMap["getBestDealsCount"] = Processor.process_getBestDealsCount
7375 
    self._processMap["getComingSoon"] = Processor.process_getComingSoon
7376 
    self._processMap["getComingSoonCatalogIds"] = Processor.process_getComingSoonCatalogIds
7377 
    self._processMap["getComingSoonCount"] = Processor.process_getComingSoonCount
7378 
    self._processMap["getLatestArrivals"] = Processor.process_getLatestArrivals
7379 
    self._processMap["getLatestArrivalsCatalogIds"] = Processor.process_getLatestArrivalsCatalogIds
7380 
    self._processMap["getLatestArrivalsCount"] = Processor.process_getLatestArrivalsCount
7381 
    self._processMap["generateNewEntityID"] = Processor.process_generateNewEntityID
7382 
    self._processMap["addCategory"] = Processor.process_addCategory
7383 
    self._processMap["getCategory"] = Processor.process_getCategory
7384 
    self._processMap["getAllCategories"] = Processor.process_getAllCategories
7385 
    self._processMap["getAllSimilarItems"] = Processor.process_getAllSimilarItems
7386 
    self._processMap["addSimilarItem"] = Processor.process_addSimilarItem
6512 kshitij.so 7387 
    self._processMap["addTag"] = Processor.process_addTag
7388 
    self._processMap["deleteEntityTag"] = Processor.process_deleteEntityTag
7389 
    self._processMap["deleteTag"] = Processor.process_deleteTag
7390 
    self._processMap["getAllTags"] = Processor.process_getAllTags
7391 
    self._processMap["getAllEntitiesByTagName"] = Processor.process_getAllEntitiesByTagName
6845 amit.gupta 7392 
    self._processMap["getAllEntityTags"] = Processor.process_getAllEntityTags
6850 kshitij.so 7393 
    self._processMap["addBanner"] = Processor.process_addBanner
8579 kshitij.so 7394 
    self._processMap["updateBanner"] = Processor.process_updateBanner
6850 kshitij.so 7395 
    self._processMap["getAllBanners"] = Processor.process_getAllBanners
7396 
    self._processMap["deleteBanner"] = Processor.process_deleteBanner
7397 
    self._processMap["getBannerDetails"] = Processor.process_getBannerDetails
7398 
    self._processMap["getActiveBanners"] = Processor.process_getActiveBanners
6849 kshitij.so 7399 
    self._processMap["addBannerMap"] = Processor.process_addBannerMap
8579 kshitij.so 7400 
    self._processMap["updateBannerMap"] = Processor.process_updateBannerMap
6849 kshitij.so 7401 
    self._processMap["deleteBannerMap"] = Processor.process_deleteBannerMap
7402 
    self._processMap["getBannerMapDetails"] = Processor.process_getBannerMapDetails
8579 kshitij.so 7403 
    self._processMap["addBannerUri"] = Processor.process_addBannerUri
7404 
    self._processMap["getUriMapping"] = Processor.process_getUriMapping
7405 
    self._processMap["addCampaign"] = Processor.process_addCampaign
7406 
    self._processMap["getCampaigns"] = Processor.process_getCampaigns
7407 
    self._processMap["deleteCampaign"] = Processor.process_deleteCampaign
7408 
    self._processMap["getAllCampaigns"] = Processor.process_getAllCampaigns
9155 kshitij.so 7409 
    self._processMap["getActiveBannersForMobileSite"] = Processor.process_getActiveBannersForMobileSite
5944 mandeep.dh 7410 
    self._processMap["deleteSimilarItem"] = Processor.process_deleteSimilarItem
7411 
    self._processMap["checkSimilarItem"] = Processor.process_checkSimilarItem
7412 
    self._processMap["validateRiskyStatus"] = Processor.process_validateRiskyStatus
7413 
    self._processMap["changeItemRiskyFlag"] = Processor.process_changeItemRiskyFlag
7414 
    self._processMap["getItemsByRiskyFlag"] = Processor.process_getItemsByRiskyFlag
7415 
    self._processMap["getItemsForMasterSheet"] = Processor.process_getItemsForMasterSheet
7416 
    self._processMap["getSimilarItemsCatalogIds"] = Processor.process_getSimilarItemsCatalogIds
7417 
    self._processMap["addProductNotification"] = Processor.process_addProductNotification
7418 
    self._processMap["sendProductNotifications"] = Processor.process_sendProductNotifications
7419 
    self._processMap["getAllBrandsByCategory"] = Processor.process_getAllBrandsByCategory
7420 
    self._processMap["getAllBrands"] = Processor.process_getAllBrands
7421 
    self._processMap["getAllSources"] = Processor.process_getAllSources
7422 
    self._processMap["getItemPricingBySource"] = Processor.process_getItemPricingBySource
7423 
    self._processMap["addSourceItemPricing"] = Processor.process_addSourceItemPricing
7424 
    self._processMap["getAllSourcePricing"] = Processor.process_getAllSourcePricing
7425 
    self._processMap["getItemForSource"] = Processor.process_getItemForSource
7426 
    self._processMap["searchItemsInRange"] = Processor.process_searchItemsInRange
7427 
    self._processMap["getSearchResultCount"] = Processor.process_getSearchResultCount
7428 
    self._processMap["getProductNotifications"] = Processor.process_getProductNotifications
7429 
    self._processMap["getProductNotificationRequestCount"] = Processor.process_getProductNotificationRequestCount
7430 
    self._processMap["addAuthorizationLog"] = Processor.process_addAuthorizationLog
7431 
    self._processMap["addupdateVoucherForItem"] = Processor.process_addupdateVoucherForItem
7432 
    self._processMap["deleteVoucherForItem"] = Processor.process_deleteVoucherForItem
7433 
    self._processMap["getVoucherAmount"] = Processor.process_getVoucherAmount
7434 
    self._processMap["getAllItemVouchers"] = Processor.process_getAllItemVouchers
7435 
    self._processMap["isValidCatalogItemId"] = Processor.process_isValidCatalogItemId
6039 amit.gupta 7436 
    self._processMap["getVatPercentageForItem"] = Processor.process_getVatPercentageForItem
7437 
    self._processMap["getVatAmountForItem"] = Processor.process_getVatAmountForItem
6531 vikram.rag 7438 
    self._processMap["getAllIgnoredInventoryUpdateItemsList"] = Processor.process_getAllIgnoredInventoryUpdateItemsList
6821 amar.kumar 7439 
    self._processMap["getAllAliveItems"] = Processor.process_getAllAliveItems
6805 anupam.sin 7440 
    self._processMap["getInsuranceAmount"] = Processor.process_getInsuranceAmount
7441 
    self._processMap["getInsurer"] = Processor.process_getInsurer
6838 vikram.rag 7442 
    self._processMap["getAllInsurers"] = Processor.process_getAllInsurers
6962 rajveer 7443 
    self._processMap["updateInsuranceDeclaredAmount"] = Processor.process_updateInsuranceDeclaredAmount
7190 amar.kumar 7444 
    self._processMap["getFreebieForItem"] = Processor.process_getFreebieForItem
7445 
    self._processMap["addOrUpdateFreebieForItem"] = Processor.process_addOrUpdateFreebieForItem
7272 amit.gupta 7446 
    self._processMap["addOrUpdateBrandInfo"] = Processor.process_addOrUpdateBrandInfo
7447 
    self._processMap["getBrandInfo"] = Processor.process_getBrandInfo
7256 rajveer 7448 
    self._processMap["getStorePricing"] = Processor.process_getStorePricing
7306 rajveer 7449 
    self._processMap["getStorePricings"] = Processor.process_getStorePricings
7265 rajveer 7450 
    self._processMap["updateStorePricing"] = Processor.process_updateStorePricing
7281 kshitij.so 7451 
    self._processMap["getAllAmazonListedItems"] = Processor.process_getAllAmazonListedItems
8619 kshitij.so 7452 
    self._processMap["searchAmazonItems"] = Processor.process_searchAmazonItems
7453 
    self._processMap["getAmazonSearchResultCount"] = Processor.process_getAmazonSearchResultCount
7454 
    self._processMap["getCountForAmazonlistedItems"] = Processor.process_getCountForAmazonlistedItems
7281 kshitij.so 7455 
    self._processMap["getAmazonItemDetails"] = Processor.process_getAmazonItemDetails
7456 
    self._processMap["updateAmazonItemDetails"] = Processor.process_updateAmazonItemDetails
7457 
    self._processMap["addAmazonItem"] = Processor.process_addAmazonItem
7291 vikram.rag 7458 
    self._processMap["getAsinItems"] = Processor.process_getAsinItems
7459 
    self._processMap["getAllFbaListedItems"] = Processor.process_getAllFbaListedItems
7460 
    self._processMap["getAllNonFbaListedItems"] = Processor.process_getAllNonFbaListedItems
7460 kshitij.so 7461 
    self._processMap["updateItemInventory"] = Processor.process_updateItemInventory
7770 kshitij.so 7462 
    self._processMap["updateTimestampForAmazonFeeds"] = Processor.process_updateTimestampForAmazonFeeds
7897 amar.kumar 7463 
    self._processMap["getAllParentCategories"] = Processor.process_getAllParentCategories
7977 kshitij.so 7464 
    self._processMap["addPageViewEvent"] = Processor.process_addPageViewEvent
7465 
    self._processMap["addCartEvent"] = Processor.process_addCartEvent
8182 amar.kumar 7466 
    self._processMap["addEbayItem"] = Processor.process_addEbayItem
7467 
    self._processMap["getEbayItem"] = Processor.process_getEbayItem
7468 
    self._processMap["updateEbayItem"] = Processor.process_updateEbayItem
8139 kshitij.so 7469 
    self._processMap["getAmazonListedItems"] = Processor.process_getAmazonListedItems
8168 kshitij.so 7470 
    self._processMap["updateAmazonAttributesInBulk"] = Processor.process_updateAmazonAttributesInBulk
8379 vikram.rag 7471 
    self._processMap["getAllItemstoListOnFba"] = Processor.process_getAllItemstoListOnFba
7472 
    self._processMap["getAllItemstoListOnNonFba"] = Processor.process_getAllItemstoListOnNonFba
8619 kshitij.so 7473 
    self._processMap["updateAsin"] = Processor.process_updateAsin
8739 vikram.rag 7474 
    self._processMap["addOrUpdateSnapdealItem"] = Processor.process_addOrUpdateSnapdealItem
7475 
    self._processMap["getSnapdealItem"] = Processor.process_getSnapdealItem
9242 kshitij.so 7476 
    self._processMap["getSnapdealItemDetails"] = Processor.process_getSnapdealItemDetails
8739 vikram.rag 7477 
    self._processMap["getAllSnapdealItems"] = Processor.process_getAllSnapdealItems
9242 kshitij.so 7478 
    self._processMap["getSnapdealItems"] = Processor.process_getSnapdealItems
7479 
    self._processMap["searchSnapdealItems"] = Processor.process_searchSnapdealItems
7480 
    self._processMap["getCountForSnapdealItems"] = Processor.process_getCountForSnapdealItems
7481 
    self._processMap["getSnapdealSearchResultCount"] = Processor.process_getSnapdealSearchResultCount
9299 kshitij.so 7482 
    self._processMap["getPrefferedInsurerForItem"] = Processor.process_getPrefferedInsurerForItem
9456 vikram.rag 7483 
    self._processMap["getSnapdealItembySkuAtSnapdeal"] = Processor.process_getSnapdealItembySkuAtSnapdeal
9621 manish.sha 7484 
    self._processMap["getProductFeedSubmit"] = Processor.process_getProductFeedSubmit
7485 
    self._processMap["addProductFeedSubmit"] = Processor.process_addProductFeedSubmit
7486 
    self._processMap["updateProductFeedSubmit"] = Processor.process_updateProductFeedSubmit
7487 
    self._processMap["deleteProductFeedSubmit"] = Processor.process_deleteProductFeedSubmit
7488 
    self._processMap["getAllProductFeedSubmit"] = Processor.process_getAllProductFeedSubmit
9724 kshitij.so 7489 
    self._processMap["getMarketplacedetailsForItem"] = Processor.process_getMarketplacedetailsForItem
7490 
    self._processMap["updateMarketplaceAttributesForItem"] = Processor.process_updateMarketplaceAttributesForItem
9779 kshitij.so 7491 
    self._processMap["getCostingForMarketplace"] = Processor.process_getCostingForMarketplace
9776 vikram.rag 7492 
    self._processMap["getMarketPlaceItemsForPriceUpdate"] = Processor.process_getMarketPlaceItemsForPriceUpdate
7493 
    self._processMap["updateMarketPlacePriceUpdateStatus"] = Processor.process_updateMarketPlacePriceUpdateStatus
9861 rajveer 7494 
    self._processMap["updateItemHoldInventory"] = Processor.process_updateItemHoldInventory
9895 vikram.rag 7495 
    self._processMap["updateNlcAtMarketplaces"] = Processor.process_updateNlcAtMarketplaces
9945 vikram.rag 7496 
    self._processMap["getAllFlipkartItems"] = Processor.process_getAllFlipkartItems
10097 kshitij.so 7497 
    self._processMap["addOrUpdateFlipkartItem"] = Processor.process_addOrUpdateFlipkartItem
7498 
    self._processMap["getFlipkartItem"] = Processor.process_getFlipkartItem
7499 
    self._processMap["getFlipkartItemDetails"] = Processor.process_getFlipkartItemDetails
7500 
    self._processMap["getFlipkartItems"] = Processor.process_getFlipkartItems
7501 
    self._processMap["searchFlipkartItems"] = Processor.process_searchFlipkartItems
7502 
    self._processMap["getCountForFlipkartItems"] = Processor.process_getCountForFlipkartItems
7503 
    self._processMap["getFlipkartSearchResultCount"] = Processor.process_getFlipkartSearchResultCount
7504 
    self._processMap["getAllFkItems"] = Processor.process_getAllFkItems
10140 vikram.rag 7505 
    self._processMap["getFlipkartItemBySkyAtFlipkart"] = Processor.process_getFlipkartItemBySkyAtFlipkart
11015 kshitij.so 7506 
    self._processMap["getMarketplaceHistory"] = Processor.process_getMarketplaceHistory
10909 vikram.rag 7507 
    self._processMap["getAllFbbListedItems"] = Processor.process_getAllFbbListedItems
10924 vikram.rag 7508 
    self._processMap["getAllFbbPricingItems"] = Processor.process_getAllFbbPricingItems
11015 kshitij.so 7509 
    self._processMap["getCountForMarketplaceHistory"] = Processor.process_getCountForMarketplaceHistory
7510 
    self._processMap["getMarketplaceHistoryByDate"] = Processor.process_getMarketplaceHistoryByDate
11531 vikram.rag 7511 
    self._processMap["getPrivateDealDetails"] = Processor.process_getPrivateDealDetails
7512 
    self._processMap["getPrivateDealItems"] = Processor.process_getPrivateDealItems
11592 amit.gupta 7513 
    self._processMap["getAllActivePrivateDeals"] = Processor.process_getAllActivePrivateDeals
11531 vikram.rag 7514 
    self._processMap["addOrUpdatePrivateDeal"] = Processor.process_addOrUpdatePrivateDeal
11635 vikram.rag 7515 
    self._processMap["getPrivateDealsCatalogIds"] = Processor.process_getPrivateDealsCatalogIds
11645 amit.gupta 7516 
    self._processMap["getPrivateDealsCount"] = Processor.process_getPrivateDealsCount
11905 kshitij.so 7517 
    self._processMap["getAmazonOutSyncItems"] = Processor.process_getAmazonOutSyncItems
7518 
    self._processMap["getAllPrivateDealsComparison"] = Processor.process_getAllPrivateDealsComparison
12133 kshitij.so 7519 
    self._processMap["getAllSnapdealMarketplaceItem"] = Processor.process_getAllSnapdealMarketplaceItem
7520 
    self._processMap["getAllFlipkartMarketplaceItem"] = Processor.process_getAllFlipkartMarketplaceItem
12243 kshitij.so 7521 
    self._processMap["addCompetitorScraping"] = Processor.process_addCompetitorScraping
7522 
    self._processMap["getPreviousCompetitorScraping"] = Processor.process_getPreviousCompetitorScraping
12256 kshitij.so 7523 
    self._processMap["getUploadResultById"] = Processor.process_getUploadResultById
12363 kshitij.so 7524 
    self._processMap["addAmazonPromotion"] = Processor.process_addAmazonPromotion
7525 
    self._processMap["getAmazonPromotion"] = Processor.process_getAmazonPromotion
7526 
    self._processMap["updateAmazonPromotion"] = Processor.process_updateAmazonPromotion
12567 amit.gupta 7527 
    self._processMap["markPartiallyActive"] = Processor.process_markPartiallyActive
7528 
    self._processMap["updateItemStateVat"] = Processor.process_updateItemStateVat
12620 amit.gupta 7529 
    self._processMap["getExAffiliateItemInfo"] = Processor.process_getExAffiliateItemInfo
12888 kshitij.so 7530 
    self._processMap["getAllItemstoListOnFbg"] = Processor.process_getAllItemstoListOnFbg
12892 kshitij.so 7531 
    self._processMap["getAllFbgListedItems"] = Processor.process_getAllFbgListedItems
13136 amit.gupta 7532 
    self._processMap["checkServices"] = Processor.process_checkServices
13709 manish.sha 7533 
    self._processMap["addHsItem"] = Processor.process_addHsItem
7534 
    self._processMap["getHsItem"] = Processor.process_getHsItem
7535 
    self._processMap["updateHsItem"] = Processor.process_updateHsItem
14182 kshitij.so 7536 
    self._processMap["getPricingForDtr"] = Processor.process_getPricingForDtr
15702 kshitij.so 7537 
    self._processMap["getAllItemstoListOnFbd"] = Processor.process_getAllItemstoListOnFbd
15706 kshitij.so 7538 
    self._processMap["getAllFbdListedItems"] = Processor.process_getAllFbdListedItems
18150 kshitij.so 7539 
    self._processMap["getBulkPricingForItems"] = Processor.process_getBulkPricingForItems
7540 
    self._processMap["addBulkPricingForItem"] = Processor.process_addBulkPricingForItem
7541 
    self._processMap["deleteBulkPricingForItemById"] = Processor.process_deleteBulkPricingForItemById
7542 
    self._processMap["deleteBulkPricingForItem"] = Processor.process_deleteBulkPricingForItem
7543 
    self._processMap["getBulkPricingByItemId"] = Processor.process_getBulkPricingByItemId
18602 kshitij.so 7544 
    self._processMap["updateBulkPricesOnProduction"] = Processor.process_updateBulkPricesOnProduction
18764 kshitij.so 7545 
    self._processMap["getCartByValue"] = Processor.process_getCartByValue
5944 mandeep.dh 7546 
 
7547 
  def process(self, iprot, oprot):
7548 
    (name, type, seqid) = iprot.readMessageBegin()
7549 
    if name not in self._processMap:
7550 
      iprot.skip(TType.STRUCT)
7551 
      iprot.readMessageEnd()
7552 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
7553 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
7554 
      x.write(oprot)
7555 
      oprot.writeMessageEnd()
7556 
      oprot.trans.flush()
7557 
      return
7558 
    else:
7559 
      self._processMap[name](self, seqid, iprot, oprot)
7560 
    return True
7561 
 
7562 
  def process_addItem(self, seqid, iprot, oprot):
7563 
    args = addItem_args()
7564 
    args.read(iprot)
7565 
    iprot.readMessageEnd()
7566 
    result = addItem_result()
7567 
    try:
7568 
      result.success = self._handler.addItem(args.item)
7569 
    except CatalogServiceException, cex:
7570 
      result.cex = cex
7571 
    oprot.writeMessageBegin("addItem", TMessageType.REPLY, seqid)
7572 
    result.write(oprot)
7573 
    oprot.writeMessageEnd()
7574 
    oprot.trans.flush()
7575 
 
7576 
  def process_updateItem(self, seqid, iprot, oprot):
7577 
    args = updateItem_args()
7578 
    args.read(iprot)
7579 
    iprot.readMessageEnd()
7580 
    result = updateItem_result()
7581 
    try:
7582 
      result.success = self._handler.updateItem(args.item)
7583 
    except CatalogServiceException, cex:
7584 
      result.cex = cex
7585 
    oprot.writeMessageBegin("updateItem", TMessageType.REPLY, seqid)
7586 
    result.write(oprot)
7587 
    oprot.writeMessageEnd()
7588 
    oprot.trans.flush()
7589 
 
7590 
  def process_isActive(self, seqid, iprot, oprot):
7591 
    args = isActive_args()
7592 
    args.read(iprot)
7593 
    iprot.readMessageEnd()
7594 
    result = isActive_result()
7595 
    try:
7596 
      result.success = self._handler.isActive(args.itemId)
7597 
    except CatalogServiceException, isex:
7598 
      result.isex = isex
7599 
    oprot.writeMessageBegin("isActive", TMessageType.REPLY, seqid)
7600 
    result.write(oprot)
7601 
    oprot.writeMessageEnd()
7602 
    oprot.trans.flush()
7603 
 
7438 amit.gupta 7604 
  def process_getItemsStatus(self, seqid, iprot, oprot):
7605 
    args = getItemsStatus_args()
7606 
    args.read(iprot)
7607 
    iprot.readMessageEnd()
7608 
    result = getItemsStatus_result()
7609 
    try:
7610 
      result.success = self._handler.getItemsStatus(args.itemIds)
7611 
    except CatalogServiceException, isex:
7612 
      result.isex = isex
7613 
    oprot.writeMessageBegin("getItemsStatus", TMessageType.REPLY, seqid)
7614 
    result.write(oprot)
7615 
    oprot.writeMessageEnd()
7616 
    oprot.trans.flush()
7617 
 
5944 mandeep.dh 7618 
  def process_getItemStatusDescription(self, seqid, iprot, oprot):
7619 
    args = getItemStatusDescription_args()
7620 
    args.read(iprot)
7621 
    iprot.readMessageEnd()
7622 
    result = getItemStatusDescription_result()
7623 
    try:
7624 
      result.success = self._handler.getItemStatusDescription(args.itemId)
7625 
    except CatalogServiceException, isex:
7626 
      result.isex = isex
7627 
    oprot.writeMessageBegin("getItemStatusDescription", TMessageType.REPLY, seqid)
7628 
    result.write(oprot)
7629 
    oprot.writeMessageEnd()
7630 
    oprot.trans.flush()
7631 
 
7632 
  def process_startItemOn(self, seqid, iprot, oprot):
7633 
    args = startItemOn_args()
7634 
    args.read(iprot)
7635 
    iprot.readMessageEnd()
7636 
    result = startItemOn_result()
7637 
    try:
7638 
      self._handler.startItemOn(args.item_id, args.timestamp)
7639 
    except CatalogServiceException, cex:
7640 
      result.cex = cex
7641 
    oprot.writeMessageBegin("startItemOn", TMessageType.REPLY, seqid)
7642 
    result.write(oprot)
7643 
    oprot.writeMessageEnd()
7644 
    oprot.trans.flush()
7645 
 
7646 
  def process_retireItemOn(self, seqid, iprot, oprot):
7647 
    args = retireItemOn_args()
7648 
    args.read(iprot)
7649 
    iprot.readMessageEnd()
7650 
    result = retireItemOn_result()
7651 
    try:
7652 
      self._handler.retireItemOn(args.item_id, args.timestamp)
7653 
    except CatalogServiceException, cex:
7654 
      result.cex = cex
7655 
    oprot.writeMessageBegin("retireItemOn", TMessageType.REPLY, seqid)
7656 
    result.write(oprot)
7657 
    oprot.writeMessageEnd()
7658 
    oprot.trans.flush()
7659 
 
7660 
  def process_changeItemStatus(self, seqid, iprot, oprot):
7661 
    args = changeItemStatus_args()
7662 
    args.read(iprot)
7663 
    iprot.readMessageEnd()
7664 
    result = changeItemStatus_result()
7665 
    try:
7666 
      self._handler.changeItemStatus(args.item_id, args.timestamp, args.newstatus)
7667 
    except CatalogServiceException, cex:
7668 
      result.cex = cex
7669 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
7670 
    result.write(oprot)
7671 
    oprot.writeMessageEnd()
7672 
    oprot.trans.flush()
7673 
 
7674 
  def process_getItem(self, seqid, iprot, oprot):
7675 
    args = getItem_args()
7676 
    args.read(iprot)
7677 
    iprot.readMessageEnd()
7678 
    result = getItem_result()
7679 
    try:
7680 
      result.success = self._handler.getItem(args.item_id)
7681 
    except CatalogServiceException, cex:
7682 
      result.cex = cex
7683 
    oprot.writeMessageBegin("getItem", TMessageType.REPLY, seqid)
7684 
    result.write(oprot)
7685 
    oprot.writeMessageEnd()
7686 
    oprot.trans.flush()
7687 
 
13493 amit.gupta 7688 
  def process_getItems(self, seqid, iprot, oprot):
7689 
    args = getItems_args()
7690 
    args.read(iprot)
7691 
    iprot.readMessageEnd()
7692 
    result = getItems_result()
7693 
    try:
7694 
      result.success = self._handler.getItems(args.item_ids)
7695 
    except CatalogServiceException, cex:
7696 
      result.cex = cex
7697 
    oprot.writeMessageBegin("getItems", TMessageType.REPLY, seqid)
7698 
    result.write(oprot)
7699 
    oprot.writeMessageEnd()
7700 
    oprot.trans.flush()
7701 
 
5944 mandeep.dh 7702 
  def process_getItemsByCatalogId(self, seqid, iprot, oprot):
7703 
    args = getItemsByCatalogId_args()
7704 
    args.read(iprot)
7705 
    iprot.readMessageEnd()
7706 
    result = getItemsByCatalogId_result()
7707 
    try:
7708 
      result.success = self._handler.getItemsByCatalogId(args.catalog_item_id)
7709 
    except CatalogServiceException, cex:
7710 
      result.cex = cex
7711 
    oprot.writeMessageBegin("getItemsByCatalogId", TMessageType.REPLY, seqid)
7712 
    result.write(oprot)
7713 
    oprot.writeMessageEnd()
7714 
    oprot.trans.flush()
7715 
 
7716 
  def process_getValidItemsByCatalogId(self, seqid, iprot, oprot):
7717 
    args = getValidItemsByCatalogId_args()
7718 
    args.read(iprot)
7719 
    iprot.readMessageEnd()
7720 
    result = getValidItemsByCatalogId_result()
7721 
    try:
7722 
      result.success = self._handler.getValidItemsByCatalogId(args.catalog_item_id)
7723 
    except CatalogServiceException, cex:
7724 
      result.cex = cex
7725 
    oprot.writeMessageBegin("getValidItemsByCatalogId", TMessageType.REPLY, seqid)
7726 
    result.write(oprot)
7727 
    oprot.writeMessageEnd()
7728 
    oprot.trans.flush()
7729 
 
7730 
  def process_getAllItems(self, seqid, iprot, oprot):
7731 
    args = getAllItems_args()
7732 
    args.read(iprot)
7733 
    iprot.readMessageEnd()
7734 
    result = getAllItems_result()
7735 
    try:
7736 
      result.success = self._handler.getAllItems(args.isActive)
7737 
    except CatalogServiceException, cex:
7738 
      result.cex = cex
7739 
    oprot.writeMessageBegin("getAllItems", TMessageType.REPLY, seqid)
7740 
    result.write(oprot)
7741 
    oprot.writeMessageEnd()
7742 
    oprot.trans.flush()
7743 
 
7744 
  def process_getAllItemsByStatus(self, seqid, iprot, oprot):
7745 
    args = getAllItemsByStatus_args()
7746 
    args.read(iprot)
7747 
    iprot.readMessageEnd()
7748 
    result = getAllItemsByStatus_result()
7749 
    try:
7750 
      result.success = self._handler.getAllItemsByStatus(args.itemStatus)
7751 
    except CatalogServiceException, cex:
7752 
      result.cex = cex
7753 
    oprot.writeMessageBegin("getAllItemsByStatus", TMessageType.REPLY, seqid)
7754 
    result.write(oprot)
7755 
    oprot.writeMessageEnd()
7756 
    oprot.trans.flush()
7757 
 
7758 
  def process_markItemAsContentComplete(self, seqid, iprot, oprot):
7759 
    args = markItemAsContentComplete_args()
7760 
    args.read(iprot)
7761 
    iprot.readMessageEnd()
7762 
    result = markItemAsContentComplete_result()
7763 
    try:
9253 rajveer 7764 
      result.success = self._handler.markItemAsContentComplete(args.entityId, args.category, args.brand, args.modelName, args.modelNumber, args.isAndroid)
5944 mandeep.dh 7765 
    except CatalogServiceException, cex:
7766 
      result.cex = cex
7767 
    oprot.writeMessageBegin("markItemAsContentComplete", TMessageType.REPLY, seqid)
7768 
    result.write(oprot)
7769 
    oprot.writeMessageEnd()
7770 
    oprot.trans.flush()
7771 
 
12567 amit.gupta 7772 
  def process_getVatRates(self, seqid, iprot, oprot):
7773 
    args = getVatRates_args()
7774 
    args.read(iprot)
7775 
    iprot.readMessageEnd()
7776 
    result = getVatRates_result()
7777 
    try:
7778 
      result.success = self._handler.getVatRates(args.itemId, args.categoryId)
7779 
    except CatalogServiceException, cex:
7780 
      result.cex = cex
7781 
    oprot.writeMessageBegin("getVatRates", TMessageType.REPLY, seqid)
7782 
    result.write(oprot)
7783 
    oprot.writeMessageEnd()
7784 
    oprot.trans.flush()
7785 
 
5944 mandeep.dh 7786 
  def process_getAllItemsInRange(self, seqid, iprot, oprot):
7787 
    args = getAllItemsInRange_args()
7788 
    args.read(iprot)
7789 
    iprot.readMessageEnd()
7790 
    result = getAllItemsInRange_result()
7791 
    try:
7792 
      result.success = self._handler.getAllItemsInRange(args.offset, args.limit)
7793 
    except CatalogServiceException, cex:
7794 
      result.cex = cex
7795 
    oprot.writeMessageBegin("getAllItemsInRange", TMessageType.REPLY, seqid)
7796 
    result.write(oprot)
7797 
    oprot.writeMessageEnd()
7798 
    oprot.trans.flush()
7799 
 
7800 
  def process_getAllItemsByStatusInRange(self, seqid, iprot, oprot):
7801 
    args = getAllItemsByStatusInRange_args()
7802 
    args.read(iprot)
7803 
    iprot.readMessageEnd()
7804 
    result = getAllItemsByStatusInRange_result()
7805 
    try:
7806 
      result.success = self._handler.getAllItemsByStatusInRange(args.itemStatus, args.offset, args.limit)
7807 
    except CatalogServiceException, cex:
7808 
      result.cex = cex
7809 
    oprot.writeMessageBegin("getAllItemsByStatusInRange", TMessageType.REPLY, seqid)
7810 
    result.write(oprot)
7811 
    oprot.writeMessageEnd()
7812 
    oprot.trans.flush()
7813 
 
7814 
  def process_getItemCountByStatus(self, seqid, iprot, oprot):
7815 
    args = getItemCountByStatus_args()
7816 
    args.read(iprot)
7817 
    iprot.readMessageEnd()
7818 
    result = getItemCountByStatus_result()
7819 
    result.success = self._handler.getItemCountByStatus(args.useStatus, args.itemStatus)
7820 
    oprot.writeMessageBegin("getItemCountByStatus", TMessageType.REPLY, seqid)
7821 
    result.write(oprot)
7822 
    oprot.writeMessageEnd()
7823 
    oprot.trans.flush()
7824 
 
7825 
  def process_getBestSellers(self, seqid, iprot, oprot):
7826 
    args = getBestSellers_args()
7827 
    args.read(iprot)
7828 
    iprot.readMessageEnd()
7829 
    result = getBestSellers_result()
7830 
    try:
7831 
      result.success = self._handler.getBestSellers()
7832 
    except CatalogServiceException, isex:
7833 
      result.isex = isex
7834 
    oprot.writeMessageBegin("getBestSellers", TMessageType.REPLY, seqid)
7835 
    result.write(oprot)
7836 
    oprot.writeMessageEnd()
7837 
    oprot.trans.flush()
7838 
 
7839 
  def process_getBestSellersCatalogIds(self, seqid, iprot, oprot):
7840 
    args = getBestSellersCatalogIds_args()
7841 
    args.read(iprot)
7842 
    iprot.readMessageEnd()
7843 
    result = getBestSellersCatalogIds_result()
7844 
    try:
7845 
      result.success = self._handler.getBestSellersCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
7846 
    except CatalogServiceException, cex:
7847 
      result.cex = cex
7848 
    oprot.writeMessageBegin("getBestSellersCatalogIds", TMessageType.REPLY, seqid)
7849 
    result.write(oprot)
7850 
    oprot.writeMessageEnd()
7851 
    oprot.trans.flush()
7852 
 
7853 
  def process_getBestSellersCount(self, seqid, iprot, oprot):
7854 
    args = getBestSellersCount_args()
7855 
    args.read(iprot)
7856 
    iprot.readMessageEnd()
7857 
    result = getBestSellersCount_result()
7858 
    try:
7859 
      result.success = self._handler.getBestSellersCount()
7860 
    except CatalogServiceException, cex:
7861 
      result.cex = cex
7862 
    oprot.writeMessageBegin("getBestSellersCount", TMessageType.REPLY, seqid)
7863 
    result.write(oprot)
7864 
    oprot.writeMessageEnd()
7865 
    oprot.trans.flush()
7866 
 
7867 
  def process_getBestDeals(self, seqid, iprot, oprot):
7868 
    args = getBestDeals_args()
7869 
    args.read(iprot)
7870 
    iprot.readMessageEnd()
7871 
    result = getBestDeals_result()
7872 
    try:
7873 
      result.success = self._handler.getBestDeals()
7874 
    except CatalogServiceException, isex:
7875 
      result.isex = isex
7876 
    oprot.writeMessageBegin("getBestDeals", TMessageType.REPLY, seqid)
7877 
    result.write(oprot)
7878 
    oprot.writeMessageEnd()
7879 
    oprot.trans.flush()
7880 
 
7881 
  def process_getBestDealsCatalogIds(self, seqid, iprot, oprot):
7882 
    args = getBestDealsCatalogIds_args()
7883 
    args.read(iprot)
7884 
    iprot.readMessageEnd()
7885 
    result = getBestDealsCatalogIds_result()
7886 
    try:
7887 
      result.success = self._handler.getBestDealsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
7888 
    except CatalogServiceException, cex:
7889 
      result.cex = cex
7890 
    oprot.writeMessageBegin("getBestDealsCatalogIds", TMessageType.REPLY, seqid)
7891 
    result.write(oprot)
7892 
    oprot.writeMessageEnd()
7893 
    oprot.trans.flush()
7894 
 
7895 
  def process_getBestDealsCount(self, seqid, iprot, oprot):
7896 
    args = getBestDealsCount_args()
7897 
    args.read(iprot)
7898 
    iprot.readMessageEnd()
7899 
    result = getBestDealsCount_result()
7900 
    try:
7901 
      result.success = self._handler.getBestDealsCount()
7902 
    except CatalogServiceException, cex:
7903 
      result.cex = cex
7904 
    oprot.writeMessageBegin("getBestDealsCount", TMessageType.REPLY, seqid)
7905 
    result.write(oprot)
7906 
    oprot.writeMessageEnd()
7907 
    oprot.trans.flush()
7908 
 
7909 
  def process_getComingSoon(self, seqid, iprot, oprot):
7910 
    args = getComingSoon_args()
7911 
    args.read(iprot)
7912 
    iprot.readMessageEnd()
7913 
    result = getComingSoon_result()
7914 
    try:
7915 
      result.success = self._handler.getComingSoon()
7916 
    except CatalogServiceException, isex:
7917 
      result.isex = isex
7918 
    oprot.writeMessageBegin("getComingSoon", TMessageType.REPLY, seqid)
7919 
    result.write(oprot)
7920 
    oprot.writeMessageEnd()
7921 
    oprot.trans.flush()
7922 
 
7923 
  def process_getComingSoonCatalogIds(self, seqid, iprot, oprot):
7924 
    args = getComingSoonCatalogIds_args()
7925 
    args.read(iprot)
7926 
    iprot.readMessageEnd()
7927 
    result = getComingSoonCatalogIds_result()
7928 
    try:
7929 
      result.success = self._handler.getComingSoonCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
7930 
    except CatalogServiceException, cex:
7931 
      result.cex = cex
7932 
    oprot.writeMessageBegin("getComingSoonCatalogIds", TMessageType.REPLY, seqid)
7933 
    result.write(oprot)
7934 
    oprot.writeMessageEnd()
7935 
    oprot.trans.flush()
7936 
 
7937 
  def process_getComingSoonCount(self, seqid, iprot, oprot):
7938 
    args = getComingSoonCount_args()
7939 
    args.read(iprot)
7940 
    iprot.readMessageEnd()
7941 
    result = getComingSoonCount_result()
7942 
    try:
7943 
      result.success = self._handler.getComingSoonCount()
7944 
    except CatalogServiceException, cex:
7945 
      result.cex = cex
7946 
    oprot.writeMessageBegin("getComingSoonCount", TMessageType.REPLY, seqid)
7947 
    result.write(oprot)
7948 
    oprot.writeMessageEnd()
7949 
    oprot.trans.flush()
7950 
 
7951 
  def process_getLatestArrivals(self, seqid, iprot, oprot):
7952 
    args = getLatestArrivals_args()
7953 
    args.read(iprot)
7954 
    iprot.readMessageEnd()
7955 
    result = getLatestArrivals_result()
7956 
    try:
7957 
      result.success = self._handler.getLatestArrivals()
7958 
    except CatalogServiceException, isex:
7959 
      result.isex = isex
7960 
    oprot.writeMessageBegin("getLatestArrivals", TMessageType.REPLY, seqid)
7961 
    result.write(oprot)
7962 
    oprot.writeMessageEnd()
7963 
    oprot.trans.flush()
7964 
 
7965 
  def process_getLatestArrivalsCatalogIds(self, seqid, iprot, oprot):
7966 
    args = getLatestArrivalsCatalogIds_args()
7967 
    args.read(iprot)
7968 
    iprot.readMessageEnd()
7969 
    result = getLatestArrivalsCatalogIds_result()
7970 
    try:
7971 
      result.success = self._handler.getLatestArrivalsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.categories)
7972 
    except CatalogServiceException, cex:
7973 
      result.cex = cex
7974 
    oprot.writeMessageBegin("getLatestArrivalsCatalogIds", TMessageType.REPLY, seqid)
7975 
    result.write(oprot)
7976 
    oprot.writeMessageEnd()
7977 
    oprot.trans.flush()
7978 
 
7979 
  def process_getLatestArrivalsCount(self, seqid, iprot, oprot):
7980 
    args = getLatestArrivalsCount_args()
7981 
    args.read(iprot)
7982 
    iprot.readMessageEnd()
7983 
    result = getLatestArrivalsCount_result()
7984 
    try:
7985 
      result.success = self._handler.getLatestArrivalsCount()
7986 
    except CatalogServiceException, cex:
7987 
      result.cex = cex
7988 
    oprot.writeMessageBegin("getLatestArrivalsCount", TMessageType.REPLY, seqid)
7989 
    result.write(oprot)
7990 
    oprot.writeMessageEnd()
7991 
    oprot.trans.flush()
7992 
 
7993 
  def process_generateNewEntityID(self, seqid, iprot, oprot):
7994 
    args = generateNewEntityID_args()
7995 
    args.read(iprot)
7996 
    iprot.readMessageEnd()
7997 
    result = generateNewEntityID_result()
7998 
    result.success = self._handler.generateNewEntityID()
7999 
    oprot.writeMessageBegin("generateNewEntityID", TMessageType.REPLY, seqid)
8000 
    result.write(oprot)
8001 
    oprot.writeMessageEnd()
8002 
    oprot.trans.flush()
8003 
 
8004 
  def process_addCategory(self, seqid, iprot, oprot):
8005 
    args = addCategory_args()
8006 
    args.read(iprot)
8007 
    iprot.readMessageEnd()
8008 
    result = addCategory_result()
8009 
    result.success = self._handler.addCategory(args.category)
8010 
    oprot.writeMessageBegin("addCategory", TMessageType.REPLY, seqid)
8011 
    result.write(oprot)
8012 
    oprot.writeMessageEnd()
8013 
    oprot.trans.flush()
8014 
 
8015 
  def process_getCategory(self, seqid, iprot, oprot):
8016 
    args = getCategory_args()
8017 
    args.read(iprot)
8018 
    iprot.readMessageEnd()
8019 
    result = getCategory_result()
8020 
    result.success = self._handler.getCategory(args.id)
8021 
    oprot.writeMessageBegin("getCategory", TMessageType.REPLY, seqid)
8022 
    result.write(oprot)
8023 
    oprot.writeMessageEnd()
8024 
    oprot.trans.flush()
8025 
 
8026 
  def process_getAllCategories(self, seqid, iprot, oprot):
8027 
    args = getAllCategories_args()
8028 
    args.read(iprot)
8029 
    iprot.readMessageEnd()
8030 
    result = getAllCategories_result()
8031 
    result.success = self._handler.getAllCategories()
8032 
    oprot.writeMessageBegin("getAllCategories", TMessageType.REPLY, seqid)
8033 
    result.write(oprot)
8034 
    oprot.writeMessageEnd()
8035 
    oprot.trans.flush()
8036 
 
8037 
  def process_getAllSimilarItems(self, seqid, iprot, oprot):
8038 
    args = getAllSimilarItems_args()
8039 
    args.read(iprot)
8040 
    iprot.readMessageEnd()
8041 
    result = getAllSimilarItems_result()
8042 
    result.success = self._handler.getAllSimilarItems(args.itemId)
8043 
    oprot.writeMessageBegin("getAllSimilarItems", TMessageType.REPLY, seqid)
8044 
    result.write(oprot)
8045 
    oprot.writeMessageEnd()
8046 
    oprot.trans.flush()
8047 
 
8048 
  def process_addSimilarItem(self, seqid, iprot, oprot):
8049 
    args = addSimilarItem_args()
8050 
    args.read(iprot)
8051 
    iprot.readMessageEnd()
8052 
    result = addSimilarItem_result()
8053 
    try:
8054 
      result.success = self._handler.addSimilarItem(args.itemId, args.catalogItemId)
8055 
    except CatalogServiceException, cex:
8056 
      result.cex = cex
8057 
    oprot.writeMessageBegin("addSimilarItem", TMessageType.REPLY, seqid)
8058 
    result.write(oprot)
8059 
    oprot.writeMessageEnd()
8060 
    oprot.trans.flush()
8061 
 
6512 kshitij.so 8062 
  def process_addTag(self, seqid, iprot, oprot):
8063 
    args = addTag_args()
8064 
    args.read(iprot)
8065 
    iprot.readMessageEnd()
8066 
    result = addTag_result()
8067 
    result.success = self._handler.addTag(args.displayName, args.itemId)
8068 
    oprot.writeMessageBegin("addTag", TMessageType.REPLY, seqid)
8069 
    result.write(oprot)
8070 
    oprot.writeMessageEnd()
8071 
    oprot.trans.flush()
8072 
 
8073 
  def process_deleteEntityTag(self, seqid, iprot, oprot):
8074 
    args = deleteEntityTag_args()
8075 
    args.read(iprot)
8076 
    iprot.readMessageEnd()
8077 
    result = deleteEntityTag_result()
8078 
    result.success = self._handler.deleteEntityTag(args.displayName, args.itemId)
8079 
    oprot.writeMessageBegin("deleteEntityTag", TMessageType.REPLY, seqid)
8080 
    result.write(oprot)
8081 
    oprot.writeMessageEnd()
8082 
    oprot.trans.flush()
8083 
 
8084 
  def process_deleteTag(self, seqid, iprot, oprot):
8085 
    args = deleteTag_args()
8086 
    args.read(iprot)
8087 
    iprot.readMessageEnd()
8088 
    result = deleteTag_result()
8089 
    result.success = self._handler.deleteTag(args.displayName)
8090 
    oprot.writeMessageBegin("deleteTag", TMessageType.REPLY, seqid)
8091 
    result.write(oprot)
8092 
    oprot.writeMessageEnd()
8093 
    oprot.trans.flush()
8094 
 
8095 
  def process_getAllTags(self, seqid, iprot, oprot):
8096 
    args = getAllTags_args()
8097 
    args.read(iprot)
8098 
    iprot.readMessageEnd()
8099 
    result = getAllTags_result()
8100 
    result.success = self._handler.getAllTags()
8101 
    oprot.writeMessageBegin("getAllTags", TMessageType.REPLY, seqid)
8102 
    result.write(oprot)
8103 
    oprot.writeMessageEnd()
8104 
    oprot.trans.flush()
8105 
 
8106 
  def process_getAllEntitiesByTagName(self, seqid, iprot, oprot):
8107 
    args = getAllEntitiesByTagName_args()
8108 
    args.read(iprot)
8109 
    iprot.readMessageEnd()
8110 
    result = getAllEntitiesByTagName_result()
8111 
    result.success = self._handler.getAllEntitiesByTagName(args.displayName)
8112 
    oprot.writeMessageBegin("getAllEntitiesByTagName", TMessageType.REPLY, seqid)
8113 
    result.write(oprot)
8114 
    oprot.writeMessageEnd()
8115 
    oprot.trans.flush()
8116 
 
6845 amit.gupta 8117 
  def process_getAllEntityTags(self, seqid, iprot, oprot):
8118 
    args = getAllEntityTags_args()
8119 
    args.read(iprot)
8120 
    iprot.readMessageEnd()
8121 
    result = getAllEntityTags_result()
8122 
    result.success = self._handler.getAllEntityTags()
8123 
    oprot.writeMessageBegin("getAllEntityTags", TMessageType.REPLY, seqid)
8124 
    result.write(oprot)
8125 
    oprot.writeMessageEnd()
8126 
    oprot.trans.flush()
8127 
 
6850 kshitij.so 8128 
  def process_addBanner(self, seqid, iprot, oprot):
8129 
    args = addBanner_args()
8130 
    args.read(iprot)
8131 
    iprot.readMessageEnd()
8132 
    result = addBanner_result()
10097 kshitij.so 8133 
    result.success = self._handler.addBanner(args.bannerCongregate)
6850 kshitij.so 8134 
    oprot.writeMessageBegin("addBanner", TMessageType.REPLY, seqid)
8135 
    result.write(oprot)
8136 
    oprot.writeMessageEnd()
8137 
    oprot.trans.flush()
8138 
 
8579 kshitij.so 8139 
  def process_updateBanner(self, seqid, iprot, oprot):
8140 
    args = updateBanner_args()
8141 
    args.read(iprot)
8142 
    iprot.readMessageEnd()
8143 
    result = updateBanner_result()
8144 
    result.success = self._handler.updateBanner(args.banner)
8145 
    oprot.writeMessageBegin("updateBanner", TMessageType.REPLY, seqid)
8146 
    result.write(oprot)
8147 
    oprot.writeMessageEnd()
8148 
    oprot.trans.flush()
8149 
 
6850 kshitij.so 8150 
  def process_getAllBanners(self, seqid, iprot, oprot):
8151 
    args = getAllBanners_args()
8152 
    args.read(iprot)
8153 
    iprot.readMessageEnd()
8154 
    result = getAllBanners_result()
8155 
    result.success = self._handler.getAllBanners()
8156 
    oprot.writeMessageBegin("getAllBanners", TMessageType.REPLY, seqid)
8157 
    result.write(oprot)
8158 
    oprot.writeMessageEnd()
8159 
    oprot.trans.flush()
8160 
 
8161 
  def process_deleteBanner(self, seqid, iprot, oprot):
8162 
    args = deleteBanner_args()
8163 
    args.read(iprot)
8164 
    iprot.readMessageEnd()
8165 
    result = deleteBanner_result()
9155 kshitij.so 8166 
    result.success = self._handler.deleteBanner(args.bannerName, args.bannerType)
6850 kshitij.so 8167 
    oprot.writeMessageBegin("deleteBanner", TMessageType.REPLY, seqid)
8168 
    result.write(oprot)
8169 
    oprot.writeMessageEnd()
8170 
    oprot.trans.flush()
8171 
 
8172 
  def process_getBannerDetails(self, seqid, iprot, oprot):
8173 
    args = getBannerDetails_args()
8174 
    args.read(iprot)
8175 
    iprot.readMessageEnd()
8176 
    result = getBannerDetails_result()
9155 kshitij.so 8177 
    result.success = self._handler.getBannerDetails(args.bannerName, args.bannerType)
6850 kshitij.so 8178 
    oprot.writeMessageBegin("getBannerDetails", TMessageType.REPLY, seqid)
8179 
    result.write(oprot)
8180 
    oprot.writeMessageEnd()
8181 
    oprot.trans.flush()
8182 
 
8183 
  def process_getActiveBanners(self, seqid, iprot, oprot):
8184 
    args = getActiveBanners_args()
8185 
    args.read(iprot)
8186 
    iprot.readMessageEnd()
8187 
    result = getActiveBanners_result()
8188 
    result.success = self._handler.getActiveBanners()
8189 
    oprot.writeMessageBegin("getActiveBanners", TMessageType.REPLY, seqid)
8190 
    result.write(oprot)
8191 
    oprot.writeMessageEnd()
8192 
    oprot.trans.flush()
8193 
 
6849 kshitij.so 8194 
  def process_addBannerMap(self, seqid, iprot, oprot):
8195 
    args = addBannerMap_args()
8196 
    args.read(iprot)
8197 
    iprot.readMessageEnd()
8198 
    result = addBannerMap_result()
8579 kshitij.so 8199 
    result.success = self._handler.addBannerMap(args.bannerMaps)
6849 kshitij.so 8200 
    oprot.writeMessageBegin("addBannerMap", TMessageType.REPLY, seqid)
8201 
    result.write(oprot)
8202 
    oprot.writeMessageEnd()
8203 
    oprot.trans.flush()
8204 
 
8579 kshitij.so 8205 
  def process_updateBannerMap(self, seqid, iprot, oprot):
8206 
    args = updateBannerMap_args()
8207 
    args.read(iprot)
8208 
    iprot.readMessageEnd()
8209 
    result = updateBannerMap_result()
8210 
    result.success = self._handler.updateBannerMap(args.bannerMap)
8211 
    oprot.writeMessageBegin("updateBannerMap", TMessageType.REPLY, seqid)
8212 
    result.write(oprot)
8213 
    oprot.writeMessageEnd()
8214 
    oprot.trans.flush()
8215 
 
6849 kshitij.so 8216 
  def process_deleteBannerMap(self, seqid, iprot, oprot):
8217 
    args = deleteBannerMap_args()
8218 
    args.read(iprot)
8219 
    iprot.readMessageEnd()
8220 
    result = deleteBannerMap_result()
8221 
    result.success = self._handler.deleteBannerMap(args.bannerName)
8222 
    oprot.writeMessageBegin("deleteBannerMap", TMessageType.REPLY, seqid)
8223 
    result.write(oprot)
8224 
    oprot.writeMessageEnd()
8225 
    oprot.trans.flush()
8226 
 
8227 
  def process_getBannerMapDetails(self, seqid, iprot, oprot):
8228 
    args = getBannerMapDetails_args()
8229 
    args.read(iprot)
8230 
    iprot.readMessageEnd()
8231 
    result = getBannerMapDetails_result()
9155 kshitij.so 8232 
    result.success = self._handler.getBannerMapDetails(args.bannerName, args.bannerType)
6849 kshitij.so 8233 
    oprot.writeMessageBegin("getBannerMapDetails", TMessageType.REPLY, seqid)
8234 
    result.write(oprot)
8235 
    oprot.writeMessageEnd()
8236 
    oprot.trans.flush()
8237 
 
8579 kshitij.so 8238 
  def process_addBannerUri(self, seqid, iprot, oprot):
8239 
    args = addBannerUri_args()
8240 
    args.read(iprot)
8241 
    iprot.readMessageEnd()
8242 
    result = addBannerUri_result()
8243 
    self._handler.addBannerUri(args.bannerUriMappings)
8244 
    oprot.writeMessageBegin("addBannerUri", TMessageType.REPLY, seqid)
8245 
    result.write(oprot)
8246 
    oprot.writeMessageEnd()
8247 
    oprot.trans.flush()
8248 
 
8249 
  def process_getUriMapping(self, seqid, iprot, oprot):
8250 
    args = getUriMapping_args()
8251 
    args.read(iprot)
8252 
    iprot.readMessageEnd()
8253 
    result = getUriMapping_result()
9155 kshitij.so 8254 
    result.success = self._handler.getUriMapping(args.bannerName, args.bannerType)
8579 kshitij.so 8255 
    oprot.writeMessageBegin("getUriMapping", TMessageType.REPLY, seqid)
8256 
    result.write(oprot)
8257 
    oprot.writeMessageEnd()
8258 
    oprot.trans.flush()
8259 
 
8260 
  def process_addCampaign(self, seqid, iprot, oprot):
8261 
    args = addCampaign_args()
8262 
    args.read(iprot)
8263 
    iprot.readMessageEnd()
8264 
    result = addCampaign_result()
8265 
    self._handler.addCampaign(args.campaign)
8266 
    oprot.writeMessageBegin("addCampaign", TMessageType.REPLY, seqid)
8267 
    result.write(oprot)
8268 
    oprot.writeMessageEnd()
8269 
    oprot.trans.flush()
8270 
 
8271 
  def process_getCampaigns(self, seqid, iprot, oprot):
8272 
    args = getCampaigns_args()
8273 
    args.read(iprot)
8274 
    iprot.readMessageEnd()
8275 
    result = getCampaigns_result()
8276 
    result.success = self._handler.getCampaigns(args.campaignName)
8277 
    oprot.writeMessageBegin("getCampaigns", TMessageType.REPLY, seqid)
8278 
    result.write(oprot)
8279 
    oprot.writeMessageEnd()
8280 
    oprot.trans.flush()
8281 
 
8282 
  def process_deleteCampaign(self, seqid, iprot, oprot):
8283 
    args = deleteCampaign_args()
8284 
    args.read(iprot)
8285 
    iprot.readMessageEnd()
8286 
    result = deleteCampaign_result()
8287 
    self._handler.deleteCampaign(args.campaignId)
8288 
    oprot.writeMessageBegin("deleteCampaign", TMessageType.REPLY, seqid)
8289 
    result.write(oprot)
8290 
    oprot.writeMessageEnd()
8291 
    oprot.trans.flush()
8292 
 
8293 
  def process_getAllCampaigns(self, seqid, iprot, oprot):
8294 
    args = getAllCampaigns_args()
8295 
    args.read(iprot)
8296 
    iprot.readMessageEnd()
8297 
    result = getAllCampaigns_result()
8298 
    result.success = self._handler.getAllCampaigns()
8299 
    oprot.writeMessageBegin("getAllCampaigns", TMessageType.REPLY, seqid)
8300 
    result.write(oprot)
8301 
    oprot.writeMessageEnd()
8302 
    oprot.trans.flush()
8303 
 
9155 kshitij.so 8304 
  def process_getActiveBannersForMobileSite(self, seqid, iprot, oprot):
8305 
    args = getActiveBannersForMobileSite_args()
8306 
    args.read(iprot)
8307 
    iprot.readMessageEnd()
8308 
    result = getActiveBannersForMobileSite_result()
8309 
    result.success = self._handler.getActiveBannersForMobileSite()
8310 
    oprot.writeMessageBegin("getActiveBannersForMobileSite", TMessageType.REPLY, seqid)
8311 
    result.write(oprot)
8312 
    oprot.writeMessageEnd()
8313 
    oprot.trans.flush()
8314 
 
5944 mandeep.dh 8315 
  def process_deleteSimilarItem(self, seqid, iprot, oprot):
8316 
    args = deleteSimilarItem_args()
8317 
    args.read(iprot)
8318 
    iprot.readMessageEnd()
8319 
    result = deleteSimilarItem_result()
8320 
    try:
8321 
      result.success = self._handler.deleteSimilarItem(args.itemId, args.catalogItemId)
8322 
    except CatalogServiceException, cex:
8323 
      result.cex = cex
8324 
    oprot.writeMessageBegin("deleteSimilarItem", TMessageType.REPLY, seqid)
8325 
    result.write(oprot)
8326 
    oprot.writeMessageEnd()
8327 
    oprot.trans.flush()
8328 
 
8329 
  def process_checkSimilarItem(self, seqid, iprot, oprot):
8330 
    args = checkSimilarItem_args()
8331 
    args.read(iprot)
8332 
    iprot.readMessageEnd()
8333 
    result = checkSimilarItem_result()
8334 
    result.success = self._handler.checkSimilarItem(args.brand, args.modelNumber, args.modelName, args.color)
8335 
    oprot.writeMessageBegin("checkSimilarItem", TMessageType.REPLY, seqid)
8336 
    result.write(oprot)
8337 
    oprot.writeMessageEnd()
8338 
    oprot.trans.flush()
8339 
 
8340 
  def process_validateRiskyStatus(self, seqid, iprot, oprot):
8341 
    args = validateRiskyStatus_args()
8342 
    args.read(iprot)
8343 
    iprot.readMessageEnd()
8344 
    result = validateRiskyStatus_result()
8345 
    self._handler.validateRiskyStatus(args.itemId)
8346 
    oprot.writeMessageBegin("validateRiskyStatus", TMessageType.REPLY, seqid)
8347 
    result.write(oprot)
8348 
    oprot.writeMessageEnd()
8349 
    oprot.trans.flush()
8350 
 
8351 
  def process_changeItemRiskyFlag(self, seqid, iprot, oprot):
8352 
    args = changeItemRiskyFlag_args()
8353 
    args.read(iprot)
8354 
    iprot.readMessageEnd()
8355 
    result = changeItemRiskyFlag_result()
8356 
    self._handler.changeItemRiskyFlag(args.itemId, args.risky)
8357 
    oprot.writeMessageBegin("changeItemRiskyFlag", TMessageType.REPLY, seqid)
8358 
    result.write(oprot)
8359 
    oprot.writeMessageEnd()
8360 
    oprot.trans.flush()
8361 
 
8362 
  def process_getItemsByRiskyFlag(self, seqid, iprot, oprot):
8363 
    args = getItemsByRiskyFlag_args()
8364 
    args.read(iprot)
8365 
    iprot.readMessageEnd()
8366 
    result = getItemsByRiskyFlag_result()
8367 
    result.success = self._handler.getItemsByRiskyFlag()
8368 
    oprot.writeMessageBegin("getItemsByRiskyFlag", TMessageType.REPLY, seqid)
8369 
    result.write(oprot)
8370 
    oprot.writeMessageEnd()
8371 
    oprot.trans.flush()
8372 
 
8373 
  def process_getItemsForMasterSheet(self, seqid, iprot, oprot):
8374 
    args = getItemsForMasterSheet_args()
8375 
    args.read(iprot)
8376 
    iprot.readMessageEnd()
8377 
    result = getItemsForMasterSheet_result()
8378 
    result.success = self._handler.getItemsForMasterSheet(args.category, args.brand)
8379 
    oprot.writeMessageBegin("getItemsForMasterSheet", TMessageType.REPLY, seqid)
8380 
    result.write(oprot)
8381 
    oprot.writeMessageEnd()
8382 
    oprot.trans.flush()
8383 
 
8384 
  def process_getSimilarItemsCatalogIds(self, seqid, iprot, oprot):
8385 
    args = getSimilarItemsCatalogIds_args()
8386 
    args.read(iprot)
8387 
    iprot.readMessageEnd()
8388 
    result = getSimilarItemsCatalogIds_result()
8389 
    result.success = self._handler.getSimilarItemsCatalogIds(args.beginIndex, args.totalItems, args.itemId)
8390 
    oprot.writeMessageBegin("getSimilarItemsCatalogIds", TMessageType.REPLY, seqid)
8391 
    result.write(oprot)
8392 
    oprot.writeMessageEnd()
8393 
    oprot.trans.flush()
8394 
 
8395 
  def process_addProductNotification(self, seqid, iprot, oprot):
8396 
    args = addProductNotification_args()
8397 
    args.read(iprot)
8398 
    iprot.readMessageEnd()
8399 
    result = addProductNotification_result()
8400 
    result.success = self._handler.addProductNotification(args.itemId, args.email)
8401 
    oprot.writeMessageBegin("addProductNotification", TMessageType.REPLY, seqid)
8402 
    result.write(oprot)
8403 
    oprot.writeMessageEnd()
8404 
    oprot.trans.flush()
8405 
 
8406 
  def process_sendProductNotifications(self, seqid, iprot, oprot):
8407 
    args = sendProductNotifications_args()
8408 
    args.read(iprot)
8409 
    iprot.readMessageEnd()
8410 
    result = sendProductNotifications_result()
8411 
    result.success = self._handler.sendProductNotifications()
8412 
    oprot.writeMessageBegin("sendProductNotifications", TMessageType.REPLY, seqid)
8413 
    result.write(oprot)
8414 
    oprot.writeMessageEnd()
8415 
    oprot.trans.flush()
8416 
 
8417 
  def process_getAllBrandsByCategory(self, seqid, iprot, oprot):
8418 
    args = getAllBrandsByCategory_args()
8419 
    args.read(iprot)
8420 
    iprot.readMessageEnd()
8421 
    result = getAllBrandsByCategory_result()
8422 
    result.success = self._handler.getAllBrandsByCategory(args.categoryId)
8423 
    oprot.writeMessageBegin("getAllBrandsByCategory", TMessageType.REPLY, seqid)
8424 
    result.write(oprot)
8425 
    oprot.writeMessageEnd()
8426 
    oprot.trans.flush()
8427 
 
8428 
  def process_getAllBrands(self, seqid, iprot, oprot):
8429 
    args = getAllBrands_args()
8430 
    args.read(iprot)
8431 
    iprot.readMessageEnd()
8432 
    result = getAllBrands_result()
8433 
    result.success = self._handler.getAllBrands()
8434 
    oprot.writeMessageBegin("getAllBrands", TMessageType.REPLY, seqid)
8435 
    result.write(oprot)
8436 
    oprot.writeMessageEnd()
8437 
    oprot.trans.flush()
8438 
 
8439 
  def process_getAllSources(self, seqid, iprot, oprot):
8440 
    args = getAllSources_args()
8441 
    args.read(iprot)
8442 
    iprot.readMessageEnd()
8443 
    result = getAllSources_result()
8444 
    result.success = self._handler.getAllSources()
8445 
    oprot.writeMessageBegin("getAllSources", TMessageType.REPLY, seqid)
8446 
    result.write(oprot)
8447 
    oprot.writeMessageEnd()
8448 
    oprot.trans.flush()
8449 
 
8450 
  def process_getItemPricingBySource(self, seqid, iprot, oprot):
8451 
    args = getItemPricingBySource_args()
8452 
    args.read(iprot)
8453 
    iprot.readMessageEnd()
8454 
    result = getItemPricingBySource_result()
8455 
    try:
8456 
      result.success = self._handler.getItemPricingBySource(args.itemId, args.sourceId)
8457 
    except CatalogServiceException, cex:
8458 
      result.cex = cex
8459 
    oprot.writeMessageBegin("getItemPricingBySource", TMessageType.REPLY, seqid)
8460 
    result.write(oprot)
8461 
    oprot.writeMessageEnd()
8462 
    oprot.trans.flush()
8463 
 
8464 
  def process_addSourceItemPricing(self, seqid, iprot, oprot):
8465 
    args = addSourceItemPricing_args()
8466 
    args.read(iprot)
8467 
    iprot.readMessageEnd()
8468 
    result = addSourceItemPricing_result()
8469 
    try:
8470 
      self._handler.addSourceItemPricing(args.sourceItemPricing)
8471 
    except CatalogServiceException, cex:
8472 
      result.cex = cex
8473 
    oprot.writeMessageBegin("addSourceItemPricing", TMessageType.REPLY, seqid)
8474 
    result.write(oprot)
8475 
    oprot.writeMessageEnd()
8476 
    oprot.trans.flush()
8477 
 
8478 
  def process_getAllSourcePricing(self, seqid, iprot, oprot):
8479 
    args = getAllSourcePricing_args()
8480 
    args.read(iprot)
8481 
    iprot.readMessageEnd()
8482 
    result = getAllSourcePricing_result()
8483 
    try:
8484 
      result.success = self._handler.getAllSourcePricing(args.itemId)
8485 
    except CatalogServiceException, cex:
8486 
      result.cex = cex
8487 
    oprot.writeMessageBegin("getAllSourcePricing", TMessageType.REPLY, seqid)
8488 
    result.write(oprot)
8489 
    oprot.writeMessageEnd()
8490 
    oprot.trans.flush()
8491 
 
8492 
  def process_getItemForSource(self, seqid, iprot, oprot):
8493 
    args = getItemForSource_args()
8494 
    args.read(iprot)
8495 
    iprot.readMessageEnd()
8496 
    result = getItemForSource_result()
8497 
    try:
8498 
      result.success = self._handler.getItemForSource(args.item_id, args.sourceId)
8499 
    except CatalogServiceException, cex:
8500 
      result.cex = cex
8501 
    oprot.writeMessageBegin("getItemForSource", TMessageType.REPLY, seqid)
8502 
    result.write(oprot)
8503 
    oprot.writeMessageEnd()
8504 
    oprot.trans.flush()
8505 
 
8506 
  def process_searchItemsInRange(self, seqid, iprot, oprot):
8507 
    args = searchItemsInRange_args()
8508 
    args.read(iprot)
8509 
    iprot.readMessageEnd()
8510 
    result = searchItemsInRange_result()
8511 
    result.success = self._handler.searchItemsInRange(args.searchTerms, args.offset, args.limit)
8512 
    oprot.writeMessageBegin("searchItemsInRange", TMessageType.REPLY, seqid)
8513 
    result.write(oprot)
8514 
    oprot.writeMessageEnd()
8515 
    oprot.trans.flush()
8516 
 
8517 
  def process_getSearchResultCount(self, seqid, iprot, oprot):
8518 
    args = getSearchResultCount_args()
8519 
    args.read(iprot)
8520 
    iprot.readMessageEnd()
8521 
    result = getSearchResultCount_result()
8522 
    result.success = self._handler.getSearchResultCount(args.searchTerms)
8523 
    oprot.writeMessageBegin("getSearchResultCount", TMessageType.REPLY, seqid)
8524 
    result.write(oprot)
8525 
    oprot.writeMessageEnd()
8526 
    oprot.trans.flush()
8527 
 
8528 
  def process_getProductNotifications(self, seqid, iprot, oprot):
8529 
    args = getProductNotifications_args()
8530 
    args.read(iprot)
8531 
    iprot.readMessageEnd()
8532 
    result = getProductNotifications_result()
8533 
    result.success = self._handler.getProductNotifications(args.startDateTime)
8534 
    oprot.writeMessageBegin("getProductNotifications", TMessageType.REPLY, seqid)
8535 
    result.write(oprot)
8536 
    oprot.writeMessageEnd()
8537 
    oprot.trans.flush()
8538 
 
8539 
  def process_getProductNotificationRequestCount(self, seqid, iprot, oprot):
8540 
    args = getProductNotificationRequestCount_args()
8541 
    args.read(iprot)
8542 
    iprot.readMessageEnd()
8543 
    result = getProductNotificationRequestCount_result()
7897 amar.kumar 8544 
    result.success = self._handler.getProductNotificationRequestCount(args.startDateTime, args.categoryId)
5944 mandeep.dh 8545 
    oprot.writeMessageBegin("getProductNotificationRequestCount", TMessageType.REPLY, seqid)
8546 
    result.write(oprot)
8547 
    oprot.writeMessageEnd()
8548 
    oprot.trans.flush()
8549 
 
8550 
  def process_addAuthorizationLog(self, seqid, iprot, oprot):
8551 
    args = addAuthorizationLog_args()
8552 
    args.read(iprot)
8553 
    iprot.readMessageEnd()
8554 
    result = addAuthorizationLog_result()
8555 
    try:
8556 
      result.success = self._handler.addAuthorizationLog(args.itemId, args.username, args.reason)
8557 
    except CatalogServiceException, cex:
8558 
      result.cex = cex
8559 
    oprot.writeMessageBegin("addAuthorizationLog", TMessageType.REPLY, seqid)
8560 
    result.write(oprot)
8561 
    oprot.writeMessageEnd()
8562 
    oprot.trans.flush()
8563 
 
8564 
  def process_addupdateVoucherForItem(self, seqid, iprot, oprot):
8565 
    args = addupdateVoucherForItem_args()
8566 
    args.read(iprot)
8567 
    iprot.readMessageEnd()
8568 
    result = addupdateVoucherForItem_result()
8569 
    try:
8570 
      result.success = self._handler.addupdateVoucherForItem(args.catalog_item_id, args.voucherType, args.voucherAmount)
8571 
    except CatalogServiceException, cex:
8572 
      result.cex = cex
8573 
    oprot.writeMessageBegin("addupdateVoucherForItem", TMessageType.REPLY, seqid)
8574 
    result.write(oprot)
8575 
    oprot.writeMessageEnd()
8576 
    oprot.trans.flush()
8577 
 
8578 
  def process_deleteVoucherForItem(self, seqid, iprot, oprot):
8579 
    args = deleteVoucherForItem_args()
8580 
    args.read(iprot)
8581 
    iprot.readMessageEnd()
8582 
    result = deleteVoucherForItem_result()
8583 
    try:
8584 
      result.success = self._handler.deleteVoucherForItem(args.catalog_item_id, args.voucherType)
8585 
    except CatalogServiceException, cex:
8586 
      result.cex = cex
8587 
    oprot.writeMessageBegin("deleteVoucherForItem", TMessageType.REPLY, seqid)
8588 
    result.write(oprot)
8589 
    oprot.writeMessageEnd()
8590 
    oprot.trans.flush()
8591 
 
8592 
  def process_getVoucherAmount(self, seqid, iprot, oprot):
8593 
    args = getVoucherAmount_args()
8594 
    args.read(iprot)
8595 
    iprot.readMessageEnd()
8596 
    result = getVoucherAmount_result()
8597 
    result.success = self._handler.getVoucherAmount(args.itemId, args.voucherType)
8598 
    oprot.writeMessageBegin("getVoucherAmount", TMessageType.REPLY, seqid)
8599 
    result.write(oprot)
8600 
    oprot.writeMessageEnd()
8601 
    oprot.trans.flush()
8602 
 
8603 
  def process_getAllItemVouchers(self, seqid, iprot, oprot):
8604 
    args = getAllItemVouchers_args()
8605 
    args.read(iprot)
8606 
    iprot.readMessageEnd()
8607 
    result = getAllItemVouchers_result()
8608 
    result.success = self._handler.getAllItemVouchers(args.itemId)
8609 
    oprot.writeMessageBegin("getAllItemVouchers", TMessageType.REPLY, seqid)
8610 
    result.write(oprot)
8611 
    oprot.writeMessageEnd()
8612 
    oprot.trans.flush()
8613 
 
8614 
  def process_isValidCatalogItemId(self, seqid, iprot, oprot):
8615 
    args = isValidCatalogItemId_args()
8616 
    args.read(iprot)
8617 
    iprot.readMessageEnd()
8618 
    result = isValidCatalogItemId_result()
8619 
    result.success = self._handler.isValidCatalogItemId(args.catalog_item_id)
8620 
    oprot.writeMessageBegin("isValidCatalogItemId", TMessageType.REPLY, seqid)
8621 
    result.write(oprot)
8622 
    oprot.writeMessageEnd()
8623 
    oprot.trans.flush()
8624 
 
6039 amit.gupta 8625 
  def process_getVatPercentageForItem(self, seqid, iprot, oprot):
8626 
    args = getVatPercentageForItem_args()
8627 
    args.read(iprot)
8628 
    iprot.readMessageEnd()
8629 
    result = getVatPercentageForItem_result()
7340 amit.gupta 8630 
    try:
8631 
      result.success = self._handler.getVatPercentageForItem(args.itemId, args.stateId, args.price)
8632 
    except CatalogServiceException, cex:
8633 
      result.cex = cex
6039 amit.gupta 8634 
    oprot.writeMessageBegin("getVatPercentageForItem", TMessageType.REPLY, seqid)
8635 
    result.write(oprot)
8636 
    oprot.writeMessageEnd()
8637 
    oprot.trans.flush()
5944 mandeep.dh 8638 
 
6039 amit.gupta 8639 
  def process_getVatAmountForItem(self, seqid, iprot, oprot):
8640 
    args = getVatAmountForItem_args()
8641 
    args.read(iprot)
8642 
    iprot.readMessageEnd()
8643 
    result = getVatAmountForItem_result()
8644 
    result.success = self._handler.getVatAmountForItem(args.itemId, args.price)
8645 
    oprot.writeMessageBegin("getVatAmountForItem", TMessageType.REPLY, seqid)
8646 
    result.write(oprot)
8647 
    oprot.writeMessageEnd()
8648 
    oprot.trans.flush()
8649 
 
6531 vikram.rag 8650 
  def process_getAllIgnoredInventoryUpdateItemsList(self, seqid, iprot, oprot):
8651 
    args = getAllIgnoredInventoryUpdateItemsList_args()
8652 
    args.read(iprot)
8653 
    iprot.readMessageEnd()
8654 
    result = getAllIgnoredInventoryUpdateItemsList_result()
8655 
    result.success = self._handler.getAllIgnoredInventoryUpdateItemsList(args.offset, args.limit)
8656 
    oprot.writeMessageBegin("getAllIgnoredInventoryUpdateItemsList", TMessageType.REPLY, seqid)
8657 
    result.write(oprot)
8658 
    oprot.writeMessageEnd()
8659 
    oprot.trans.flush()
6039 amit.gupta 8660 
 
6821 amar.kumar 8661 
  def process_getAllAliveItems(self, seqid, iprot, oprot):
8662 
    args = getAllAliveItems_args()
8663 
    args.read(iprot)
8664 
    iprot.readMessageEnd()
8665 
    result = getAllAliveItems_result()
8666 
    result.success = self._handler.getAllAliveItems()
8667 
    oprot.writeMessageBegin("getAllAliveItems", TMessageType.REPLY, seqid)
8668 
    result.write(oprot)
8669 
    oprot.writeMessageEnd()
8670 
    oprot.trans.flush()
8671 
 
6805 anupam.sin 8672 
  def process_getInsuranceAmount(self, seqid, iprot, oprot):
8673 
    args = getInsuranceAmount_args()
8674 
    args.read(iprot)
8675 
    iprot.readMessageEnd()
8676 
    result = getInsuranceAmount_result()
6921 anupam.sin 8677 
    result.success = self._handler.getInsuranceAmount(args.itemId, args.price, args.insurerId, args.quantity)
6805 anupam.sin 8678 
    oprot.writeMessageBegin("getInsuranceAmount", TMessageType.REPLY, seqid)
8679 
    result.write(oprot)
8680 
    oprot.writeMessageEnd()
8681 
    oprot.trans.flush()
6531 vikram.rag 8682 
 
6805 anupam.sin 8683 
  def process_getInsurer(self, seqid, iprot, oprot):
8684 
    args = getInsurer_args()
8685 
    args.read(iprot)
8686 
    iprot.readMessageEnd()
8687 
    result = getInsurer_result()
8688 
    result.success = self._handler.getInsurer(args.insurerId)
8689 
    oprot.writeMessageBegin("getInsurer", TMessageType.REPLY, seqid)
8690 
    result.write(oprot)
8691 
    oprot.writeMessageEnd()
8692 
    oprot.trans.flush()
8693 
 
6838 vikram.rag 8694 
  def process_getAllInsurers(self, seqid, iprot, oprot):
8695 
    args = getAllInsurers_args()
8696 
    args.read(iprot)
8697 
    iprot.readMessageEnd()
8698 
    result = getAllInsurers_result()
8699 
    result.success = self._handler.getAllInsurers()
8700 
    oprot.writeMessageBegin("getAllInsurers", TMessageType.REPLY, seqid)
8701 
    result.write(oprot)
8702 
    oprot.writeMessageEnd()
8703 
    oprot.trans.flush()
6805 anupam.sin 8704 
 
6962 rajveer 8705 
  def process_updateInsuranceDeclaredAmount(self, seqid, iprot, oprot):
8706 
    args = updateInsuranceDeclaredAmount_args()
8707 
    args.read(iprot)
8708 
    iprot.readMessageEnd()
8709 
    result = updateInsuranceDeclaredAmount_result()
8710 
    self._handler.updateInsuranceDeclaredAmount(args.insurerId, args.amount)
8711 
    oprot.writeMessageBegin("updateInsuranceDeclaredAmount", TMessageType.REPLY, seqid)
8712 
    result.write(oprot)
8713 
    oprot.writeMessageEnd()
8714 
    oprot.trans.flush()
6838 vikram.rag 8715 
 
7190 amar.kumar 8716 
  def process_getFreebieForItem(self, seqid, iprot, oprot):
8717 
    args = getFreebieForItem_args()
8718 
    args.read(iprot)
8719 
    iprot.readMessageEnd()
8720 
    result = getFreebieForItem_result()
8721 
    result.success = self._handler.getFreebieForItem(args.itemId)
8722 
    oprot.writeMessageBegin("getFreebieForItem", TMessageType.REPLY, seqid)
8723 
    result.write(oprot)
8724 
    oprot.writeMessageEnd()
8725 
    oprot.trans.flush()
6962 rajveer 8726 
 
7190 amar.kumar 8727 
  def process_addOrUpdateFreebieForItem(self, seqid, iprot, oprot):
8728 
    args = addOrUpdateFreebieForItem_args()
8729 
    args.read(iprot)
8730 
    iprot.readMessageEnd()
8731 
    result = addOrUpdateFreebieForItem_result()
8732 
    self._handler.addOrUpdateFreebieForItem(args.freebieItem)
8733 
    oprot.writeMessageBegin("addOrUpdateFreebieForItem", TMessageType.REPLY, seqid)
8734 
    result.write(oprot)
8735 
    oprot.writeMessageEnd()
8736 
    oprot.trans.flush()
8737 
 
7272 amit.gupta 8738 
  def process_addOrUpdateBrandInfo(self, seqid, iprot, oprot):
8739 
    args = addOrUpdateBrandInfo_args()
8740 
    args.read(iprot)
8741 
    iprot.readMessageEnd()
8742 
    result = addOrUpdateBrandInfo_result()
8743 
    self._handler.addOrUpdateBrandInfo(args.brandInfo)
8744 
    oprot.writeMessageBegin("addOrUpdateBrandInfo", TMessageType.REPLY, seqid)
8745 
    result.write(oprot)
8746 
    oprot.writeMessageEnd()
8747 
    oprot.trans.flush()
8748 
 
8749 
  def process_getBrandInfo(self, seqid, iprot, oprot):
8750 
    args = getBrandInfo_args()
8751 
    args.read(iprot)
8752 
    iprot.readMessageEnd()
8753 
    result = getBrandInfo_result()
8754 
    result.success = self._handler.getBrandInfo()
8755 
    oprot.writeMessageBegin("getBrandInfo", TMessageType.REPLY, seqid)
8756 
    result.write(oprot)
8757 
    oprot.writeMessageEnd()
8758 
    oprot.trans.flush()
8759 
 
7256 rajveer 8760 
  def process_getStorePricing(self, seqid, iprot, oprot):
8761 
    args = getStorePricing_args()
8762 
    args.read(iprot)
8763 
    iprot.readMessageEnd()
8764 
    result = getStorePricing_result()
8765 
    result.success = self._handler.getStorePricing(args.itemId)
8766 
    oprot.writeMessageBegin("getStorePricing", TMessageType.REPLY, seqid)
8767 
    result.write(oprot)
8768 
    oprot.writeMessageEnd()
8769 
    oprot.trans.flush()
7190 amar.kumar 8770 
 
7306 rajveer 8771 
  def process_getStorePricings(self, seqid, iprot, oprot):
8772 
    args = getStorePricings_args()
8773 
    args.read(iprot)
8774 
    iprot.readMessageEnd()
8775 
    result = getStorePricings_result()
8776 
    result.success = self._handler.getStorePricings(args.itemIds)
8777 
    oprot.writeMessageBegin("getStorePricings", TMessageType.REPLY, seqid)
8778 
    result.write(oprot)
8779 
    oprot.writeMessageEnd()
8780 
    oprot.trans.flush()
8781 
 
7265 rajveer 8782 
  def process_updateStorePricing(self, seqid, iprot, oprot):
8783 
    args = updateStorePricing_args()
8784 
    args.read(iprot)
8785 
    iprot.readMessageEnd()
8786 
    result = updateStorePricing_result()
7382 rajveer 8787 
    self._handler.updateStorePricing(args.sp, args.allColors)
7265 rajveer 8788 
    oprot.writeMessageBegin("updateStorePricing", TMessageType.REPLY, seqid)
8789 
    result.write(oprot)
8790 
    oprot.writeMessageEnd()
8791 
    oprot.trans.flush()
7256 rajveer 8792 
 
7281 kshitij.so 8793 
  def process_getAllAmazonListedItems(self, seqid, iprot, oprot):
8794 
    args = getAllAmazonListedItems_args()
8795 
    args.read(iprot)
8796 
    iprot.readMessageEnd()
8797 
    result = getAllAmazonListedItems_result()
8798 
    result.success = self._handler.getAllAmazonListedItems()
8799 
    oprot.writeMessageBegin("getAllAmazonListedItems", TMessageType.REPLY, seqid)
8800 
    result.write(oprot)
8801 
    oprot.writeMessageEnd()
8802 
    oprot.trans.flush()
7265 rajveer 8803 
 
8619 kshitij.so 8804 
  def process_searchAmazonItems(self, seqid, iprot, oprot):
8805 
    args = searchAmazonItems_args()
8806 
    args.read(iprot)
8807 
    iprot.readMessageEnd()
8808 
    result = searchAmazonItems_result()
8809 
    result.success = self._handler.searchAmazonItems(args.searchTerm, args.offset, args.limit)
8810 
    oprot.writeMessageBegin("searchAmazonItems", TMessageType.REPLY, seqid)
8811 
    result.write(oprot)
8812 
    oprot.writeMessageEnd()
8813 
    oprot.trans.flush()
8814 
 
8815 
  def process_getAmazonSearchResultCount(self, seqid, iprot, oprot):
8816 
    args = getAmazonSearchResultCount_args()
8817 
    args.read(iprot)
8818 
    iprot.readMessageEnd()
8819 
    result = getAmazonSearchResultCount_result()
8820 
    result.success = self._handler.getAmazonSearchResultCount(args.searchTerm)
8821 
    oprot.writeMessageBegin("getAmazonSearchResultCount", TMessageType.REPLY, seqid)
8822 
    result.write(oprot)
8823 
    oprot.writeMessageEnd()
8824 
    oprot.trans.flush()
8825 
 
8826 
  def process_getCountForAmazonlistedItems(self, seqid, iprot, oprot):
8827 
    args = getCountForAmazonlistedItems_args()
8828 
    args.read(iprot)
8829 
    iprot.readMessageEnd()
8830 
    result = getCountForAmazonlistedItems_result()
8831 
    result.success = self._handler.getCountForAmazonlistedItems()
8832 
    oprot.writeMessageBegin("getCountForAmazonlistedItems", TMessageType.REPLY, seqid)
8833 
    result.write(oprot)
8834 
    oprot.writeMessageEnd()
8835 
    oprot.trans.flush()
8836 
 
7281 kshitij.so 8837 
  def process_getAmazonItemDetails(self, seqid, iprot, oprot):
8838 
    args = getAmazonItemDetails_args()
8839 
    args.read(iprot)
8840 
    iprot.readMessageEnd()
8841 
    result = getAmazonItemDetails_result()
8842 
    result.success = self._handler.getAmazonItemDetails(args.itemId)
8843 
    oprot.writeMessageBegin("getAmazonItemDetails", TMessageType.REPLY, seqid)
8844 
    result.write(oprot)
8845 
    oprot.writeMessageEnd()
8846 
    oprot.trans.flush()
8847 
 
8848 
  def process_updateAmazonItemDetails(self, seqid, iprot, oprot):
8849 
    args = updateAmazonItemDetails_args()
8850 
    args.read(iprot)
8851 
    iprot.readMessageEnd()
8852 
    result = updateAmazonItemDetails_result()
8168 kshitij.so 8853 
    self._handler.updateAmazonItemDetails(args.amazonlisted)
7281 kshitij.so 8854 
    oprot.writeMessageBegin("updateAmazonItemDetails", TMessageType.REPLY, seqid)
8855 
    result.write(oprot)
8856 
    oprot.writeMessageEnd()
8857 
    oprot.trans.flush()
8858 
 
8859 
  def process_addAmazonItem(self, seqid, iprot, oprot):
8860 
    args = addAmazonItem_args()
8861 
    args.read(iprot)
8862 
    iprot.readMessageEnd()
8863 
    result = addAmazonItem_result()
8864 
    self._handler.addAmazonItem(args.amazonlisted)
8865 
    oprot.writeMessageBegin("addAmazonItem", TMessageType.REPLY, seqid)
8866 
    result.write(oprot)
8867 
    oprot.writeMessageEnd()
8868 
    oprot.trans.flush()
8869 
 
7291 vikram.rag 8870 
  def process_getAsinItems(self, seqid, iprot, oprot):
8871 
    args = getAsinItems_args()
8872 
    args.read(iprot)
8873 
    iprot.readMessageEnd()
8874 
    result = getAsinItems_result()
8875 
    result.success = self._handler.getAsinItems()
8876 
    oprot.writeMessageBegin("getAsinItems", TMessageType.REPLY, seqid)
8877 
    result.write(oprot)
8878 
    oprot.writeMessageEnd()
8879 
    oprot.trans.flush()
7281 kshitij.so 8880 
 
7291 vikram.rag 8881 
  def process_getAllFbaListedItems(self, seqid, iprot, oprot):
8882 
    args = getAllFbaListedItems_args()
8883 
    args.read(iprot)
8884 
    iprot.readMessageEnd()
8885 
    result = getAllFbaListedItems_result()
8886 
    result.success = self._handler.getAllFbaListedItems()
8887 
    oprot.writeMessageBegin("getAllFbaListedItems", TMessageType.REPLY, seqid)
8888 
    result.write(oprot)
8889 
    oprot.writeMessageEnd()
8890 
    oprot.trans.flush()
8891 
 
8892 
  def process_getAllNonFbaListedItems(self, seqid, iprot, oprot):
8893 
    args = getAllNonFbaListedItems_args()
8894 
    args.read(iprot)
8895 
    iprot.readMessageEnd()
8896 
    result = getAllNonFbaListedItems_result()
8897 
    result.success = self._handler.getAllNonFbaListedItems()
8898 
    oprot.writeMessageBegin("getAllNonFbaListedItems", TMessageType.REPLY, seqid)
8899 
    result.write(oprot)
8900 
    oprot.writeMessageEnd()
8901 
    oprot.trans.flush()
8902 
 
7460 kshitij.so 8903 
  def process_updateItemInventory(self, seqid, iprot, oprot):
8904 
    args = updateItemInventory_args()
8905 
    args.read(iprot)
8906 
    iprot.readMessageEnd()
8907 
    result = updateItemInventory_result()
8908 
    result.success = self._handler.updateItemInventory(args.itemId, args.holdInventory, args.defaultInventory)
8909 
    oprot.writeMessageBegin("updateItemInventory", TMessageType.REPLY, seqid)
8910 
    result.write(oprot)
8911 
    oprot.writeMessageEnd()
8912 
    oprot.trans.flush()
7291 vikram.rag 8913 
 
7770 kshitij.so 8914 
  def process_updateTimestampForAmazonFeeds(self, seqid, iprot, oprot):
8915 
    args = updateTimestampForAmazonFeeds_args()
8916 
    args.read(iprot)
8917 
    iprot.readMessageEnd()
8918 
    result = updateTimestampForAmazonFeeds_result()
8919 
    result.success = self._handler.updateTimestampForAmazonFeeds(args.type, args.sku, args.timestamp)
8920 
    oprot.writeMessageBegin("updateTimestampForAmazonFeeds", TMessageType.REPLY, seqid)
8921 
    result.write(oprot)
8922 
    oprot.writeMessageEnd()
8923 
    oprot.trans.flush()
7460 kshitij.so 8924 
 
7897 amar.kumar 8925 
  def process_getAllParentCategories(self, seqid, iprot, oprot):
8926 
    args = getAllParentCategories_args()
8927 
    args.read(iprot)
8928 
    iprot.readMessageEnd()
8929 
    result = getAllParentCategories_result()
8930 
    result.success = self._handler.getAllParentCategories()
8931 
    oprot.writeMessageBegin("getAllParentCategories", TMessageType.REPLY, seqid)
8932 
    result.write(oprot)
8933 
    oprot.writeMessageEnd()
8934 
    oprot.trans.flush()
7770 kshitij.so 8935 
 
7977 kshitij.so 8936 
  def process_addPageViewEvent(self, seqid, iprot, oprot):
8937 
    args = addPageViewEvent_args()
8938 
    args.read(iprot)
8939 
    iprot.readMessageEnd()
8940 
    result = addPageViewEvent_result()
8941 
    self._handler.addPageViewEvent(args.pageViewEvents)
8942 
    oprot.writeMessageBegin("addPageViewEvent", TMessageType.REPLY, seqid)
8943 
    result.write(oprot)
8944 
    oprot.writeMessageEnd()
8945 
    oprot.trans.flush()
7897 amar.kumar 8946 
 
7977 kshitij.so 8947 
  def process_addCartEvent(self, seqid, iprot, oprot):
8948 
    args = addCartEvent_args()
8949 
    args.read(iprot)
8950 
    iprot.readMessageEnd()
8951 
    result = addCartEvent_result()
8952 
    self._handler.addCartEvent(args.cartEvents)
8953 
    oprot.writeMessageBegin("addCartEvent", TMessageType.REPLY, seqid)
8954 
    result.write(oprot)
8955 
    oprot.writeMessageEnd()
8956 
    oprot.trans.flush()
8957 
 
8182 amar.kumar 8958 
  def process_addEbayItem(self, seqid, iprot, oprot):
8959 
    args = addEbayItem_args()
8960 
    args.read(iprot)
8961 
    iprot.readMessageEnd()
8962 
    result = addEbayItem_result()
8963 
    self._handler.addEbayItem(args.ebayItem)
8964 
    oprot.writeMessageBegin("addEbayItem", TMessageType.REPLY, seqid)
8965 
    result.write(oprot)
8966 
    oprot.writeMessageEnd()
8967 
    oprot.trans.flush()
8968 
 
8969 
  def process_getEbayItem(self, seqid, iprot, oprot):
8970 
    args = getEbayItem_args()
8971 
    args.read(iprot)
8972 
    iprot.readMessageEnd()
8973 
    result = getEbayItem_result()
8974 
    result.success = self._handler.getEbayItem(args.listingId)
8975 
    oprot.writeMessageBegin("getEbayItem", TMessageType.REPLY, seqid)
8976 
    result.write(oprot)
8977 
    oprot.writeMessageEnd()
8978 
    oprot.trans.flush()
8979 
 
8980 
  def process_updateEbayItem(self, seqid, iprot, oprot):
8981 
    args = updateEbayItem_args()
8982 
    args.read(iprot)
8983 
    iprot.readMessageEnd()
8984 
    result = updateEbayItem_result()
8985 
    self._handler.updateEbayItem(args.ebayItem)
8986 
    oprot.writeMessageBegin("updateEbayItem", TMessageType.REPLY, seqid)
8987 
    result.write(oprot)
8988 
    oprot.writeMessageEnd()
8989 
    oprot.trans.flush()
8990 
 
8139 kshitij.so 8991 
  def process_getAmazonListedItems(self, seqid, iprot, oprot):
8992 
    args = getAmazonListedItems_args()
8993 
    args.read(iprot)
8994 
    iprot.readMessageEnd()
8995 
    result = getAmazonListedItems_result()
8996 
    result.success = self._handler.getAmazonListedItems(args.offset, args.limit)
8997 
    oprot.writeMessageBegin("getAmazonListedItems", TMessageType.REPLY, seqid)
8998 
    result.write(oprot)
8999 
    oprot.writeMessageEnd()
9000 
    oprot.trans.flush()
7977 kshitij.so 9001 
 
8168 kshitij.so 9002 
  def process_updateAmazonAttributesInBulk(self, seqid, iprot, oprot):
9003 
    args = updateAmazonAttributesInBulk_args()
9004 
    args.read(iprot)
9005 
    iprot.readMessageEnd()
9006 
    result = updateAmazonAttributesInBulk_result()
9007 
    result.success = self._handler.updateAmazonAttributesInBulk(args.amazonlisted)
9008 
    oprot.writeMessageBegin("updateAmazonAttributesInBulk", TMessageType.REPLY, seqid)
9009 
    result.write(oprot)
9010 
    oprot.writeMessageEnd()
9011 
    oprot.trans.flush()
8139 kshitij.so 9012 
 
8379 vikram.rag 9013 
  def process_getAllItemstoListOnFba(self, seqid, iprot, oprot):
9014 
    args = getAllItemstoListOnFba_args()
9015 
    args.read(iprot)
9016 
    iprot.readMessageEnd()
9017 
    result = getAllItemstoListOnFba_result()
9018 
    result.success = self._handler.getAllItemstoListOnFba()
9019 
    oprot.writeMessageBegin("getAllItemstoListOnFba", TMessageType.REPLY, seqid)
9020 
    result.write(oprot)
9021 
    oprot.writeMessageEnd()
9022 
    oprot.trans.flush()
8168 kshitij.so 9023 
 
8379 vikram.rag 9024 
  def process_getAllItemstoListOnNonFba(self, seqid, iprot, oprot):
9025 
    args = getAllItemstoListOnNonFba_args()
9026 
    args.read(iprot)
9027 
    iprot.readMessageEnd()
9028 
    result = getAllItemstoListOnNonFba_result()
9029 
    result.success = self._handler.getAllItemstoListOnNonFba()
9030 
    oprot.writeMessageBegin("getAllItemstoListOnNonFba", TMessageType.REPLY, seqid)
9031 
    result.write(oprot)
9032 
    oprot.writeMessageEnd()
9033 
    oprot.trans.flush()
9034 
 
8619 kshitij.so 9035 
  def process_updateAsin(self, seqid, iprot, oprot):
9036 
    args = updateAsin_args()
9037 
    args.read(iprot)
9038 
    iprot.readMessageEnd()
9039 
    result = updateAsin_result()
9040 
    self._handler.updateAsin(args.item)
9041 
    oprot.writeMessageBegin("updateAsin", TMessageType.REPLY, seqid)
9042 
    result.write(oprot)
9043 
    oprot.writeMessageEnd()
9044 
    oprot.trans.flush()
8616 vikram.rag 9045 
 
8739 vikram.rag 9046 
  def process_addOrUpdateSnapdealItem(self, seqid, iprot, oprot):
9047 
    args = addOrUpdateSnapdealItem_args()
9048 
    args.read(iprot)
9049 
    iprot.readMessageEnd()
9050 
    result = addOrUpdateSnapdealItem_result()
9051 
    result.success = self._handler.addOrUpdateSnapdealItem(args.snapdealitem)
9052 
    oprot.writeMessageBegin("addOrUpdateSnapdealItem", TMessageType.REPLY, seqid)
9053 
    result.write(oprot)
9054 
    oprot.writeMessageEnd()
9055 
    oprot.trans.flush()
8619 kshitij.so 9056 
 
8739 vikram.rag 9057 
  def process_getSnapdealItem(self, seqid, iprot, oprot):
9058 
    args = getSnapdealItem_args()
9059 
    args.read(iprot)
9060 
    iprot.readMessageEnd()
9061 
    result = getSnapdealItem_result()
9062 
    result.success = self._handler.getSnapdealItem(args.item_id)
9063 
    oprot.writeMessageBegin("getSnapdealItem", TMessageType.REPLY, seqid)
9064 
    result.write(oprot)
9065 
    oprot.writeMessageEnd()
9066 
    oprot.trans.flush()
9067 
 
9242 kshitij.so 9068 
  def process_getSnapdealItemDetails(self, seqid, iprot, oprot):
9069 
    args = getSnapdealItemDetails_args()
9070 
    args.read(iprot)
9071 
    iprot.readMessageEnd()
9072 
    result = getSnapdealItemDetails_result()
9073 
    result.success = self._handler.getSnapdealItemDetails(args.item_id)
9074 
    oprot.writeMessageBegin("getSnapdealItemDetails", TMessageType.REPLY, seqid)
9075 
    result.write(oprot)
9076 
    oprot.writeMessageEnd()
9077 
    oprot.trans.flush()
9078 
 
8739 vikram.rag 9079 
  def process_getAllSnapdealItems(self, seqid, iprot, oprot):
9080 
    args = getAllSnapdealItems_args()
9081 
    args.read(iprot)
9082 
    iprot.readMessageEnd()
9083 
    result = getAllSnapdealItems_result()
9084 
    result.success = self._handler.getAllSnapdealItems()
9085 
    oprot.writeMessageBegin("getAllSnapdealItems", TMessageType.REPLY, seqid)
9086 
    result.write(oprot)
9087 
    oprot.writeMessageEnd()
9088 
    oprot.trans.flush()
9089 
 
9242 kshitij.so 9090 
  def process_getSnapdealItems(self, seqid, iprot, oprot):
9091 
    args = getSnapdealItems_args()
9092 
    args.read(iprot)
9093 
    iprot.readMessageEnd()
9094 
    result = getSnapdealItems_result()
9095 
    result.success = self._handler.getSnapdealItems(args.offset, args.limit)
9096 
    oprot.writeMessageBegin("getSnapdealItems", TMessageType.REPLY, seqid)
9097 
    result.write(oprot)
9098 
    oprot.writeMessageEnd()
9099 
    oprot.trans.flush()
8739 vikram.rag 9100 
 
9242 kshitij.so 9101 
  def process_searchSnapdealItems(self, seqid, iprot, oprot):
9102 
    args = searchSnapdealItems_args()
9103 
    args.read(iprot)
9104 
    iprot.readMessageEnd()
9105 
    result = searchSnapdealItems_result()
9106 
    result.success = self._handler.searchSnapdealItems(args.searchTerm, args.offset, args.limit)
9107 
    oprot.writeMessageBegin("searchSnapdealItems", TMessageType.REPLY, seqid)
9108 
    result.write(oprot)
9109 
    oprot.writeMessageEnd()
9110 
    oprot.trans.flush()
9111 
 
9112 
  def process_getCountForSnapdealItems(self, seqid, iprot, oprot):
9113 
    args = getCountForSnapdealItems_args()
9114 
    args.read(iprot)
9115 
    iprot.readMessageEnd()
9116 
    result = getCountForSnapdealItems_result()
9117 
    result.success = self._handler.getCountForSnapdealItems()
9118 
    oprot.writeMessageBegin("getCountForSnapdealItems", TMessageType.REPLY, seqid)
9119 
    result.write(oprot)
9120 
    oprot.writeMessageEnd()
9121 
    oprot.trans.flush()
9122 
 
9123 
  def process_getSnapdealSearchResultCount(self, seqid, iprot, oprot):
9124 
    args = getSnapdealSearchResultCount_args()
9125 
    args.read(iprot)
9126 
    iprot.readMessageEnd()
9127 
    result = getSnapdealSearchResultCount_result()
9128 
    result.success = self._handler.getSnapdealSearchResultCount(args.searchTerm)
9129 
    oprot.writeMessageBegin("getSnapdealSearchResultCount", TMessageType.REPLY, seqid)
9130 
    result.write(oprot)
9131 
    oprot.writeMessageEnd()
9132 
    oprot.trans.flush()
9133 
 
9299 kshitij.so 9134 
  def process_getPrefferedInsurerForItem(self, seqid, iprot, oprot):
9135 
    args = getPrefferedInsurerForItem_args()
9136 
    args.read(iprot)
9137 
    iprot.readMessageEnd()
9138 
    result = getPrefferedInsurerForItem_result()
9139 
    result.success = self._handler.getPrefferedInsurerForItem(args.itemId, args.insurerType)
9140 
    oprot.writeMessageBegin("getPrefferedInsurerForItem", TMessageType.REPLY, seqid)
9141 
    result.write(oprot)
9142 
    oprot.writeMessageEnd()
9143 
    oprot.trans.flush()
9242 kshitij.so 9144 
 
9456 vikram.rag 9145 
  def process_getSnapdealItembySkuAtSnapdeal(self, seqid, iprot, oprot):
9146 
    args = getSnapdealItembySkuAtSnapdeal_args()
9147 
    args.read(iprot)
9148 
    iprot.readMessageEnd()
9149 
    result = getSnapdealItembySkuAtSnapdeal_result()
9150 
    result.success = self._handler.getSnapdealItembySkuAtSnapdeal(args.skuAtSnapdeal)
9151 
    oprot.writeMessageBegin("getSnapdealItembySkuAtSnapdeal", TMessageType.REPLY, seqid)
9152 
    result.write(oprot)
9153 
    oprot.writeMessageEnd()
9154 
    oprot.trans.flush()
9299 kshitij.so 9155 
 
9621 manish.sha 9156 
  def process_getProductFeedSubmit(self, seqid, iprot, oprot):
9157 
    args = getProductFeedSubmit_args()
9158 
    args.read(iprot)
9159 
    iprot.readMessageEnd()
9160 
    result = getProductFeedSubmit_result()
9161 
    try:
9162 
      result.success = self._handler.getProductFeedSubmit(args.catalogItemId)
9163 
    except CatalogServiceException, cex:
9164 
      result.cex = cex
9165 
    oprot.writeMessageBegin("getProductFeedSubmit", TMessageType.REPLY, seqid)
9166 
    result.write(oprot)
9167 
    oprot.writeMessageEnd()
9168 
    oprot.trans.flush()
9456 vikram.rag 9169 
 
9621 manish.sha 9170 
  def process_addProductFeedSubmit(self, seqid, iprot, oprot):
9171 
    args = addProductFeedSubmit_args()
9172 
    args.read(iprot)
9173 
    iprot.readMessageEnd()
9174 
    result = addProductFeedSubmit_result()
9175 
    try:
9176 
      result.success = self._handler.addProductFeedSubmit(args.productFeedSubmit)
9177 
    except CatalogServiceException, cex:
9178 
      result.cex = cex
9179 
    oprot.writeMessageBegin("addProductFeedSubmit", TMessageType.REPLY, seqid)
9180 
    result.write(oprot)
9181 
    oprot.writeMessageEnd()
9182 
    oprot.trans.flush()
9183 
 
9184 
  def process_updateProductFeedSubmit(self, seqid, iprot, oprot):
9185 
    args = updateProductFeedSubmit_args()
9186 
    args.read(iprot)
9187 
    iprot.readMessageEnd()
9188 
    result = updateProductFeedSubmit_result()
9189 
    try:
9190 
      result.success = self._handler.updateProductFeedSubmit(args.productFeedSubmit)
9191 
    except CatalogServiceException, cex:
9192 
      result.cex = cex
9193 
    oprot.writeMessageBegin("updateProductFeedSubmit", TMessageType.REPLY, seqid)
9194 
    result.write(oprot)
9195 
    oprot.writeMessageEnd()
9196 
    oprot.trans.flush()
9197 
 
9198 
  def process_deleteProductFeedSubmit(self, seqid, iprot, oprot):
9199 
    args = deleteProductFeedSubmit_args()
9200 
    args.read(iprot)
9201 
    iprot.readMessageEnd()
9202 
    result = deleteProductFeedSubmit_result()
9203 
    try:
9204 
      result.success = self._handler.deleteProductFeedSubmit(args.catalogItemId)
9205 
    except CatalogServiceException, cex:
9206 
      result.cex = cex
9207 
    oprot.writeMessageBegin("deleteProductFeedSubmit", TMessageType.REPLY, seqid)
9208 
    result.write(oprot)
9209 
    oprot.writeMessageEnd()
9210 
    oprot.trans.flush()
9211 
 
9212 
  def process_getAllProductFeedSubmit(self, seqid, iprot, oprot):
9213 
    args = getAllProductFeedSubmit_args()
9214 
    args.read(iprot)
9215 
    iprot.readMessageEnd()
9216 
    result = getAllProductFeedSubmit_result()
9217 
    try:
9218 
      result.success = self._handler.getAllProductFeedSubmit()
9219 
    except CatalogServiceException, cex:
9220 
      result.cex = cex
9221 
    oprot.writeMessageBegin("getAllProductFeedSubmit", TMessageType.REPLY, seqid)
9222 
    result.write(oprot)
9223 
    oprot.writeMessageEnd()
9224 
    oprot.trans.flush()
9225 
 
9724 kshitij.so 9226 
  def process_getMarketplacedetailsForItem(self, seqid, iprot, oprot):
9227 
    args = getMarketplacedetailsForItem_args()
9228 
    args.read(iprot)
9229 
    iprot.readMessageEnd()
9230 
    result = getMarketplacedetailsForItem_result()
9231 
    result.success = self._handler.getMarketplacedetailsForItem(args.itemId, args.sourceId)
9232 
    oprot.writeMessageBegin("getMarketplacedetailsForItem", TMessageType.REPLY, seqid)
9233 
    result.write(oprot)
9234 
    oprot.writeMessageEnd()
9235 
    oprot.trans.flush()
9621 manish.sha 9236 
 
9724 kshitij.so 9237 
  def process_updateMarketplaceAttributesForItem(self, seqid, iprot, oprot):
9238 
    args = updateMarketplaceAttributesForItem_args()
9239 
    args.read(iprot)
9240 
    iprot.readMessageEnd()
9241 
    result = updateMarketplaceAttributesForItem_result()
9242 
    result.success = self._handler.updateMarketplaceAttributesForItem(args.marketPlaceItem)
9243 
    oprot.writeMessageBegin("updateMarketplaceAttributesForItem", TMessageType.REPLY, seqid)
9244 
    result.write(oprot)
9245 
    oprot.writeMessageEnd()
9246 
    oprot.trans.flush()
9247 
 
9779 kshitij.so 9248 
  def process_getCostingForMarketplace(self, seqid, iprot, oprot):
9249 
    args = getCostingForMarketplace_args()
9250 
    args.read(iprot)
9251 
    iprot.readMessageEnd()
9252 
    result = getCostingForMarketplace_result()
9253 
    result.success = self._handler.getCostingForMarketplace(args.source, args.item_id)
9254 
    oprot.writeMessageBegin("getCostingForMarketplace", TMessageType.REPLY, seqid)
9255 
    result.write(oprot)
9256 
    oprot.writeMessageEnd()
9257 
    oprot.trans.flush()
9258 
 
9776 vikram.rag 9259 
  def process_getMarketPlaceItemsForPriceUpdate(self, seqid, iprot, oprot):
9260 
    args = getMarketPlaceItemsForPriceUpdate_args()
9261 
    args.read(iprot)
9262 
    iprot.readMessageEnd()
9263 
    result = getMarketPlaceItemsForPriceUpdate_result()
9264 
    result.success = self._handler.getMarketPlaceItemsForPriceUpdate(args.source)
9265 
    oprot.writeMessageBegin("getMarketPlaceItemsForPriceUpdate", TMessageType.REPLY, seqid)
9266 
    result.write(oprot)
9267 
    oprot.writeMessageEnd()
9268 
    oprot.trans.flush()
9724 kshitij.so 9269 
 
9776 vikram.rag 9270 
  def process_updateMarketPlacePriceUpdateStatus(self, seqid, iprot, oprot):
9271 
    args = updateMarketPlacePriceUpdateStatus_args()
9272 
    args.read(iprot)
9273 
    iprot.readMessageEnd()
9274 
    result = updateMarketPlacePriceUpdateStatus_result()
9816 kshitij.so 9275 
    self._handler.updateMarketPlacePriceUpdateStatus(args.skulist, args.timestamp, args.source)
9776 vikram.rag 9276 
    oprot.writeMessageBegin("updateMarketPlacePriceUpdateStatus", TMessageType.REPLY, seqid)
9277 
    result.write(oprot)
9278 
    oprot.writeMessageEnd()
9279 
    oprot.trans.flush()
9280 
 
9861 rajveer 9281 
  def process_updateItemHoldInventory(self, seqid, iprot, oprot):
9282 
    args = updateItemHoldInventory_args()
9283 
    args.read(iprot)
9284 
    iprot.readMessageEnd()
9285 
    result = updateItemHoldInventory_result()
9286 
    self._handler.updateItemHoldInventory(args.itemHoldMap)
9287 
    oprot.writeMessageBegin("updateItemHoldInventory", TMessageType.REPLY, seqid)
9288 
    result.write(oprot)
9289 
    oprot.writeMessageEnd()
9290 
    oprot.trans.flush()
9776 vikram.rag 9291 
 
9895 vikram.rag 9292 
  def process_updateNlcAtMarketplaces(self, seqid, iprot, oprot):
9293 
    args = updateNlcAtMarketplaces_args()
9294 
    args.read(iprot)
9295 
    iprot.readMessageEnd()
9296 
    result = updateNlcAtMarketplaces_result()
9297 
    self._handler.updateNlcAtMarketplaces(args.item_id, args.vendor_id, args.nlc)
9298 
    oprot.writeMessageBegin("updateNlcAtMarketplaces", TMessageType.REPLY, seqid)
9299 
    result.write(oprot)
9300 
    oprot.writeMessageEnd()
9301 
    oprot.trans.flush()
9861 rajveer 9302 
 
9945 vikram.rag 9303 
  def process_getAllFlipkartItems(self, seqid, iprot, oprot):
9304 
    args = getAllFlipkartItems_args()
9305 
    args.read(iprot)
9306 
    iprot.readMessageEnd()
9307 
    result = getAllFlipkartItems_result()
9308 
    result.success = self._handler.getAllFlipkartItems()
9309 
    oprot.writeMessageBegin("getAllFlipkartItems", TMessageType.REPLY, seqid)
9310 
    result.write(oprot)
9311 
    oprot.writeMessageEnd()
9312 
    oprot.trans.flush()
9895 vikram.rag 9313 
 
10097 kshitij.so 9314 
  def process_addOrUpdateFlipkartItem(self, seqid, iprot, oprot):
9315 
    args = addOrUpdateFlipkartItem_args()
9316 
    args.read(iprot)
9317 
    iprot.readMessageEnd()
9318 
    result = addOrUpdateFlipkartItem_result()
9319 
    result.success = self._handler.addOrUpdateFlipkartItem(args.flipkartitem)
9320 
    oprot.writeMessageBegin("addOrUpdateFlipkartItem", TMessageType.REPLY, seqid)
9321 
    result.write(oprot)
9322 
    oprot.writeMessageEnd()
9323 
    oprot.trans.flush()
9945 vikram.rag 9324 
 
10097 kshitij.so 9325 
  def process_getFlipkartItem(self, seqid, iprot, oprot):
9326 
    args = getFlipkartItem_args()
9327 
    args.read(iprot)
9328 
    iprot.readMessageEnd()
9329 
    result = getFlipkartItem_result()
9330 
    result.success = self._handler.getFlipkartItem(args.item_id)
9331 
    oprot.writeMessageBegin("getFlipkartItem", TMessageType.REPLY, seqid)
9332 
    result.write(oprot)
9333 
    oprot.writeMessageEnd()
9334 
    oprot.trans.flush()
9335 
 
9336 
  def process_getFlipkartItemDetails(self, seqid, iprot, oprot):
9337 
    args = getFlipkartItemDetails_args()
9338 
    args.read(iprot)
9339 
    iprot.readMessageEnd()
9340 
    result = getFlipkartItemDetails_result()
9341 
    result.success = self._handler.getFlipkartItemDetails(args.item_id)
9342 
    oprot.writeMessageBegin("getFlipkartItemDetails", TMessageType.REPLY, seqid)
9343 
    result.write(oprot)
9344 
    oprot.writeMessageEnd()
9345 
    oprot.trans.flush()
9346 
 
9347 
  def process_getFlipkartItems(self, seqid, iprot, oprot):
9348 
    args = getFlipkartItems_args()
9349 
    args.read(iprot)
9350 
    iprot.readMessageEnd()
9351 
    result = getFlipkartItems_result()
9352 
    result.success = self._handler.getFlipkartItems(args.offset, args.limit)
9353 
    oprot.writeMessageBegin("getFlipkartItems", TMessageType.REPLY, seqid)
9354 
    result.write(oprot)
9355 
    oprot.writeMessageEnd()
9356 
    oprot.trans.flush()
9357 
 
9358 
  def process_searchFlipkartItems(self, seqid, iprot, oprot):
9359 
    args = searchFlipkartItems_args()
9360 
    args.read(iprot)
9361 
    iprot.readMessageEnd()
9362 
    result = searchFlipkartItems_result()
9363 
    result.success = self._handler.searchFlipkartItems(args.searchTerm, args.offset, args.limit)
9364 
    oprot.writeMessageBegin("searchFlipkartItems", TMessageType.REPLY, seqid)
9365 
    result.write(oprot)
9366 
    oprot.writeMessageEnd()
9367 
    oprot.trans.flush()
9368 
 
9369 
  def process_getCountForFlipkartItems(self, seqid, iprot, oprot):
9370 
    args = getCountForFlipkartItems_args()
9371 
    args.read(iprot)
9372 
    iprot.readMessageEnd()
9373 
    result = getCountForFlipkartItems_result()
9374 
    result.success = self._handler.getCountForFlipkartItems()
9375 
    oprot.writeMessageBegin("getCountForFlipkartItems", TMessageType.REPLY, seqid)
9376 
    result.write(oprot)
9377 
    oprot.writeMessageEnd()
9378 
    oprot.trans.flush()
9379 
 
9380 
  def process_getFlipkartSearchResultCount(self, seqid, iprot, oprot):
9381 
    args = getFlipkartSearchResultCount_args()
9382 
    args.read(iprot)
9383 
    iprot.readMessageEnd()
9384 
    result = getFlipkartSearchResultCount_result()
9385 
    result.success = self._handler.getFlipkartSearchResultCount(args.searchTerm)
9386 
    oprot.writeMessageBegin("getFlipkartSearchResultCount", TMessageType.REPLY, seqid)
9387 
    result.write(oprot)
9388 
    oprot.writeMessageEnd()
9389 
    oprot.trans.flush()
9390 
 
9391 
  def process_getAllFkItems(self, seqid, iprot, oprot):
9392 
    args = getAllFkItems_args()
9393 
    args.read(iprot)
9394 
    iprot.readMessageEnd()
9395 
    result = getAllFkItems_result()
9396 
    result.success = self._handler.getAllFkItems()
9397 
    oprot.writeMessageBegin("getAllFkItems", TMessageType.REPLY, seqid)
9398 
    result.write(oprot)
9399 
    oprot.writeMessageEnd()
9400 
    oprot.trans.flush()
9401 
 
10140 vikram.rag 9402 
  def process_getFlipkartItemBySkyAtFlipkart(self, seqid, iprot, oprot):
9403 
    args = getFlipkartItemBySkyAtFlipkart_args()
9404 
    args.read(iprot)
9405 
    iprot.readMessageEnd()
9406 
    result = getFlipkartItemBySkyAtFlipkart_result()
9407 
    result.success = self._handler.getFlipkartItemBySkyAtFlipkart(args.sku)
9408 
    oprot.writeMessageBegin("getFlipkartItemBySkyAtFlipkart", TMessageType.REPLY, seqid)
9409 
    result.write(oprot)
9410 
    oprot.writeMessageEnd()
9411 
    oprot.trans.flush()
10097 kshitij.so 9412 
 
11015 kshitij.so 9413 
  def process_getMarketplaceHistory(self, seqid, iprot, oprot):
9414 
    args = getMarketplaceHistory_args()
9415 
    args.read(iprot)
9416 
    iprot.readMessageEnd()
9417 
    result = getMarketplaceHistory_result()
9418 
    result.success = self._handler.getMarketplaceHistory(args.source, args.offset, args.itemId)
9419 
    oprot.writeMessageBegin("getMarketplaceHistory", TMessageType.REPLY, seqid)
9420 
    result.write(oprot)
9421 
    oprot.writeMessageEnd()
9422 
    oprot.trans.flush()
9423 
 
10909 vikram.rag 9424 
  def process_getAllFbbListedItems(self, seqid, iprot, oprot):
9425 
    args = getAllFbbListedItems_args()
9426 
    args.read(iprot)
9427 
    iprot.readMessageEnd()
9428 
    result = getAllFbbListedItems_result()
9429 
    result.success = self._handler.getAllFbbListedItems()
9430 
    oprot.writeMessageBegin("getAllFbbListedItems", TMessageType.REPLY, seqid)
9431 
    result.write(oprot)
9432 
    oprot.writeMessageEnd()
9433 
    oprot.trans.flush()
10140 vikram.rag 9434 
 
10924 vikram.rag 9435 
  def process_getAllFbbPricingItems(self, seqid, iprot, oprot):
9436 
    args = getAllFbbPricingItems_args()
9437 
    args.read(iprot)
9438 
    iprot.readMessageEnd()
9439 
    result = getAllFbbPricingItems_result()
9440 
    result.success = self._handler.getAllFbbPricingItems()
9441 
    oprot.writeMessageBegin("getAllFbbPricingItems", TMessageType.REPLY, seqid)
9442 
    result.write(oprot)
9443 
    oprot.writeMessageEnd()
9444 
    oprot.trans.flush()
10909 vikram.rag 9445 
 
11015 kshitij.so 9446 
  def process_getCountForMarketplaceHistory(self, seqid, iprot, oprot):
9447 
    args = getCountForMarketplaceHistory_args()
9448 
    args.read(iprot)
9449 
    iprot.readMessageEnd()
9450 
    result = getCountForMarketplaceHistory_result()
9451 
    result.success = self._handler.getCountForMarketplaceHistory(args.source, args.itemId)
9452 
    oprot.writeMessageBegin("getCountForMarketplaceHistory", TMessageType.REPLY, seqid)
9453 
    result.write(oprot)
9454 
    oprot.writeMessageEnd()
9455 
    oprot.trans.flush()
10924 vikram.rag 9456 
 
11015 kshitij.so 9457 
  def process_getMarketplaceHistoryByDate(self, seqid, iprot, oprot):
9458 
    args = getMarketplaceHistoryByDate_args()
9459 
    args.read(iprot)
9460 
    iprot.readMessageEnd()
9461 
    result = getMarketplaceHistoryByDate_result()
9462 
    result.success = self._handler.getMarketplaceHistoryByDate(args.source, args.startDate, args.endDate, args.offset, args.limit, args.itemId)
9463 
    oprot.writeMessageBegin("getMarketplaceHistoryByDate", TMessageType.REPLY, seqid)
9464 
    result.write(oprot)
9465 
    oprot.writeMessageEnd()
9466 
    oprot.trans.flush()
9467 
 
11531 vikram.rag 9468 
  def process_getPrivateDealDetails(self, seqid, iprot, oprot):
9469 
    args = getPrivateDealDetails_args()
9470 
    args.read(iprot)
9471 
    iprot.readMessageEnd()
9472 
    result = getPrivateDealDetails_result()
9473 
    result.success = self._handler.getPrivateDealDetails(args.item_id)
9474 
    oprot.writeMessageBegin("getPrivateDealDetails", TMessageType.REPLY, seqid)
9475 
    result.write(oprot)
9476 
    oprot.writeMessageEnd()
9477 
    oprot.trans.flush()
11015 kshitij.so 9478 
 
11531 vikram.rag 9479 
  def process_getPrivateDealItems(self, seqid, iprot, oprot):
9480 
    args = getPrivateDealItems_args()
9481 
    args.read(iprot)
9482 
    iprot.readMessageEnd()
9483 
    result = getPrivateDealItems_result()
9484 
    result.success = self._handler.getPrivateDealItems(args.offset, args.limit)
9485 
    oprot.writeMessageBegin("getPrivateDealItems", TMessageType.REPLY, seqid)
9486 
    result.write(oprot)
9487 
    oprot.writeMessageEnd()
9488 
    oprot.trans.flush()
9489 
 
11592 amit.gupta 9490 
  def process_getAllActivePrivateDeals(self, seqid, iprot, oprot):
9491 
    args = getAllActivePrivateDeals_args()
9492 
    args.read(iprot)
9493 
    iprot.readMessageEnd()
9494 
    result = getAllActivePrivateDeals_result()
11653 amit.gupta 9495 
    result.success = self._handler.getAllActivePrivateDeals(args.itemIds, args.daysDelta)
11592 amit.gupta 9496 
    oprot.writeMessageBegin("getAllActivePrivateDeals", TMessageType.REPLY, seqid)
9497 
    result.write(oprot)
9498 
    oprot.writeMessageEnd()
9499 
    oprot.trans.flush()
9500 
 
11531 vikram.rag 9501 
  def process_addOrUpdatePrivateDeal(self, seqid, iprot, oprot):
9502 
    args = addOrUpdatePrivateDeal_args()
9503 
    args.read(iprot)
9504 
    iprot.readMessageEnd()
9505 
    result = addOrUpdatePrivateDeal_result()
9506 
    result.success = self._handler.addOrUpdatePrivateDeal(args.privateDeal)
9507 
    oprot.writeMessageBegin("addOrUpdatePrivateDeal", TMessageType.REPLY, seqid)
9508 
    result.write(oprot)
9509 
    oprot.writeMessageEnd()
9510 
    oprot.trans.flush()
9511 
 
11635 vikram.rag 9512 
  def process_getPrivateDealsCatalogIds(self, seqid, iprot, oprot):
9513 
    args = getPrivateDealsCatalogIds_args()
9514 
    args.read(iprot)
9515 
    iprot.readMessageEnd()
9516 
    result = getPrivateDealsCatalogIds_result()
9517 
    try:
9518 
      result.success = self._handler.getPrivateDealsCatalogIds(args.beginIndex, args.totalItems)
9519 
    except CatalogServiceException, cex:
9520 
      result.cex = cex
9521 
    oprot.writeMessageBegin("getPrivateDealsCatalogIds", TMessageType.REPLY, seqid)
9522 
    result.write(oprot)
9523 
    oprot.writeMessageEnd()
9524 
    oprot.trans.flush()
11531 vikram.rag 9525 
 
11645 amit.gupta 9526 
  def process_getPrivateDealsCount(self, seqid, iprot, oprot):
9527 
    args = getPrivateDealsCount_args()
9528 
    args.read(iprot)
9529 
    iprot.readMessageEnd()
9530 
    result = getPrivateDealsCount_result()
9531 
    result.success = self._handler.getPrivateDealsCount()
9532 
    oprot.writeMessageBegin("getPrivateDealsCount", TMessageType.REPLY, seqid)
9533 
    result.write(oprot)
9534 
    oprot.writeMessageEnd()
9535 
    oprot.trans.flush()
11635 vikram.rag 9536 
 
11905 kshitij.so 9537 
  def process_getAmazonOutSyncItems(self, seqid, iprot, oprot):
9538 
    args = getAmazonOutSyncItems_args()
9539 
    args.read(iprot)
9540 
    iprot.readMessageEnd()
9541 
    result = getAmazonOutSyncItems_result()
9542 
    result.success = self._handler.getAmazonOutSyncItems(args.item_id)
9543 
    oprot.writeMessageBegin("getAmazonOutSyncItems", TMessageType.REPLY, seqid)
9544 
    result.write(oprot)
9545 
    oprot.writeMessageEnd()
9546 
    oprot.trans.flush()
11645 amit.gupta 9547 
 
11905 kshitij.so 9548 
  def process_getAllPrivateDealsComparison(self, seqid, iprot, oprot):
9549 
    args = getAllPrivateDealsComparison_args()
9550 
    args.read(iprot)
9551 
    iprot.readMessageEnd()
9552 
    result = getAllPrivateDealsComparison_result()
9553 
    result.success = self._handler.getAllPrivateDealsComparison()
9554 
    oprot.writeMessageBegin("getAllPrivateDealsComparison", TMessageType.REPLY, seqid)
9555 
    result.write(oprot)
9556 
    oprot.writeMessageEnd()
9557 
    oprot.trans.flush()
9558 
 
12133 kshitij.so 9559 
  def process_getAllSnapdealMarketplaceItem(self, seqid, iprot, oprot):
9560 
    args = getAllSnapdealMarketplaceItem_args()
9561 
    args.read(iprot)
9562 
    iprot.readMessageEnd()
9563 
    result = getAllSnapdealMarketplaceItem_result()
9564 
    result.success = self._handler.getAllSnapdealMarketplaceItem()
9565 
    oprot.writeMessageBegin("getAllSnapdealMarketplaceItem", TMessageType.REPLY, seqid)
9566 
    result.write(oprot)
9567 
    oprot.writeMessageEnd()
9568 
    oprot.trans.flush()
11905 kshitij.so 9569 
 
12133 kshitij.so 9570 
  def process_getAllFlipkartMarketplaceItem(self, seqid, iprot, oprot):
9571 
    args = getAllFlipkartMarketplaceItem_args()
9572 
    args.read(iprot)
9573 
    iprot.readMessageEnd()
9574 
    result = getAllFlipkartMarketplaceItem_result()
9575 
    result.success = self._handler.getAllFlipkartMarketplaceItem()
9576 
    oprot.writeMessageBegin("getAllFlipkartMarketplaceItem", TMessageType.REPLY, seqid)
9577 
    result.write(oprot)
9578 
    oprot.writeMessageEnd()
9579 
    oprot.trans.flush()
9580 
 
12243 kshitij.so 9581 
  def process_addCompetitorScraping(self, seqid, iprot, oprot):
9582 
    args = addCompetitorScraping_args()
9583 
    args.read(iprot)
9584 
    iprot.readMessageEnd()
9585 
    result = addCompetitorScraping_result()
9586 
    self._handler.addCompetitorScraping(args.competitorPricingMap)
9587 
    oprot.writeMessageBegin("addCompetitorScraping", TMessageType.REPLY, seqid)
9588 
    result.write(oprot)
9589 
    oprot.writeMessageEnd()
9590 
    oprot.trans.flush()
12133 kshitij.so 9591 
 
12243 kshitij.so 9592 
  def process_getPreviousCompetitorScraping(self, seqid, iprot, oprot):
9593 
    args = getPreviousCompetitorScraping_args()
9594 
    args.read(iprot)
9595 
    iprot.readMessageEnd()
9596 
    result = getPreviousCompetitorScraping_result()
9597 
    result.success = self._handler.getPreviousCompetitorScraping(args.delta)
9598 
    oprot.writeMessageBegin("getPreviousCompetitorScraping", TMessageType.REPLY, seqid)
9599 
    result.write(oprot)
9600 
    oprot.writeMessageEnd()
9601 
    oprot.trans.flush()
9602 
 
12256 kshitij.so 9603 
  def process_getUploadResultById(self, seqid, iprot, oprot):
9604 
    args = getUploadResultById_args()
9605 
    args.read(iprot)
9606 
    iprot.readMessageEnd()
9607 
    result = getUploadResultById_result()
9608 
    result.success = self._handler.getUploadResultById(args.uploadId)
9609 
    oprot.writeMessageBegin("getUploadResultById", TMessageType.REPLY, seqid)
9610 
    result.write(oprot)
9611 
    oprot.writeMessageEnd()
9612 
    oprot.trans.flush()
12243 kshitij.so 9613 
 
12363 kshitij.so 9614 
  def process_addAmazonPromotion(self, seqid, iprot, oprot):
9615 
    args = addAmazonPromotion_args()
9616 
    args.read(iprot)
9617 
    iprot.readMessageEnd()
9618 
    result = addAmazonPromotion_result()
12947 kshitij.so 9619 
    try:
9620 
      result.success = self._handler.addAmazonPromotion(args.amazonPromotions)
9621 
    except CatalogServiceException, cex:
9622 
      result.cex = cex
12363 kshitij.so 9623 
    oprot.writeMessageBegin("addAmazonPromotion", TMessageType.REPLY, seqid)
9624 
    result.write(oprot)
9625 
    oprot.writeMessageEnd()
9626 
    oprot.trans.flush()
12256 kshitij.so 9627 
 
12363 kshitij.so 9628 
  def process_getAmazonPromotion(self, seqid, iprot, oprot):
9629 
    args = getAmazonPromotion_args()
9630 
    args.read(iprot)
9631 
    iprot.readMessageEnd()
9632 
    result = getAmazonPromotion_result()
9633 
    result.success = self._handler.getAmazonPromotion(args.startDate, args.endDate)
9634 
    oprot.writeMessageBegin("getAmazonPromotion", TMessageType.REPLY, seqid)
9635 
    result.write(oprot)
9636 
    oprot.writeMessageEnd()
9637 
    oprot.trans.flush()
9638 
 
9639 
  def process_updateAmazonPromotion(self, seqid, iprot, oprot):
9640 
    args = updateAmazonPromotion_args()
9641 
    args.read(iprot)
9642 
    iprot.readMessageEnd()
9643 
    result = updateAmazonPromotion_result()
9644 
    result.success = self._handler.updateAmazonPromotion(args.amazonPromotions)
9645 
    oprot.writeMessageBegin("updateAmazonPromotion", TMessageType.REPLY, seqid)
9646 
    result.write(oprot)
9647 
    oprot.writeMessageEnd()
9648 
    oprot.trans.flush()
9649 
 
12567 amit.gupta 9650 
  def process_markPartiallyActive(self, seqid, iprot, oprot):
9651 
    args = markPartiallyActive_args()
9652 
    args.read(iprot)
9653 
    iprot.readMessageEnd()
9654 
    result = markPartiallyActive_result()
9655 
    result.success = self._handler.markPartiallyActive(args.itemId, args.categoryId)
9656 
    oprot.writeMessageBegin("markPartiallyActive", TMessageType.REPLY, seqid)
9657 
    result.write(oprot)
9658 
    oprot.writeMessageEnd()
9659 
    oprot.trans.flush()
12363 kshitij.so 9660 
 
12567 amit.gupta 9661 
  def process_updateItemStateVat(self, seqid, iprot, oprot):
9662 
    args = updateItemStateVat_args()
9663 
    args.read(iprot)
9664 
    iprot.readMessageEnd()
9665 
    result = updateItemStateVat_result()
9666 
    result.success = self._handler.updateItemStateVat(args.itemId, args.statevat)
9667 
    oprot.writeMessageBegin("updateItemStateVat", TMessageType.REPLY, seqid)
9668 
    result.write(oprot)
9669 
    oprot.writeMessageEnd()
9670 
    oprot.trans.flush()
9671 
 
12620 amit.gupta 9672 
  def process_getExAffiliateItemInfo(self, seqid, iprot, oprot):
9673 
    args = getExAffiliateItemInfo_args()
9674 
    args.read(iprot)
9675 
    iprot.readMessageEnd()
9676 
    result = getExAffiliateItemInfo_result()
9677 
    result.success = self._handler.getExAffiliateItemInfo()
9678 
    oprot.writeMessageBegin("getExAffiliateItemInfo", TMessageType.REPLY, seqid)
9679 
    result.write(oprot)
9680 
    oprot.writeMessageEnd()
9681 
    oprot.trans.flush()
12567 amit.gupta 9682 
 
12888 kshitij.so 9683 
  def process_getAllItemstoListOnFbg(self, seqid, iprot, oprot):
9684 
    args = getAllItemstoListOnFbg_args()
9685 
    args.read(iprot)
9686 
    iprot.readMessageEnd()
9687 
    result = getAllItemstoListOnFbg_result()
9688 
    result.success = self._handler.getAllItemstoListOnFbg()
9689 
    oprot.writeMessageBegin("getAllItemstoListOnFbg", TMessageType.REPLY, seqid)
9690 
    result.write(oprot)
9691 
    oprot.writeMessageEnd()
9692 
    oprot.trans.flush()
12620 amit.gupta 9693 
 
12892 kshitij.so 9694 
  def process_getAllFbgListedItems(self, seqid, iprot, oprot):
9695 
    args = getAllFbgListedItems_args()
9696 
    args.read(iprot)
9697 
    iprot.readMessageEnd()
9698 
    result = getAllFbgListedItems_result()
9699 
    result.success = self._handler.getAllFbgListedItems()
9700 
    oprot.writeMessageBegin("getAllFbgListedItems", TMessageType.REPLY, seqid)
9701 
    result.write(oprot)
9702 
    oprot.writeMessageEnd()
9703 
    oprot.trans.flush()
12888 kshitij.so 9704 
 
13136 amit.gupta 9705 
  def process_checkServices(self, seqid, iprot, oprot):
9706 
    args = checkServices_args()
9707 
    args.read(iprot)
9708 
    iprot.readMessageEnd()
9709 
    result = checkServices_result()
9710 
    try:
9711 
      result.success = self._handler.checkServices(args.lines)
9712 
    except CatalogServiceException, cex:
9713 
      result.cex = cex
9714 
    oprot.writeMessageBegin("checkServices", TMessageType.REPLY, seqid)
9715 
    result.write(oprot)
9716 
    oprot.writeMessageEnd()
9717 
    oprot.trans.flush()
12892 kshitij.so 9718 
 
13709 manish.sha 9719 
  def process_addHsItem(self, seqid, iprot, oprot):
9720 
    args = addHsItem_args()
9721 
    args.read(iprot)
9722 
    iprot.readMessageEnd()
9723 
    result = addHsItem_result()
9724 
    self._handler.addHsItem(args.hsItems)
9725 
    oprot.writeMessageBegin("addHsItem", TMessageType.REPLY, seqid)
9726 
    result.write(oprot)
9727 
    oprot.writeMessageEnd()
9728 
    oprot.trans.flush()
13136 amit.gupta 9729 
 
13709 manish.sha 9730 
  def process_getHsItem(self, seqid, iprot, oprot):
9731 
    args = getHsItem_args()
9732 
    args.read(iprot)
9733 
    iprot.readMessageEnd()
9734 
    result = getHsItem_result()
9735 
    result.success = self._handler.getHsItem(args.hsItemId)
9736 
    oprot.writeMessageBegin("getHsItem", TMessageType.REPLY, seqid)
9737 
    result.write(oprot)
9738 
    oprot.writeMessageEnd()
9739 
    oprot.trans.flush()
9740 
 
9741 
  def process_updateHsItem(self, seqid, iprot, oprot):
9742 
    args = updateHsItem_args()
9743 
    args.read(iprot)
9744 
    iprot.readMessageEnd()
9745 
    result = updateHsItem_result()
9746 
    self._handler.updateHsItem(args.hsItem)
9747 
    oprot.writeMessageBegin("updateHsItem", TMessageType.REPLY, seqid)
9748 
    result.write(oprot)
9749 
    oprot.writeMessageEnd()
9750 
    oprot.trans.flush()
9751 
 
14182 kshitij.so 9752 
  def process_getPricingForDtr(self, seqid, iprot, oprot):
9753 
    args = getPricingForDtr_args()
9754 
    args.read(iprot)
9755 
    iprot.readMessageEnd()
9756 
    result = getPricingForDtr_result()
9757 
    result.success = self._handler.getPricingForDtr(args.catalogItemId)
9758 
    oprot.writeMessageBegin("getPricingForDtr", TMessageType.REPLY, seqid)
9759 
    result.write(oprot)
9760 
    oprot.writeMessageEnd()
9761 
    oprot.trans.flush()
13709 manish.sha 9762 
 
15702 kshitij.so 9763 
  def process_getAllItemstoListOnFbd(self, seqid, iprot, oprot):
9764 
    args = getAllItemstoListOnFbd_args()
9765 
    args.read(iprot)
9766 
    iprot.readMessageEnd()
9767 
    result = getAllItemstoListOnFbd_result()
9768 
    result.success = self._handler.getAllItemstoListOnFbd()
9769 
    oprot.writeMessageBegin("getAllItemstoListOnFbd", TMessageType.REPLY, seqid)
9770 
    result.write(oprot)
9771 
    oprot.writeMessageEnd()
9772 
    oprot.trans.flush()
14182 kshitij.so 9773 
 
15706 kshitij.so 9774 
  def process_getAllFbdListedItems(self, seqid, iprot, oprot):
9775 
    args = getAllFbdListedItems_args()
9776 
    args.read(iprot)
9777 
    iprot.readMessageEnd()
9778 
    result = getAllFbdListedItems_result()
9779 
    result.success = self._handler.getAllFbdListedItems()
9780 
    oprot.writeMessageBegin("getAllFbdListedItems", TMessageType.REPLY, seqid)
9781 
    result.write(oprot)
9782 
    oprot.writeMessageEnd()
9783 
    oprot.trans.flush()
15702 kshitij.so 9784 
 
18150 kshitij.so 9785 
  def process_getBulkPricingForItems(self, seqid, iprot, oprot):
9786 
    args = getBulkPricingForItems_args()
9787 
    args.read(iprot)
9788 
    iprot.readMessageEnd()
9789 
    result = getBulkPricingForItems_result()
9790 
    result.success = self._handler.getBulkPricingForItems(args.itemIds)
9791 
    oprot.writeMessageBegin("getBulkPricingForItems", TMessageType.REPLY, seqid)
9792 
    result.write(oprot)
9793 
    oprot.writeMessageEnd()
9794 
    oprot.trans.flush()
15706 kshitij.so 9795 
 
18150 kshitij.so 9796 
  def process_addBulkPricingForItem(self, seqid, iprot, oprot):
9797 
    args = addBulkPricingForItem_args()
9798 
    args.read(iprot)
9799 
    iprot.readMessageEnd()
9800 
    result = addBulkPricingForItem_result()
9801 
    result.success = self._handler.addBulkPricingForItem(args.bulkItemPricing)
9802 
    oprot.writeMessageBegin("addBulkPricingForItem", TMessageType.REPLY, seqid)
9803 
    result.write(oprot)
9804 
    oprot.writeMessageEnd()
9805 
    oprot.trans.flush()
9806 
 
9807 
  def process_deleteBulkPricingForItemById(self, seqid, iprot, oprot):
9808 
    args = deleteBulkPricingForItemById_args()
9809 
    args.read(iprot)
9810 
    iprot.readMessageEnd()
9811 
    result = deleteBulkPricingForItemById_result()
9812 
    result.success = self._handler.deleteBulkPricingForItemById(args.id)
9813 
    oprot.writeMessageBegin("deleteBulkPricingForItemById", TMessageType.REPLY, seqid)
9814 
    result.write(oprot)
9815 
    oprot.writeMessageEnd()
9816 
    oprot.trans.flush()
9817 
 
9818 
  def process_deleteBulkPricingForItem(self, seqid, iprot, oprot):
9819 
    args = deleteBulkPricingForItem_args()
9820 
    args.read(iprot)
9821 
    iprot.readMessageEnd()
9822 
    result = deleteBulkPricingForItem_result()
9823 
    result.success = self._handler.deleteBulkPricingForItem(args.item_id)
9824 
    oprot.writeMessageBegin("deleteBulkPricingForItem", TMessageType.REPLY, seqid)
9825 
    result.write(oprot)
9826 
    oprot.writeMessageEnd()
9827 
    oprot.trans.flush()
9828 
 
9829 
  def process_getBulkPricingByItemId(self, seqid, iprot, oprot):
9830 
    args = getBulkPricingByItemId_args()
9831 
    args.read(iprot)
9832 
    iprot.readMessageEnd()
9833 
    result = getBulkPricingByItemId_result()
9834 
    result.success = self._handler.getBulkPricingByItemId(args.item_id)
9835 
    oprot.writeMessageBegin("getBulkPricingByItemId", TMessageType.REPLY, seqid)
9836 
    result.write(oprot)
9837 
    oprot.writeMessageEnd()
9838 
    oprot.trans.flush()
9839 
 
18602 kshitij.so 9840 
  def process_updateBulkPricesOnProduction(self, seqid, iprot, oprot):
9841 
    args = updateBulkPricesOnProduction_args()
9842 
    args.read(iprot)
9843 
    iprot.readMessageEnd()
9844 
    result = updateBulkPricesOnProduction_result()
9845 
    result.success = self._handler.updateBulkPricesOnProduction(args.item_id, args.bulkItemPricingList)
9846 
    oprot.writeMessageBegin("updateBulkPricesOnProduction", TMessageType.REPLY, seqid)
9847 
    result.write(oprot)
9848 
    oprot.writeMessageEnd()
9849 
    oprot.trans.flush()
18150 kshitij.so 9850 
 
18764 kshitij.so 9851 
  def process_getCartByValue(self, seqid, iprot, oprot):
9852 
    args = getCartByValue_args()
9853 
    args.read(iprot)
9854 
    iprot.readMessageEnd()
9855 
    result = getCartByValue_result()
9856 
    result.success = self._handler.getCartByValue(args.cartIds)
9857 
    oprot.writeMessageBegin("getCartByValue", TMessageType.REPLY, seqid)
9858 
    result.write(oprot)
9859 
    oprot.writeMessageEnd()
9860 
    oprot.trans.flush()
18602 kshitij.so 9861 
 
18764 kshitij.so 9862 
 
5944 mandeep.dh 9863 
# HELPER FUNCTIONS AND STRUCTURES
9864 
 
9865 
class addItem_args:
9866 
  """
9867 
  Attributes:
9868 
   - item
9869 
  """
9870 
 
9871 
  thrift_spec = (
9872 
    None, # 0
9873 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
9874 
  )
9875 
 
9876 
  def __init__(self, item=None,):
9877 
    self.item = item
9878 
 
9879 
  def read(self, iprot):
9880 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9881 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9882 
      return
9883 
    iprot.readStructBegin()
9884 
    while True:
9885 
      (fname, ftype, fid) = iprot.readFieldBegin()
9886 
      if ftype == TType.STOP:
9887 
        break
9888 
      if fid == 1:
9889 
        if ftype == TType.STRUCT:
9890 
          self.item = Item()
9891 
          self.item.read(iprot)
9892 
        else:
9893 
          iprot.skip(ftype)
9894 
      else:
9895 
        iprot.skip(ftype)
9896 
      iprot.readFieldEnd()
9897 
    iprot.readStructEnd()
9898 
 
9899 
  def write(self, oprot):
9900 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9901 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9902 
      return
9903 
    oprot.writeStructBegin('addItem_args')
9904 
    if self.item is not None:
9905 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
9906 
      self.item.write(oprot)
9907 
      oprot.writeFieldEnd()
9908 
    oprot.writeFieldStop()
9909 
    oprot.writeStructEnd()
9910 
 
9911 
  def validate(self):
9912 
    return
9913 
 
9914 
 
9915 
  def __repr__(self):
9916 
    L = ['%s=%r' % (key, value)
9917 
      for key, value in self.__dict__.iteritems()]
9918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9919 
 
9920 
  def __eq__(self, other):
9921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9922 
 
9923 
  def __ne__(self, other):
9924 
    return not (self == other)
9925 
 
9926 
class addItem_result:
9927 
  """
9928 
  Attributes:
9929 
   - success
9930 
   - cex
9931 
  """
9932 
 
9933 
  thrift_spec = (
9934 
    (0, TType.I64, 'success', None, None, ), # 0
9935 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9936 
  )
9937 
 
9938 
  def __init__(self, success=None, cex=None,):
9939 
    self.success = success
9940 
    self.cex = cex
9941 
 
9942 
  def read(self, iprot):
9943 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9944 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9945 
      return
9946 
    iprot.readStructBegin()
9947 
    while True:
9948 
      (fname, ftype, fid) = iprot.readFieldBegin()
9949 
      if ftype == TType.STOP:
9950 
        break
9951 
      if fid == 0:
9952 
        if ftype == TType.I64:
9953 
          self.success = iprot.readI64();
9954 
        else:
9955 
          iprot.skip(ftype)
9956 
      elif fid == 1:
9957 
        if ftype == TType.STRUCT:
9958 
          self.cex = CatalogServiceException()
9959 
          self.cex.read(iprot)
9960 
        else:
9961 
          iprot.skip(ftype)
9962 
      else:
9963 
        iprot.skip(ftype)
9964 
      iprot.readFieldEnd()
9965 
    iprot.readStructEnd()
9966 
 
9967 
  def write(self, oprot):
9968 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9969 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9970 
      return
9971 
    oprot.writeStructBegin('addItem_result')
9972 
    if self.success is not None:
9973 
      oprot.writeFieldBegin('success', TType.I64, 0)
9974 
      oprot.writeI64(self.success)
9975 
      oprot.writeFieldEnd()
9976 
    if self.cex is not None:
9977 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9978 
      self.cex.write(oprot)
9979 
      oprot.writeFieldEnd()
9980 
    oprot.writeFieldStop()
9981 
    oprot.writeStructEnd()
9982 
 
9983 
  def validate(self):
9984 
    return
9985 
 
9986 
 
9987 
  def __repr__(self):
9988 
    L = ['%s=%r' % (key, value)
9989 
      for key, value in self.__dict__.iteritems()]
9990 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9991 
 
9992 
  def __eq__(self, other):
9993 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9994 
 
9995 
  def __ne__(self, other):
9996 
    return not (self == other)
9997 
 
9998 
class updateItem_args:
9999 
  """
10000 
  Attributes:
10001 
   - item
10002 
  """
10003 
 
10004 
  thrift_spec = (
10005 
    None, # 0
10006 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
10007 
  )
10008 
 
10009 
  def __init__(self, item=None,):
10010 
    self.item = item
10011 
 
10012 
  def read(self, iprot):
10013 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10014 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10015 
      return
10016 
    iprot.readStructBegin()
10017 
    while True:
10018 
      (fname, ftype, fid) = iprot.readFieldBegin()
10019 
      if ftype == TType.STOP:
10020 
        break
10021 
      if fid == 1:
10022 
        if ftype == TType.STRUCT:
10023 
          self.item = Item()
10024 
          self.item.read(iprot)
10025 
        else:
10026 
          iprot.skip(ftype)
10027 
      else:
10028 
        iprot.skip(ftype)
10029 
      iprot.readFieldEnd()
10030 
    iprot.readStructEnd()
10031 
 
10032 
  def write(self, oprot):
10033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10035 
      return
10036 
    oprot.writeStructBegin('updateItem_args')
10037 
    if self.item is not None:
10038 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
10039 
      self.item.write(oprot)
10040 
      oprot.writeFieldEnd()
10041 
    oprot.writeFieldStop()
10042 
    oprot.writeStructEnd()
10043 
 
10044 
  def validate(self):
10045 
    return
10046 
 
10047 
 
10048 
  def __repr__(self):
10049 
    L = ['%s=%r' % (key, value)
10050 
      for key, value in self.__dict__.iteritems()]
10051 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10052 
 
10053 
  def __eq__(self, other):
10054 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10055 
 
10056 
  def __ne__(self, other):
10057 
    return not (self == other)
10058 
 
10059 
class updateItem_result:
10060 
  """
10061 
  Attributes:
10062 
   - success
10063 
   - cex
10064 
  """
10065 
 
10066 
  thrift_spec = (
10067 
    (0, TType.I64, 'success', None, None, ), # 0
10068 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10069 
  )
10070 
 
10071 
  def __init__(self, success=None, cex=None,):
10072 
    self.success = success
10073 
    self.cex = cex
10074 
 
10075 
  def read(self, iprot):
10076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10078 
      return
10079 
    iprot.readStructBegin()
10080 
    while True:
10081 
      (fname, ftype, fid) = iprot.readFieldBegin()
10082 
      if ftype == TType.STOP:
10083 
        break
10084 
      if fid == 0:
10085 
        if ftype == TType.I64:
10086 
          self.success = iprot.readI64();
10087 
        else:
10088 
          iprot.skip(ftype)
10089 
      elif fid == 1:
10090 
        if ftype == TType.STRUCT:
10091 
          self.cex = CatalogServiceException()
10092 
          self.cex.read(iprot)
10093 
        else:
10094 
          iprot.skip(ftype)
10095 
      else:
10096 
        iprot.skip(ftype)
10097 
      iprot.readFieldEnd()
10098 
    iprot.readStructEnd()
10099 
 
10100 
  def write(self, oprot):
10101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10103 
      return
10104 
    oprot.writeStructBegin('updateItem_result')
10105 
    if self.success is not None:
10106 
      oprot.writeFieldBegin('success', TType.I64, 0)
10107 
      oprot.writeI64(self.success)
10108 
      oprot.writeFieldEnd()
10109 
    if self.cex is not None:
10110 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10111 
      self.cex.write(oprot)
10112 
      oprot.writeFieldEnd()
10113 
    oprot.writeFieldStop()
10114 
    oprot.writeStructEnd()
10115 
 
10116 
  def validate(self):
10117 
    return
10118 
 
10119 
 
10120 
  def __repr__(self):
10121 
    L = ['%s=%r' % (key, value)
10122 
      for key, value in self.__dict__.iteritems()]
10123 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10124 
 
10125 
  def __eq__(self, other):
10126 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10127 
 
10128 
  def __ne__(self, other):
10129 
    return not (self == other)
10130 
 
10131 
class isActive_args:
10132 
  """
10133 
  Attributes:
10134 
   - itemId
10135 
  """
10136 
 
10137 
  thrift_spec = (
10138 
    None, # 0
10139 
    (1, TType.I64, 'itemId', None, None, ), # 1
10140 
  )
10141 
 
10142 
  def __init__(self, itemId=None,):
10143 
    self.itemId = itemId
10144 
 
10145 
  def read(self, iprot):
10146 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10147 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10148 
      return
10149 
    iprot.readStructBegin()
10150 
    while True:
10151 
      (fname, ftype, fid) = iprot.readFieldBegin()
10152 
      if ftype == TType.STOP:
10153 
        break
10154 
      if fid == 1:
10155 
        if ftype == TType.I64:
10156 
          self.itemId = iprot.readI64();
10157 
        else:
10158 
          iprot.skip(ftype)
10159 
      else:
10160 
        iprot.skip(ftype)
10161 
      iprot.readFieldEnd()
10162 
    iprot.readStructEnd()
10163 
 
10164 
  def write(self, oprot):
10165 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10166 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10167 
      return
10168 
    oprot.writeStructBegin('isActive_args')
10169 
    if self.itemId is not None:
10170 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
10171 
      oprot.writeI64(self.itemId)
10172 
      oprot.writeFieldEnd()
10173 
    oprot.writeFieldStop()
10174 
    oprot.writeStructEnd()
10175 
 
10176 
  def validate(self):
10177 
    return
10178 
 
10179 
 
10180 
  def __repr__(self):
10181 
    L = ['%s=%r' % (key, value)
10182 
      for key, value in self.__dict__.iteritems()]
10183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10184 
 
10185 
  def __eq__(self, other):
10186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10187 
 
10188 
  def __ne__(self, other):
10189 
    return not (self == other)
10190 
 
10191 
class isActive_result:
10192 
  """
10193 
  Attributes:
10194 
   - success
10195 
   - isex
10196 
  """
10197 
 
10198 
  thrift_spec = (
10199 
    (0, TType.STRUCT, 'success', (ItemShippingInfo, ItemShippingInfo.thrift_spec), None, ), # 0
10200 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10201 
  )
10202 
 
10203 
  def __init__(self, success=None, isex=None,):
10204 
    self.success = success
10205 
    self.isex = isex
10206 
 
10207 
  def read(self, iprot):
10208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10210 
      return
10211 
    iprot.readStructBegin()
10212 
    while True:
10213 
      (fname, ftype, fid) = iprot.readFieldBegin()
10214 
      if ftype == TType.STOP:
10215 
        break
10216 
      if fid == 0:
10217 
        if ftype == TType.STRUCT:
10218 
          self.success = ItemShippingInfo()
10219 
          self.success.read(iprot)
10220 
        else:
10221 
          iprot.skip(ftype)
10222 
      elif fid == 1:
10223 
        if ftype == TType.STRUCT:
10224 
          self.isex = CatalogServiceException()
10225 
          self.isex.read(iprot)
10226 
        else:
10227 
          iprot.skip(ftype)
10228 
      else:
10229 
        iprot.skip(ftype)
10230 
      iprot.readFieldEnd()
10231 
    iprot.readStructEnd()
10232 
 
10233 
  def write(self, oprot):
10234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10236 
      return
10237 
    oprot.writeStructBegin('isActive_result')
10238 
    if self.success is not None:
10239 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10240 
      self.success.write(oprot)
10241 
      oprot.writeFieldEnd()
10242 
    if self.isex is not None:
10243 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
10244 
      self.isex.write(oprot)
10245 
      oprot.writeFieldEnd()
10246 
    oprot.writeFieldStop()
10247 
    oprot.writeStructEnd()
10248 
 
10249 
  def validate(self):
10250 
    return
10251 
 
10252 
 
10253 
  def __repr__(self):
10254 
    L = ['%s=%r' % (key, value)
10255 
      for key, value in self.__dict__.iteritems()]
10256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10257 
 
10258 
  def __eq__(self, other):
10259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10260 
 
10261 
  def __ne__(self, other):
10262 
    return not (self == other)
10263 
 
7438 amit.gupta 10264 
class getItemsStatus_args:
10265 
  """
10266 
  Attributes:
10267 
   - itemIds
10268 
  """
10269 
 
10270 
  thrift_spec = (
10271 
    None, # 0
10272 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
10273 
  )
10274 
 
10275 
  def __init__(self, itemIds=None,):
10276 
    self.itemIds = itemIds
10277 
 
10278 
  def read(self, iprot):
10279 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10280 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10281 
      return
10282 
    iprot.readStructBegin()
10283 
    while True:
10284 
      (fname, ftype, fid) = iprot.readFieldBegin()
10285 
      if ftype == TType.STOP:
10286 
        break
10287 
      if fid == 1:
10288 
        if ftype == TType.LIST:
10289 
          self.itemIds = []
18719 kshitij.so 10290 
          (_etype42, _size39) = iprot.readListBegin()
10291 
          for _i43 in xrange(_size39):
10292 
            _elem44 = iprot.readI64();
10293 
            self.itemIds.append(_elem44)
7438 amit.gupta 10294 
          iprot.readListEnd()
10295 
        else:
10296 
          iprot.skip(ftype)
10297 
      else:
10298 
        iprot.skip(ftype)
10299 
      iprot.readFieldEnd()
10300 
    iprot.readStructEnd()
10301 
 
10302 
  def write(self, oprot):
10303 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10304 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10305 
      return
10306 
    oprot.writeStructBegin('getItemsStatus_args')
10307 
    if self.itemIds is not None:
10308 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
10309 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
18719 kshitij.so 10310 
      for iter45 in self.itemIds:
10311 
        oprot.writeI64(iter45)
7438 amit.gupta 10312 
      oprot.writeListEnd()
10313 
      oprot.writeFieldEnd()
10314 
    oprot.writeFieldStop()
10315 
    oprot.writeStructEnd()
10316 
 
10317 
  def validate(self):
10318 
    return
10319 
 
10320 
 
10321 
  def __repr__(self):
10322 
    L = ['%s=%r' % (key, value)
10323 
      for key, value in self.__dict__.iteritems()]
10324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10325 
 
10326 
  def __eq__(self, other):
10327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10328 
 
10329 
  def __ne__(self, other):
10330 
    return not (self == other)
10331 
 
10332 
class getItemsStatus_result:
10333 
  """
10334 
  Attributes:
10335 
   - success
10336 
   - isex
10337 
  """
10338 
 
10339 
  thrift_spec = (
10340 
    (0, TType.MAP, 'success', (TType.I64,None,TType.BOOL,None), None, ), # 0
10341 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10342 
  )
10343 
 
10344 
  def __init__(self, success=None, isex=None,):
10345 
    self.success = success
10346 
    self.isex = isex
10347 
 
10348 
  def read(self, iprot):
10349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10351 
      return
10352 
    iprot.readStructBegin()
10353 
    while True:
10354 
      (fname, ftype, fid) = iprot.readFieldBegin()
10355 
      if ftype == TType.STOP:
10356 
        break
10357 
      if fid == 0:
10358 
        if ftype == TType.MAP:
10359 
          self.success = {}
18719 kshitij.so 10360 
          (_ktype47, _vtype48, _size46 ) = iprot.readMapBegin()
10361 
          for _i50 in xrange(_size46):
10362 
            _key51 = iprot.readI64();
10363 
            _val52 = iprot.readBool();
10364 
            self.success[_key51] = _val52
7438 amit.gupta 10365 
          iprot.readMapEnd()
10366 
        else:
10367 
          iprot.skip(ftype)
10368 
      elif fid == 1:
10369 
        if ftype == TType.STRUCT:
10370 
          self.isex = CatalogServiceException()
10371 
          self.isex.read(iprot)
10372 
        else:
10373 
          iprot.skip(ftype)
10374 
      else:
10375 
        iprot.skip(ftype)
10376 
      iprot.readFieldEnd()
10377 
    iprot.readStructEnd()
10378 
 
10379 
  def write(self, oprot):
10380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10382 
      return
10383 
    oprot.writeStructBegin('getItemsStatus_result')
10384 
    if self.success is not None:
10385 
      oprot.writeFieldBegin('success', TType.MAP, 0)
10386 
      oprot.writeMapBegin(TType.I64, TType.BOOL, len(self.success))
18719 kshitij.so 10387 
      for kiter53,viter54 in self.success.items():
10388 
        oprot.writeI64(kiter53)
10389 
        oprot.writeBool(viter54)
7438 amit.gupta 10390 
      oprot.writeMapEnd()
10391 
      oprot.writeFieldEnd()
10392 
    if self.isex is not None:
10393 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
10394 
      self.isex.write(oprot)
10395 
      oprot.writeFieldEnd()
10396 
    oprot.writeFieldStop()
10397 
    oprot.writeStructEnd()
10398 
 
10399 
  def validate(self):
10400 
    return
10401 
 
10402 
 
10403 
  def __repr__(self):
10404 
    L = ['%s=%r' % (key, value)
10405 
      for key, value in self.__dict__.iteritems()]
10406 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10407 
 
10408 
  def __eq__(self, other):
10409 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10410 
 
10411 
  def __ne__(self, other):
10412 
    return not (self == other)
10413 
 
5944 mandeep.dh 10414 
class getItemStatusDescription_args:
10415 
  """
10416 
  Attributes:
10417 
   - itemId
10418 
  """
10419 
 
10420 
  thrift_spec = (
10421 
    None, # 0
10422 
    (1, TType.I64, 'itemId', None, None, ), # 1
10423 
  )
10424 
 
10425 
  def __init__(self, itemId=None,):
10426 
    self.itemId = itemId
10427 
 
10428 
  def read(self, iprot):
10429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10431 
      return
10432 
    iprot.readStructBegin()
10433 
    while True:
10434 
      (fname, ftype, fid) = iprot.readFieldBegin()
10435 
      if ftype == TType.STOP:
10436 
        break
10437 
      if fid == 1:
10438 
        if ftype == TType.I64:
10439 
          self.itemId = iprot.readI64();
10440 
        else:
10441 
          iprot.skip(ftype)
10442 
      else:
10443 
        iprot.skip(ftype)
10444 
      iprot.readFieldEnd()
10445 
    iprot.readStructEnd()
10446 
 
10447 
  def write(self, oprot):
10448 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10449 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10450 
      return
10451 
    oprot.writeStructBegin('getItemStatusDescription_args')
10452 
    if self.itemId is not None:
10453 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
10454 
      oprot.writeI64(self.itemId)
10455 
      oprot.writeFieldEnd()
10456 
    oprot.writeFieldStop()
10457 
    oprot.writeStructEnd()
10458 
 
10459 
  def validate(self):
10460 
    return
10461 
 
10462 
 
10463 
  def __repr__(self):
10464 
    L = ['%s=%r' % (key, value)
10465 
      for key, value in self.__dict__.iteritems()]
10466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10467 
 
10468 
  def __eq__(self, other):
10469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10470 
 
10471 
  def __ne__(self, other):
10472 
    return not (self == other)
10473 
 
10474 
class getItemStatusDescription_result:
10475 
  """
10476 
  Attributes:
10477 
   - success
10478 
   - isex
10479 
  """
10480 
 
10481 
  thrift_spec = (
10482 
    (0, TType.STRING, 'success', None, None, ), # 0
10483 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10484 
  )
10485 
 
10486 
  def __init__(self, success=None, isex=None,):
10487 
    self.success = success
10488 
    self.isex = isex
10489 
 
10490 
  def read(self, iprot):
10491 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10492 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10493 
      return
10494 
    iprot.readStructBegin()
10495 
    while True:
10496 
      (fname, ftype, fid) = iprot.readFieldBegin()
10497 
      if ftype == TType.STOP:
10498 
        break
10499 
      if fid == 0:
10500 
        if ftype == TType.STRING:
10501 
          self.success = iprot.readString();
10502 
        else:
10503 
          iprot.skip(ftype)
10504 
      elif fid == 1:
10505 
        if ftype == TType.STRUCT:
10506 
          self.isex = CatalogServiceException()
10507 
          self.isex.read(iprot)
10508 
        else:
10509 
          iprot.skip(ftype)
10510 
      else:
10511 
        iprot.skip(ftype)
10512 
      iprot.readFieldEnd()
10513 
    iprot.readStructEnd()
10514 
 
10515 
  def write(self, oprot):
10516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10518 
      return
10519 
    oprot.writeStructBegin('getItemStatusDescription_result')
10520 
    if self.success is not None:
10521 
      oprot.writeFieldBegin('success', TType.STRING, 0)
10522 
      oprot.writeString(self.success)
10523 
      oprot.writeFieldEnd()
10524 
    if self.isex is not None:
10525 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
10526 
      self.isex.write(oprot)
10527 
      oprot.writeFieldEnd()
10528 
    oprot.writeFieldStop()
10529 
    oprot.writeStructEnd()
10530 
 
10531 
  def validate(self):
10532 
    return
10533 
 
10534 
 
10535 
  def __repr__(self):
10536 
    L = ['%s=%r' % (key, value)
10537 
      for key, value in self.__dict__.iteritems()]
10538 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10539 
 
10540 
  def __eq__(self, other):
10541 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10542 
 
10543 
  def __ne__(self, other):
10544 
    return not (self == other)
10545 
 
10546 
class startItemOn_args:
10547 
  """
10548 
  Attributes:
10549 
   - item_id
10550 
   - timestamp
10551 
  """
10552 
 
10553 
  thrift_spec = (
10554 
    None, # 0
10555 
    (1, TType.I64, 'item_id', None, None, ), # 1
10556 
    (2, TType.I64, 'timestamp', None, None, ), # 2
10557 
  )
10558 
 
10559 
  def __init__(self, item_id=None, timestamp=None,):
10560 
    self.item_id = item_id
10561 
    self.timestamp = timestamp
10562 
 
10563 
  def read(self, iprot):
10564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10566 
      return
10567 
    iprot.readStructBegin()
10568 
    while True:
10569 
      (fname, ftype, fid) = iprot.readFieldBegin()
10570 
      if ftype == TType.STOP:
10571 
        break
10572 
      if fid == 1:
10573 
        if ftype == TType.I64:
10574 
          self.item_id = iprot.readI64();
10575 
        else:
10576 
          iprot.skip(ftype)
10577 
      elif fid == 2:
10578 
        if ftype == TType.I64:
10579 
          self.timestamp = iprot.readI64();
10580 
        else:
10581 
          iprot.skip(ftype)
10582 
      else:
10583 
        iprot.skip(ftype)
10584 
      iprot.readFieldEnd()
10585 
    iprot.readStructEnd()
10586 
 
10587 
  def write(self, oprot):
10588 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10589 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10590 
      return
10591 
    oprot.writeStructBegin('startItemOn_args')
10592 
    if self.item_id is not None:
10593 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
10594 
      oprot.writeI64(self.item_id)
10595 
      oprot.writeFieldEnd()
10596 
    if self.timestamp is not None:
10597 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
10598 
      oprot.writeI64(self.timestamp)
10599 
      oprot.writeFieldEnd()
10600 
    oprot.writeFieldStop()
10601 
    oprot.writeStructEnd()
10602 
 
10603 
  def validate(self):
10604 
    return
10605 
 
10606 
 
10607 
  def __repr__(self):
10608 
    L = ['%s=%r' % (key, value)
10609 
      for key, value in self.__dict__.iteritems()]
10610 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10611 
 
10612 
  def __eq__(self, other):
10613 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10614 
 
10615 
  def __ne__(self, other):
10616 
    return not (self == other)
10617 
 
10618 
class startItemOn_result:
10619 
  """
10620 
  Attributes:
10621 
   - cex
10622 
  """
10623 
 
10624 
  thrift_spec = (
10625 
    None, # 0
10626 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10627 
  )
10628 
 
10629 
  def __init__(self, cex=None,):
10630 
    self.cex = cex
10631 
 
10632 
  def read(self, iprot):
10633 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10634 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10635 
      return
10636 
    iprot.readStructBegin()
10637 
    while True:
10638 
      (fname, ftype, fid) = iprot.readFieldBegin()
10639 
      if ftype == TType.STOP:
10640 
        break
10641 
      if fid == 1:
10642 
        if ftype == TType.STRUCT:
10643 
          self.cex = CatalogServiceException()
10644 
          self.cex.read(iprot)
10645 
        else:
10646 
          iprot.skip(ftype)
10647 
      else:
10648 
        iprot.skip(ftype)
10649 
      iprot.readFieldEnd()
10650 
    iprot.readStructEnd()
10651 
 
10652 
  def write(self, oprot):
10653 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10654 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10655 
      return
10656 
    oprot.writeStructBegin('startItemOn_result')
10657 
    if self.cex is not None:
10658 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10659 
      self.cex.write(oprot)
10660 
      oprot.writeFieldEnd()
10661 
    oprot.writeFieldStop()
10662 
    oprot.writeStructEnd()
10663 
 
10664 
  def validate(self):
10665 
    return
10666 
 
10667 
 
10668 
  def __repr__(self):
10669 
    L = ['%s=%r' % (key, value)
10670 
      for key, value in self.__dict__.iteritems()]
10671 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10672 
 
10673 
  def __eq__(self, other):
10674 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10675 
 
10676 
  def __ne__(self, other):
10677 
    return not (self == other)
10678 
 
10679 
class retireItemOn_args:
10680 
  """
10681 
  Attributes:
10682 
   - item_id
10683 
   - timestamp
10684 
  """
10685 
 
10686 
  thrift_spec = (
10687 
    None, # 0
10688 
    (1, TType.I64, 'item_id', None, None, ), # 1
10689 
    (2, TType.I64, 'timestamp', None, None, ), # 2
10690 
  )
10691 
 
10692 
  def __init__(self, item_id=None, timestamp=None,):
10693 
    self.item_id = item_id
10694 
    self.timestamp = timestamp
10695 
 
10696 
  def read(self, iprot):
10697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10699 
      return
10700 
    iprot.readStructBegin()
10701 
    while True:
10702 
      (fname, ftype, fid) = iprot.readFieldBegin()
10703 
      if ftype == TType.STOP:
10704 
        break
10705 
      if fid == 1:
10706 
        if ftype == TType.I64:
10707 
          self.item_id = iprot.readI64();
10708 
        else:
10709 
          iprot.skip(ftype)
10710 
      elif fid == 2:
10711 
        if ftype == TType.I64:
10712 
          self.timestamp = iprot.readI64();
10713 
        else:
10714 
          iprot.skip(ftype)
10715 
      else:
10716 
        iprot.skip(ftype)
10717 
      iprot.readFieldEnd()
10718 
    iprot.readStructEnd()
10719 
 
10720 
  def write(self, oprot):
10721 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10722 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10723 
      return
10724 
    oprot.writeStructBegin('retireItemOn_args')
10725 
    if self.item_id is not None:
10726 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
10727 
      oprot.writeI64(self.item_id)
10728 
      oprot.writeFieldEnd()
10729 
    if self.timestamp is not None:
10730 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
10731 
      oprot.writeI64(self.timestamp)
10732 
      oprot.writeFieldEnd()
10733 
    oprot.writeFieldStop()
10734 
    oprot.writeStructEnd()
10735 
 
10736 
  def validate(self):
10737 
    return
10738 
 
10739 
 
10740 
  def __repr__(self):
10741 
    L = ['%s=%r' % (key, value)
10742 
      for key, value in self.__dict__.iteritems()]
10743 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10744 
 
10745 
  def __eq__(self, other):
10746 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10747 
 
10748 
  def __ne__(self, other):
10749 
    return not (self == other)
10750 
 
10751 
class retireItemOn_result:
10752 
  """
10753 
  Attributes:
10754 
   - cex
10755 
  """
10756 
 
10757 
  thrift_spec = (
10758 
    None, # 0
10759 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10760 
  )
10761 
 
10762 
  def __init__(self, cex=None,):
10763 
    self.cex = cex
10764 
 
10765 
  def read(self, iprot):
10766 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10767 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10768 
      return
10769 
    iprot.readStructBegin()
10770 
    while True:
10771 
      (fname, ftype, fid) = iprot.readFieldBegin()
10772 
      if ftype == TType.STOP:
10773 
        break
10774 
      if fid == 1:
10775 
        if ftype == TType.STRUCT:
10776 
          self.cex = CatalogServiceException()
10777 
          self.cex.read(iprot)
10778 
        else:
10779 
          iprot.skip(ftype)
10780 
      else:
10781 
        iprot.skip(ftype)
10782 
      iprot.readFieldEnd()
10783 
    iprot.readStructEnd()
10784 
 
10785 
  def write(self, oprot):
10786 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10787 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10788 
      return
10789 
    oprot.writeStructBegin('retireItemOn_result')
10790 
    if self.cex is not None:
10791 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10792 
      self.cex.write(oprot)
10793 
      oprot.writeFieldEnd()
10794 
    oprot.writeFieldStop()
10795 
    oprot.writeStructEnd()
10796 
 
10797 
  def validate(self):
10798 
    return
10799 
 
10800 
 
10801 
  def __repr__(self):
10802 
    L = ['%s=%r' % (key, value)
10803 
      for key, value in self.__dict__.iteritems()]
10804 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10805 
 
10806 
  def __eq__(self, other):
10807 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10808 
 
10809 
  def __ne__(self, other):
10810 
    return not (self == other)
10811 
 
10812 
class changeItemStatus_args:
10813 
  """
10814 
  Attributes:
10815 
   - item_id
10816 
   - timestamp
10817 
   - newstatus
10818 
  """
10819 
 
10820 
  thrift_spec = (
10821 
    None, # 0
10822 
    (1, TType.I64, 'item_id', None, None, ), # 1
10823 
    (2, TType.I64, 'timestamp', None, None, ), # 2
10824 
    (3, TType.I32, 'newstatus', None, None, ), # 3
10825 
  )
10826 
 
10827 
  def __init__(self, item_id=None, timestamp=None, newstatus=None,):
10828 
    self.item_id = item_id
10829 
    self.timestamp = timestamp
10830 
    self.newstatus = newstatus
10831 
 
10832 
  def read(self, iprot):
10833 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10834 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10835 
      return
10836 
    iprot.readStructBegin()
10837 
    while True:
10838 
      (fname, ftype, fid) = iprot.readFieldBegin()
10839 
      if ftype == TType.STOP:
10840 
        break
10841 
      if fid == 1:
10842 
        if ftype == TType.I64:
10843 
          self.item_id = iprot.readI64();
10844 
        else:
10845 
          iprot.skip(ftype)
10846 
      elif fid == 2:
10847 
        if ftype == TType.I64:
10848 
          self.timestamp = iprot.readI64();
10849 
        else:
10850 
          iprot.skip(ftype)
10851 
      elif fid == 3:
10852 
        if ftype == TType.I32:
10853 
          self.newstatus = iprot.readI32();
10854 
        else:
10855 
          iprot.skip(ftype)
10856 
      else:
10857 
        iprot.skip(ftype)
10858 
      iprot.readFieldEnd()
10859 
    iprot.readStructEnd()
10860 
 
10861 
  def write(self, oprot):
10862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10864 
      return
10865 
    oprot.writeStructBegin('changeItemStatus_args')
10866 
    if self.item_id is not None:
10867 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
10868 
      oprot.writeI64(self.item_id)
10869 
      oprot.writeFieldEnd()
10870 
    if self.timestamp is not None:
10871 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
10872 
      oprot.writeI64(self.timestamp)
10873 
      oprot.writeFieldEnd()
10874 
    if self.newstatus is not None:
10875 
      oprot.writeFieldBegin('newstatus', TType.I32, 3)
10876 
      oprot.writeI32(self.newstatus)
10877 
      oprot.writeFieldEnd()
10878 
    oprot.writeFieldStop()
10879 
    oprot.writeStructEnd()
10880 
 
10881 
  def validate(self):
10882 
    return
10883 
 
10884 
 
10885 
  def __repr__(self):
10886 
    L = ['%s=%r' % (key, value)
10887 
      for key, value in self.__dict__.iteritems()]
10888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10889 
 
10890 
  def __eq__(self, other):
10891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10892 
 
10893 
  def __ne__(self, other):
10894 
    return not (self == other)
10895 
 
10896 
class changeItemStatus_result:
10897 
  """
10898 
  Attributes:
10899 
   - cex
10900 
  """
10901 
 
10902 
  thrift_spec = (
10903 
    None, # 0
10904 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10905 
  )
10906 
 
10907 
  def __init__(self, cex=None,):
10908 
    self.cex = cex
10909 
 
10910 
  def read(self, iprot):
10911 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10912 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10913 
      return
10914 
    iprot.readStructBegin()
10915 
    while True:
10916 
      (fname, ftype, fid) = iprot.readFieldBegin()
10917 
      if ftype == TType.STOP:
10918 
        break
10919 
      if fid == 1:
10920 
        if ftype == TType.STRUCT:
10921 
          self.cex = CatalogServiceException()
10922 
          self.cex.read(iprot)
10923 
        else:
10924 
          iprot.skip(ftype)
10925 
      else:
10926 
        iprot.skip(ftype)
10927 
      iprot.readFieldEnd()
10928 
    iprot.readStructEnd()
10929 
 
10930 
  def write(self, oprot):
10931 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10932 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10933 
      return
10934 
    oprot.writeStructBegin('changeItemStatus_result')
10935 
    if self.cex is not None:
10936 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10937 
      self.cex.write(oprot)
10938 
      oprot.writeFieldEnd()
10939 
    oprot.writeFieldStop()
10940 
    oprot.writeStructEnd()
10941 
 
10942 
  def validate(self):
10943 
    return
10944 
 
10945 
 
10946 
  def __repr__(self):
10947 
    L = ['%s=%r' % (key, value)
10948 
      for key, value in self.__dict__.iteritems()]
10949 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10950 
 
10951 
  def __eq__(self, other):
10952 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10953 
 
10954 
  def __ne__(self, other):
10955 
    return not (self == other)
10956 
 
10957 
class getItem_args:
10958 
  """
10959 
  Attributes:
10960 
   - item_id
10961 
  """
10962 
 
10963 
  thrift_spec = (
10964 
    None, # 0
10965 
    (1, TType.I64, 'item_id', None, None, ), # 1
10966 
  )
10967 
 
10968 
  def __init__(self, item_id=None,):
10969 
    self.item_id = item_id
10970 
 
10971 
  def read(self, iprot):
10972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10974 
      return
10975 
    iprot.readStructBegin()
10976 
    while True:
10977 
      (fname, ftype, fid) = iprot.readFieldBegin()
10978 
      if ftype == TType.STOP:
10979 
        break
10980 
      if fid == 1:
10981 
        if ftype == TType.I64:
10982 
          self.item_id = iprot.readI64();
10983 
        else:
10984 
          iprot.skip(ftype)
10985 
      else:
10986 
        iprot.skip(ftype)
10987 
      iprot.readFieldEnd()
10988 
    iprot.readStructEnd()
10989 
 
10990 
  def write(self, oprot):
10991 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10992 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10993 
      return
10994 
    oprot.writeStructBegin('getItem_args')
10995 
    if self.item_id is not None:
10996 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
10997 
      oprot.writeI64(self.item_id)
10998 
      oprot.writeFieldEnd()
10999 
    oprot.writeFieldStop()
11000 
    oprot.writeStructEnd()
11001 
 
11002 
  def validate(self):
11003 
    return
11004 
 
11005 
 
11006 
  def __repr__(self):
11007 
    L = ['%s=%r' % (key, value)
11008 
      for key, value in self.__dict__.iteritems()]
11009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11010 
 
11011 
  def __eq__(self, other):
11012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11013 
 
11014 
  def __ne__(self, other):
11015 
    return not (self == other)
11016 
 
11017 
class getItem_result:
11018 
  """
11019 
  Attributes:
11020 
   - success
11021 
   - cex
11022 
  """
11023 
 
11024 
  thrift_spec = (
11025 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
11026 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11027 
  )
11028 
 
11029 
  def __init__(self, success=None, cex=None,):
11030 
    self.success = success
11031 
    self.cex = cex
11032 
 
11033 
  def read(self, iprot):
11034 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11035 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11036 
      return
11037 
    iprot.readStructBegin()
11038 
    while True:
11039 
      (fname, ftype, fid) = iprot.readFieldBegin()
11040 
      if ftype == TType.STOP:
11041 
        break
11042 
      if fid == 0:
11043 
        if ftype == TType.STRUCT:
11044 
          self.success = Item()
11045 
          self.success.read(iprot)
11046 
        else:
11047 
          iprot.skip(ftype)
11048 
      elif fid == 1:
11049 
        if ftype == TType.STRUCT:
11050 
          self.cex = CatalogServiceException()
11051 
          self.cex.read(iprot)
11052 
        else:
11053 
          iprot.skip(ftype)
11054 
      else:
11055 
        iprot.skip(ftype)
11056 
      iprot.readFieldEnd()
11057 
    iprot.readStructEnd()
11058 
 
11059 
  def write(self, oprot):
11060 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11061 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11062 
      return
11063 
    oprot.writeStructBegin('getItem_result')
11064 
    if self.success is not None:
11065 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11066 
      self.success.write(oprot)
11067 
      oprot.writeFieldEnd()
11068 
    if self.cex is not None:
11069 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11070 
      self.cex.write(oprot)
11071 
      oprot.writeFieldEnd()
11072 
    oprot.writeFieldStop()
11073 
    oprot.writeStructEnd()
11074 
 
11075 
  def validate(self):
11076 
    return
11077 
 
11078 
 
11079 
  def __repr__(self):
11080 
    L = ['%s=%r' % (key, value)
11081 
      for key, value in self.__dict__.iteritems()]
11082 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11083 
 
11084 
  def __eq__(self, other):
11085 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11086 
 
11087 
  def __ne__(self, other):
11088 
    return not (self == other)
11089 
 
13493 amit.gupta 11090 
class getItems_args:
11091 
  """
11092 
  Attributes:
11093 
   - item_ids
11094 
  """
11095 
 
11096 
  thrift_spec = (
11097 
    None, # 0
11098 
    (1, TType.LIST, 'item_ids', (TType.I64,None), None, ), # 1
11099 
  )
11100 
 
11101 
  def __init__(self, item_ids=None,):
11102 
    self.item_ids = item_ids
11103 
 
11104 
  def read(self, iprot):
11105 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11106 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11107 
      return
11108 
    iprot.readStructBegin()
11109 
    while True:
11110 
      (fname, ftype, fid) = iprot.readFieldBegin()
11111 
      if ftype == TType.STOP:
11112 
        break
11113 
      if fid == 1:
11114 
        if ftype == TType.LIST:
11115 
          self.item_ids = []
18719 kshitij.so 11116 
          (_etype58, _size55) = iprot.readListBegin()
11117 
          for _i59 in xrange(_size55):
11118 
            _elem60 = iprot.readI64();
11119 
            self.item_ids.append(_elem60)
13493 amit.gupta 11120 
          iprot.readListEnd()
11121 
        else:
11122 
          iprot.skip(ftype)
11123 
      else:
11124 
        iprot.skip(ftype)
11125 
      iprot.readFieldEnd()
11126 
    iprot.readStructEnd()
11127 
 
11128 
  def write(self, oprot):
11129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11131 
      return
11132 
    oprot.writeStructBegin('getItems_args')
11133 
    if self.item_ids is not None:
11134 
      oprot.writeFieldBegin('item_ids', TType.LIST, 1)
11135 
      oprot.writeListBegin(TType.I64, len(self.item_ids))
18719 kshitij.so 11136 
      for iter61 in self.item_ids:
11137 
        oprot.writeI64(iter61)
13493 amit.gupta 11138 
      oprot.writeListEnd()
11139 
      oprot.writeFieldEnd()
11140 
    oprot.writeFieldStop()
11141 
    oprot.writeStructEnd()
11142 
 
11143 
  def validate(self):
11144 
    return
11145 
 
11146 
 
11147 
  def __repr__(self):
11148 
    L = ['%s=%r' % (key, value)
11149 
      for key, value in self.__dict__.iteritems()]
11150 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11151 
 
11152 
  def __eq__(self, other):
11153 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11154 
 
11155 
  def __ne__(self, other):
11156 
    return not (self == other)
11157 
 
11158 
class getItems_result:
11159 
  """
11160 
  Attributes:
11161 
   - success
11162 
   - cex
11163 
  """
11164 
 
11165 
  thrift_spec = (
11166 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11167 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11168 
  )
11169 
 
11170 
  def __init__(self, success=None, cex=None,):
11171 
    self.success = success
11172 
    self.cex = cex
11173 
 
11174 
  def read(self, iprot):
11175 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11176 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11177 
      return
11178 
    iprot.readStructBegin()
11179 
    while True:
11180 
      (fname, ftype, fid) = iprot.readFieldBegin()
11181 
      if ftype == TType.STOP:
11182 
        break
11183 
      if fid == 0:
11184 
        if ftype == TType.MAP:
11185 
          self.success = {}
18719 kshitij.so 11186 
          (_ktype63, _vtype64, _size62 ) = iprot.readMapBegin()
11187 
          for _i66 in xrange(_size62):
11188 
            _key67 = iprot.readI64();
11189 
            _val68 = Item()
11190 
            _val68.read(iprot)
11191 
            self.success[_key67] = _val68
13493 amit.gupta 11192 
          iprot.readMapEnd()
11193 
        else:
11194 
          iprot.skip(ftype)
11195 
      elif fid == 1:
11196 
        if ftype == TType.STRUCT:
11197 
          self.cex = CatalogServiceException()
11198 
          self.cex.read(iprot)
11199 
        else:
11200 
          iprot.skip(ftype)
11201 
      else:
11202 
        iprot.skip(ftype)
11203 
      iprot.readFieldEnd()
11204 
    iprot.readStructEnd()
11205 
 
11206 
  def write(self, oprot):
11207 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11208 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11209 
      return
11210 
    oprot.writeStructBegin('getItems_result')
11211 
    if self.success is not None:
11212 
      oprot.writeFieldBegin('success', TType.MAP, 0)
11213 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.success))
18719 kshitij.so 11214 
      for kiter69,viter70 in self.success.items():
11215 
        oprot.writeI64(kiter69)
11216 
        viter70.write(oprot)
13493 amit.gupta 11217 
      oprot.writeMapEnd()
11218 
      oprot.writeFieldEnd()
11219 
    if self.cex is not None:
11220 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11221 
      self.cex.write(oprot)
11222 
      oprot.writeFieldEnd()
11223 
    oprot.writeFieldStop()
11224 
    oprot.writeStructEnd()
11225 
 
11226 
  def validate(self):
11227 
    return
11228 
 
11229 
 
11230 
  def __repr__(self):
11231 
    L = ['%s=%r' % (key, value)
11232 
      for key, value in self.__dict__.iteritems()]
11233 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11234 
 
11235 
  def __eq__(self, other):
11236 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11237 
 
11238 
  def __ne__(self, other):
11239 
    return not (self == other)
11240 
 
5944 mandeep.dh 11241 
class getItemsByCatalogId_args:
11242 
  """
11243 
  Attributes:
11244 
   - catalog_item_id
11245 
  """
11246 
 
11247 
  thrift_spec = (
11248 
    None, # 0
11249 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
11250 
  )
11251 
 
11252 
  def __init__(self, catalog_item_id=None,):
11253 
    self.catalog_item_id = catalog_item_id
11254 
 
11255 
  def read(self, iprot):
11256 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11257 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11258 
      return
11259 
    iprot.readStructBegin()
11260 
    while True:
11261 
      (fname, ftype, fid) = iprot.readFieldBegin()
11262 
      if ftype == TType.STOP:
11263 
        break
11264 
      if fid == 1:
11265 
        if ftype == TType.I64:
11266 
          self.catalog_item_id = iprot.readI64();
11267 
        else:
11268 
          iprot.skip(ftype)
11269 
      else:
11270 
        iprot.skip(ftype)
11271 
      iprot.readFieldEnd()
11272 
    iprot.readStructEnd()
11273 
 
11274 
  def write(self, oprot):
11275 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11276 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11277 
      return
11278 
    oprot.writeStructBegin('getItemsByCatalogId_args')
11279 
    if self.catalog_item_id is not None:
11280 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
11281 
      oprot.writeI64(self.catalog_item_id)
11282 
      oprot.writeFieldEnd()
11283 
    oprot.writeFieldStop()
11284 
    oprot.writeStructEnd()
11285 
 
11286 
  def validate(self):
11287 
    return
11288 
 
11289 
 
11290 
  def __repr__(self):
11291 
    L = ['%s=%r' % (key, value)
11292 
      for key, value in self.__dict__.iteritems()]
11293 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11294 
 
11295 
  def __eq__(self, other):
11296 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11297 
 
11298 
  def __ne__(self, other):
11299 
    return not (self == other)
11300 
 
11301 
class getItemsByCatalogId_result:
11302 
  """
11303 
  Attributes:
11304 
   - success
11305 
   - cex
11306 
  """
11307 
 
11308 
  thrift_spec = (
11309 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11310 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11311 
  )
11312 
 
11313 
  def __init__(self, success=None, cex=None,):
11314 
    self.success = success
11315 
    self.cex = cex
11316 
 
11317 
  def read(self, iprot):
11318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11320 
      return
11321 
    iprot.readStructBegin()
11322 
    while True:
11323 
      (fname, ftype, fid) = iprot.readFieldBegin()
11324 
      if ftype == TType.STOP:
11325 
        break
11326 
      if fid == 0:
11327 
        if ftype == TType.LIST:
11328 
          self.success = []
18719 kshitij.so 11329 
          (_etype74, _size71) = iprot.readListBegin()
11330 
          for _i75 in xrange(_size71):
11331 
            _elem76 = Item()
11332 
            _elem76.read(iprot)
11333 
            self.success.append(_elem76)
5944 mandeep.dh 11334 
          iprot.readListEnd()
11335 
        else:
11336 
          iprot.skip(ftype)
11337 
      elif fid == 1:
11338 
        if ftype == TType.STRUCT:
11339 
          self.cex = CatalogServiceException()
11340 
          self.cex.read(iprot)
11341 
        else:
11342 
          iprot.skip(ftype)
11343 
      else:
11344 
        iprot.skip(ftype)
11345 
      iprot.readFieldEnd()
11346 
    iprot.readStructEnd()
11347 
 
11348 
  def write(self, oprot):
11349 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11350 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11351 
      return
11352 
    oprot.writeStructBegin('getItemsByCatalogId_result')
11353 
    if self.success is not None:
11354 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11355 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 11356 
      for iter77 in self.success:
11357 
        iter77.write(oprot)
5944 mandeep.dh 11358 
      oprot.writeListEnd()
11359 
      oprot.writeFieldEnd()
11360 
    if self.cex is not None:
11361 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11362 
      self.cex.write(oprot)
11363 
      oprot.writeFieldEnd()
11364 
    oprot.writeFieldStop()
11365 
    oprot.writeStructEnd()
11366 
 
11367 
  def validate(self):
11368 
    return
11369 
 
11370 
 
11371 
  def __repr__(self):
11372 
    L = ['%s=%r' % (key, value)
11373 
      for key, value in self.__dict__.iteritems()]
11374 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11375 
 
11376 
  def __eq__(self, other):
11377 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11378 
 
11379 
  def __ne__(self, other):
11380 
    return not (self == other)
11381 
 
11382 
class getValidItemsByCatalogId_args:
11383 
  """
11384 
  Attributes:
11385 
   - catalog_item_id
11386 
  """
11387 
 
11388 
  thrift_spec = (
11389 
    None, # 0
11390 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
11391 
  )
11392 
 
11393 
  def __init__(self, catalog_item_id=None,):
11394 
    self.catalog_item_id = catalog_item_id
11395 
 
11396 
  def read(self, iprot):
11397 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11398 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11399 
      return
11400 
    iprot.readStructBegin()
11401 
    while True:
11402 
      (fname, ftype, fid) = iprot.readFieldBegin()
11403 
      if ftype == TType.STOP:
11404 
        break
11405 
      if fid == 1:
11406 
        if ftype == TType.I64:
11407 
          self.catalog_item_id = iprot.readI64();
11408 
        else:
11409 
          iprot.skip(ftype)
11410 
      else:
11411 
        iprot.skip(ftype)
11412 
      iprot.readFieldEnd()
11413 
    iprot.readStructEnd()
11414 
 
11415 
  def write(self, oprot):
11416 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11417 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11418 
      return
11419 
    oprot.writeStructBegin('getValidItemsByCatalogId_args')
11420 
    if self.catalog_item_id is not None:
11421 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
11422 
      oprot.writeI64(self.catalog_item_id)
11423 
      oprot.writeFieldEnd()
11424 
    oprot.writeFieldStop()
11425 
    oprot.writeStructEnd()
11426 
 
11427 
  def validate(self):
11428 
    return
11429 
 
11430 
 
11431 
  def __repr__(self):
11432 
    L = ['%s=%r' % (key, value)
11433 
      for key, value in self.__dict__.iteritems()]
11434 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11435 
 
11436 
  def __eq__(self, other):
11437 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11438 
 
11439 
  def __ne__(self, other):
11440 
    return not (self == other)
11441 
 
11442 
class getValidItemsByCatalogId_result:
11443 
  """
11444 
  Attributes:
11445 
   - success
11446 
   - cex
11447 
  """
11448 
 
11449 
  thrift_spec = (
11450 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11451 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11452 
  )
11453 
 
11454 
  def __init__(self, success=None, cex=None,):
11455 
    self.success = success
11456 
    self.cex = cex
11457 
 
11458 
  def read(self, iprot):
11459 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11460 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11461 
      return
11462 
    iprot.readStructBegin()
11463 
    while True:
11464 
      (fname, ftype, fid) = iprot.readFieldBegin()
11465 
      if ftype == TType.STOP:
11466 
        break
11467 
      if fid == 0:
11468 
        if ftype == TType.LIST:
11469 
          self.success = []
18719 kshitij.so 11470 
          (_etype81, _size78) = iprot.readListBegin()
11471 
          for _i82 in xrange(_size78):
11472 
            _elem83 = Item()
11473 
            _elem83.read(iprot)
11474 
            self.success.append(_elem83)
5944 mandeep.dh 11475 
          iprot.readListEnd()
11476 
        else:
11477 
          iprot.skip(ftype)
11478 
      elif fid == 1:
11479 
        if ftype == TType.STRUCT:
11480 
          self.cex = CatalogServiceException()
11481 
          self.cex.read(iprot)
11482 
        else:
11483 
          iprot.skip(ftype)
11484 
      else:
11485 
        iprot.skip(ftype)
11486 
      iprot.readFieldEnd()
11487 
    iprot.readStructEnd()
11488 
 
11489 
  def write(self, oprot):
11490 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11491 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11492 
      return
11493 
    oprot.writeStructBegin('getValidItemsByCatalogId_result')
11494 
    if self.success is not None:
11495 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11496 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 11497 
      for iter84 in self.success:
11498 
        iter84.write(oprot)
5944 mandeep.dh 11499 
      oprot.writeListEnd()
11500 
      oprot.writeFieldEnd()
11501 
    if self.cex is not None:
11502 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11503 
      self.cex.write(oprot)
11504 
      oprot.writeFieldEnd()
11505 
    oprot.writeFieldStop()
11506 
    oprot.writeStructEnd()
11507 
 
11508 
  def validate(self):
11509 
    return
11510 
 
11511 
 
11512 
  def __repr__(self):
11513 
    L = ['%s=%r' % (key, value)
11514 
      for key, value in self.__dict__.iteritems()]
11515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11516 
 
11517 
  def __eq__(self, other):
11518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11519 
 
11520 
  def __ne__(self, other):
11521 
    return not (self == other)
11522 
 
11523 
class getAllItems_args:
11524 
  """
11525 
  Attributes:
11526 
   - isActive
11527 
  """
11528 
 
11529 
  thrift_spec = (
11530 
    None, # 0
11531 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
11532 
  )
11533 
 
11534 
  def __init__(self, isActive=None,):
11535 
    self.isActive = isActive
11536 
 
11537 
  def read(self, iprot):
11538 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11539 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11540 
      return
11541 
    iprot.readStructBegin()
11542 
    while True:
11543 
      (fname, ftype, fid) = iprot.readFieldBegin()
11544 
      if ftype == TType.STOP:
11545 
        break
11546 
      if fid == 1:
11547 
        if ftype == TType.BOOL:
11548 
          self.isActive = iprot.readBool();
11549 
        else:
11550 
          iprot.skip(ftype)
11551 
      else:
11552 
        iprot.skip(ftype)
11553 
      iprot.readFieldEnd()
11554 
    iprot.readStructEnd()
11555 
 
11556 
  def write(self, oprot):
11557 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11558 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11559 
      return
11560 
    oprot.writeStructBegin('getAllItems_args')
11561 
    if self.isActive is not None:
11562 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
11563 
      oprot.writeBool(self.isActive)
11564 
      oprot.writeFieldEnd()
11565 
    oprot.writeFieldStop()
11566 
    oprot.writeStructEnd()
11567 
 
11568 
  def validate(self):
11569 
    return
11570 
 
11571 
 
11572 
  def __repr__(self):
11573 
    L = ['%s=%r' % (key, value)
11574 
      for key, value in self.__dict__.iteritems()]
11575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11576 
 
11577 
  def __eq__(self, other):
11578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11579 
 
11580 
  def __ne__(self, other):
11581 
    return not (self == other)
11582 
 
11583 
class getAllItems_result:
11584 
  """
11585 
  Attributes:
11586 
   - success
11587 
   - cex
11588 
  """
11589 
 
11590 
  thrift_spec = (
11591 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11592 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11593 
  )
11594 
 
11595 
  def __init__(self, success=None, cex=None,):
11596 
    self.success = success
11597 
    self.cex = cex
11598 
 
11599 
  def read(self, iprot):
11600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11602 
      return
11603 
    iprot.readStructBegin()
11604 
    while True:
11605 
      (fname, ftype, fid) = iprot.readFieldBegin()
11606 
      if ftype == TType.STOP:
11607 
        break
11608 
      if fid == 0:
11609 
        if ftype == TType.LIST:
11610 
          self.success = []
18719 kshitij.so 11611 
          (_etype88, _size85) = iprot.readListBegin()
11612 
          for _i89 in xrange(_size85):
11613 
            _elem90 = Item()
11614 
            _elem90.read(iprot)
11615 
            self.success.append(_elem90)
5944 mandeep.dh 11616 
          iprot.readListEnd()
11617 
        else:
11618 
          iprot.skip(ftype)
11619 
      elif fid == 1:
11620 
        if ftype == TType.STRUCT:
11621 
          self.cex = CatalogServiceException()
11622 
          self.cex.read(iprot)
11623 
        else:
11624 
          iprot.skip(ftype)
11625 
      else:
11626 
        iprot.skip(ftype)
11627 
      iprot.readFieldEnd()
11628 
    iprot.readStructEnd()
11629 
 
11630 
  def write(self, oprot):
11631 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11632 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11633 
      return
11634 
    oprot.writeStructBegin('getAllItems_result')
11635 
    if self.success is not None:
11636 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11637 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 11638 
      for iter91 in self.success:
11639 
        iter91.write(oprot)
5944 mandeep.dh 11640 
      oprot.writeListEnd()
11641 
      oprot.writeFieldEnd()
11642 
    if self.cex is not None:
11643 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11644 
      self.cex.write(oprot)
11645 
      oprot.writeFieldEnd()
11646 
    oprot.writeFieldStop()
11647 
    oprot.writeStructEnd()
11648 
 
11649 
  def validate(self):
11650 
    return
11651 
 
11652 
 
11653 
  def __repr__(self):
11654 
    L = ['%s=%r' % (key, value)
11655 
      for key, value in self.__dict__.iteritems()]
11656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11657 
 
11658 
  def __eq__(self, other):
11659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11660 
 
11661 
  def __ne__(self, other):
11662 
    return not (self == other)
11663 
 
11664 
class getAllItemsByStatus_args:
11665 
  """
11666 
  Attributes:
11667 
   - itemStatus
11668 
  """
11669 
 
11670 
  thrift_spec = (
11671 
    None, # 0
11672 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
11673 
  )
11674 
 
11675 
  def __init__(self, itemStatus=None,):
11676 
    self.itemStatus = itemStatus
11677 
 
11678 
  def read(self, iprot):
11679 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11680 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11681 
      return
11682 
    iprot.readStructBegin()
11683 
    while True:
11684 
      (fname, ftype, fid) = iprot.readFieldBegin()
11685 
      if ftype == TType.STOP:
11686 
        break
11687 
      if fid == 1:
11688 
        if ftype == TType.I32:
11689 
          self.itemStatus = iprot.readI32();
11690 
        else:
11691 
          iprot.skip(ftype)
11692 
      else:
11693 
        iprot.skip(ftype)
11694 
      iprot.readFieldEnd()
11695 
    iprot.readStructEnd()
11696 
 
11697 
  def write(self, oprot):
11698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11700 
      return
11701 
    oprot.writeStructBegin('getAllItemsByStatus_args')
11702 
    if self.itemStatus is not None:
11703 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
11704 
      oprot.writeI32(self.itemStatus)
11705 
      oprot.writeFieldEnd()
11706 
    oprot.writeFieldStop()
11707 
    oprot.writeStructEnd()
11708 
 
11709 
  def validate(self):
11710 
    return
11711 
 
11712 
 
11713 
  def __repr__(self):
11714 
    L = ['%s=%r' % (key, value)
11715 
      for key, value in self.__dict__.iteritems()]
11716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11717 
 
11718 
  def __eq__(self, other):
11719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11720 
 
11721 
  def __ne__(self, other):
11722 
    return not (self == other)
11723 
 
11724 
class getAllItemsByStatus_result:
11725 
  """
11726 
  Attributes:
11727 
   - success
11728 
   - cex
11729 
  """
11730 
 
11731 
  thrift_spec = (
11732 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11733 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11734 
  )
11735 
 
11736 
  def __init__(self, success=None, cex=None,):
11737 
    self.success = success
11738 
    self.cex = cex
11739 
 
11740 
  def read(self, iprot):
11741 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11742 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11743 
      return
11744 
    iprot.readStructBegin()
11745 
    while True:
11746 
      (fname, ftype, fid) = iprot.readFieldBegin()
11747 
      if ftype == TType.STOP:
11748 
        break
11749 
      if fid == 0:
11750 
        if ftype == TType.LIST:
11751 
          self.success = []
18719 kshitij.so 11752 
          (_etype95, _size92) = iprot.readListBegin()
11753 
          for _i96 in xrange(_size92):
11754 
            _elem97 = Item()
11755 
            _elem97.read(iprot)
11756 
            self.success.append(_elem97)
5944 mandeep.dh 11757 
          iprot.readListEnd()
11758 
        else:
11759 
          iprot.skip(ftype)
11760 
      elif fid == 1:
11761 
        if ftype == TType.STRUCT:
11762 
          self.cex = CatalogServiceException()
11763 
          self.cex.read(iprot)
11764 
        else:
11765 
          iprot.skip(ftype)
11766 
      else:
11767 
        iprot.skip(ftype)
11768 
      iprot.readFieldEnd()
11769 
    iprot.readStructEnd()
11770 
 
11771 
  def write(self, oprot):
11772 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11773 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11774 
      return
11775 
    oprot.writeStructBegin('getAllItemsByStatus_result')
11776 
    if self.success is not None:
11777 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11778 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 11779 
      for iter98 in self.success:
11780 
        iter98.write(oprot)
5944 mandeep.dh 11781 
      oprot.writeListEnd()
11782 
      oprot.writeFieldEnd()
11783 
    if self.cex is not None:
11784 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11785 
      self.cex.write(oprot)
11786 
      oprot.writeFieldEnd()
11787 
    oprot.writeFieldStop()
11788 
    oprot.writeStructEnd()
11789 
 
11790 
  def validate(self):
11791 
    return
11792 
 
11793 
 
11794 
  def __repr__(self):
11795 
    L = ['%s=%r' % (key, value)
11796 
      for key, value in self.__dict__.iteritems()]
11797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11798 
 
11799 
  def __eq__(self, other):
11800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11801 
 
11802 
  def __ne__(self, other):
11803 
    return not (self == other)
11804 
 
11805 
class markItemAsContentComplete_args:
11806 
  """
11807 
  Attributes:
11808 
   - entityId
11809 
   - category
11810 
   - brand
11811 
   - modelName
11812 
   - modelNumber
9253 rajveer 11813 
   - isAndroid
5944 mandeep.dh 11814 
  """
11815 
 
11816 
  thrift_spec = (
11817 
    None, # 0
11818 
    (1, TType.I64, 'entityId', None, None, ), # 1
11819 
    (2, TType.I64, 'category', None, None, ), # 2
11820 
    (3, TType.STRING, 'brand', None, None, ), # 3
11821 
    (4, TType.STRING, 'modelName', None, None, ), # 4
11822 
    (5, TType.STRING, 'modelNumber', None, None, ), # 5
9253 rajveer 11823 
    (6, TType.BOOL, 'isAndroid', None, None, ), # 6
5944 mandeep.dh 11824 
  )
11825 
 
9253 rajveer 11826 
  def __init__(self, entityId=None, category=None, brand=None, modelName=None, modelNumber=None, isAndroid=None,):
5944 mandeep.dh 11827 
    self.entityId = entityId
11828 
    self.category = category
11829 
    self.brand = brand
11830 
    self.modelName = modelName
11831 
    self.modelNumber = modelNumber
9253 rajveer 11832 
    self.isAndroid = isAndroid
5944 mandeep.dh 11833 
 
11834 
  def read(self, iprot):
11835 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11836 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11837 
      return
11838 
    iprot.readStructBegin()
11839 
    while True:
11840 
      (fname, ftype, fid) = iprot.readFieldBegin()
11841 
      if ftype == TType.STOP:
11842 
        break
11843 
      if fid == 1:
11844 
        if ftype == TType.I64:
11845 
          self.entityId = iprot.readI64();
11846 
        else:
11847 
          iprot.skip(ftype)
11848 
      elif fid == 2:
11849 
        if ftype == TType.I64:
11850 
          self.category = iprot.readI64();
11851 
        else:
11852 
          iprot.skip(ftype)
11853 
      elif fid == 3:
11854 
        if ftype == TType.STRING:
11855 
          self.brand = iprot.readString();
11856 
        else:
11857 
          iprot.skip(ftype)
11858 
      elif fid == 4:
11859 
        if ftype == TType.STRING:
11860 
          self.modelName = iprot.readString();
11861 
        else:
11862 
          iprot.skip(ftype)
11863 
      elif fid == 5:
11864 
        if ftype == TType.STRING:
11865 
          self.modelNumber = iprot.readString();
11866 
        else:
11867 
          iprot.skip(ftype)
9253 rajveer 11868 
      elif fid == 6:
11869 
        if ftype == TType.BOOL:
11870 
          self.isAndroid = iprot.readBool();
11871 
        else:
11872 
          iprot.skip(ftype)
5944 mandeep.dh 11873 
      else:
11874 
        iprot.skip(ftype)
11875 
      iprot.readFieldEnd()
11876 
    iprot.readStructEnd()
11877 
 
11878 
  def write(self, oprot):
11879 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11880 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11881 
      return
11882 
    oprot.writeStructBegin('markItemAsContentComplete_args')
11883 
    if self.entityId is not None:
11884 
      oprot.writeFieldBegin('entityId', TType.I64, 1)
11885 
      oprot.writeI64(self.entityId)
11886 
      oprot.writeFieldEnd()
11887 
    if self.category is not None:
11888 
      oprot.writeFieldBegin('category', TType.I64, 2)
11889 
      oprot.writeI64(self.category)
11890 
      oprot.writeFieldEnd()
11891 
    if self.brand is not None:
11892 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
11893 
      oprot.writeString(self.brand)
11894 
      oprot.writeFieldEnd()
11895 
    if self.modelName is not None:
11896 
      oprot.writeFieldBegin('modelName', TType.STRING, 4)
11897 
      oprot.writeString(self.modelName)
11898 
      oprot.writeFieldEnd()
11899 
    if self.modelNumber is not None:
11900 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 5)
11901 
      oprot.writeString(self.modelNumber)
11902 
      oprot.writeFieldEnd()
9253 rajveer 11903 
    if self.isAndroid is not None:
11904 
      oprot.writeFieldBegin('isAndroid', TType.BOOL, 6)
11905 
      oprot.writeBool(self.isAndroid)
11906 
      oprot.writeFieldEnd()
5944 mandeep.dh 11907 
    oprot.writeFieldStop()
11908 
    oprot.writeStructEnd()
11909 
 
11910 
  def validate(self):
11911 
    return
11912 
 
11913 
 
11914 
  def __repr__(self):
11915 
    L = ['%s=%r' % (key, value)
11916 
      for key, value in self.__dict__.iteritems()]
11917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11918 
 
11919 
  def __eq__(self, other):
11920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11921 
 
11922 
  def __ne__(self, other):
11923 
    return not (self == other)
11924 
 
11925 
class markItemAsContentComplete_result:
11926 
  """
11927 
  Attributes:
11928 
   - success
11929 
   - cex
11930 
  """
11931 
 
11932 
  thrift_spec = (
11933 
    (0, TType.BOOL, 'success', None, None, ), # 0
11934 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11935 
  )
11936 
 
11937 
  def __init__(self, success=None, cex=None,):
11938 
    self.success = success
11939 
    self.cex = cex
11940 
 
11941 
  def read(self, iprot):
11942 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11943 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11944 
      return
11945 
    iprot.readStructBegin()
11946 
    while True:
11947 
      (fname, ftype, fid) = iprot.readFieldBegin()
11948 
      if ftype == TType.STOP:
11949 
        break
11950 
      if fid == 0:
11951 
        if ftype == TType.BOOL:
11952 
          self.success = iprot.readBool();
11953 
        else:
11954 
          iprot.skip(ftype)
11955 
      elif fid == 1:
11956 
        if ftype == TType.STRUCT:
11957 
          self.cex = CatalogServiceException()
11958 
          self.cex.read(iprot)
11959 
        else:
11960 
          iprot.skip(ftype)
11961 
      else:
11962 
        iprot.skip(ftype)
11963 
      iprot.readFieldEnd()
11964 
    iprot.readStructEnd()
11965 
 
11966 
  def write(self, oprot):
11967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11969 
      return
11970 
    oprot.writeStructBegin('markItemAsContentComplete_result')
11971 
    if self.success is not None:
11972 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11973 
      oprot.writeBool(self.success)
11974 
      oprot.writeFieldEnd()
11975 
    if self.cex is not None:
11976 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11977 
      self.cex.write(oprot)
11978 
      oprot.writeFieldEnd()
11979 
    oprot.writeFieldStop()
11980 
    oprot.writeStructEnd()
11981 
 
11982 
  def validate(self):
11983 
    return
11984 
 
11985 
 
11986 
  def __repr__(self):
11987 
    L = ['%s=%r' % (key, value)
11988 
      for key, value in self.__dict__.iteritems()]
11989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11990 
 
11991 
  def __eq__(self, other):
11992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11993 
 
11994 
  def __ne__(self, other):
11995 
    return not (self == other)
11996 
 
12567 amit.gupta 11997 
class getVatRates_args:
11998 
  """
11999 
  Attributes:
12000 
   - itemId
12001 
   - categoryId
12002 
  """
12003 
 
12004 
  thrift_spec = (
12005 
    None, # 0
12006 
    (1, TType.I64, 'itemId', None, None, ), # 1
12007 
    (2, TType.I64, 'categoryId', None, None, ), # 2
12008 
  )
12009 
 
12010 
  def __init__(self, itemId=None, categoryId=None,):
12011 
    self.itemId = itemId
12012 
    self.categoryId = categoryId
12013 
 
12014 
  def read(self, iprot):
12015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12017 
      return
12018 
    iprot.readStructBegin()
12019 
    while True:
12020 
      (fname, ftype, fid) = iprot.readFieldBegin()
12021 
      if ftype == TType.STOP:
12022 
        break
12023 
      if fid == 1:
12024 
        if ftype == TType.I64:
12025 
          self.itemId = iprot.readI64();
12026 
        else:
12027 
          iprot.skip(ftype)
12028 
      elif fid == 2:
12029 
        if ftype == TType.I64:
12030 
          self.categoryId = iprot.readI64();
12031 
        else:
12032 
          iprot.skip(ftype)
12033 
      else:
12034 
        iprot.skip(ftype)
12035 
      iprot.readFieldEnd()
12036 
    iprot.readStructEnd()
12037 
 
12038 
  def write(self, oprot):
12039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12041 
      return
12042 
    oprot.writeStructBegin('getVatRates_args')
12043 
    if self.itemId is not None:
12044 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12045 
      oprot.writeI64(self.itemId)
12046 
      oprot.writeFieldEnd()
12047 
    if self.categoryId is not None:
12048 
      oprot.writeFieldBegin('categoryId', TType.I64, 2)
12049 
      oprot.writeI64(self.categoryId)
12050 
      oprot.writeFieldEnd()
12051 
    oprot.writeFieldStop()
12052 
    oprot.writeStructEnd()
12053 
 
12054 
  def validate(self):
12055 
    return
12056 
 
12057 
 
12058 
  def __repr__(self):
12059 
    L = ['%s=%r' % (key, value)
12060 
      for key, value in self.__dict__.iteritems()]
12061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12062 
 
12063 
  def __eq__(self, other):
12064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12065 
 
12066 
  def __ne__(self, other):
12067 
    return not (self == other)
12068 
 
12069 
class getVatRates_result:
12070 
  """
12071 
  Attributes:
12072 
   - success
12073 
   - cex
12074 
  """
12075 
 
12076 
  thrift_spec = (
12077 
    (0, TType.MAP, 'success', (TType.I64,None,TType.DOUBLE,None), None, ), # 0
12078 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12079 
  )
12080 
 
12081 
  def __init__(self, success=None, cex=None,):
12082 
    self.success = success
12083 
    self.cex = cex
12084 
 
12085 
  def read(self, iprot):
12086 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12087 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12088 
      return
12089 
    iprot.readStructBegin()
12090 
    while True:
12091 
      (fname, ftype, fid) = iprot.readFieldBegin()
12092 
      if ftype == TType.STOP:
12093 
        break
12094 
      if fid == 0:
12095 
        if ftype == TType.MAP:
12096 
          self.success = {}
18719 kshitij.so 12097 
          (_ktype100, _vtype101, _size99 ) = iprot.readMapBegin()
12098 
          for _i103 in xrange(_size99):
12099 
            _key104 = iprot.readI64();
12100 
            _val105 = iprot.readDouble();
12101 
            self.success[_key104] = _val105
12567 amit.gupta 12102 
          iprot.readMapEnd()
12103 
        else:
12104 
          iprot.skip(ftype)
12105 
      elif fid == 1:
12106 
        if ftype == TType.STRUCT:
12107 
          self.cex = CatalogServiceException()
12108 
          self.cex.read(iprot)
12109 
        else:
12110 
          iprot.skip(ftype)
12111 
      else:
12112 
        iprot.skip(ftype)
12113 
      iprot.readFieldEnd()
12114 
    iprot.readStructEnd()
12115 
 
12116 
  def write(self, oprot):
12117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12119 
      return
12120 
    oprot.writeStructBegin('getVatRates_result')
12121 
    if self.success is not None:
12122 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12123 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.success))
18719 kshitij.so 12124 
      for kiter106,viter107 in self.success.items():
12125 
        oprot.writeI64(kiter106)
12126 
        oprot.writeDouble(viter107)
12567 amit.gupta 12127 
      oprot.writeMapEnd()
12128 
      oprot.writeFieldEnd()
12129 
    if self.cex is not None:
12130 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
12131 
      self.cex.write(oprot)
12132 
      oprot.writeFieldEnd()
12133 
    oprot.writeFieldStop()
12134 
    oprot.writeStructEnd()
12135 
 
12136 
  def validate(self):
12137 
    return
12138 
 
12139 
 
12140 
  def __repr__(self):
12141 
    L = ['%s=%r' % (key, value)
12142 
      for key, value in self.__dict__.iteritems()]
12143 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12144 
 
12145 
  def __eq__(self, other):
12146 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12147 
 
12148 
  def __ne__(self, other):
12149 
    return not (self == other)
12150 
 
5944 mandeep.dh 12151 
class getAllItemsInRange_args:
12152 
  """
12153 
  Attributes:
12154 
   - offset
12155 
   - limit
12156 
  """
12157 
 
12158 
  thrift_spec = (
12159 
    None, # 0
12160 
    (1, TType.I64, 'offset', None, None, ), # 1
12161 
    (2, TType.I64, 'limit', None, None, ), # 2
12162 
  )
12163 
 
12164 
  def __init__(self, offset=None, limit=None,):
12165 
    self.offset = offset
12166 
    self.limit = limit
12167 
 
12168 
  def read(self, iprot):
12169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12171 
      return
12172 
    iprot.readStructBegin()
12173 
    while True:
12174 
      (fname, ftype, fid) = iprot.readFieldBegin()
12175 
      if ftype == TType.STOP:
12176 
        break
12177 
      if fid == 1:
12178 
        if ftype == TType.I64:
12179 
          self.offset = iprot.readI64();
12180 
        else:
12181 
          iprot.skip(ftype)
12182 
      elif fid == 2:
12183 
        if ftype == TType.I64:
12184 
          self.limit = iprot.readI64();
12185 
        else:
12186 
          iprot.skip(ftype)
12187 
      else:
12188 
        iprot.skip(ftype)
12189 
      iprot.readFieldEnd()
12190 
    iprot.readStructEnd()
12191 
 
12192 
  def write(self, oprot):
12193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12195 
      return
12196 
    oprot.writeStructBegin('getAllItemsInRange_args')
12197 
    if self.offset is not None:
12198 
      oprot.writeFieldBegin('offset', TType.I64, 1)
12199 
      oprot.writeI64(self.offset)
12200 
      oprot.writeFieldEnd()
12201 
    if self.limit is not None:
12202 
      oprot.writeFieldBegin('limit', TType.I64, 2)
12203 
      oprot.writeI64(self.limit)
12204 
      oprot.writeFieldEnd()
12205 
    oprot.writeFieldStop()
12206 
    oprot.writeStructEnd()
12207 
 
12208 
  def validate(self):
12209 
    return
12210 
 
12211 
 
12212 
  def __repr__(self):
12213 
    L = ['%s=%r' % (key, value)
12214 
      for key, value in self.__dict__.iteritems()]
12215 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12216 
 
12217 
  def __eq__(self, other):
12218 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12219 
 
12220 
  def __ne__(self, other):
12221 
    return not (self == other)
12222 
 
12223 
class getAllItemsInRange_result:
12224 
  """
12225 
  Attributes:
12226 
   - success
12227 
   - cex
12228 
  """
12229 
 
12230 
  thrift_spec = (
12231 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12232 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12233 
  )
12234 
 
12235 
  def __init__(self, success=None, cex=None,):
12236 
    self.success = success
12237 
    self.cex = cex
12238 
 
12239 
  def read(self, iprot):
12240 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12241 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12242 
      return
12243 
    iprot.readStructBegin()
12244 
    while True:
12245 
      (fname, ftype, fid) = iprot.readFieldBegin()
12246 
      if ftype == TType.STOP:
12247 
        break
12248 
      if fid == 0:
12249 
        if ftype == TType.LIST:
12250 
          self.success = []
18719 kshitij.so 12251 
          (_etype111, _size108) = iprot.readListBegin()
12252 
          for _i112 in xrange(_size108):
12253 
            _elem113 = Item()
12254 
            _elem113.read(iprot)
12255 
            self.success.append(_elem113)
5944 mandeep.dh 12256 
          iprot.readListEnd()
12257 
        else:
12258 
          iprot.skip(ftype)
12259 
      elif fid == 1:
12260 
        if ftype == TType.STRUCT:
12261 
          self.cex = CatalogServiceException()
12262 
          self.cex.read(iprot)
12263 
        else:
12264 
          iprot.skip(ftype)
12265 
      else:
12266 
        iprot.skip(ftype)
12267 
      iprot.readFieldEnd()
12268 
    iprot.readStructEnd()
12269 
 
12270 
  def write(self, oprot):
12271 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12272 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12273 
      return
12274 
    oprot.writeStructBegin('getAllItemsInRange_result')
12275 
    if self.success is not None:
12276 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12277 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 12278 
      for iter114 in self.success:
12279 
        iter114.write(oprot)
5944 mandeep.dh 12280 
      oprot.writeListEnd()
12281 
      oprot.writeFieldEnd()
12282 
    if self.cex is not None:
12283 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
12284 
      self.cex.write(oprot)
12285 
      oprot.writeFieldEnd()
12286 
    oprot.writeFieldStop()
12287 
    oprot.writeStructEnd()
12288 
 
12289 
  def validate(self):
12290 
    return
12291 
 
12292 
 
12293 
  def __repr__(self):
12294 
    L = ['%s=%r' % (key, value)
12295 
      for key, value in self.__dict__.iteritems()]
12296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12297 
 
12298 
  def __eq__(self, other):
12299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12300 
 
12301 
  def __ne__(self, other):
12302 
    return not (self == other)
12303 
 
12304 
class getAllItemsByStatusInRange_args:
12305 
  """
12306 
  Attributes:
12307 
   - itemStatus
12308 
   - offset
12309 
   - limit
12310 
  """
12311 
 
12312 
  thrift_spec = (
12313 
    None, # 0
12314 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
12315 
    (2, TType.I64, 'offset', None, None, ), # 2
12316 
    (3, TType.I64, 'limit', None, None, ), # 3
12317 
  )
12318 
 
12319 
  def __init__(self, itemStatus=None, offset=None, limit=None,):
12320 
    self.itemStatus = itemStatus
12321 
    self.offset = offset
12322 
    self.limit = limit
12323 
 
12324 
  def read(self, iprot):
12325 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12326 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12327 
      return
12328 
    iprot.readStructBegin()
12329 
    while True:
12330 
      (fname, ftype, fid) = iprot.readFieldBegin()
12331 
      if ftype == TType.STOP:
12332 
        break
12333 
      if fid == 1:
12334 
        if ftype == TType.I32:
12335 
          self.itemStatus = iprot.readI32();
12336 
        else:
12337 
          iprot.skip(ftype)
12338 
      elif fid == 2:
12339 
        if ftype == TType.I64:
12340 
          self.offset = iprot.readI64();
12341 
        else:
12342 
          iprot.skip(ftype)
12343 
      elif fid == 3:
12344 
        if ftype == TType.I64:
12345 
          self.limit = iprot.readI64();
12346 
        else:
12347 
          iprot.skip(ftype)
12348 
      else:
12349 
        iprot.skip(ftype)
12350 
      iprot.readFieldEnd()
12351 
    iprot.readStructEnd()
12352 
 
12353 
  def write(self, oprot):
12354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12356 
      return
12357 
    oprot.writeStructBegin('getAllItemsByStatusInRange_args')
12358 
    if self.itemStatus is not None:
12359 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
12360 
      oprot.writeI32(self.itemStatus)
12361 
      oprot.writeFieldEnd()
12362 
    if self.offset is not None:
12363 
      oprot.writeFieldBegin('offset', TType.I64, 2)
12364 
      oprot.writeI64(self.offset)
12365 
      oprot.writeFieldEnd()
12366 
    if self.limit is not None:
12367 
      oprot.writeFieldBegin('limit', TType.I64, 3)
12368 
      oprot.writeI64(self.limit)
12369 
      oprot.writeFieldEnd()
12370 
    oprot.writeFieldStop()
12371 
    oprot.writeStructEnd()
12372 
 
12373 
  def validate(self):
12374 
    return
12375 
 
12376 
 
12377 
  def __repr__(self):
12378 
    L = ['%s=%r' % (key, value)
12379 
      for key, value in self.__dict__.iteritems()]
12380 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12381 
 
12382 
  def __eq__(self, other):
12383 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12384 
 
12385 
  def __ne__(self, other):
12386 
    return not (self == other)
12387 
 
12388 
class getAllItemsByStatusInRange_result:
12389 
  """
12390 
  Attributes:
12391 
   - success
12392 
   - cex
12393 
  """
12394 
 
12395 
  thrift_spec = (
12396 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12397 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12398 
  )
12399 
 
12400 
  def __init__(self, success=None, cex=None,):
12401 
    self.success = success
12402 
    self.cex = cex
12403 
 
12404 
  def read(self, iprot):
12405 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12406 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12407 
      return
12408 
    iprot.readStructBegin()
12409 
    while True:
12410 
      (fname, ftype, fid) = iprot.readFieldBegin()
12411 
      if ftype == TType.STOP:
12412 
        break
12413 
      if fid == 0:
12414 
        if ftype == TType.LIST:
12415 
          self.success = []
18719 kshitij.so 12416 
          (_etype118, _size115) = iprot.readListBegin()
12417 
          for _i119 in xrange(_size115):
12418 
            _elem120 = Item()
12419 
            _elem120.read(iprot)
12420 
            self.success.append(_elem120)
5944 mandeep.dh 12421 
          iprot.readListEnd()
12422 
        else:
12423 
          iprot.skip(ftype)
12424 
      elif fid == 1:
12425 
        if ftype == TType.STRUCT:
12426 
          self.cex = CatalogServiceException()
12427 
          self.cex.read(iprot)
12428 
        else:
12429 
          iprot.skip(ftype)
12430 
      else:
12431 
        iprot.skip(ftype)
12432 
      iprot.readFieldEnd()
12433 
    iprot.readStructEnd()
12434 
 
12435 
  def write(self, oprot):
12436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12438 
      return
12439 
    oprot.writeStructBegin('getAllItemsByStatusInRange_result')
12440 
    if self.success is not None:
12441 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12442 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 12443 
      for iter121 in self.success:
12444 
        iter121.write(oprot)
5944 mandeep.dh 12445 
      oprot.writeListEnd()
12446 
      oprot.writeFieldEnd()
12447 
    if self.cex is not None:
12448 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
12449 
      self.cex.write(oprot)
12450 
      oprot.writeFieldEnd()
12451 
    oprot.writeFieldStop()
12452 
    oprot.writeStructEnd()
12453 
 
12454 
  def validate(self):
12455 
    return
12456 
 
12457 
 
12458 
  def __repr__(self):
12459 
    L = ['%s=%r' % (key, value)
12460 
      for key, value in self.__dict__.iteritems()]
12461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12462 
 
12463 
  def __eq__(self, other):
12464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12465 
 
12466 
  def __ne__(self, other):
12467 
    return not (self == other)
12468 
 
12469 
class getItemCountByStatus_args:
12470 
  """
12471 
  Attributes:
12472 
   - useStatus
12473 
   - itemStatus
12474 
  """
12475 
 
12476 
  thrift_spec = (
12477 
    None, # 0
12478 
    (1, TType.BOOL, 'useStatus', None, None, ), # 1
12479 
    (2, TType.I32, 'itemStatus', None, None, ), # 2
12480 
  )
12481 
 
12482 
  def __init__(self, useStatus=None, itemStatus=None,):
12483 
    self.useStatus = useStatus
12484 
    self.itemStatus = itemStatus
12485 
 
12486 
  def read(self, iprot):
12487 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12488 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12489 
      return
12490 
    iprot.readStructBegin()
12491 
    while True:
12492 
      (fname, ftype, fid) = iprot.readFieldBegin()
12493 
      if ftype == TType.STOP:
12494 
        break
12495 
      if fid == 1:
12496 
        if ftype == TType.BOOL:
12497 
          self.useStatus = iprot.readBool();
12498 
        else:
12499 
          iprot.skip(ftype)
12500 
      elif fid == 2:
12501 
        if ftype == TType.I32:
12502 
          self.itemStatus = iprot.readI32();
12503 
        else:
12504 
          iprot.skip(ftype)
12505 
      else:
12506 
        iprot.skip(ftype)
12507 
      iprot.readFieldEnd()
12508 
    iprot.readStructEnd()
12509 
 
12510 
  def write(self, oprot):
12511 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12512 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12513 
      return
12514 
    oprot.writeStructBegin('getItemCountByStatus_args')
12515 
    if self.useStatus is not None:
12516 
      oprot.writeFieldBegin('useStatus', TType.BOOL, 1)
12517 
      oprot.writeBool(self.useStatus)
12518 
      oprot.writeFieldEnd()
12519 
    if self.itemStatus is not None:
12520 
      oprot.writeFieldBegin('itemStatus', TType.I32, 2)
12521 
      oprot.writeI32(self.itemStatus)
12522 
      oprot.writeFieldEnd()
12523 
    oprot.writeFieldStop()
12524 
    oprot.writeStructEnd()
12525 
 
12526 
  def validate(self):
12527 
    return
12528 
 
12529 
 
12530 
  def __repr__(self):
12531 
    L = ['%s=%r' % (key, value)
12532 
      for key, value in self.__dict__.iteritems()]
12533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12534 
 
12535 
  def __eq__(self, other):
12536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12537 
 
12538 
  def __ne__(self, other):
12539 
    return not (self == other)
12540 
 
12541 
class getItemCountByStatus_result:
12542 
  """
12543 
  Attributes:
12544 
   - success
12545 
  """
12546 
 
12547 
  thrift_spec = (
12548 
    (0, TType.I32, 'success', None, None, ), # 0
12549 
  )
12550 
 
12551 
  def __init__(self, success=None,):
12552 
    self.success = success
12553 
 
12554 
  def read(self, iprot):
12555 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12556 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12557 
      return
12558 
    iprot.readStructBegin()
12559 
    while True:
12560 
      (fname, ftype, fid) = iprot.readFieldBegin()
12561 
      if ftype == TType.STOP:
12562 
        break
12563 
      if fid == 0:
12564 
        if ftype == TType.I32:
12565 
          self.success = iprot.readI32();
12566 
        else:
12567 
          iprot.skip(ftype)
12568 
      else:
12569 
        iprot.skip(ftype)
12570 
      iprot.readFieldEnd()
12571 
    iprot.readStructEnd()
12572 
 
12573 
  def write(self, oprot):
12574 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12575 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12576 
      return
12577 
    oprot.writeStructBegin('getItemCountByStatus_result')
12578 
    if self.success is not None:
12579 
      oprot.writeFieldBegin('success', TType.I32, 0)
12580 
      oprot.writeI32(self.success)
12581 
      oprot.writeFieldEnd()
12582 
    oprot.writeFieldStop()
12583 
    oprot.writeStructEnd()
12584 
 
12585 
  def validate(self):
12586 
    return
12587 
 
12588 
 
12589 
  def __repr__(self):
12590 
    L = ['%s=%r' % (key, value)
12591 
      for key, value in self.__dict__.iteritems()]
12592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12593 
 
12594 
  def __eq__(self, other):
12595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12596 
 
12597 
  def __ne__(self, other):
12598 
    return not (self == other)
12599 
 
12600 
class getBestSellers_args:
12601 
 
12602 
  thrift_spec = (
12603 
  )
12604 
 
12605 
  def read(self, iprot):
12606 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12607 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12608 
      return
12609 
    iprot.readStructBegin()
12610 
    while True:
12611 
      (fname, ftype, fid) = iprot.readFieldBegin()
12612 
      if ftype == TType.STOP:
12613 
        break
12614 
      else:
12615 
        iprot.skip(ftype)
12616 
      iprot.readFieldEnd()
12617 
    iprot.readStructEnd()
12618 
 
12619 
  def write(self, oprot):
12620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12622 
      return
12623 
    oprot.writeStructBegin('getBestSellers_args')
12624 
    oprot.writeFieldStop()
12625 
    oprot.writeStructEnd()
12626 
 
12627 
  def validate(self):
12628 
    return
12629 
 
12630 
 
12631 
  def __repr__(self):
12632 
    L = ['%s=%r' % (key, value)
12633 
      for key, value in self.__dict__.iteritems()]
12634 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12635 
 
12636 
  def __eq__(self, other):
12637 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12638 
 
12639 
  def __ne__(self, other):
12640 
    return not (self == other)
12641 
 
12642 
class getBestSellers_result:
12643 
  """
12644 
  Attributes:
12645 
   - success
12646 
   - isex
12647 
  """
12648 
 
12649 
  thrift_spec = (
12650 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12651 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12652 
  )
12653 
 
12654 
  def __init__(self, success=None, isex=None,):
12655 
    self.success = success
12656 
    self.isex = isex
12657 
 
12658 
  def read(self, iprot):
12659 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12660 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12661 
      return
12662 
    iprot.readStructBegin()
12663 
    while True:
12664 
      (fname, ftype, fid) = iprot.readFieldBegin()
12665 
      if ftype == TType.STOP:
12666 
        break
12667 
      if fid == 0:
12668 
        if ftype == TType.LIST:
12669 
          self.success = []
18719 kshitij.so 12670 
          (_etype125, _size122) = iprot.readListBegin()
12671 
          for _i126 in xrange(_size122):
12672 
            _elem127 = Item()
12673 
            _elem127.read(iprot)
12674 
            self.success.append(_elem127)
5944 mandeep.dh 12675 
          iprot.readListEnd()
12676 
        else:
12677 
          iprot.skip(ftype)
12678 
      elif fid == 1:
12679 
        if ftype == TType.STRUCT:
12680 
          self.isex = CatalogServiceException()
12681 
          self.isex.read(iprot)
12682 
        else:
12683 
          iprot.skip(ftype)
12684 
      else:
12685 
        iprot.skip(ftype)
12686 
      iprot.readFieldEnd()
12687 
    iprot.readStructEnd()
12688 
 
12689 
  def write(self, oprot):
12690 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12691 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12692 
      return
12693 
    oprot.writeStructBegin('getBestSellers_result')
12694 
    if self.success is not None:
12695 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12696 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 12697 
      for iter128 in self.success:
12698 
        iter128.write(oprot)
5944 mandeep.dh 12699 
      oprot.writeListEnd()
12700 
      oprot.writeFieldEnd()
12701 
    if self.isex is not None:
12702 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
12703 
      self.isex.write(oprot)
12704 
      oprot.writeFieldEnd()
12705 
    oprot.writeFieldStop()
12706 
    oprot.writeStructEnd()
12707 
 
12708 
  def validate(self):
12709 
    return
12710 
 
12711 
 
12712 
  def __repr__(self):
12713 
    L = ['%s=%r' % (key, value)
12714 
      for key, value in self.__dict__.iteritems()]
12715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12716 
 
12717 
  def __eq__(self, other):
12718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12719 
 
12720 
  def __ne__(self, other):
12721 
    return not (self == other)
12722 
 
12723 
class getBestSellersCatalogIds_args:
12724 
  """
12725 
  Attributes:
12726 
   - beginIndex
12727 
   - totalItems
12728 
   - brand
12729 
   - category
12730 
  """
12731 
 
12732 
  thrift_spec = (
12733 
    None, # 0
12734 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
12735 
    (2, TType.I64, 'totalItems', None, None, ), # 2
12736 
    (3, TType.STRING, 'brand', None, None, ), # 3
12737 
    (4, TType.I64, 'category', None, None, ), # 4
12738 
  )
12739 
 
12740 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
12741 
    self.beginIndex = beginIndex
12742 
    self.totalItems = totalItems
12743 
    self.brand = brand
12744 
    self.category = category
12745 
 
12746 
  def read(self, iprot):
12747 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12748 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12749 
      return
12750 
    iprot.readStructBegin()
12751 
    while True:
12752 
      (fname, ftype, fid) = iprot.readFieldBegin()
12753 
      if ftype == TType.STOP:
12754 
        break
12755 
      if fid == 1:
12756 
        if ftype == TType.I64:
12757 
          self.beginIndex = iprot.readI64();
12758 
        else:
12759 
          iprot.skip(ftype)
12760 
      elif fid == 2:
12761 
        if ftype == TType.I64:
12762 
          self.totalItems = iprot.readI64();
12763 
        else:
12764 
          iprot.skip(ftype)
12765 
      elif fid == 3:
12766 
        if ftype == TType.STRING:
12767 
          self.brand = iprot.readString();
12768 
        else:
12769 
          iprot.skip(ftype)
12770 
      elif fid == 4:
12771 
        if ftype == TType.I64:
12772 
          self.category = iprot.readI64();
12773 
        else:
12774 
          iprot.skip(ftype)
12775 
      else:
12776 
        iprot.skip(ftype)
12777 
      iprot.readFieldEnd()
12778 
    iprot.readStructEnd()
12779 
 
12780 
  def write(self, oprot):
12781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12783 
      return
12784 
    oprot.writeStructBegin('getBestSellersCatalogIds_args')
12785 
    if self.beginIndex is not None:
12786 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
12787 
      oprot.writeI64(self.beginIndex)
12788 
      oprot.writeFieldEnd()
12789 
    if self.totalItems is not None:
12790 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
12791 
      oprot.writeI64(self.totalItems)
12792 
      oprot.writeFieldEnd()
12793 
    if self.brand is not None:
12794 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
12795 
      oprot.writeString(self.brand)
12796 
      oprot.writeFieldEnd()
12797 
    if self.category is not None:
12798 
      oprot.writeFieldBegin('category', TType.I64, 4)
12799 
      oprot.writeI64(self.category)
12800 
      oprot.writeFieldEnd()
12801 
    oprot.writeFieldStop()
12802 
    oprot.writeStructEnd()
12803 
 
12804 
  def validate(self):
12805 
    return
12806 
 
12807 
 
12808 
  def __repr__(self):
12809 
    L = ['%s=%r' % (key, value)
12810 
      for key, value in self.__dict__.iteritems()]
12811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12812 
 
12813 
  def __eq__(self, other):
12814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12815 
 
12816 
  def __ne__(self, other):
12817 
    return not (self == other)
12818 
 
12819 
class getBestSellersCatalogIds_result:
12820 
  """
12821 
  Attributes:
12822 
   - success
12823 
   - cex
12824 
  """
12825 
 
12826 
  thrift_spec = (
12827 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12828 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12829 
  )
12830 
 
12831 
  def __init__(self, success=None, cex=None,):
12832 
    self.success = success
12833 
    self.cex = cex
12834 
 
12835 
  def read(self, iprot):
12836 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12837 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12838 
      return
12839 
    iprot.readStructBegin()
12840 
    while True:
12841 
      (fname, ftype, fid) = iprot.readFieldBegin()
12842 
      if ftype == TType.STOP:
12843 
        break
12844 
      if fid == 0:
12845 
        if ftype == TType.LIST:
12846 
          self.success = []
18719 kshitij.so 12847 
          (_etype132, _size129) = iprot.readListBegin()
12848 
          for _i133 in xrange(_size129):
12849 
            _elem134 = iprot.readI64();
12850 
            self.success.append(_elem134)
5944 mandeep.dh 12851 
          iprot.readListEnd()
12852 
        else:
12853 
          iprot.skip(ftype)
12854 
      elif fid == 1:
12855 
        if ftype == TType.STRUCT:
12856 
          self.cex = CatalogServiceException()
12857 
          self.cex.read(iprot)
12858 
        else:
12859 
          iprot.skip(ftype)
12860 
      else:
12861 
        iprot.skip(ftype)
12862 
      iprot.readFieldEnd()
12863 
    iprot.readStructEnd()
12864 
 
12865 
  def write(self, oprot):
12866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12868 
      return
12869 
    oprot.writeStructBegin('getBestSellersCatalogIds_result')
12870 
    if self.success is not None:
12871 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12872 
      oprot.writeListBegin(TType.I64, len(self.success))
18719 kshitij.so 12873 
      for iter135 in self.success:
12874 
        oprot.writeI64(iter135)
5944 mandeep.dh 12875 
      oprot.writeListEnd()
12876 
      oprot.writeFieldEnd()
12877 
    if self.cex is not None:
12878 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
12879 
      self.cex.write(oprot)
12880 
      oprot.writeFieldEnd()
12881 
    oprot.writeFieldStop()
12882 
    oprot.writeStructEnd()
12883 
 
12884 
  def validate(self):
12885 
    return
12886 
 
12887 
 
12888 
  def __repr__(self):
12889 
    L = ['%s=%r' % (key, value)
12890 
      for key, value in self.__dict__.iteritems()]
12891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12892 
 
12893 
  def __eq__(self, other):
12894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12895 
 
12896 
  def __ne__(self, other):
12897 
    return not (self == other)
12898 
 
12899 
class getBestSellersCount_args:
12900 
 
12901 
  thrift_spec = (
12902 
  )
12903 
 
12904 
  def read(self, iprot):
12905 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12906 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12907 
      return
12908 
    iprot.readStructBegin()
12909 
    while True:
12910 
      (fname, ftype, fid) = iprot.readFieldBegin()
12911 
      if ftype == TType.STOP:
12912 
        break
12913 
      else:
12914 
        iprot.skip(ftype)
12915 
      iprot.readFieldEnd()
12916 
    iprot.readStructEnd()
12917 
 
12918 
  def write(self, oprot):
12919 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12920 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12921 
      return
12922 
    oprot.writeStructBegin('getBestSellersCount_args')
12923 
    oprot.writeFieldStop()
12924 
    oprot.writeStructEnd()
12925 
 
12926 
  def validate(self):
12927 
    return
12928 
 
12929 
 
12930 
  def __repr__(self):
12931 
    L = ['%s=%r' % (key, value)
12932 
      for key, value in self.__dict__.iteritems()]
12933 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12934 
 
12935 
  def __eq__(self, other):
12936 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12937 
 
12938 
  def __ne__(self, other):
12939 
    return not (self == other)
12940 
 
12941 
class getBestSellersCount_result:
12942 
  """
12943 
  Attributes:
12944 
   - success
12945 
   - cex
12946 
  """
12947 
 
12948 
  thrift_spec = (
12949 
    (0, TType.I64, 'success', None, None, ), # 0
12950 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12951 
  )
12952 
 
12953 
  def __init__(self, success=None, cex=None,):
12954 
    self.success = success
12955 
    self.cex = cex
12956 
 
12957 
  def read(self, iprot):
12958 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12959 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12960 
      return
12961 
    iprot.readStructBegin()
12962 
    while True:
12963 
      (fname, ftype, fid) = iprot.readFieldBegin()
12964 
      if ftype == TType.STOP:
12965 
        break
12966 
      if fid == 0:
12967 
        if ftype == TType.I64:
12968 
          self.success = iprot.readI64();
12969 
        else:
12970 
          iprot.skip(ftype)
12971 
      elif fid == 1:
12972 
        if ftype == TType.STRUCT:
12973 
          self.cex = CatalogServiceException()
12974 
          self.cex.read(iprot)
12975 
        else:
12976 
          iprot.skip(ftype)
12977 
      else:
12978 
        iprot.skip(ftype)
12979 
      iprot.readFieldEnd()
12980 
    iprot.readStructEnd()
12981 
 
12982 
  def write(self, oprot):
12983 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12984 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12985 
      return
12986 
    oprot.writeStructBegin('getBestSellersCount_result')
12987 
    if self.success is not None:
12988 
      oprot.writeFieldBegin('success', TType.I64, 0)
12989 
      oprot.writeI64(self.success)
12990 
      oprot.writeFieldEnd()
12991 
    if self.cex is not None:
12992 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
12993 
      self.cex.write(oprot)
12994 
      oprot.writeFieldEnd()
12995 
    oprot.writeFieldStop()
12996 
    oprot.writeStructEnd()
12997 
 
12998 
  def validate(self):
12999 
    return
13000 
 
13001 
 
13002 
  def __repr__(self):
13003 
    L = ['%s=%r' % (key, value)
13004 
      for key, value in self.__dict__.iteritems()]
13005 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13006 
 
13007 
  def __eq__(self, other):
13008 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13009 
 
13010 
  def __ne__(self, other):
13011 
    return not (self == other)
13012 
 
13013 
class getBestDeals_args:
13014 
 
13015 
  thrift_spec = (
13016 
  )
13017 
 
13018 
  def read(self, iprot):
13019 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13020 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13021 
      return
13022 
    iprot.readStructBegin()
13023 
    while True:
13024 
      (fname, ftype, fid) = iprot.readFieldBegin()
13025 
      if ftype == TType.STOP:
13026 
        break
13027 
      else:
13028 
        iprot.skip(ftype)
13029 
      iprot.readFieldEnd()
13030 
    iprot.readStructEnd()
13031 
 
13032 
  def write(self, oprot):
13033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13035 
      return
13036 
    oprot.writeStructBegin('getBestDeals_args')
13037 
    oprot.writeFieldStop()
13038 
    oprot.writeStructEnd()
13039 
 
13040 
  def validate(self):
13041 
    return
13042 
 
13043 
 
13044 
  def __repr__(self):
13045 
    L = ['%s=%r' % (key, value)
13046 
      for key, value in self.__dict__.iteritems()]
13047 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13048 
 
13049 
  def __eq__(self, other):
13050 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13051 
 
13052 
  def __ne__(self, other):
13053 
    return not (self == other)
13054 
 
13055 
class getBestDeals_result:
13056 
  """
13057 
  Attributes:
13058 
   - success
13059 
   - isex
13060 
  """
13061 
 
13062 
  thrift_spec = (
13063 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
13064 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13065 
  )
13066 
 
13067 
  def __init__(self, success=None, isex=None,):
13068 
    self.success = success
13069 
    self.isex = isex
13070 
 
13071 
  def read(self, iprot):
13072 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13073 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13074 
      return
13075 
    iprot.readStructBegin()
13076 
    while True:
13077 
      (fname, ftype, fid) = iprot.readFieldBegin()
13078 
      if ftype == TType.STOP:
13079 
        break
13080 
      if fid == 0:
13081 
        if ftype == TType.LIST:
13082 
          self.success = []
18719 kshitij.so 13083 
          (_etype139, _size136) = iprot.readListBegin()
13084 
          for _i140 in xrange(_size136):
13085 
            _elem141 = Item()
13086 
            _elem141.read(iprot)
13087 
            self.success.append(_elem141)
5944 mandeep.dh 13088 
          iprot.readListEnd()
13089 
        else:
13090 
          iprot.skip(ftype)
13091 
      elif fid == 1:
13092 
        if ftype == TType.STRUCT:
13093 
          self.isex = CatalogServiceException()
13094 
          self.isex.read(iprot)
13095 
        else:
13096 
          iprot.skip(ftype)
13097 
      else:
13098 
        iprot.skip(ftype)
13099 
      iprot.readFieldEnd()
13100 
    iprot.readStructEnd()
13101 
 
13102 
  def write(self, oprot):
13103 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13104 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13105 
      return
13106 
    oprot.writeStructBegin('getBestDeals_result')
13107 
    if self.success is not None:
13108 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13109 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 13110 
      for iter142 in self.success:
13111 
        iter142.write(oprot)
5944 mandeep.dh 13112 
      oprot.writeListEnd()
13113 
      oprot.writeFieldEnd()
13114 
    if self.isex is not None:
13115 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
13116 
      self.isex.write(oprot)
13117 
      oprot.writeFieldEnd()
13118 
    oprot.writeFieldStop()
13119 
    oprot.writeStructEnd()
13120 
 
13121 
  def validate(self):
13122 
    return
13123 
 
13124 
 
13125 
  def __repr__(self):
13126 
    L = ['%s=%r' % (key, value)
13127 
      for key, value in self.__dict__.iteritems()]
13128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13129 
 
13130 
  def __eq__(self, other):
13131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13132 
 
13133 
  def __ne__(self, other):
13134 
    return not (self == other)
13135 
 
13136 
class getBestDealsCatalogIds_args:
13137 
  """
13138 
  Attributes:
13139 
   - beginIndex
13140 
   - totalItems
13141 
   - brand
13142 
   - category
13143 
  """
13144 
 
13145 
  thrift_spec = (
13146 
    None, # 0
13147 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
13148 
    (2, TType.I64, 'totalItems', None, None, ), # 2
13149 
    (3, TType.STRING, 'brand', None, None, ), # 3
13150 
    (4, TType.I64, 'category', None, None, ), # 4
13151 
  )
13152 
 
13153 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
13154 
    self.beginIndex = beginIndex
13155 
    self.totalItems = totalItems
13156 
    self.brand = brand
13157 
    self.category = category
13158 
 
13159 
  def read(self, iprot):
13160 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13161 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13162 
      return
13163 
    iprot.readStructBegin()
13164 
    while True:
13165 
      (fname, ftype, fid) = iprot.readFieldBegin()
13166 
      if ftype == TType.STOP:
13167 
        break
13168 
      if fid == 1:
13169 
        if ftype == TType.I64:
13170 
          self.beginIndex = iprot.readI64();
13171 
        else:
13172 
          iprot.skip(ftype)
13173 
      elif fid == 2:
13174 
        if ftype == TType.I64:
13175 
          self.totalItems = iprot.readI64();
13176 
        else:
13177 
          iprot.skip(ftype)
13178 
      elif fid == 3:
13179 
        if ftype == TType.STRING:
13180 
          self.brand = iprot.readString();
13181 
        else:
13182 
          iprot.skip(ftype)
13183 
      elif fid == 4:
13184 
        if ftype == TType.I64:
13185 
          self.category = iprot.readI64();
13186 
        else:
13187 
          iprot.skip(ftype)
13188 
      else:
13189 
        iprot.skip(ftype)
13190 
      iprot.readFieldEnd()
13191 
    iprot.readStructEnd()
13192 
 
13193 
  def write(self, oprot):
13194 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13195 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13196 
      return
13197 
    oprot.writeStructBegin('getBestDealsCatalogIds_args')
13198 
    if self.beginIndex is not None:
13199 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
13200 
      oprot.writeI64(self.beginIndex)
13201 
      oprot.writeFieldEnd()
13202 
    if self.totalItems is not None:
13203 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
13204 
      oprot.writeI64(self.totalItems)
13205 
      oprot.writeFieldEnd()
13206 
    if self.brand is not None:
13207 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
13208 
      oprot.writeString(self.brand)
13209 
      oprot.writeFieldEnd()
13210 
    if self.category is not None:
13211 
      oprot.writeFieldBegin('category', TType.I64, 4)
13212 
      oprot.writeI64(self.category)
13213 
      oprot.writeFieldEnd()
13214 
    oprot.writeFieldStop()
13215 
    oprot.writeStructEnd()
13216 
 
13217 
  def validate(self):
13218 
    return
13219 
 
13220 
 
13221 
  def __repr__(self):
13222 
    L = ['%s=%r' % (key, value)
13223 
      for key, value in self.__dict__.iteritems()]
13224 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13225 
 
13226 
  def __eq__(self, other):
13227 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13228 
 
13229 
  def __ne__(self, other):
13230 
    return not (self == other)
13231 
 
13232 
class getBestDealsCatalogIds_result:
13233 
  """
13234 
  Attributes:
13235 
   - success
13236 
   - cex
13237 
  """
13238 
 
13239 
  thrift_spec = (
13240 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
13241 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13242 
  )
13243 
 
13244 
  def __init__(self, success=None, cex=None,):
13245 
    self.success = success
13246 
    self.cex = cex
13247 
 
13248 
  def read(self, iprot):
13249 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13250 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13251 
      return
13252 
    iprot.readStructBegin()
13253 
    while True:
13254 
      (fname, ftype, fid) = iprot.readFieldBegin()
13255 
      if ftype == TType.STOP:
13256 
        break
13257 
      if fid == 0:
13258 
        if ftype == TType.LIST:
13259 
          self.success = []
18719 kshitij.so 13260 
          (_etype146, _size143) = iprot.readListBegin()
13261 
          for _i147 in xrange(_size143):
13262 
            _elem148 = iprot.readI64();
13263 
            self.success.append(_elem148)
5944 mandeep.dh 13264 
          iprot.readListEnd()
13265 
        else:
13266 
          iprot.skip(ftype)
13267 
      elif fid == 1:
13268 
        if ftype == TType.STRUCT:
13269 
          self.cex = CatalogServiceException()
13270 
          self.cex.read(iprot)
13271 
        else:
13272 
          iprot.skip(ftype)
13273 
      else:
13274 
        iprot.skip(ftype)
13275 
      iprot.readFieldEnd()
13276 
    iprot.readStructEnd()
13277 
 
13278 
  def write(self, oprot):
13279 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13280 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13281 
      return
13282 
    oprot.writeStructBegin('getBestDealsCatalogIds_result')
13283 
    if self.success is not None:
13284 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13285 
      oprot.writeListBegin(TType.I64, len(self.success))
18719 kshitij.so 13286 
      for iter149 in self.success:
13287 
        oprot.writeI64(iter149)
5944 mandeep.dh 13288 
      oprot.writeListEnd()
13289 
      oprot.writeFieldEnd()
13290 
    if self.cex is not None:
13291 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13292 
      self.cex.write(oprot)
13293 
      oprot.writeFieldEnd()
13294 
    oprot.writeFieldStop()
13295 
    oprot.writeStructEnd()
13296 
 
13297 
  def validate(self):
13298 
    return
13299 
 
13300 
 
13301 
  def __repr__(self):
13302 
    L = ['%s=%r' % (key, value)
13303 
      for key, value in self.__dict__.iteritems()]
13304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13305 
 
13306 
  def __eq__(self, other):
13307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13308 
 
13309 
  def __ne__(self, other):
13310 
    return not (self == other)
13311 
 
13312 
class getBestDealsCount_args:
13313 
 
13314 
  thrift_spec = (
13315 
  )
13316 
 
13317 
  def read(self, iprot):
13318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13320 
      return
13321 
    iprot.readStructBegin()
13322 
    while True:
13323 
      (fname, ftype, fid) = iprot.readFieldBegin()
13324 
      if ftype == TType.STOP:
13325 
        break
13326 
      else:
13327 
        iprot.skip(ftype)
13328 
      iprot.readFieldEnd()
13329 
    iprot.readStructEnd()
13330 
 
13331 
  def write(self, oprot):
13332 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13333 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13334 
      return
13335 
    oprot.writeStructBegin('getBestDealsCount_args')
13336 
    oprot.writeFieldStop()
13337 
    oprot.writeStructEnd()
13338 
 
13339 
  def validate(self):
13340 
    return
13341 
 
13342 
 
13343 
  def __repr__(self):
13344 
    L = ['%s=%r' % (key, value)
13345 
      for key, value in self.__dict__.iteritems()]
13346 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13347 
 
13348 
  def __eq__(self, other):
13349 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13350 
 
13351 
  def __ne__(self, other):
13352 
    return not (self == other)
13353 
 
13354 
class getBestDealsCount_result:
13355 
  """
13356 
  Attributes:
13357 
   - success
13358 
   - cex
13359 
  """
13360 
 
13361 
  thrift_spec = (
13362 
    (0, TType.I64, 'success', None, None, ), # 0
13363 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13364 
  )
13365 
 
13366 
  def __init__(self, success=None, cex=None,):
13367 
    self.success = success
13368 
    self.cex = cex
13369 
 
13370 
  def read(self, iprot):
13371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13373 
      return
13374 
    iprot.readStructBegin()
13375 
    while True:
13376 
      (fname, ftype, fid) = iprot.readFieldBegin()
13377 
      if ftype == TType.STOP:
13378 
        break
13379 
      if fid == 0:
13380 
        if ftype == TType.I64:
13381 
          self.success = iprot.readI64();
13382 
        else:
13383 
          iprot.skip(ftype)
13384 
      elif fid == 1:
13385 
        if ftype == TType.STRUCT:
13386 
          self.cex = CatalogServiceException()
13387 
          self.cex.read(iprot)
13388 
        else:
13389 
          iprot.skip(ftype)
13390 
      else:
13391 
        iprot.skip(ftype)
13392 
      iprot.readFieldEnd()
13393 
    iprot.readStructEnd()
13394 
 
13395 
  def write(self, oprot):
13396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13398 
      return
13399 
    oprot.writeStructBegin('getBestDealsCount_result')
13400 
    if self.success is not None:
13401 
      oprot.writeFieldBegin('success', TType.I64, 0)
13402 
      oprot.writeI64(self.success)
13403 
      oprot.writeFieldEnd()
13404 
    if self.cex is not None:
13405 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13406 
      self.cex.write(oprot)
13407 
      oprot.writeFieldEnd()
13408 
    oprot.writeFieldStop()
13409 
    oprot.writeStructEnd()
13410 
 
13411 
  def validate(self):
13412 
    return
13413 
 
13414 
 
13415 
  def __repr__(self):
13416 
    L = ['%s=%r' % (key, value)
13417 
      for key, value in self.__dict__.iteritems()]
13418 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13419 
 
13420 
  def __eq__(self, other):
13421 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13422 
 
13423 
  def __ne__(self, other):
13424 
    return not (self == other)
13425 
 
13426 
class getComingSoon_args:
13427 
 
13428 
  thrift_spec = (
13429 
  )
13430 
 
13431 
  def read(self, iprot):
13432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13434 
      return
13435 
    iprot.readStructBegin()
13436 
    while True:
13437 
      (fname, ftype, fid) = iprot.readFieldBegin()
13438 
      if ftype == TType.STOP:
13439 
        break
13440 
      else:
13441 
        iprot.skip(ftype)
13442 
      iprot.readFieldEnd()
13443 
    iprot.readStructEnd()
13444 
 
13445 
  def write(self, oprot):
13446 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13447 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13448 
      return
13449 
    oprot.writeStructBegin('getComingSoon_args')
13450 
    oprot.writeFieldStop()
13451 
    oprot.writeStructEnd()
13452 
 
13453 
  def validate(self):
13454 
    return
13455 
 
13456 
 
13457 
  def __repr__(self):
13458 
    L = ['%s=%r' % (key, value)
13459 
      for key, value in self.__dict__.iteritems()]
13460 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13461 
 
13462 
  def __eq__(self, other):
13463 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13464 
 
13465 
  def __ne__(self, other):
13466 
    return not (self == other)
13467 
 
13468 
class getComingSoon_result:
13469 
  """
13470 
  Attributes:
13471 
   - success
13472 
   - isex
13473 
  """
13474 
 
13475 
  thrift_spec = (
13476 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
13477 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13478 
  )
13479 
 
13480 
  def __init__(self, success=None, isex=None,):
13481 
    self.success = success
13482 
    self.isex = isex
13483 
 
13484 
  def read(self, iprot):
13485 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13486 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13487 
      return
13488 
    iprot.readStructBegin()
13489 
    while True:
13490 
      (fname, ftype, fid) = iprot.readFieldBegin()
13491 
      if ftype == TType.STOP:
13492 
        break
13493 
      if fid == 0:
13494 
        if ftype == TType.LIST:
13495 
          self.success = []
18719 kshitij.so 13496 
          (_etype153, _size150) = iprot.readListBegin()
13497 
          for _i154 in xrange(_size150):
13498 
            _elem155 = Item()
13499 
            _elem155.read(iprot)
13500 
            self.success.append(_elem155)
5944 mandeep.dh 13501 
          iprot.readListEnd()
13502 
        else:
13503 
          iprot.skip(ftype)
13504 
      elif fid == 1:
13505 
        if ftype == TType.STRUCT:
13506 
          self.isex = CatalogServiceException()
13507 
          self.isex.read(iprot)
13508 
        else:
13509 
          iprot.skip(ftype)
13510 
      else:
13511 
        iprot.skip(ftype)
13512 
      iprot.readFieldEnd()
13513 
    iprot.readStructEnd()
13514 
 
13515 
  def write(self, oprot):
13516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13518 
      return
13519 
    oprot.writeStructBegin('getComingSoon_result')
13520 
    if self.success is not None:
13521 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13522 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 13523 
      for iter156 in self.success:
13524 
        iter156.write(oprot)
5944 mandeep.dh 13525 
      oprot.writeListEnd()
13526 
      oprot.writeFieldEnd()
13527 
    if self.isex is not None:
13528 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
13529 
      self.isex.write(oprot)
13530 
      oprot.writeFieldEnd()
13531 
    oprot.writeFieldStop()
13532 
    oprot.writeStructEnd()
13533 
 
13534 
  def validate(self):
13535 
    return
13536 
 
13537 
 
13538 
  def __repr__(self):
13539 
    L = ['%s=%r' % (key, value)
13540 
      for key, value in self.__dict__.iteritems()]
13541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13542 
 
13543 
  def __eq__(self, other):
13544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13545 
 
13546 
  def __ne__(self, other):
13547 
    return not (self == other)
13548 
 
13549 
class getComingSoonCatalogIds_args:
13550 
  """
13551 
  Attributes:
13552 
   - beginIndex
13553 
   - totalItems
13554 
   - brand
13555 
   - category
13556 
  """
13557 
 
13558 
  thrift_spec = (
13559 
    None, # 0
13560 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
13561 
    (2, TType.I64, 'totalItems', None, None, ), # 2
13562 
    (3, TType.STRING, 'brand', None, None, ), # 3
13563 
    (4, TType.I64, 'category', None, None, ), # 4
13564 
  )
13565 
 
13566 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
13567 
    self.beginIndex = beginIndex
13568 
    self.totalItems = totalItems
13569 
    self.brand = brand
13570 
    self.category = category
13571 
 
13572 
  def read(self, iprot):
13573 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13574 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13575 
      return
13576 
    iprot.readStructBegin()
13577 
    while True:
13578 
      (fname, ftype, fid) = iprot.readFieldBegin()
13579 
      if ftype == TType.STOP:
13580 
        break
13581 
      if fid == 1:
13582 
        if ftype == TType.I64:
13583 
          self.beginIndex = iprot.readI64();
13584 
        else:
13585 
          iprot.skip(ftype)
13586 
      elif fid == 2:
13587 
        if ftype == TType.I64:
13588 
          self.totalItems = iprot.readI64();
13589 
        else:
13590 
          iprot.skip(ftype)
13591 
      elif fid == 3:
13592 
        if ftype == TType.STRING:
13593 
          self.brand = iprot.readString();
13594 
        else:
13595 
          iprot.skip(ftype)
13596 
      elif fid == 4:
13597 
        if ftype == TType.I64:
13598 
          self.category = iprot.readI64();
13599 
        else:
13600 
          iprot.skip(ftype)
13601 
      else:
13602 
        iprot.skip(ftype)
13603 
      iprot.readFieldEnd()
13604 
    iprot.readStructEnd()
13605 
 
13606 
  def write(self, oprot):
13607 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13608 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13609 
      return
13610 
    oprot.writeStructBegin('getComingSoonCatalogIds_args')
13611 
    if self.beginIndex is not None:
13612 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
13613 
      oprot.writeI64(self.beginIndex)
13614 
      oprot.writeFieldEnd()
13615 
    if self.totalItems is not None:
13616 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
13617 
      oprot.writeI64(self.totalItems)
13618 
      oprot.writeFieldEnd()
13619 
    if self.brand is not None:
13620 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
13621 
      oprot.writeString(self.brand)
13622 
      oprot.writeFieldEnd()
13623 
    if self.category is not None:
13624 
      oprot.writeFieldBegin('category', TType.I64, 4)
13625 
      oprot.writeI64(self.category)
13626 
      oprot.writeFieldEnd()
13627 
    oprot.writeFieldStop()
13628 
    oprot.writeStructEnd()
13629 
 
13630 
  def validate(self):
13631 
    return
13632 
 
13633 
 
13634 
  def __repr__(self):
13635 
    L = ['%s=%r' % (key, value)
13636 
      for key, value in self.__dict__.iteritems()]
13637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13638 
 
13639 
  def __eq__(self, other):
13640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13641 
 
13642 
  def __ne__(self, other):
13643 
    return not (self == other)
13644 
 
13645 
class getComingSoonCatalogIds_result:
13646 
  """
13647 
  Attributes:
13648 
   - success
13649 
   - cex
13650 
  """
13651 
 
13652 
  thrift_spec = (
13653 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
13654 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13655 
  )
13656 
 
13657 
  def __init__(self, success=None, cex=None,):
13658 
    self.success = success
13659 
    self.cex = cex
13660 
 
13661 
  def read(self, iprot):
13662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13664 
      return
13665 
    iprot.readStructBegin()
13666 
    while True:
13667 
      (fname, ftype, fid) = iprot.readFieldBegin()
13668 
      if ftype == TType.STOP:
13669 
        break
13670 
      if fid == 0:
13671 
        if ftype == TType.LIST:
13672 
          self.success = []
18719 kshitij.so 13673 
          (_etype160, _size157) = iprot.readListBegin()
13674 
          for _i161 in xrange(_size157):
13675 
            _elem162 = iprot.readI64();
13676 
            self.success.append(_elem162)
5944 mandeep.dh 13677 
          iprot.readListEnd()
13678 
        else:
13679 
          iprot.skip(ftype)
13680 
      elif fid == 1:
13681 
        if ftype == TType.STRUCT:
13682 
          self.cex = CatalogServiceException()
13683 
          self.cex.read(iprot)
13684 
        else:
13685 
          iprot.skip(ftype)
13686 
      else:
13687 
        iprot.skip(ftype)
13688 
      iprot.readFieldEnd()
13689 
    iprot.readStructEnd()
13690 
 
13691 
  def write(self, oprot):
13692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13694 
      return
13695 
    oprot.writeStructBegin('getComingSoonCatalogIds_result')
13696 
    if self.success is not None:
13697 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13698 
      oprot.writeListBegin(TType.I64, len(self.success))
18719 kshitij.so 13699 
      for iter163 in self.success:
13700 
        oprot.writeI64(iter163)
5944 mandeep.dh 13701 
      oprot.writeListEnd()
13702 
      oprot.writeFieldEnd()
13703 
    if self.cex is not None:
13704 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13705 
      self.cex.write(oprot)
13706 
      oprot.writeFieldEnd()
13707 
    oprot.writeFieldStop()
13708 
    oprot.writeStructEnd()
13709 
 
13710 
  def validate(self):
13711 
    return
13712 
 
13713 
 
13714 
  def __repr__(self):
13715 
    L = ['%s=%r' % (key, value)
13716 
      for key, value in self.__dict__.iteritems()]
13717 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13718 
 
13719 
  def __eq__(self, other):
13720 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13721 
 
13722 
  def __ne__(self, other):
13723 
    return not (self == other)
13724 
 
13725 
class getComingSoonCount_args:
13726 
 
13727 
  thrift_spec = (
13728 
  )
13729 
 
13730 
  def read(self, iprot):
13731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13733 
      return
13734 
    iprot.readStructBegin()
13735 
    while True:
13736 
      (fname, ftype, fid) = iprot.readFieldBegin()
13737 
      if ftype == TType.STOP:
13738 
        break
13739 
      else:
13740 
        iprot.skip(ftype)
13741 
      iprot.readFieldEnd()
13742 
    iprot.readStructEnd()
13743 
 
13744 
  def write(self, oprot):
13745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13747 
      return
13748 
    oprot.writeStructBegin('getComingSoonCount_args')
13749 
    oprot.writeFieldStop()
13750 
    oprot.writeStructEnd()
13751 
 
13752 
  def validate(self):
13753 
    return
13754 
 
13755 
 
13756 
  def __repr__(self):
13757 
    L = ['%s=%r' % (key, value)
13758 
      for key, value in self.__dict__.iteritems()]
13759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13760 
 
13761 
  def __eq__(self, other):
13762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13763 
 
13764 
  def __ne__(self, other):
13765 
    return not (self == other)
13766 
 
13767 
class getComingSoonCount_result:
13768 
  """
13769 
  Attributes:
13770 
   - success
13771 
   - cex
13772 
  """
13773 
 
13774 
  thrift_spec = (
13775 
    (0, TType.I64, 'success', None, None, ), # 0
13776 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13777 
  )
13778 
 
13779 
  def __init__(self, success=None, cex=None,):
13780 
    self.success = success
13781 
    self.cex = cex
13782 
 
13783 
  def read(self, iprot):
13784 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13785 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13786 
      return
13787 
    iprot.readStructBegin()
13788 
    while True:
13789 
      (fname, ftype, fid) = iprot.readFieldBegin()
13790 
      if ftype == TType.STOP:
13791 
        break
13792 
      if fid == 0:
13793 
        if ftype == TType.I64:
13794 
          self.success = iprot.readI64();
13795 
        else:
13796 
          iprot.skip(ftype)
13797 
      elif fid == 1:
13798 
        if ftype == TType.STRUCT:
13799 
          self.cex = CatalogServiceException()
13800 
          self.cex.read(iprot)
13801 
        else:
13802 
          iprot.skip(ftype)
13803 
      else:
13804 
        iprot.skip(ftype)
13805 
      iprot.readFieldEnd()
13806 
    iprot.readStructEnd()
13807 
 
13808 
  def write(self, oprot):
13809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13811 
      return
13812 
    oprot.writeStructBegin('getComingSoonCount_result')
13813 
    if self.success is not None:
13814 
      oprot.writeFieldBegin('success', TType.I64, 0)
13815 
      oprot.writeI64(self.success)
13816 
      oprot.writeFieldEnd()
13817 
    if self.cex is not None:
13818 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13819 
      self.cex.write(oprot)
13820 
      oprot.writeFieldEnd()
13821 
    oprot.writeFieldStop()
13822 
    oprot.writeStructEnd()
13823 
 
13824 
  def validate(self):
13825 
    return
13826 
 
13827 
 
13828 
  def __repr__(self):
13829 
    L = ['%s=%r' % (key, value)
13830 
      for key, value in self.__dict__.iteritems()]
13831 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13832 
 
13833 
  def __eq__(self, other):
13834 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13835 
 
13836 
  def __ne__(self, other):
13837 
    return not (self == other)
13838 
 
13839 
class getLatestArrivals_args:
13840 
 
13841 
  thrift_spec = (
13842 
  )
13843 
 
13844 
  def read(self, iprot):
13845 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13846 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13847 
      return
13848 
    iprot.readStructBegin()
13849 
    while True:
13850 
      (fname, ftype, fid) = iprot.readFieldBegin()
13851 
      if ftype == TType.STOP:
13852 
        break
13853 
      else:
13854 
        iprot.skip(ftype)
13855 
      iprot.readFieldEnd()
13856 
    iprot.readStructEnd()
13857 
 
13858 
  def write(self, oprot):
13859 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13860 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13861 
      return
13862 
    oprot.writeStructBegin('getLatestArrivals_args')
13863 
    oprot.writeFieldStop()
13864 
    oprot.writeStructEnd()
13865 
 
13866 
  def validate(self):
13867 
    return
13868 
 
13869 
 
13870 
  def __repr__(self):
13871 
    L = ['%s=%r' % (key, value)
13872 
      for key, value in self.__dict__.iteritems()]
13873 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13874 
 
13875 
  def __eq__(self, other):
13876 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13877 
 
13878 
  def __ne__(self, other):
13879 
    return not (self == other)
13880 
 
13881 
class getLatestArrivals_result:
13882 
  """
13883 
  Attributes:
13884 
   - success
13885 
   - isex
13886 
  """
13887 
 
13888 
  thrift_spec = (
13889 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
13890 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13891 
  )
13892 
 
13893 
  def __init__(self, success=None, isex=None,):
13894 
    self.success = success
13895 
    self.isex = isex
13896 
 
13897 
  def read(self, iprot):
13898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13900 
      return
13901 
    iprot.readStructBegin()
13902 
    while True:
13903 
      (fname, ftype, fid) = iprot.readFieldBegin()
13904 
      if ftype == TType.STOP:
13905 
        break
13906 
      if fid == 0:
13907 
        if ftype == TType.LIST:
13908 
          self.success = []
18719 kshitij.so 13909 
          (_etype167, _size164) = iprot.readListBegin()
13910 
          for _i168 in xrange(_size164):
13911 
            _elem169 = Item()
13912 
            _elem169.read(iprot)
13913 
            self.success.append(_elem169)
5944 mandeep.dh 13914 
          iprot.readListEnd()
13915 
        else:
13916 
          iprot.skip(ftype)
13917 
      elif fid == 1:
13918 
        if ftype == TType.STRUCT:
13919 
          self.isex = CatalogServiceException()
13920 
          self.isex.read(iprot)
13921 
        else:
13922 
          iprot.skip(ftype)
13923 
      else:
13924 
        iprot.skip(ftype)
13925 
      iprot.readFieldEnd()
13926 
    iprot.readStructEnd()
13927 
 
13928 
  def write(self, oprot):
13929 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13930 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13931 
      return
13932 
    oprot.writeStructBegin('getLatestArrivals_result')
13933 
    if self.success is not None:
13934 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13935 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 13936 
      for iter170 in self.success:
13937 
        iter170.write(oprot)
5944 mandeep.dh 13938 
      oprot.writeListEnd()
13939 
      oprot.writeFieldEnd()
13940 
    if self.isex is not None:
13941 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
13942 
      self.isex.write(oprot)
13943 
      oprot.writeFieldEnd()
13944 
    oprot.writeFieldStop()
13945 
    oprot.writeStructEnd()
13946 
 
13947 
  def validate(self):
13948 
    return
13949 
 
13950 
 
13951 
  def __repr__(self):
13952 
    L = ['%s=%r' % (key, value)
13953 
      for key, value in self.__dict__.iteritems()]
13954 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13955 
 
13956 
  def __eq__(self, other):
13957 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13958 
 
13959 
  def __ne__(self, other):
13960 
    return not (self == other)
13961 
 
13962 
class getLatestArrivalsCatalogIds_args:
13963 
  """
13964 
  Attributes:
13965 
   - beginIndex
13966 
   - totalItems
13967 
   - brand
13968 
   - categories
13969 
  """
13970 
 
13971 
  thrift_spec = (
13972 
    None, # 0
13973 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
13974 
    (2, TType.I64, 'totalItems', None, None, ), # 2
13975 
    (3, TType.STRING, 'brand', None, None, ), # 3
13976 
    (4, TType.LIST, 'categories', (TType.I64,None), None, ), # 4
13977 
  )
13978 
 
13979 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, categories=None,):
13980 
    self.beginIndex = beginIndex
13981 
    self.totalItems = totalItems
13982 
    self.brand = brand
13983 
    self.categories = categories
13984 
 
13985 
  def read(self, iprot):
13986 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13987 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13988 
      return
13989 
    iprot.readStructBegin()
13990 
    while True:
13991 
      (fname, ftype, fid) = iprot.readFieldBegin()
13992 
      if ftype == TType.STOP:
13993 
        break
13994 
      if fid == 1:
13995 
        if ftype == TType.I64:
13996 
          self.beginIndex = iprot.readI64();
13997 
        else:
13998 
          iprot.skip(ftype)
13999 
      elif fid == 2:
14000 
        if ftype == TType.I64:
14001 
          self.totalItems = iprot.readI64();
14002 
        else:
14003 
          iprot.skip(ftype)
14004 
      elif fid == 3:
14005 
        if ftype == TType.STRING:
14006 
          self.brand = iprot.readString();
14007 
        else:
14008 
          iprot.skip(ftype)
14009 
      elif fid == 4:
14010 
        if ftype == TType.LIST:
14011 
          self.categories = []
18719 kshitij.so 14012 
          (_etype174, _size171) = iprot.readListBegin()
14013 
          for _i175 in xrange(_size171):
14014 
            _elem176 = iprot.readI64();
14015 
            self.categories.append(_elem176)
5944 mandeep.dh 14016 
          iprot.readListEnd()
14017 
        else:
14018 
          iprot.skip(ftype)
14019 
      else:
14020 
        iprot.skip(ftype)
14021 
      iprot.readFieldEnd()
14022 
    iprot.readStructEnd()
14023 
 
14024 
  def write(self, oprot):
14025 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14026 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14027 
      return
14028 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_args')
14029 
    if self.beginIndex is not None:
14030 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
14031 
      oprot.writeI64(self.beginIndex)
14032 
      oprot.writeFieldEnd()
14033 
    if self.totalItems is not None:
14034 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
14035 
      oprot.writeI64(self.totalItems)
14036 
      oprot.writeFieldEnd()
14037 
    if self.brand is not None:
14038 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
14039 
      oprot.writeString(self.brand)
14040 
      oprot.writeFieldEnd()
14041 
    if self.categories is not None:
14042 
      oprot.writeFieldBegin('categories', TType.LIST, 4)
14043 
      oprot.writeListBegin(TType.I64, len(self.categories))
18719 kshitij.so 14044 
      for iter177 in self.categories:
14045 
        oprot.writeI64(iter177)
5944 mandeep.dh 14046 
      oprot.writeListEnd()
14047 
      oprot.writeFieldEnd()
14048 
    oprot.writeFieldStop()
14049 
    oprot.writeStructEnd()
14050 
 
14051 
  def validate(self):
14052 
    return
14053 
 
14054 
 
14055 
  def __repr__(self):
14056 
    L = ['%s=%r' % (key, value)
14057 
      for key, value in self.__dict__.iteritems()]
14058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14059 
 
14060 
  def __eq__(self, other):
14061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14062 
 
14063 
  def __ne__(self, other):
14064 
    return not (self == other)
14065 
 
14066 
class getLatestArrivalsCatalogIds_result:
14067 
  """
14068 
  Attributes:
14069 
   - success
14070 
   - cex
14071 
  """
14072 
 
14073 
  thrift_spec = (
14074 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
14075 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14076 
  )
14077 
 
14078 
  def __init__(self, success=None, cex=None,):
14079 
    self.success = success
14080 
    self.cex = cex
14081 
 
14082 
  def read(self, iprot):
14083 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14084 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14085 
      return
14086 
    iprot.readStructBegin()
14087 
    while True:
14088 
      (fname, ftype, fid) = iprot.readFieldBegin()
14089 
      if ftype == TType.STOP:
14090 
        break
14091 
      if fid == 0:
14092 
        if ftype == TType.LIST:
14093 
          self.success = []
18719 kshitij.so 14094 
          (_etype181, _size178) = iprot.readListBegin()
14095 
          for _i182 in xrange(_size178):
14096 
            _elem183 = iprot.readI64();
14097 
            self.success.append(_elem183)
5944 mandeep.dh 14098 
          iprot.readListEnd()
14099 
        else:
14100 
          iprot.skip(ftype)
14101 
      elif fid == 1:
14102 
        if ftype == TType.STRUCT:
14103 
          self.cex = CatalogServiceException()
14104 
          self.cex.read(iprot)
14105 
        else:
14106 
          iprot.skip(ftype)
14107 
      else:
14108 
        iprot.skip(ftype)
14109 
      iprot.readFieldEnd()
14110 
    iprot.readStructEnd()
14111 
 
14112 
  def write(self, oprot):
14113 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14114 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14115 
      return
14116 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_result')
14117 
    if self.success is not None:
14118 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14119 
      oprot.writeListBegin(TType.I64, len(self.success))
18719 kshitij.so 14120 
      for iter184 in self.success:
14121 
        oprot.writeI64(iter184)
5944 mandeep.dh 14122 
      oprot.writeListEnd()
14123 
      oprot.writeFieldEnd()
14124 
    if self.cex is not None:
14125 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14126 
      self.cex.write(oprot)
14127 
      oprot.writeFieldEnd()
14128 
    oprot.writeFieldStop()
14129 
    oprot.writeStructEnd()
14130 
 
14131 
  def validate(self):
14132 
    return
14133 
 
14134 
 
14135 
  def __repr__(self):
14136 
    L = ['%s=%r' % (key, value)
14137 
      for key, value in self.__dict__.iteritems()]
14138 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14139 
 
14140 
  def __eq__(self, other):
14141 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14142 
 
14143 
  def __ne__(self, other):
14144 
    return not (self == other)
14145 
 
14146 
class getLatestArrivalsCount_args:
14147 
 
14148 
  thrift_spec = (
14149 
  )
14150 
 
14151 
  def read(self, iprot):
14152 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14153 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14154 
      return
14155 
    iprot.readStructBegin()
14156 
    while True:
14157 
      (fname, ftype, fid) = iprot.readFieldBegin()
14158 
      if ftype == TType.STOP:
14159 
        break
14160 
      else:
14161 
        iprot.skip(ftype)
14162 
      iprot.readFieldEnd()
14163 
    iprot.readStructEnd()
14164 
 
14165 
  def write(self, oprot):
14166 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14167 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14168 
      return
14169 
    oprot.writeStructBegin('getLatestArrivalsCount_args')
14170 
    oprot.writeFieldStop()
14171 
    oprot.writeStructEnd()
14172 
 
14173 
  def validate(self):
14174 
    return
14175 
 
14176 
 
14177 
  def __repr__(self):
14178 
    L = ['%s=%r' % (key, value)
14179 
      for key, value in self.__dict__.iteritems()]
14180 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14181 
 
14182 
  def __eq__(self, other):
14183 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14184 
 
14185 
  def __ne__(self, other):
14186 
    return not (self == other)
14187 
 
14188 
class getLatestArrivalsCount_result:
14189 
  """
14190 
  Attributes:
14191 
   - success
14192 
   - cex
14193 
  """
14194 
 
14195 
  thrift_spec = (
14196 
    (0, TType.I64, 'success', None, None, ), # 0
14197 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14198 
  )
14199 
 
14200 
  def __init__(self, success=None, cex=None,):
14201 
    self.success = success
14202 
    self.cex = cex
14203 
 
14204 
  def read(self, iprot):
14205 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14206 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14207 
      return
14208 
    iprot.readStructBegin()
14209 
    while True:
14210 
      (fname, ftype, fid) = iprot.readFieldBegin()
14211 
      if ftype == TType.STOP:
14212 
        break
14213 
      if fid == 0:
14214 
        if ftype == TType.I64:
14215 
          self.success = iprot.readI64();
14216 
        else:
14217 
          iprot.skip(ftype)
14218 
      elif fid == 1:
14219 
        if ftype == TType.STRUCT:
14220 
          self.cex = CatalogServiceException()
14221 
          self.cex.read(iprot)
14222 
        else:
14223 
          iprot.skip(ftype)
14224 
      else:
14225 
        iprot.skip(ftype)
14226 
      iprot.readFieldEnd()
14227 
    iprot.readStructEnd()
14228 
 
14229 
  def write(self, oprot):
14230 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14231 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14232 
      return
14233 
    oprot.writeStructBegin('getLatestArrivalsCount_result')
14234 
    if self.success is not None:
14235 
      oprot.writeFieldBegin('success', TType.I64, 0)
14236 
      oprot.writeI64(self.success)
14237 
      oprot.writeFieldEnd()
14238 
    if self.cex is not None:
14239 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14240 
      self.cex.write(oprot)
14241 
      oprot.writeFieldEnd()
14242 
    oprot.writeFieldStop()
14243 
    oprot.writeStructEnd()
14244 
 
14245 
  def validate(self):
14246 
    return
14247 
 
14248 
 
14249 
  def __repr__(self):
14250 
    L = ['%s=%r' % (key, value)
14251 
      for key, value in self.__dict__.iteritems()]
14252 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14253 
 
14254 
  def __eq__(self, other):
14255 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14256 
 
14257 
  def __ne__(self, other):
14258 
    return not (self == other)
14259 
 
14260 
class generateNewEntityID_args:
14261 
 
14262 
  thrift_spec = (
14263 
  )
14264 
 
14265 
  def read(self, iprot):
14266 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14267 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14268 
      return
14269 
    iprot.readStructBegin()
14270 
    while True:
14271 
      (fname, ftype, fid) = iprot.readFieldBegin()
14272 
      if ftype == TType.STOP:
14273 
        break
14274 
      else:
14275 
        iprot.skip(ftype)
14276 
      iprot.readFieldEnd()
14277 
    iprot.readStructEnd()
14278 
 
14279 
  def write(self, oprot):
14280 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14281 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14282 
      return
14283 
    oprot.writeStructBegin('generateNewEntityID_args')
14284 
    oprot.writeFieldStop()
14285 
    oprot.writeStructEnd()
14286 
 
14287 
  def validate(self):
14288 
    return
14289 
 
14290 
 
14291 
  def __repr__(self):
14292 
    L = ['%s=%r' % (key, value)
14293 
      for key, value in self.__dict__.iteritems()]
14294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14295 
 
14296 
  def __eq__(self, other):
14297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14298 
 
14299 
  def __ne__(self, other):
14300 
    return not (self == other)
14301 
 
14302 
class generateNewEntityID_result:
14303 
  """
14304 
  Attributes:
14305 
   - success
14306 
  """
14307 
 
14308 
  thrift_spec = (
14309 
    (0, TType.I64, 'success', None, None, ), # 0
14310 
  )
14311 
 
14312 
  def __init__(self, success=None,):
14313 
    self.success = success
14314 
 
14315 
  def read(self, iprot):
14316 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14317 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14318 
      return
14319 
    iprot.readStructBegin()
14320 
    while True:
14321 
      (fname, ftype, fid) = iprot.readFieldBegin()
14322 
      if ftype == TType.STOP:
14323 
        break
14324 
      if fid == 0:
14325 
        if ftype == TType.I64:
14326 
          self.success = iprot.readI64();
14327 
        else:
14328 
          iprot.skip(ftype)
14329 
      else:
14330 
        iprot.skip(ftype)
14331 
      iprot.readFieldEnd()
14332 
    iprot.readStructEnd()
14333 
 
14334 
  def write(self, oprot):
14335 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14336 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14337 
      return
14338 
    oprot.writeStructBegin('generateNewEntityID_result')
14339 
    if self.success is not None:
14340 
      oprot.writeFieldBegin('success', TType.I64, 0)
14341 
      oprot.writeI64(self.success)
14342 
      oprot.writeFieldEnd()
14343 
    oprot.writeFieldStop()
14344 
    oprot.writeStructEnd()
14345 
 
14346 
  def validate(self):
14347 
    return
14348 
 
14349 
 
14350 
  def __repr__(self):
14351 
    L = ['%s=%r' % (key, value)
14352 
      for key, value in self.__dict__.iteritems()]
14353 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14354 
 
14355 
  def __eq__(self, other):
14356 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14357 
 
14358 
  def __ne__(self, other):
14359 
    return not (self == other)
14360 
 
14361 
class addCategory_args:
14362 
  """
14363 
  Attributes:
14364 
   - category
14365 
  """
14366 
 
14367 
  thrift_spec = (
14368 
    None, # 0
14369 
    (1, TType.STRUCT, 'category', (Category, Category.thrift_spec), None, ), # 1
14370 
  )
14371 
 
14372 
  def __init__(self, category=None,):
14373 
    self.category = category
14374 
 
14375 
  def read(self, iprot):
14376 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14377 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14378 
      return
14379 
    iprot.readStructBegin()
14380 
    while True:
14381 
      (fname, ftype, fid) = iprot.readFieldBegin()
14382 
      if ftype == TType.STOP:
14383 
        break
14384 
      if fid == 1:
14385 
        if ftype == TType.STRUCT:
14386 
          self.category = Category()
14387 
          self.category.read(iprot)
14388 
        else:
14389 
          iprot.skip(ftype)
14390 
      else:
14391 
        iprot.skip(ftype)
14392 
      iprot.readFieldEnd()
14393 
    iprot.readStructEnd()
14394 
 
14395 
  def write(self, oprot):
14396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14398 
      return
14399 
    oprot.writeStructBegin('addCategory_args')
14400 
    if self.category is not None:
14401 
      oprot.writeFieldBegin('category', TType.STRUCT, 1)
14402 
      self.category.write(oprot)
14403 
      oprot.writeFieldEnd()
14404 
    oprot.writeFieldStop()
14405 
    oprot.writeStructEnd()
14406 
 
14407 
  def validate(self):
14408 
    return
14409 
 
14410 
 
14411 
  def __repr__(self):
14412 
    L = ['%s=%r' % (key, value)
14413 
      for key, value in self.__dict__.iteritems()]
14414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14415 
 
14416 
  def __eq__(self, other):
14417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14418 
 
14419 
  def __ne__(self, other):
14420 
    return not (self == other)
14421 
 
14422 
class addCategory_result:
14423 
  """
14424 
  Attributes:
14425 
   - success
14426 
  """
14427 
 
14428 
  thrift_spec = (
14429 
    (0, TType.BOOL, 'success', None, None, ), # 0
14430 
  )
14431 
 
14432 
  def __init__(self, success=None,):
14433 
    self.success = success
14434 
 
14435 
  def read(self, iprot):
14436 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14437 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14438 
      return
14439 
    iprot.readStructBegin()
14440 
    while True:
14441 
      (fname, ftype, fid) = iprot.readFieldBegin()
14442 
      if ftype == TType.STOP:
14443 
        break
14444 
      if fid == 0:
14445 
        if ftype == TType.BOOL:
14446 
          self.success = iprot.readBool();
14447 
        else:
14448 
          iprot.skip(ftype)
14449 
      else:
14450 
        iprot.skip(ftype)
14451 
      iprot.readFieldEnd()
14452 
    iprot.readStructEnd()
14453 
 
14454 
  def write(self, oprot):
14455 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14456 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14457 
      return
14458 
    oprot.writeStructBegin('addCategory_result')
14459 
    if self.success is not None:
14460 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14461 
      oprot.writeBool(self.success)
14462 
      oprot.writeFieldEnd()
14463 
    oprot.writeFieldStop()
14464 
    oprot.writeStructEnd()
14465 
 
14466 
  def validate(self):
14467 
    return
14468 
 
14469 
 
14470 
  def __repr__(self):
14471 
    L = ['%s=%r' % (key, value)
14472 
      for key, value in self.__dict__.iteritems()]
14473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14474 
 
14475 
  def __eq__(self, other):
14476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14477 
 
14478 
  def __ne__(self, other):
14479 
    return not (self == other)
14480 
 
14481 
class getCategory_args:
14482 
  """
14483 
  Attributes:
14484 
   - id
14485 
  """
14486 
 
14487 
  thrift_spec = (
14488 
    None, # 0
14489 
    (1, TType.I64, 'id', None, None, ), # 1
14490 
  )
14491 
 
14492 
  def __init__(self, id=None,):
14493 
    self.id = id
14494 
 
14495 
  def read(self, iprot):
14496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14498 
      return
14499 
    iprot.readStructBegin()
14500 
    while True:
14501 
      (fname, ftype, fid) = iprot.readFieldBegin()
14502 
      if ftype == TType.STOP:
14503 
        break
14504 
      if fid == 1:
14505 
        if ftype == TType.I64:
14506 
          self.id = iprot.readI64();
14507 
        else:
14508 
          iprot.skip(ftype)
14509 
      else:
14510 
        iprot.skip(ftype)
14511 
      iprot.readFieldEnd()
14512 
    iprot.readStructEnd()
14513 
 
14514 
  def write(self, oprot):
14515 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14516 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14517 
      return
14518 
    oprot.writeStructBegin('getCategory_args')
14519 
    if self.id is not None:
14520 
      oprot.writeFieldBegin('id', TType.I64, 1)
14521 
      oprot.writeI64(self.id)
14522 
      oprot.writeFieldEnd()
14523 
    oprot.writeFieldStop()
14524 
    oprot.writeStructEnd()
14525 
 
14526 
  def validate(self):
14527 
    return
14528 
 
14529 
 
14530 
  def __repr__(self):
14531 
    L = ['%s=%r' % (key, value)
14532 
      for key, value in self.__dict__.iteritems()]
14533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14534 
 
14535 
  def __eq__(self, other):
14536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14537 
 
14538 
  def __ne__(self, other):
14539 
    return not (self == other)
14540 
 
14541 
class getCategory_result:
14542 
  """
14543 
  Attributes:
14544 
   - success
14545 
  """
14546 
 
14547 
  thrift_spec = (
14548 
    (0, TType.STRUCT, 'success', (Category, Category.thrift_spec), None, ), # 0
14549 
  )
14550 
 
14551 
  def __init__(self, success=None,):
14552 
    self.success = success
14553 
 
14554 
  def read(self, iprot):
14555 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14556 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14557 
      return
14558 
    iprot.readStructBegin()
14559 
    while True:
14560 
      (fname, ftype, fid) = iprot.readFieldBegin()
14561 
      if ftype == TType.STOP:
14562 
        break
14563 
      if fid == 0:
14564 
        if ftype == TType.STRUCT:
14565 
          self.success = Category()
14566 
          self.success.read(iprot)
14567 
        else:
14568 
          iprot.skip(ftype)
14569 
      else:
14570 
        iprot.skip(ftype)
14571 
      iprot.readFieldEnd()
14572 
    iprot.readStructEnd()
14573 
 
14574 
  def write(self, oprot):
14575 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14576 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14577 
      return
14578 
    oprot.writeStructBegin('getCategory_result')
14579 
    if self.success is not None:
14580 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14581 
      self.success.write(oprot)
14582 
      oprot.writeFieldEnd()
14583 
    oprot.writeFieldStop()
14584 
    oprot.writeStructEnd()
14585 
 
14586 
  def validate(self):
14587 
    return
14588 
 
14589 
 
14590 
  def __repr__(self):
14591 
    L = ['%s=%r' % (key, value)
14592 
      for key, value in self.__dict__.iteritems()]
14593 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14594 
 
14595 
  def __eq__(self, other):
14596 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14597 
 
14598 
  def __ne__(self, other):
14599 
    return not (self == other)
14600 
 
14601 
class getAllCategories_args:
14602 
 
14603 
  thrift_spec = (
14604 
  )
14605 
 
14606 
  def read(self, iprot):
14607 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14608 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14609 
      return
14610 
    iprot.readStructBegin()
14611 
    while True:
14612 
      (fname, ftype, fid) = iprot.readFieldBegin()
14613 
      if ftype == TType.STOP:
14614 
        break
14615 
      else:
14616 
        iprot.skip(ftype)
14617 
      iprot.readFieldEnd()
14618 
    iprot.readStructEnd()
14619 
 
14620 
  def write(self, oprot):
14621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14623 
      return
14624 
    oprot.writeStructBegin('getAllCategories_args')
14625 
    oprot.writeFieldStop()
14626 
    oprot.writeStructEnd()
14627 
 
14628 
  def validate(self):
14629 
    return
14630 
 
14631 
 
14632 
  def __repr__(self):
14633 
    L = ['%s=%r' % (key, value)
14634 
      for key, value in self.__dict__.iteritems()]
14635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14636 
 
14637 
  def __eq__(self, other):
14638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14639 
 
14640 
  def __ne__(self, other):
14641 
    return not (self == other)
14642 
 
14643 
class getAllCategories_result:
14644 
  """
14645 
  Attributes:
14646 
   - success
14647 
  """
14648 
 
14649 
  thrift_spec = (
14650 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
14651 
  )
14652 
 
14653 
  def __init__(self, success=None,):
14654 
    self.success = success
14655 
 
14656 
  def read(self, iprot):
14657 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14658 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14659 
      return
14660 
    iprot.readStructBegin()
14661 
    while True:
14662 
      (fname, ftype, fid) = iprot.readFieldBegin()
14663 
      if ftype == TType.STOP:
14664 
        break
14665 
      if fid == 0:
14666 
        if ftype == TType.LIST:
14667 
          self.success = []
18719 kshitij.so 14668 
          (_etype188, _size185) = iprot.readListBegin()
14669 
          for _i189 in xrange(_size185):
14670 
            _elem190 = Category()
14671 
            _elem190.read(iprot)
14672 
            self.success.append(_elem190)
5944 mandeep.dh 14673 
          iprot.readListEnd()
14674 
        else:
14675 
          iprot.skip(ftype)
14676 
      else:
14677 
        iprot.skip(ftype)
14678 
      iprot.readFieldEnd()
14679 
    iprot.readStructEnd()
14680 
 
14681 
  def write(self, oprot):
14682 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14683 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14684 
      return
14685 
    oprot.writeStructBegin('getAllCategories_result')
14686 
    if self.success is not None:
14687 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14688 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 14689 
      for iter191 in self.success:
14690 
        iter191.write(oprot)
5944 mandeep.dh 14691 
      oprot.writeListEnd()
14692 
      oprot.writeFieldEnd()
14693 
    oprot.writeFieldStop()
14694 
    oprot.writeStructEnd()
14695 
 
14696 
  def validate(self):
14697 
    return
14698 
 
14699 
 
14700 
  def __repr__(self):
14701 
    L = ['%s=%r' % (key, value)
14702 
      for key, value in self.__dict__.iteritems()]
14703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14704 
 
14705 
  def __eq__(self, other):
14706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14707 
 
14708 
  def __ne__(self, other):
14709 
    return not (self == other)
14710 
 
14711 
class getAllSimilarItems_args:
14712 
  """
14713 
  Attributes:
14714 
   - itemId
14715 
  """
14716 
 
14717 
  thrift_spec = (
14718 
    None, # 0
14719 
    (1, TType.I64, 'itemId', None, None, ), # 1
14720 
  )
14721 
 
14722 
  def __init__(self, itemId=None,):
14723 
    self.itemId = itemId
14724 
 
14725 
  def read(self, iprot):
14726 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14727 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14728 
      return
14729 
    iprot.readStructBegin()
14730 
    while True:
14731 
      (fname, ftype, fid) = iprot.readFieldBegin()
14732 
      if ftype == TType.STOP:
14733 
        break
14734 
      if fid == 1:
14735 
        if ftype == TType.I64:
14736 
          self.itemId = iprot.readI64();
14737 
        else:
14738 
          iprot.skip(ftype)
14739 
      else:
14740 
        iprot.skip(ftype)
14741 
      iprot.readFieldEnd()
14742 
    iprot.readStructEnd()
14743 
 
14744 
  def write(self, oprot):
14745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14747 
      return
14748 
    oprot.writeStructBegin('getAllSimilarItems_args')
14749 
    if self.itemId is not None:
14750 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14751 
      oprot.writeI64(self.itemId)
14752 
      oprot.writeFieldEnd()
14753 
    oprot.writeFieldStop()
14754 
    oprot.writeStructEnd()
14755 
 
14756 
  def validate(self):
14757 
    return
14758 
 
14759 
 
14760 
  def __repr__(self):
14761 
    L = ['%s=%r' % (key, value)
14762 
      for key, value in self.__dict__.iteritems()]
14763 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14764 
 
14765 
  def __eq__(self, other):
14766 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14767 
 
14768 
  def __ne__(self, other):
14769 
    return not (self == other)
14770 
 
14771 
class getAllSimilarItems_result:
14772 
  """
14773 
  Attributes:
14774 
   - success
14775 
  """
14776 
 
14777 
  thrift_spec = (
14778 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
14779 
  )
14780 
 
14781 
  def __init__(self, success=None,):
14782 
    self.success = success
14783 
 
14784 
  def read(self, iprot):
14785 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14786 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14787 
      return
14788 
    iprot.readStructBegin()
14789 
    while True:
14790 
      (fname, ftype, fid) = iprot.readFieldBegin()
14791 
      if ftype == TType.STOP:
14792 
        break
14793 
      if fid == 0:
14794 
        if ftype == TType.LIST:
14795 
          self.success = []
18719 kshitij.so 14796 
          (_etype195, _size192) = iprot.readListBegin()
14797 
          for _i196 in xrange(_size192):
14798 
            _elem197 = Item()
14799 
            _elem197.read(iprot)
14800 
            self.success.append(_elem197)
5944 mandeep.dh 14801 
          iprot.readListEnd()
14802 
        else:
14803 
          iprot.skip(ftype)
14804 
      else:
14805 
        iprot.skip(ftype)
14806 
      iprot.readFieldEnd()
14807 
    iprot.readStructEnd()
14808 
 
14809 
  def write(self, oprot):
14810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14812 
      return
14813 
    oprot.writeStructBegin('getAllSimilarItems_result')
14814 
    if self.success is not None:
14815 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14816 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 14817 
      for iter198 in self.success:
14818 
        iter198.write(oprot)
5944 mandeep.dh 14819 
      oprot.writeListEnd()
14820 
      oprot.writeFieldEnd()
14821 
    oprot.writeFieldStop()
14822 
    oprot.writeStructEnd()
14823 
 
14824 
  def validate(self):
14825 
    return
14826 
 
14827 
 
14828 
  def __repr__(self):
14829 
    L = ['%s=%r' % (key, value)
14830 
      for key, value in self.__dict__.iteritems()]
14831 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14832 
 
14833 
  def __eq__(self, other):
14834 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14835 
 
14836 
  def __ne__(self, other):
14837 
    return not (self == other)
14838 
 
14839 
class addSimilarItem_args:
14840 
  """
14841 
  Attributes:
14842 
   - itemId
14843 
   - catalogItemId
14844 
  """
14845 
 
14846 
  thrift_spec = (
14847 
    None, # 0
14848 
    (1, TType.I64, 'itemId', None, None, ), # 1
14849 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
14850 
  )
14851 
 
14852 
  def __init__(self, itemId=None, catalogItemId=None,):
14853 
    self.itemId = itemId
14854 
    self.catalogItemId = catalogItemId
14855 
 
14856 
  def read(self, iprot):
14857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14859 
      return
14860 
    iprot.readStructBegin()
14861 
    while True:
14862 
      (fname, ftype, fid) = iprot.readFieldBegin()
14863 
      if ftype == TType.STOP:
14864 
        break
14865 
      if fid == 1:
14866 
        if ftype == TType.I64:
14867 
          self.itemId = iprot.readI64();
14868 
        else:
14869 
          iprot.skip(ftype)
14870 
      elif fid == 2:
14871 
        if ftype == TType.I64:
14872 
          self.catalogItemId = iprot.readI64();
14873 
        else:
14874 
          iprot.skip(ftype)
14875 
      else:
14876 
        iprot.skip(ftype)
14877 
      iprot.readFieldEnd()
14878 
    iprot.readStructEnd()
14879 
 
14880 
  def write(self, oprot):
14881 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14882 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14883 
      return
14884 
    oprot.writeStructBegin('addSimilarItem_args')
14885 
    if self.itemId is not None:
14886 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14887 
      oprot.writeI64(self.itemId)
14888 
      oprot.writeFieldEnd()
14889 
    if self.catalogItemId is not None:
14890 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
14891 
      oprot.writeI64(self.catalogItemId)
14892 
      oprot.writeFieldEnd()
14893 
    oprot.writeFieldStop()
14894 
    oprot.writeStructEnd()
14895 
 
14896 
  def validate(self):
14897 
    return
14898 
 
14899 
 
14900 
  def __repr__(self):
14901 
    L = ['%s=%r' % (key, value)
14902 
      for key, value in self.__dict__.iteritems()]
14903 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14904 
 
14905 
  def __eq__(self, other):
14906 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14907 
 
14908 
  def __ne__(self, other):
14909 
    return not (self == other)
14910 
 
14911 
class addSimilarItem_result:
14912 
  """
14913 
  Attributes:
14914 
   - success
14915 
   - cex
14916 
  """
14917 
 
14918 
  thrift_spec = (
14919 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
14920 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14921 
  )
14922 
 
14923 
  def __init__(self, success=None, cex=None,):
14924 
    self.success = success
14925 
    self.cex = cex
14926 
 
14927 
  def read(self, iprot):
14928 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14929 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14930 
      return
14931 
    iprot.readStructBegin()
14932 
    while True:
14933 
      (fname, ftype, fid) = iprot.readFieldBegin()
14934 
      if ftype == TType.STOP:
14935 
        break
14936 
      if fid == 0:
14937 
        if ftype == TType.STRUCT:
14938 
          self.success = Item()
14939 
          self.success.read(iprot)
14940 
        else:
14941 
          iprot.skip(ftype)
14942 
      elif fid == 1:
14943 
        if ftype == TType.STRUCT:
14944 
          self.cex = CatalogServiceException()
14945 
          self.cex.read(iprot)
14946 
        else:
14947 
          iprot.skip(ftype)
14948 
      else:
14949 
        iprot.skip(ftype)
14950 
      iprot.readFieldEnd()
14951 
    iprot.readStructEnd()
14952 
 
14953 
  def write(self, oprot):
14954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14956 
      return
14957 
    oprot.writeStructBegin('addSimilarItem_result')
14958 
    if self.success is not None:
14959 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14960 
      self.success.write(oprot)
14961 
      oprot.writeFieldEnd()
14962 
    if self.cex is not None:
14963 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14964 
      self.cex.write(oprot)
14965 
      oprot.writeFieldEnd()
14966 
    oprot.writeFieldStop()
14967 
    oprot.writeStructEnd()
14968 
 
14969 
  def validate(self):
14970 
    return
14971 
 
14972 
 
14973 
  def __repr__(self):
14974 
    L = ['%s=%r' % (key, value)
14975 
      for key, value in self.__dict__.iteritems()]
14976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14977 
 
14978 
  def __eq__(self, other):
14979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14980 
 
14981 
  def __ne__(self, other):
14982 
    return not (self == other)
14983 
 
6512 kshitij.so 14984 
class addTag_args:
14985 
  """
14986 
  Attributes:
14987 
   - displayName
14988 
   - itemId
14989 
  """
14990 
 
14991 
  thrift_spec = (
14992 
    None, # 0
14993 
    (1, TType.STRING, 'displayName', None, None, ), # 1
14994 
    (2, TType.I64, 'itemId', None, None, ), # 2
14995 
  )
14996 
 
14997 
  def __init__(self, displayName=None, itemId=None,):
14998 
    self.displayName = displayName
14999 
    self.itemId = itemId
15000 
 
15001 
  def read(self, iprot):
15002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15004 
      return
15005 
    iprot.readStructBegin()
15006 
    while True:
15007 
      (fname, ftype, fid) = iprot.readFieldBegin()
15008 
      if ftype == TType.STOP:
15009 
        break
15010 
      if fid == 1:
15011 
        if ftype == TType.STRING:
15012 
          self.displayName = iprot.readString();
15013 
        else:
15014 
          iprot.skip(ftype)
15015 
      elif fid == 2:
15016 
        if ftype == TType.I64:
15017 
          self.itemId = iprot.readI64();
15018 
        else:
15019 
          iprot.skip(ftype)
15020 
      else:
15021 
        iprot.skip(ftype)
15022 
      iprot.readFieldEnd()
15023 
    iprot.readStructEnd()
15024 
 
15025 
  def write(self, oprot):
15026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15028 
      return
15029 
    oprot.writeStructBegin('addTag_args')
15030 
    if self.displayName is not None:
15031 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
15032 
      oprot.writeString(self.displayName)
15033 
      oprot.writeFieldEnd()
15034 
    if self.itemId is not None:
15035 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
15036 
      oprot.writeI64(self.itemId)
15037 
      oprot.writeFieldEnd()
15038 
    oprot.writeFieldStop()
15039 
    oprot.writeStructEnd()
15040 
 
15041 
  def validate(self):
15042 
    return
15043 
 
15044 
 
15045 
  def __repr__(self):
15046 
    L = ['%s=%r' % (key, value)
15047 
      for key, value in self.__dict__.iteritems()]
15048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15049 
 
15050 
  def __eq__(self, other):
15051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15052 
 
15053 
  def __ne__(self, other):
15054 
    return not (self == other)
15055 
 
15056 
class addTag_result:
15057 
  """
15058 
  Attributes:
15059 
   - success
15060 
  """
15061 
 
15062 
  thrift_spec = (
15063 
    (0, TType.BOOL, 'success', None, None, ), # 0
15064 
  )
15065 
 
15066 
  def __init__(self, success=None,):
15067 
    self.success = success
15068 
 
15069 
  def read(self, iprot):
15070 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15071 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15072 
      return
15073 
    iprot.readStructBegin()
15074 
    while True:
15075 
      (fname, ftype, fid) = iprot.readFieldBegin()
15076 
      if ftype == TType.STOP:
15077 
        break
15078 
      if fid == 0:
15079 
        if ftype == TType.BOOL:
15080 
          self.success = iprot.readBool();
15081 
        else:
15082 
          iprot.skip(ftype)
15083 
      else:
15084 
        iprot.skip(ftype)
15085 
      iprot.readFieldEnd()
15086 
    iprot.readStructEnd()
15087 
 
15088 
  def write(self, oprot):
15089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15091 
      return
15092 
    oprot.writeStructBegin('addTag_result')
15093 
    if self.success is not None:
15094 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15095 
      oprot.writeBool(self.success)
15096 
      oprot.writeFieldEnd()
15097 
    oprot.writeFieldStop()
15098 
    oprot.writeStructEnd()
15099 
 
15100 
  def validate(self):
15101 
    return
15102 
 
15103 
 
15104 
  def __repr__(self):
15105 
    L = ['%s=%r' % (key, value)
15106 
      for key, value in self.__dict__.iteritems()]
15107 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15108 
 
15109 
  def __eq__(self, other):
15110 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15111 
 
15112 
  def __ne__(self, other):
15113 
    return not (self == other)
15114 
 
15115 
class deleteEntityTag_args:
15116 
  """
15117 
  Attributes:
15118 
   - displayName
15119 
   - itemId
15120 
  """
15121 
 
15122 
  thrift_spec = (
15123 
    None, # 0
15124 
    (1, TType.STRING, 'displayName', None, None, ), # 1
15125 
    (2, TType.I64, 'itemId', None, None, ), # 2
15126 
  )
15127 
 
15128 
  def __init__(self, displayName=None, itemId=None,):
15129 
    self.displayName = displayName
15130 
    self.itemId = itemId
15131 
 
15132 
  def read(self, iprot):
15133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15135 
      return
15136 
    iprot.readStructBegin()
15137 
    while True:
15138 
      (fname, ftype, fid) = iprot.readFieldBegin()
15139 
      if ftype == TType.STOP:
15140 
        break
15141 
      if fid == 1:
15142 
        if ftype == TType.STRING:
15143 
          self.displayName = iprot.readString();
15144 
        else:
15145 
          iprot.skip(ftype)
15146 
      elif fid == 2:
15147 
        if ftype == TType.I64:
15148 
          self.itemId = iprot.readI64();
15149 
        else:
15150 
          iprot.skip(ftype)
15151 
      else:
15152 
        iprot.skip(ftype)
15153 
      iprot.readFieldEnd()
15154 
    iprot.readStructEnd()
15155 
 
15156 
  def write(self, oprot):
15157 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15158 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15159 
      return
15160 
    oprot.writeStructBegin('deleteEntityTag_args')
15161 
    if self.displayName is not None:
15162 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
15163 
      oprot.writeString(self.displayName)
15164 
      oprot.writeFieldEnd()
15165 
    if self.itemId is not None:
15166 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
15167 
      oprot.writeI64(self.itemId)
15168 
      oprot.writeFieldEnd()
15169 
    oprot.writeFieldStop()
15170 
    oprot.writeStructEnd()
15171 
 
15172 
  def validate(self):
15173 
    return
15174 
 
15175 
 
15176 
  def __repr__(self):
15177 
    L = ['%s=%r' % (key, value)
15178 
      for key, value in self.__dict__.iteritems()]
15179 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15180 
 
15181 
  def __eq__(self, other):
15182 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15183 
 
15184 
  def __ne__(self, other):
15185 
    return not (self == other)
15186 
 
15187 
class deleteEntityTag_result:
15188 
  """
15189 
  Attributes:
15190 
   - success
15191 
  """
15192 
 
15193 
  thrift_spec = (
15194 
    (0, TType.BOOL, 'success', None, None, ), # 0
15195 
  )
15196 
 
15197 
  def __init__(self, success=None,):
15198 
    self.success = success
15199 
 
15200 
  def read(self, iprot):
15201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15203 
      return
15204 
    iprot.readStructBegin()
15205 
    while True:
15206 
      (fname, ftype, fid) = iprot.readFieldBegin()
15207 
      if ftype == TType.STOP:
15208 
        break
15209 
      if fid == 0:
15210 
        if ftype == TType.BOOL:
15211 
          self.success = iprot.readBool();
15212 
        else:
15213 
          iprot.skip(ftype)
15214 
      else:
15215 
        iprot.skip(ftype)
15216 
      iprot.readFieldEnd()
15217 
    iprot.readStructEnd()
15218 
 
15219 
  def write(self, oprot):
15220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15222 
      return
15223 
    oprot.writeStructBegin('deleteEntityTag_result')
15224 
    if self.success is not None:
15225 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15226 
      oprot.writeBool(self.success)
15227 
      oprot.writeFieldEnd()
15228 
    oprot.writeFieldStop()
15229 
    oprot.writeStructEnd()
15230 
 
15231 
  def validate(self):
15232 
    return
15233 
 
15234 
 
15235 
  def __repr__(self):
15236 
    L = ['%s=%r' % (key, value)
15237 
      for key, value in self.__dict__.iteritems()]
15238 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15239 
 
15240 
  def __eq__(self, other):
15241 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15242 
 
15243 
  def __ne__(self, other):
15244 
    return not (self == other)
15245 
 
15246 
class deleteTag_args:
15247 
  """
15248 
  Attributes:
15249 
   - displayName
15250 
  """
15251 
 
15252 
  thrift_spec = (
15253 
    None, # 0
15254 
    (1, TType.STRING, 'displayName', None, None, ), # 1
15255 
  )
15256 
 
15257 
  def __init__(self, displayName=None,):
15258 
    self.displayName = displayName
15259 
 
15260 
  def read(self, iprot):
15261 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15262 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15263 
      return
15264 
    iprot.readStructBegin()
15265 
    while True:
15266 
      (fname, ftype, fid) = iprot.readFieldBegin()
15267 
      if ftype == TType.STOP:
15268 
        break
15269 
      if fid == 1:
15270 
        if ftype == TType.STRING:
15271 
          self.displayName = iprot.readString();
15272 
        else:
15273 
          iprot.skip(ftype)
15274 
      else:
15275 
        iprot.skip(ftype)
15276 
      iprot.readFieldEnd()
15277 
    iprot.readStructEnd()
15278 
 
15279 
  def write(self, oprot):
15280 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15281 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15282 
      return
15283 
    oprot.writeStructBegin('deleteTag_args')
15284 
    if self.displayName is not None:
15285 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
15286 
      oprot.writeString(self.displayName)
15287 
      oprot.writeFieldEnd()
15288 
    oprot.writeFieldStop()
15289 
    oprot.writeStructEnd()
15290 
 
15291 
  def validate(self):
15292 
    return
15293 
 
15294 
 
15295 
  def __repr__(self):
15296 
    L = ['%s=%r' % (key, value)
15297 
      for key, value in self.__dict__.iteritems()]
15298 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15299 
 
15300 
  def __eq__(self, other):
15301 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15302 
 
15303 
  def __ne__(self, other):
15304 
    return not (self == other)
15305 
 
15306 
class deleteTag_result:
15307 
  """
15308 
  Attributes:
15309 
   - success
15310 
  """
15311 
 
15312 
  thrift_spec = (
15313 
    (0, TType.BOOL, 'success', None, None, ), # 0
15314 
  )
15315 
 
15316 
  def __init__(self, success=None,):
15317 
    self.success = success
15318 
 
15319 
  def read(self, iprot):
15320 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15321 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15322 
      return
15323 
    iprot.readStructBegin()
15324 
    while True:
15325 
      (fname, ftype, fid) = iprot.readFieldBegin()
15326 
      if ftype == TType.STOP:
15327 
        break
15328 
      if fid == 0:
15329 
        if ftype == TType.BOOL:
15330 
          self.success = iprot.readBool();
15331 
        else:
15332 
          iprot.skip(ftype)
15333 
      else:
15334 
        iprot.skip(ftype)
15335 
      iprot.readFieldEnd()
15336 
    iprot.readStructEnd()
15337 
 
15338 
  def write(self, oprot):
15339 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15340 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15341 
      return
15342 
    oprot.writeStructBegin('deleteTag_result')
15343 
    if self.success is not None:
15344 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15345 
      oprot.writeBool(self.success)
15346 
      oprot.writeFieldEnd()
15347 
    oprot.writeFieldStop()
15348 
    oprot.writeStructEnd()
15349 
 
15350 
  def validate(self):
15351 
    return
15352 
 
15353 
 
15354 
  def __repr__(self):
15355 
    L = ['%s=%r' % (key, value)
15356 
      for key, value in self.__dict__.iteritems()]
15357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15358 
 
15359 
  def __eq__(self, other):
15360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15361 
 
15362 
  def __ne__(self, other):
15363 
    return not (self == other)
15364 
 
15365 
class getAllTags_args:
15366 
 
15367 
  thrift_spec = (
15368 
  )
15369 
 
15370 
  def read(self, iprot):
15371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15373 
      return
15374 
    iprot.readStructBegin()
15375 
    while True:
15376 
      (fname, ftype, fid) = iprot.readFieldBegin()
15377 
      if ftype == TType.STOP:
15378 
        break
15379 
      else:
15380 
        iprot.skip(ftype)
15381 
      iprot.readFieldEnd()
15382 
    iprot.readStructEnd()
15383 
 
15384 
  def write(self, oprot):
15385 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15386 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15387 
      return
15388 
    oprot.writeStructBegin('getAllTags_args')
15389 
    oprot.writeFieldStop()
15390 
    oprot.writeStructEnd()
15391 
 
15392 
  def validate(self):
15393 
    return
15394 
 
15395 
 
15396 
  def __repr__(self):
15397 
    L = ['%s=%r' % (key, value)
15398 
      for key, value in self.__dict__.iteritems()]
15399 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15400 
 
15401 
  def __eq__(self, other):
15402 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15403 
 
15404 
  def __ne__(self, other):
15405 
    return not (self == other)
15406 
 
15407 
class getAllTags_result:
15408 
  """
15409 
  Attributes:
15410 
   - success
15411 
  """
15412 
 
15413 
  thrift_spec = (
15414 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
15415 
  )
15416 
 
15417 
  def __init__(self, success=None,):
15418 
    self.success = success
15419 
 
15420 
  def read(self, iprot):
15421 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15422 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15423 
      return
15424 
    iprot.readStructBegin()
15425 
    while True:
15426 
      (fname, ftype, fid) = iprot.readFieldBegin()
15427 
      if ftype == TType.STOP:
15428 
        break
15429 
      if fid == 0:
15430 
        if ftype == TType.LIST:
15431 
          self.success = []
18719 kshitij.so 15432 
          (_etype202, _size199) = iprot.readListBegin()
15433 
          for _i203 in xrange(_size199):
15434 
            _elem204 = iprot.readString();
15435 
            self.success.append(_elem204)
6512 kshitij.so 15436 
          iprot.readListEnd()
15437 
        else:
15438 
          iprot.skip(ftype)
15439 
      else:
15440 
        iprot.skip(ftype)
15441 
      iprot.readFieldEnd()
15442 
    iprot.readStructEnd()
15443 
 
15444 
  def write(self, oprot):
15445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15447 
      return
15448 
    oprot.writeStructBegin('getAllTags_result')
15449 
    if self.success is not None:
15450 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15451 
      oprot.writeListBegin(TType.STRING, len(self.success))
18719 kshitij.so 15452 
      for iter205 in self.success:
15453 
        oprot.writeString(iter205)
6512 kshitij.so 15454 
      oprot.writeListEnd()
15455 
      oprot.writeFieldEnd()
15456 
    oprot.writeFieldStop()
15457 
    oprot.writeStructEnd()
15458 
 
15459 
  def validate(self):
15460 
    return
15461 
 
15462 
 
15463 
  def __repr__(self):
15464 
    L = ['%s=%r' % (key, value)
15465 
      for key, value in self.__dict__.iteritems()]
15466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15467 
 
15468 
  def __eq__(self, other):
15469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15470 
 
15471 
  def __ne__(self, other):
15472 
    return not (self == other)
15473 
 
15474 
class getAllEntitiesByTagName_args:
15475 
  """
15476 
  Attributes:
15477 
   - displayName
15478 
  """
15479 
 
15480 
  thrift_spec = (
15481 
    None, # 0
15482 
    (1, TType.STRING, 'displayName', None, None, ), # 1
15483 
  )
15484 
 
15485 
  def __init__(self, displayName=None,):
15486 
    self.displayName = displayName
15487 
 
15488 
  def read(self, iprot):
15489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15491 
      return
15492 
    iprot.readStructBegin()
15493 
    while True:
15494 
      (fname, ftype, fid) = iprot.readFieldBegin()
15495 
      if ftype == TType.STOP:
15496 
        break
15497 
      if fid == 1:
15498 
        if ftype == TType.STRING:
15499 
          self.displayName = iprot.readString();
15500 
        else:
15501 
          iprot.skip(ftype)
15502 
      else:
15503 
        iprot.skip(ftype)
15504 
      iprot.readFieldEnd()
15505 
    iprot.readStructEnd()
15506 
 
15507 
  def write(self, oprot):
15508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15510 
      return
15511 
    oprot.writeStructBegin('getAllEntitiesByTagName_args')
15512 
    if self.displayName is not None:
15513 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
15514 
      oprot.writeString(self.displayName)
15515 
      oprot.writeFieldEnd()
15516 
    oprot.writeFieldStop()
15517 
    oprot.writeStructEnd()
15518 
 
15519 
  def validate(self):
15520 
    return
15521 
 
15522 
 
15523 
  def __repr__(self):
15524 
    L = ['%s=%r' % (key, value)
15525 
      for key, value in self.__dict__.iteritems()]
15526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15527 
 
15528 
  def __eq__(self, other):
15529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15530 
 
15531 
  def __ne__(self, other):
15532 
    return not (self == other)
15533 
 
15534 
class getAllEntitiesByTagName_result:
15535 
  """
15536 
  Attributes:
15537 
   - success
15538 
  """
15539 
 
15540 
  thrift_spec = (
15541 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
15542 
  )
15543 
 
15544 
  def __init__(self, success=None,):
15545 
    self.success = success
15546 
 
15547 
  def read(self, iprot):
15548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15550 
      return
15551 
    iprot.readStructBegin()
15552 
    while True:
15553 
      (fname, ftype, fid) = iprot.readFieldBegin()
15554 
      if ftype == TType.STOP:
15555 
        break
15556 
      if fid == 0:
15557 
        if ftype == TType.LIST:
15558 
          self.success = []
18719 kshitij.so 15559 
          (_etype209, _size206) = iprot.readListBegin()
15560 
          for _i210 in xrange(_size206):
15561 
            _elem211 = iprot.readI64();
15562 
            self.success.append(_elem211)
6512 kshitij.so 15563 
          iprot.readListEnd()
15564 
        else:
15565 
          iprot.skip(ftype)
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('getAllEntitiesByTagName_result')
15576 
    if self.success is not None:
15577 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15578 
      oprot.writeListBegin(TType.I64, len(self.success))
18719 kshitij.so 15579 
      for iter212 in self.success:
15580 
        oprot.writeI64(iter212)
6512 kshitij.so 15581 
      oprot.writeListEnd()
15582 
      oprot.writeFieldEnd()
15583 
    oprot.writeFieldStop()
15584 
    oprot.writeStructEnd()
15585 
 
15586 
  def validate(self):
15587 
    return
15588 
 
15589 
 
15590 
  def __repr__(self):
15591 
    L = ['%s=%r' % (key, value)
15592 
      for key, value in self.__dict__.iteritems()]
15593 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15594 
 
15595 
  def __eq__(self, other):
15596 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15597 
 
15598 
  def __ne__(self, other):
15599 
    return not (self == other)
15600 
 
6845 amit.gupta 15601 
class getAllEntityTags_args:
15602 
 
15603 
  thrift_spec = (
15604 
  )
15605 
 
15606 
  def read(self, iprot):
15607 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15608 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15609 
      return
15610 
    iprot.readStructBegin()
15611 
    while True:
15612 
      (fname, ftype, fid) = iprot.readFieldBegin()
15613 
      if ftype == TType.STOP:
15614 
        break
15615 
      else:
15616 
        iprot.skip(ftype)
15617 
      iprot.readFieldEnd()
15618 
    iprot.readStructEnd()
15619 
 
15620 
  def write(self, oprot):
15621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15623 
      return
15624 
    oprot.writeStructBegin('getAllEntityTags_args')
15625 
    oprot.writeFieldStop()
15626 
    oprot.writeStructEnd()
15627 
 
15628 
  def validate(self):
15629 
    return
15630 
 
15631 
 
15632 
  def __repr__(self):
15633 
    L = ['%s=%r' % (key, value)
15634 
      for key, value in self.__dict__.iteritems()]
15635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15636 
 
15637 
  def __eq__(self, other):
15638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15639 
 
15640 
  def __ne__(self, other):
15641 
    return not (self == other)
15642 
 
15643 
class getAllEntityTags_result:
15644 
  """
15645 
  Attributes:
15646 
   - success
15647 
  """
15648 
 
15649 
  thrift_spec = (
15650 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRING,None)), None, ), # 0
15651 
  )
15652 
 
15653 
  def __init__(self, success=None,):
15654 
    self.success = success
15655 
 
15656 
  def read(self, iprot):
15657 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15658 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15659 
      return
15660 
    iprot.readStructBegin()
15661 
    while True:
15662 
      (fname, ftype, fid) = iprot.readFieldBegin()
15663 
      if ftype == TType.STOP:
15664 
        break
15665 
      if fid == 0:
15666 
        if ftype == TType.MAP:
15667 
          self.success = {}
18719 kshitij.so 15668 
          (_ktype214, _vtype215, _size213 ) = iprot.readMapBegin()
15669 
          for _i217 in xrange(_size213):
15670 
            _key218 = iprot.readI64();
15671 
            _val219 = []
15672 
            (_etype223, _size220) = iprot.readListBegin()
15673 
            for _i224 in xrange(_size220):
15674 
              _elem225 = iprot.readString();
15675 
              _val219.append(_elem225)
6845 amit.gupta 15676 
            iprot.readListEnd()
18719 kshitij.so 15677 
            self.success[_key218] = _val219
6845 amit.gupta 15678 
          iprot.readMapEnd()
15679 
        else:
15680 
          iprot.skip(ftype)
15681 
      else:
15682 
        iprot.skip(ftype)
15683 
      iprot.readFieldEnd()
15684 
    iprot.readStructEnd()
15685 
 
15686 
  def write(self, oprot):
15687 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15688 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15689 
      return
15690 
    oprot.writeStructBegin('getAllEntityTags_result')
15691 
    if self.success is not None:
15692 
      oprot.writeFieldBegin('success', TType.MAP, 0)
15693 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
18719 kshitij.so 15694 
      for kiter226,viter227 in self.success.items():
15695 
        oprot.writeI64(kiter226)
15696 
        oprot.writeListBegin(TType.STRING, len(viter227))
15697 
        for iter228 in viter227:
15698 
          oprot.writeString(iter228)
6845 amit.gupta 15699 
        oprot.writeListEnd()
15700 
      oprot.writeMapEnd()
15701 
      oprot.writeFieldEnd()
15702 
    oprot.writeFieldStop()
15703 
    oprot.writeStructEnd()
15704 
 
15705 
  def validate(self):
15706 
    return
15707 
 
15708 
 
15709 
  def __repr__(self):
15710 
    L = ['%s=%r' % (key, value)
15711 
      for key, value in self.__dict__.iteritems()]
15712 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15713 
 
15714 
  def __eq__(self, other):
15715 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15716 
 
15717 
  def __ne__(self, other):
15718 
    return not (self == other)
15719 
 
6850 kshitij.so 15720 
class addBanner_args:
15721 
  """
15722 
  Attributes:
8590 kshitij.so 15723 
   - bannerCongregate
6850 kshitij.so 15724 
  """
15725 
 
15726 
  thrift_spec = (
15727 
    None, # 0
8590 kshitij.so 15728 
    (1, TType.STRUCT, 'bannerCongregate', (BannerCongregate, BannerCongregate.thrift_spec), None, ), # 1
6850 kshitij.so 15729 
  )
15730 
 
8590 kshitij.so 15731 
  def __init__(self, bannerCongregate=None,):
15732 
    self.bannerCongregate = bannerCongregate
6850 kshitij.so 15733 
 
15734 
  def read(self, iprot):
15735 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15736 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15737 
      return
15738 
    iprot.readStructBegin()
15739 
    while True:
15740 
      (fname, ftype, fid) = iprot.readFieldBegin()
15741 
      if ftype == TType.STOP:
15742 
        break
15743 
      if fid == 1:
8579 kshitij.so 15744 
        if ftype == TType.STRUCT:
8590 kshitij.so 15745 
          self.bannerCongregate = BannerCongregate()
15746 
          self.bannerCongregate.read(iprot)
6850 kshitij.so 15747 
        else:
15748 
          iprot.skip(ftype)
8579 kshitij.so 15749 
      else:
15750 
        iprot.skip(ftype)
15751 
      iprot.readFieldEnd()
15752 
    iprot.readStructEnd()
15753 
 
15754 
  def write(self, oprot):
15755 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15756 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15757 
      return
15758 
    oprot.writeStructBegin('addBanner_args')
8590 kshitij.so 15759 
    if self.bannerCongregate is not None:
15760 
      oprot.writeFieldBegin('bannerCongregate', TType.STRUCT, 1)
15761 
      self.bannerCongregate.write(oprot)
8579 kshitij.so 15762 
      oprot.writeFieldEnd()
15763 
    oprot.writeFieldStop()
15764 
    oprot.writeStructEnd()
15765 
 
15766 
  def validate(self):
15767 
    return
15768 
 
15769 
 
15770 
  def __repr__(self):
15771 
    L = ['%s=%r' % (key, value)
15772 
      for key, value in self.__dict__.iteritems()]
15773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15774 
 
15775 
  def __eq__(self, other):
15776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15777 
 
15778 
  def __ne__(self, other):
15779 
    return not (self == other)
15780 
 
15781 
class addBanner_result:
10097 kshitij.so 15782 
  """
15783 
  Attributes:
15784 
   - success
15785 
  """
8579 kshitij.so 15786 
 
15787 
  thrift_spec = (
10097 kshitij.so 15788 
    (0, TType.BOOL, 'success', None, None, ), # 0
8579 kshitij.so 15789 
  )
15790 
 
10097 kshitij.so 15791 
  def __init__(self, success=None,):
15792 
    self.success = success
15793 
 
8579 kshitij.so 15794 
  def read(self, iprot):
15795 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15796 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15797 
      return
15798 
    iprot.readStructBegin()
15799 
    while True:
15800 
      (fname, ftype, fid) = iprot.readFieldBegin()
15801 
      if ftype == TType.STOP:
15802 
        break
10097 kshitij.so 15803 
      if fid == 0:
15804 
        if ftype == TType.BOOL:
15805 
          self.success = iprot.readBool();
15806 
        else:
15807 
          iprot.skip(ftype)
8579 kshitij.so 15808 
      else:
15809 
        iprot.skip(ftype)
15810 
      iprot.readFieldEnd()
15811 
    iprot.readStructEnd()
15812 
 
15813 
  def write(self, oprot):
15814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15816 
      return
15817 
    oprot.writeStructBegin('addBanner_result')
10097 kshitij.so 15818 
    if self.success is not None:
15819 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15820 
      oprot.writeBool(self.success)
15821 
      oprot.writeFieldEnd()
8579 kshitij.so 15822 
    oprot.writeFieldStop()
15823 
    oprot.writeStructEnd()
15824 
 
15825 
  def validate(self):
15826 
    return
15827 
 
15828 
 
15829 
  def __repr__(self):
15830 
    L = ['%s=%r' % (key, value)
15831 
      for key, value in self.__dict__.iteritems()]
15832 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15833 
 
15834 
  def __eq__(self, other):
15835 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15836 
 
15837 
  def __ne__(self, other):
15838 
    return not (self == other)
15839 
 
15840 
class updateBanner_args:
15841 
  """
15842 
  Attributes:
15843 
   - banner
15844 
  """
15845 
 
15846 
  thrift_spec = (
15847 
    None, # 0
15848 
    (1, TType.STRUCT, 'banner', (Banner, Banner.thrift_spec), None, ), # 1
15849 
  )
15850 
 
15851 
  def __init__(self, banner=None,):
15852 
    self.banner = banner
15853 
 
15854 
  def read(self, iprot):
15855 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15856 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15857 
      return
15858 
    iprot.readStructBegin()
15859 
    while True:
15860 
      (fname, ftype, fid) = iprot.readFieldBegin()
15861 
      if ftype == TType.STOP:
15862 
        break
15863 
      if fid == 1:
15864 
        if ftype == TType.STRUCT:
15865 
          self.banner = Banner()
15866 
          self.banner.read(iprot)
6850 kshitij.so 15867 
        else:
15868 
          iprot.skip(ftype)
15869 
      else:
15870 
        iprot.skip(ftype)
15871 
      iprot.readFieldEnd()
15872 
    iprot.readStructEnd()
15873 
 
15874 
  def write(self, oprot):
15875 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15876 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15877 
      return
8579 kshitij.so 15878 
    oprot.writeStructBegin('updateBanner_args')
15879 
    if self.banner is not None:
15880 
      oprot.writeFieldBegin('banner', TType.STRUCT, 1)
15881 
      self.banner.write(oprot)
6850 kshitij.so 15882 
      oprot.writeFieldEnd()
15883 
    oprot.writeFieldStop()
15884 
    oprot.writeStructEnd()
15885 
 
15886 
  def validate(self):
15887 
    return
15888 
 
15889 
 
15890 
  def __repr__(self):
15891 
    L = ['%s=%r' % (key, value)
15892 
      for key, value in self.__dict__.iteritems()]
15893 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15894 
 
15895 
  def __eq__(self, other):
15896 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15897 
 
15898 
  def __ne__(self, other):
15899 
    return not (self == other)
15900 
 
8579 kshitij.so 15901 
class updateBanner_result:
6850 kshitij.so 15902 
  """
15903 
  Attributes:
15904 
   - success
15905 
  """
15906 
 
15907 
  thrift_spec = (
15908 
    (0, TType.BOOL, 'success', None, None, ), # 0
15909 
  )
15910 
 
15911 
  def __init__(self, success=None,):
15912 
    self.success = success
15913 
 
15914 
  def read(self, iprot):
15915 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15916 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15917 
      return
15918 
    iprot.readStructBegin()
15919 
    while True:
15920 
      (fname, ftype, fid) = iprot.readFieldBegin()
15921 
      if ftype == TType.STOP:
15922 
        break
15923 
      if fid == 0:
15924 
        if ftype == TType.BOOL:
15925 
          self.success = iprot.readBool();
15926 
        else:
15927 
          iprot.skip(ftype)
15928 
      else:
15929 
        iprot.skip(ftype)
15930 
      iprot.readFieldEnd()
15931 
    iprot.readStructEnd()
15932 
 
15933 
  def write(self, oprot):
15934 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15935 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15936 
      return
8579 kshitij.so 15937 
    oprot.writeStructBegin('updateBanner_result')
6850 kshitij.so 15938 
    if self.success is not None:
15939 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15940 
      oprot.writeBool(self.success)
15941 
      oprot.writeFieldEnd()
15942 
    oprot.writeFieldStop()
15943 
    oprot.writeStructEnd()
15944 
 
15945 
  def validate(self):
15946 
    return
15947 
 
15948 
 
15949 
  def __repr__(self):
15950 
    L = ['%s=%r' % (key, value)
15951 
      for key, value in self.__dict__.iteritems()]
15952 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15953 
 
15954 
  def __eq__(self, other):
15955 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15956 
 
15957 
  def __ne__(self, other):
15958 
    return not (self == other)
15959 
 
15960 
class getAllBanners_args:
15961 
 
15962 
  thrift_spec = (
15963 
  )
15964 
 
15965 
  def read(self, iprot):
15966 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15967 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15968 
      return
15969 
    iprot.readStructBegin()
15970 
    while True:
15971 
      (fname, ftype, fid) = iprot.readFieldBegin()
15972 
      if ftype == TType.STOP:
15973 
        break
15974 
      else:
15975 
        iprot.skip(ftype)
15976 
      iprot.readFieldEnd()
15977 
    iprot.readStructEnd()
15978 
 
15979 
  def write(self, oprot):
15980 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15981 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15982 
      return
15983 
    oprot.writeStructBegin('getAllBanners_args')
15984 
    oprot.writeFieldStop()
15985 
    oprot.writeStructEnd()
15986 
 
15987 
  def validate(self):
15988 
    return
15989 
 
15990 
 
15991 
  def __repr__(self):
15992 
    L = ['%s=%r' % (key, value)
15993 
      for key, value in self.__dict__.iteritems()]
15994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15995 
 
15996 
  def __eq__(self, other):
15997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15998 
 
15999 
  def __ne__(self, other):
16000 
    return not (self == other)
16001 
 
16002 
class getAllBanners_result:
16003 
  """
16004 
  Attributes:
16005 
   - success
16006 
  """
16007 
 
16008 
  thrift_spec = (
8579 kshitij.so 16009 
    (0, TType.LIST, 'success', (TType.STRUCT,(Banner, Banner.thrift_spec)), None, ), # 0
6850 kshitij.so 16010 
  )
16011 
 
16012 
  def __init__(self, success=None,):
16013 
    self.success = success
16014 
 
16015 
  def read(self, iprot):
16016 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16017 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16018 
      return
16019 
    iprot.readStructBegin()
16020 
    while True:
16021 
      (fname, ftype, fid) = iprot.readFieldBegin()
16022 
      if ftype == TType.STOP:
16023 
        break
16024 
      if fid == 0:
16025 
        if ftype == TType.LIST:
16026 
          self.success = []
18719 kshitij.so 16027 
          (_etype232, _size229) = iprot.readListBegin()
16028 
          for _i233 in xrange(_size229):
16029 
            _elem234 = Banner()
16030 
            _elem234.read(iprot)
16031 
            self.success.append(_elem234)
6850 kshitij.so 16032 
          iprot.readListEnd()
16033 
        else:
16034 
          iprot.skip(ftype)
16035 
      else:
16036 
        iprot.skip(ftype)
16037 
      iprot.readFieldEnd()
16038 
    iprot.readStructEnd()
16039 
 
16040 
  def write(self, oprot):
16041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16043 
      return
16044 
    oprot.writeStructBegin('getAllBanners_result')
16045 
    if self.success is not None:
16046 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8579 kshitij.so 16047 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 16048 
      for iter235 in self.success:
16049 
        iter235.write(oprot)
6850 kshitij.so 16050 
      oprot.writeListEnd()
16051 
      oprot.writeFieldEnd()
16052 
    oprot.writeFieldStop()
16053 
    oprot.writeStructEnd()
16054 
 
16055 
  def validate(self):
16056 
    return
16057 
 
16058 
 
16059 
  def __repr__(self):
16060 
    L = ['%s=%r' % (key, value)
16061 
      for key, value in self.__dict__.iteritems()]
16062 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16063 
 
16064 
  def __eq__(self, other):
16065 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16066 
 
16067 
  def __ne__(self, other):
16068 
    return not (self == other)
16069 
 
16070 
class deleteBanner_args:
16071 
  """
16072 
  Attributes:
16073 
   - bannerName
9155 kshitij.so 16074 
   - bannerType
6850 kshitij.so 16075 
  """
16076 
 
16077 
  thrift_spec = (
16078 
    None, # 0
16079 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 16080 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6850 kshitij.so 16081 
  )
16082 
 
9155 kshitij.so 16083 
  def __init__(self, bannerName=None, bannerType=None,):
6850 kshitij.so 16084 
    self.bannerName = bannerName
9155 kshitij.so 16085 
    self.bannerType = bannerType
6850 kshitij.so 16086 
 
16087 
  def read(self, iprot):
16088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16090 
      return
16091 
    iprot.readStructBegin()
16092 
    while True:
16093 
      (fname, ftype, fid) = iprot.readFieldBegin()
16094 
      if ftype == TType.STOP:
16095 
        break
16096 
      if fid == 1:
16097 
        if ftype == TType.STRING:
16098 
          self.bannerName = iprot.readString();
16099 
        else:
16100 
          iprot.skip(ftype)
9155 kshitij.so 16101 
      elif fid == 2:
16102 
        if ftype == TType.I32:
16103 
          self.bannerType = iprot.readI32();
16104 
        else:
16105 
          iprot.skip(ftype)
6850 kshitij.so 16106 
      else:
16107 
        iprot.skip(ftype)
16108 
      iprot.readFieldEnd()
16109 
    iprot.readStructEnd()
16110 
 
16111 
  def write(self, oprot):
16112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16114 
      return
16115 
    oprot.writeStructBegin('deleteBanner_args')
16116 
    if self.bannerName is not None:
16117 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
16118 
      oprot.writeString(self.bannerName)
16119 
      oprot.writeFieldEnd()
9155 kshitij.so 16120 
    if self.bannerType is not None:
16121 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
16122 
      oprot.writeI32(self.bannerType)
16123 
      oprot.writeFieldEnd()
6850 kshitij.so 16124 
    oprot.writeFieldStop()
16125 
    oprot.writeStructEnd()
16126 
 
16127 
  def validate(self):
16128 
    return
16129 
 
16130 
 
16131 
  def __repr__(self):
16132 
    L = ['%s=%r' % (key, value)
16133 
      for key, value in self.__dict__.iteritems()]
16134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16135 
 
16136 
  def __eq__(self, other):
16137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16138 
 
16139 
  def __ne__(self, other):
16140 
    return not (self == other)
16141 
 
16142 
class deleteBanner_result:
16143 
  """
16144 
  Attributes:
16145 
   - success
16146 
  """
16147 
 
16148 
  thrift_spec = (
16149 
    (0, TType.BOOL, 'success', None, None, ), # 0
16150 
  )
16151 
 
16152 
  def __init__(self, success=None,):
16153 
    self.success = success
16154 
 
16155 
  def read(self, iprot):
16156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16158 
      return
16159 
    iprot.readStructBegin()
16160 
    while True:
16161 
      (fname, ftype, fid) = iprot.readFieldBegin()
16162 
      if ftype == TType.STOP:
16163 
        break
16164 
      if fid == 0:
16165 
        if ftype == TType.BOOL:
16166 
          self.success = iprot.readBool();
16167 
        else:
16168 
          iprot.skip(ftype)
16169 
      else:
16170 
        iprot.skip(ftype)
16171 
      iprot.readFieldEnd()
16172 
    iprot.readStructEnd()
16173 
 
16174 
  def write(self, oprot):
16175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16177 
      return
16178 
    oprot.writeStructBegin('deleteBanner_result')
16179 
    if self.success is not None:
16180 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16181 
      oprot.writeBool(self.success)
16182 
      oprot.writeFieldEnd()
16183 
    oprot.writeFieldStop()
16184 
    oprot.writeStructEnd()
16185 
 
16186 
  def validate(self):
16187 
    return
16188 
 
16189 
 
16190 
  def __repr__(self):
16191 
    L = ['%s=%r' % (key, value)
16192 
      for key, value in self.__dict__.iteritems()]
16193 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16194 
 
16195 
  def __eq__(self, other):
16196 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16197 
 
16198 
  def __ne__(self, other):
16199 
    return not (self == other)
16200 
 
16201 
class getBannerDetails_args:
16202 
  """
16203 
  Attributes:
16204 
   - bannerName
9155 kshitij.so 16205 
   - bannerType
6850 kshitij.so 16206 
  """
16207 
 
16208 
  thrift_spec = (
16209 
    None, # 0
16210 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 16211 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6850 kshitij.so 16212 
  )
16213 
 
9155 kshitij.so 16214 
  def __init__(self, bannerName=None, bannerType=None,):
6850 kshitij.so 16215 
    self.bannerName = bannerName
9155 kshitij.so 16216 
    self.bannerType = bannerType
6850 kshitij.so 16217 
 
16218 
  def read(self, iprot):
16219 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16220 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16221 
      return
16222 
    iprot.readStructBegin()
16223 
    while True:
16224 
      (fname, ftype, fid) = iprot.readFieldBegin()
16225 
      if ftype == TType.STOP:
16226 
        break
16227 
      if fid == 1:
16228 
        if ftype == TType.STRING:
16229 
          self.bannerName = iprot.readString();
16230 
        else:
16231 
          iprot.skip(ftype)
9155 kshitij.so 16232 
      elif fid == 2:
16233 
        if ftype == TType.I32:
16234 
          self.bannerType = iprot.readI32();
16235 
        else:
16236 
          iprot.skip(ftype)
6850 kshitij.so 16237 
      else:
16238 
        iprot.skip(ftype)
16239 
      iprot.readFieldEnd()
16240 
    iprot.readStructEnd()
16241 
 
16242 
  def write(self, oprot):
16243 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16244 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16245 
      return
16246 
    oprot.writeStructBegin('getBannerDetails_args')
16247 
    if self.bannerName is not None:
16248 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
16249 
      oprot.writeString(self.bannerName)
16250 
      oprot.writeFieldEnd()
9155 kshitij.so 16251 
    if self.bannerType is not None:
16252 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
16253 
      oprot.writeI32(self.bannerType)
16254 
      oprot.writeFieldEnd()
6850 kshitij.so 16255 
    oprot.writeFieldStop()
16256 
    oprot.writeStructEnd()
16257 
 
16258 
  def validate(self):
16259 
    return
16260 
 
16261 
 
16262 
  def __repr__(self):
16263 
    L = ['%s=%r' % (key, value)
16264 
      for key, value in self.__dict__.iteritems()]
16265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16266 
 
16267 
  def __eq__(self, other):
16268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16269 
 
16270 
  def __ne__(self, other):
16271 
    return not (self == other)
16272 
 
16273 
class getBannerDetails_result:
16274 
  """
16275 
  Attributes:
16276 
   - success
16277 
  """
16278 
 
16279 
  thrift_spec = (
16280 
    (0, TType.STRUCT, 'success', (Banner, Banner.thrift_spec), None, ), # 0
16281 
  )
16282 
 
16283 
  def __init__(self, success=None,):
16284 
    self.success = success
16285 
 
16286 
  def read(self, iprot):
16287 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16288 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16289 
      return
16290 
    iprot.readStructBegin()
16291 
    while True:
16292 
      (fname, ftype, fid) = iprot.readFieldBegin()
16293 
      if ftype == TType.STOP:
16294 
        break
16295 
      if fid == 0:
16296 
        if ftype == TType.STRUCT:
16297 
          self.success = Banner()
16298 
          self.success.read(iprot)
16299 
        else:
16300 
          iprot.skip(ftype)
16301 
      else:
16302 
        iprot.skip(ftype)
16303 
      iprot.readFieldEnd()
16304 
    iprot.readStructEnd()
16305 
 
16306 
  def write(self, oprot):
16307 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16308 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16309 
      return
16310 
    oprot.writeStructBegin('getBannerDetails_result')
16311 
    if self.success is not None:
16312 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16313 
      self.success.write(oprot)
16314 
      oprot.writeFieldEnd()
16315 
    oprot.writeFieldStop()
16316 
    oprot.writeStructEnd()
16317 
 
16318 
  def validate(self):
16319 
    return
16320 
 
16321 
 
16322 
  def __repr__(self):
16323 
    L = ['%s=%r' % (key, value)
16324 
      for key, value in self.__dict__.iteritems()]
16325 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16326 
 
16327 
  def __eq__(self, other):
16328 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16329 
 
16330 
  def __ne__(self, other):
16331 
    return not (self == other)
16332 
 
16333 
class getActiveBanners_args:
16334 
 
16335 
  thrift_spec = (
16336 
  )
16337 
 
16338 
  def read(self, iprot):
16339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16341 
      return
16342 
    iprot.readStructBegin()
16343 
    while True:
16344 
      (fname, ftype, fid) = iprot.readFieldBegin()
16345 
      if ftype == TType.STOP:
16346 
        break
16347 
      else:
16348 
        iprot.skip(ftype)
16349 
      iprot.readFieldEnd()
16350 
    iprot.readStructEnd()
16351 
 
16352 
  def write(self, oprot):
16353 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16354 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16355 
      return
16356 
    oprot.writeStructBegin('getActiveBanners_args')
16357 
    oprot.writeFieldStop()
16358 
    oprot.writeStructEnd()
16359 
 
16360 
  def validate(self):
16361 
    return
16362 
 
16363 
 
16364 
  def __repr__(self):
16365 
    L = ['%s=%r' % (key, value)
16366 
      for key, value in self.__dict__.iteritems()]
16367 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16368 
 
16369 
  def __eq__(self, other):
16370 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16371 
 
16372 
  def __ne__(self, other):
16373 
    return not (self == other)
16374 
 
16375 
class getActiveBanners_result:
16376 
  """
16377 
  Attributes:
16378 
   - success
16379 
  """
16380 
 
16381 
  thrift_spec = (
8579 kshitij.so 16382 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
6850 kshitij.so 16383 
  )
16384 
 
16385 
  def __init__(self, success=None,):
16386 
    self.success = success
16387 
 
16388 
  def read(self, iprot):
16389 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16390 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16391 
      return
16392 
    iprot.readStructBegin()
16393 
    while True:
16394 
      (fname, ftype, fid) = iprot.readFieldBegin()
16395 
      if ftype == TType.STOP:
16396 
        break
16397 
      if fid == 0:
8579 kshitij.so 16398 
        if ftype == TType.MAP:
16399 
          self.success = {}
18719 kshitij.so 16400 
          (_ktype237, _vtype238, _size236 ) = iprot.readMapBegin()
16401 
          for _i240 in xrange(_size236):
16402 
            _key241 = iprot.readString();
16403 
            _val242 = []
16404 
            (_etype246, _size243) = iprot.readListBegin()
16405 
            for _i247 in xrange(_size243):
16406 
              _elem248 = Banner()
16407 
              _elem248.read(iprot)
16408 
              _val242.append(_elem248)
8579 kshitij.so 16409 
            iprot.readListEnd()
18719 kshitij.so 16410 
            self.success[_key241] = _val242
8579 kshitij.so 16411 
          iprot.readMapEnd()
6850 kshitij.so 16412 
        else:
16413 
          iprot.skip(ftype)
16414 
      else:
16415 
        iprot.skip(ftype)
16416 
      iprot.readFieldEnd()
16417 
    iprot.readStructEnd()
16418 
 
16419 
  def write(self, oprot):
16420 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16421 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16422 
      return
16423 
    oprot.writeStructBegin('getActiveBanners_result')
16424 
    if self.success is not None:
8579 kshitij.so 16425 
      oprot.writeFieldBegin('success', TType.MAP, 0)
16426 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
18719 kshitij.so 16427 
      for kiter249,viter250 in self.success.items():
16428 
        oprot.writeString(kiter249)
16429 
        oprot.writeListBegin(TType.STRUCT, len(viter250))
16430 
        for iter251 in viter250:
16431 
          iter251.write(oprot)
8579 kshitij.so 16432 
        oprot.writeListEnd()
16433 
      oprot.writeMapEnd()
6850 kshitij.so 16434 
      oprot.writeFieldEnd()
16435 
    oprot.writeFieldStop()
16436 
    oprot.writeStructEnd()
16437 
 
16438 
  def validate(self):
16439 
    return
16440 
 
16441 
 
16442 
  def __repr__(self):
16443 
    L = ['%s=%r' % (key, value)
16444 
      for key, value in self.__dict__.iteritems()]
16445 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16446 
 
16447 
  def __eq__(self, other):
16448 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16449 
 
16450 
  def __ne__(self, other):
16451 
    return not (self == other)
16452 
 
6849 kshitij.so 16453 
class addBannerMap_args:
16454 
  """
16455 
  Attributes:
8579 kshitij.so 16456 
   - bannerMaps
6849 kshitij.so 16457 
  """
16458 
 
16459 
  thrift_spec = (
16460 
    None, # 0
8579 kshitij.so 16461 
    (1, TType.LIST, 'bannerMaps', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 1
6849 kshitij.so 16462 
  )
16463 
 
8579 kshitij.so 16464 
  def __init__(self, bannerMaps=None,):
16465 
    self.bannerMaps = bannerMaps
6849 kshitij.so 16466 
 
16467 
  def read(self, iprot):
16468 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16469 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16470 
      return
16471 
    iprot.readStructBegin()
16472 
    while True:
16473 
      (fname, ftype, fid) = iprot.readFieldBegin()
16474 
      if ftype == TType.STOP:
16475 
        break
16476 
      if fid == 1:
8579 kshitij.so 16477 
        if ftype == TType.LIST:
16478 
          self.bannerMaps = []
18719 kshitij.so 16479 
          (_etype255, _size252) = iprot.readListBegin()
16480 
          for _i256 in xrange(_size252):
16481 
            _elem257 = BannerMap()
16482 
            _elem257.read(iprot)
16483 
            self.bannerMaps.append(_elem257)
8579 kshitij.so 16484 
          iprot.readListEnd()
6849 kshitij.so 16485 
        else:
16486 
          iprot.skip(ftype)
8579 kshitij.so 16487 
      else:
16488 
        iprot.skip(ftype)
16489 
      iprot.readFieldEnd()
16490 
    iprot.readStructEnd()
16491 
 
16492 
  def write(self, oprot):
16493 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16494 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16495 
      return
16496 
    oprot.writeStructBegin('addBannerMap_args')
16497 
    if self.bannerMaps is not None:
16498 
      oprot.writeFieldBegin('bannerMaps', TType.LIST, 1)
16499 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerMaps))
18719 kshitij.so 16500 
      for iter258 in self.bannerMaps:
16501 
        iter258.write(oprot)
8579 kshitij.so 16502 
      oprot.writeListEnd()
16503 
      oprot.writeFieldEnd()
16504 
    oprot.writeFieldStop()
16505 
    oprot.writeStructEnd()
16506 
 
16507 
  def validate(self):
16508 
    return
16509 
 
16510 
 
16511 
  def __repr__(self):
16512 
    L = ['%s=%r' % (key, value)
16513 
      for key, value in self.__dict__.iteritems()]
16514 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16515 
 
16516 
  def __eq__(self, other):
16517 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16518 
 
16519 
  def __ne__(self, other):
16520 
    return not (self == other)
16521 
 
16522 
class addBannerMap_result:
16523 
  """
16524 
  Attributes:
16525 
   - success
16526 
  """
16527 
 
16528 
  thrift_spec = (
16529 
    (0, TType.BOOL, 'success', None, None, ), # 0
16530 
  )
16531 
 
16532 
  def __init__(self, success=None,):
16533 
    self.success = success
16534 
 
16535 
  def read(self, iprot):
16536 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16537 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16538 
      return
16539 
    iprot.readStructBegin()
16540 
    while True:
16541 
      (fname, ftype, fid) = iprot.readFieldBegin()
16542 
      if ftype == TType.STOP:
16543 
        break
16544 
      if fid == 0:
16545 
        if ftype == TType.BOOL:
16546 
          self.success = iprot.readBool();
6849 kshitij.so 16547 
        else:
16548 
          iprot.skip(ftype)
8579 kshitij.so 16549 
      else:
16550 
        iprot.skip(ftype)
16551 
      iprot.readFieldEnd()
16552 
    iprot.readStructEnd()
16553 
 
16554 
  def write(self, oprot):
16555 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16556 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16557 
      return
16558 
    oprot.writeStructBegin('addBannerMap_result')
16559 
    if self.success is not None:
16560 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16561 
      oprot.writeBool(self.success)
16562 
      oprot.writeFieldEnd()
16563 
    oprot.writeFieldStop()
16564 
    oprot.writeStructEnd()
16565 
 
16566 
  def validate(self):
16567 
    return
16568 
 
16569 
 
16570 
  def __repr__(self):
16571 
    L = ['%s=%r' % (key, value)
16572 
      for key, value in self.__dict__.iteritems()]
16573 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16574 
 
16575 
  def __eq__(self, other):
16576 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16577 
 
16578 
  def __ne__(self, other):
16579 
    return not (self == other)
16580 
 
16581 
class updateBannerMap_args:
16582 
  """
16583 
  Attributes:
16584 
   - bannerMap
16585 
  """
16586 
 
16587 
  thrift_spec = (
16588 
    None, # 0
16589 
    (1, TType.STRUCT, 'bannerMap', (BannerMap, BannerMap.thrift_spec), None, ), # 1
16590 
  )
16591 
 
16592 
  def __init__(self, bannerMap=None,):
16593 
    self.bannerMap = bannerMap
16594 
 
16595 
  def read(self, iprot):
16596 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16597 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16598 
      return
16599 
    iprot.readStructBegin()
16600 
    while True:
16601 
      (fname, ftype, fid) = iprot.readFieldBegin()
16602 
      if ftype == TType.STOP:
16603 
        break
16604 
      if fid == 1:
16605 
        if ftype == TType.STRUCT:
16606 
          self.bannerMap = BannerMap()
16607 
          self.bannerMap.read(iprot)
6849 kshitij.so 16608 
        else:
16609 
          iprot.skip(ftype)
16610 
      else:
16611 
        iprot.skip(ftype)
16612 
      iprot.readFieldEnd()
16613 
    iprot.readStructEnd()
16614 
 
16615 
  def write(self, oprot):
16616 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16617 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16618 
      return
8579 kshitij.so 16619 
    oprot.writeStructBegin('updateBannerMap_args')
16620 
    if self.bannerMap is not None:
16621 
      oprot.writeFieldBegin('bannerMap', TType.STRUCT, 1)
16622 
      self.bannerMap.write(oprot)
6849 kshitij.so 16623 
      oprot.writeFieldEnd()
16624 
    oprot.writeFieldStop()
16625 
    oprot.writeStructEnd()
16626 
 
16627 
  def validate(self):
16628 
    return
16629 
 
16630 
 
16631 
  def __repr__(self):
16632 
    L = ['%s=%r' % (key, value)
16633 
      for key, value in self.__dict__.iteritems()]
16634 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16635 
 
16636 
  def __eq__(self, other):
16637 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16638 
 
16639 
  def __ne__(self, other):
16640 
    return not (self == other)
16641 
 
8579 kshitij.so 16642 
class updateBannerMap_result:
6849 kshitij.so 16643 
  """
16644 
  Attributes:
16645 
   - success
16646 
  """
16647 
 
16648 
  thrift_spec = (
16649 
    (0, TType.BOOL, 'success', None, None, ), # 0
16650 
  )
16651 
 
16652 
  def __init__(self, success=None,):
16653 
    self.success = success
16654 
 
16655 
  def read(self, iprot):
16656 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16657 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16658 
      return
16659 
    iprot.readStructBegin()
16660 
    while True:
16661 
      (fname, ftype, fid) = iprot.readFieldBegin()
16662 
      if ftype == TType.STOP:
16663 
        break
16664 
      if fid == 0:
16665 
        if ftype == TType.BOOL:
16666 
          self.success = iprot.readBool();
16667 
        else:
16668 
          iprot.skip(ftype)
16669 
      else:
16670 
        iprot.skip(ftype)
16671 
      iprot.readFieldEnd()
16672 
    iprot.readStructEnd()
16673 
 
16674 
  def write(self, oprot):
16675 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16676 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16677 
      return
8579 kshitij.so 16678 
    oprot.writeStructBegin('updateBannerMap_result')
6849 kshitij.so 16679 
    if self.success is not None:
16680 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16681 
      oprot.writeBool(self.success)
16682 
      oprot.writeFieldEnd()
16683 
    oprot.writeFieldStop()
16684 
    oprot.writeStructEnd()
16685 
 
16686 
  def validate(self):
16687 
    return
16688 
 
16689 
 
16690 
  def __repr__(self):
16691 
    L = ['%s=%r' % (key, value)
16692 
      for key, value in self.__dict__.iteritems()]
16693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16694 
 
16695 
  def __eq__(self, other):
16696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16697 
 
16698 
  def __ne__(self, other):
16699 
    return not (self == other)
16700 
 
16701 
class deleteBannerMap_args:
16702 
  """
16703 
  Attributes:
16704 
   - bannerName
16705 
  """
16706 
 
16707 
  thrift_spec = (
16708 
    None, # 0
16709 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
16710 
  )
16711 
 
16712 
  def __init__(self, bannerName=None,):
16713 
    self.bannerName = bannerName
16714 
 
16715 
  def read(self, iprot):
16716 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16717 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16718 
      return
16719 
    iprot.readStructBegin()
16720 
    while True:
16721 
      (fname, ftype, fid) = iprot.readFieldBegin()
16722 
      if ftype == TType.STOP:
16723 
        break
16724 
      if fid == 1:
16725 
        if ftype == TType.STRING:
16726 
          self.bannerName = iprot.readString();
16727 
        else:
16728 
          iprot.skip(ftype)
16729 
      else:
16730 
        iprot.skip(ftype)
16731 
      iprot.readFieldEnd()
16732 
    iprot.readStructEnd()
16733 
 
16734 
  def write(self, oprot):
16735 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16736 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16737 
      return
16738 
    oprot.writeStructBegin('deleteBannerMap_args')
16739 
    if self.bannerName is not None:
16740 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
16741 
      oprot.writeString(self.bannerName)
16742 
      oprot.writeFieldEnd()
16743 
    oprot.writeFieldStop()
16744 
    oprot.writeStructEnd()
16745 
 
16746 
  def validate(self):
16747 
    return
16748 
 
16749 
 
16750 
  def __repr__(self):
16751 
    L = ['%s=%r' % (key, value)
16752 
      for key, value in self.__dict__.iteritems()]
16753 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16754 
 
16755 
  def __eq__(self, other):
16756 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16757 
 
16758 
  def __ne__(self, other):
16759 
    return not (self == other)
16760 
 
16761 
class deleteBannerMap_result:
16762 
  """
16763 
  Attributes:
16764 
   - success
16765 
  """
16766 
 
16767 
  thrift_spec = (
16768 
    (0, TType.BOOL, 'success', None, None, ), # 0
16769 
  )
16770 
 
16771 
  def __init__(self, success=None,):
16772 
    self.success = success
16773 
 
16774 
  def read(self, iprot):
16775 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16776 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16777 
      return
16778 
    iprot.readStructBegin()
16779 
    while True:
16780 
      (fname, ftype, fid) = iprot.readFieldBegin()
16781 
      if ftype == TType.STOP:
16782 
        break
16783 
      if fid == 0:
16784 
        if ftype == TType.BOOL:
16785 
          self.success = iprot.readBool();
16786 
        else:
16787 
          iprot.skip(ftype)
16788 
      else:
16789 
        iprot.skip(ftype)
16790 
      iprot.readFieldEnd()
16791 
    iprot.readStructEnd()
16792 
 
16793 
  def write(self, oprot):
16794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16796 
      return
16797 
    oprot.writeStructBegin('deleteBannerMap_result')
16798 
    if self.success is not None:
16799 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16800 
      oprot.writeBool(self.success)
16801 
      oprot.writeFieldEnd()
16802 
    oprot.writeFieldStop()
16803 
    oprot.writeStructEnd()
16804 
 
16805 
  def validate(self):
16806 
    return
16807 
 
16808 
 
16809 
  def __repr__(self):
16810 
    L = ['%s=%r' % (key, value)
16811 
      for key, value in self.__dict__.iteritems()]
16812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16813 
 
16814 
  def __eq__(self, other):
16815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16816 
 
16817 
  def __ne__(self, other):
16818 
    return not (self == other)
16819 
 
16820 
class getBannerMapDetails_args:
16821 
  """
16822 
  Attributes:
16823 
   - bannerName
9155 kshitij.so 16824 
   - bannerType
6849 kshitij.so 16825 
  """
16826 
 
16827 
  thrift_spec = (
16828 
    None, # 0
16829 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 16830 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6849 kshitij.so 16831 
  )
16832 
 
9155 kshitij.so 16833 
  def __init__(self, bannerName=None, bannerType=None,):
6849 kshitij.so 16834 
    self.bannerName = bannerName
9155 kshitij.so 16835 
    self.bannerType = bannerType
6849 kshitij.so 16836 
 
16837 
  def read(self, iprot):
16838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16840 
      return
16841 
    iprot.readStructBegin()
16842 
    while True:
16843 
      (fname, ftype, fid) = iprot.readFieldBegin()
16844 
      if ftype == TType.STOP:
16845 
        break
16846 
      if fid == 1:
16847 
        if ftype == TType.STRING:
16848 
          self.bannerName = iprot.readString();
16849 
        else:
16850 
          iprot.skip(ftype)
9155 kshitij.so 16851 
      elif fid == 2:
16852 
        if ftype == TType.I32:
16853 
          self.bannerType = iprot.readI32();
16854 
        else:
16855 
          iprot.skip(ftype)
6849 kshitij.so 16856 
      else:
16857 
        iprot.skip(ftype)
16858 
      iprot.readFieldEnd()
16859 
    iprot.readStructEnd()
16860 
 
16861 
  def write(self, oprot):
16862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16864 
      return
16865 
    oprot.writeStructBegin('getBannerMapDetails_args')
16866 
    if self.bannerName is not None:
16867 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
16868 
      oprot.writeString(self.bannerName)
16869 
      oprot.writeFieldEnd()
9155 kshitij.so 16870 
    if self.bannerType is not None:
16871 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
16872 
      oprot.writeI32(self.bannerType)
16873 
      oprot.writeFieldEnd()
6849 kshitij.so 16874 
    oprot.writeFieldStop()
16875 
    oprot.writeStructEnd()
16876 
 
16877 
  def validate(self):
16878 
    return
16879 
 
16880 
 
16881 
  def __repr__(self):
16882 
    L = ['%s=%r' % (key, value)
16883 
      for key, value in self.__dict__.iteritems()]
16884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16885 
 
16886 
  def __eq__(self, other):
16887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16888 
 
16889 
  def __ne__(self, other):
16890 
    return not (self == other)
16891 
 
16892 
class getBannerMapDetails_result:
16893 
  """
16894 
  Attributes:
16895 
   - success
16896 
  """
16897 
 
16898 
  thrift_spec = (
16899 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 0
16900 
  )
16901 
 
16902 
  def __init__(self, success=None,):
16903 
    self.success = success
16904 
 
16905 
  def read(self, iprot):
16906 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16907 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16908 
      return
16909 
    iprot.readStructBegin()
16910 
    while True:
16911 
      (fname, ftype, fid) = iprot.readFieldBegin()
16912 
      if ftype == TType.STOP:
16913 
        break
16914 
      if fid == 0:
16915 
        if ftype == TType.LIST:
16916 
          self.success = []
18719 kshitij.so 16917 
          (_etype262, _size259) = iprot.readListBegin()
16918 
          for _i263 in xrange(_size259):
16919 
            _elem264 = BannerMap()
16920 
            _elem264.read(iprot)
16921 
            self.success.append(_elem264)
6849 kshitij.so 16922 
          iprot.readListEnd()
16923 
        else:
16924 
          iprot.skip(ftype)
16925 
      else:
16926 
        iprot.skip(ftype)
16927 
      iprot.readFieldEnd()
16928 
    iprot.readStructEnd()
16929 
 
16930 
  def write(self, oprot):
16931 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16932 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16933 
      return
16934 
    oprot.writeStructBegin('getBannerMapDetails_result')
16935 
    if self.success is not None:
16936 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16937 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 16938 
      for iter265 in self.success:
16939 
        iter265.write(oprot)
6849 kshitij.so 16940 
      oprot.writeListEnd()
16941 
      oprot.writeFieldEnd()
16942 
    oprot.writeFieldStop()
16943 
    oprot.writeStructEnd()
16944 
 
16945 
  def validate(self):
16946 
    return
16947 
 
16948 
 
16949 
  def __repr__(self):
16950 
    L = ['%s=%r' % (key, value)
16951 
      for key, value in self.__dict__.iteritems()]
16952 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16953 
 
16954 
  def __eq__(self, other):
16955 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16956 
 
16957 
  def __ne__(self, other):
16958 
    return not (self == other)
16959 
 
8579 kshitij.so 16960 
class addBannerUri_args:
16961 
  """
16962 
  Attributes:
16963 
   - bannerUriMappings
16964 
  """
16965 
 
16966 
  thrift_spec = (
16967 
    None, # 0
16968 
    (1, TType.LIST, 'bannerUriMappings', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 1
16969 
  )
16970 
 
16971 
  def __init__(self, bannerUriMappings=None,):
16972 
    self.bannerUriMappings = bannerUriMappings
16973 
 
16974 
  def read(self, iprot):
16975 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16976 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16977 
      return
16978 
    iprot.readStructBegin()
16979 
    while True:
16980 
      (fname, ftype, fid) = iprot.readFieldBegin()
16981 
      if ftype == TType.STOP:
16982 
        break
16983 
      if fid == 1:
16984 
        if ftype == TType.LIST:
16985 
          self.bannerUriMappings = []
18719 kshitij.so 16986 
          (_etype269, _size266) = iprot.readListBegin()
16987 
          for _i270 in xrange(_size266):
16988 
            _elem271 = BannerUriMapping()
16989 
            _elem271.read(iprot)
16990 
            self.bannerUriMappings.append(_elem271)
8579 kshitij.so 16991 
          iprot.readListEnd()
16992 
        else:
16993 
          iprot.skip(ftype)
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_args')
17004 
    if self.bannerUriMappings is not None:
17005 
      oprot.writeFieldBegin('bannerUriMappings', TType.LIST, 1)
17006 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerUriMappings))
18719 kshitij.so 17007 
      for iter272 in self.bannerUriMappings:
17008 
        iter272.write(oprot)
8579 kshitij.so 17009 
      oprot.writeListEnd()
17010 
      oprot.writeFieldEnd()
17011 
    oprot.writeFieldStop()
17012 
    oprot.writeStructEnd()
17013 
 
17014 
  def validate(self):
17015 
    return
17016 
 
17017 
 
17018 
  def __repr__(self):
17019 
    L = ['%s=%r' % (key, value)
17020 
      for key, value in self.__dict__.iteritems()]
17021 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17022 
 
17023 
  def __eq__(self, other):
17024 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17025 
 
17026 
  def __ne__(self, other):
17027 
    return not (self == other)
17028 
 
17029 
class addBannerUri_result:
17030 
 
17031 
  thrift_spec = (
17032 
  )
17033 
 
17034 
  def read(self, iprot):
17035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17037 
      return
17038 
    iprot.readStructBegin()
17039 
    while True:
17040 
      (fname, ftype, fid) = iprot.readFieldBegin()
17041 
      if ftype == TType.STOP:
17042 
        break
17043 
      else:
17044 
        iprot.skip(ftype)
17045 
      iprot.readFieldEnd()
17046 
    iprot.readStructEnd()
17047 
 
17048 
  def write(self, oprot):
17049 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17050 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17051 
      return
17052 
    oprot.writeStructBegin('addBannerUri_result')
17053 
    oprot.writeFieldStop()
17054 
    oprot.writeStructEnd()
17055 
 
17056 
  def validate(self):
17057 
    return
17058 
 
17059 
 
17060 
  def __repr__(self):
17061 
    L = ['%s=%r' % (key, value)
17062 
      for key, value in self.__dict__.iteritems()]
17063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17064 
 
17065 
  def __eq__(self, other):
17066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17067 
 
17068 
  def __ne__(self, other):
17069 
    return not (self == other)
17070 
 
17071 
class getUriMapping_args:
17072 
  """
17073 
  Attributes:
17074 
   - bannerName
9155 kshitij.so 17075 
   - bannerType
8579 kshitij.so 17076 
  """
17077 
 
17078 
  thrift_spec = (
17079 
    None, # 0
17080 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 17081 
    (2, TType.I32, 'bannerType', None, None, ), # 2
8579 kshitij.so 17082 
  )
17083 
 
9155 kshitij.so 17084 
  def __init__(self, bannerName=None, bannerType=None,):
8579 kshitij.so 17085 
    self.bannerName = bannerName
9155 kshitij.so 17086 
    self.bannerType = bannerType
8579 kshitij.so 17087 
 
17088 
  def read(self, iprot):
17089 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17090 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17091 
      return
17092 
    iprot.readStructBegin()
17093 
    while True:
17094 
      (fname, ftype, fid) = iprot.readFieldBegin()
17095 
      if ftype == TType.STOP:
17096 
        break
17097 
      if fid == 1:
17098 
        if ftype == TType.STRING:
17099 
          self.bannerName = iprot.readString();
17100 
        else:
17101 
          iprot.skip(ftype)
9155 kshitij.so 17102 
      elif fid == 2:
17103 
        if ftype == TType.I32:
17104 
          self.bannerType = iprot.readI32();
17105 
        else:
17106 
          iprot.skip(ftype)
8579 kshitij.so 17107 
      else:
17108 
        iprot.skip(ftype)
17109 
      iprot.readFieldEnd()
17110 
    iprot.readStructEnd()
17111 
 
17112 
  def write(self, oprot):
17113 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17114 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17115 
      return
17116 
    oprot.writeStructBegin('getUriMapping_args')
17117 
    if self.bannerName is not None:
17118 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
17119 
      oprot.writeString(self.bannerName)
17120 
      oprot.writeFieldEnd()
9155 kshitij.so 17121 
    if self.bannerType is not None:
17122 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
17123 
      oprot.writeI32(self.bannerType)
17124 
      oprot.writeFieldEnd()
8579 kshitij.so 17125 
    oprot.writeFieldStop()
17126 
    oprot.writeStructEnd()
17127 
 
17128 
  def validate(self):
17129 
    return
17130 
 
17131 
 
17132 
  def __repr__(self):
17133 
    L = ['%s=%r' % (key, value)
17134 
      for key, value in self.__dict__.iteritems()]
17135 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17136 
 
17137 
  def __eq__(self, other):
17138 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17139 
 
17140 
  def __ne__(self, other):
17141 
    return not (self == other)
17142 
 
17143 
class getUriMapping_result:
17144 
  """
17145 
  Attributes:
17146 
   - success
17147 
  """
17148 
 
17149 
  thrift_spec = (
17150 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 0
17151 
  )
17152 
 
17153 
  def __init__(self, success=None,):
17154 
    self.success = success
17155 
 
17156 
  def read(self, iprot):
17157 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17158 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17159 
      return
17160 
    iprot.readStructBegin()
17161 
    while True:
17162 
      (fname, ftype, fid) = iprot.readFieldBegin()
17163 
      if ftype == TType.STOP:
17164 
        break
17165 
      if fid == 0:
17166 
        if ftype == TType.LIST:
17167 
          self.success = []
18719 kshitij.so 17168 
          (_etype276, _size273) = iprot.readListBegin()
17169 
          for _i277 in xrange(_size273):
17170 
            _elem278 = BannerUriMapping()
17171 
            _elem278.read(iprot)
17172 
            self.success.append(_elem278)
8579 kshitij.so 17173 
          iprot.readListEnd()
17174 
        else:
17175 
          iprot.skip(ftype)
17176 
      else:
17177 
        iprot.skip(ftype)
17178 
      iprot.readFieldEnd()
17179 
    iprot.readStructEnd()
17180 
 
17181 
  def write(self, oprot):
17182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17184 
      return
17185 
    oprot.writeStructBegin('getUriMapping_result')
17186 
    if self.success is not None:
17187 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17188 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 17189 
      for iter279 in self.success:
17190 
        iter279.write(oprot)
8579 kshitij.so 17191 
      oprot.writeListEnd()
17192 
      oprot.writeFieldEnd()
17193 
    oprot.writeFieldStop()
17194 
    oprot.writeStructEnd()
17195 
 
17196 
  def validate(self):
17197 
    return
17198 
 
17199 
 
17200 
  def __repr__(self):
17201 
    L = ['%s=%r' % (key, value)
17202 
      for key, value in self.__dict__.iteritems()]
17203 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17204 
 
17205 
  def __eq__(self, other):
17206 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17207 
 
17208 
  def __ne__(self, other):
17209 
    return not (self == other)
17210 
 
17211 
class addCampaign_args:
17212 
  """
17213 
  Attributes:
17214 
   - campaign
17215 
  """
17216 
 
17217 
  thrift_spec = (
17218 
    None, # 0
17219 
    (1, TType.STRUCT, 'campaign', (Campaign, Campaign.thrift_spec), None, ), # 1
17220 
  )
17221 
 
17222 
  def __init__(self, campaign=None,):
17223 
    self.campaign = campaign
17224 
 
17225 
  def read(self, iprot):
17226 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17227 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17228 
      return
17229 
    iprot.readStructBegin()
17230 
    while True:
17231 
      (fname, ftype, fid) = iprot.readFieldBegin()
17232 
      if ftype == TType.STOP:
17233 
        break
17234 
      if fid == 1:
17235 
        if ftype == TType.STRUCT:
17236 
          self.campaign = Campaign()
17237 
          self.campaign.read(iprot)
17238 
        else:
17239 
          iprot.skip(ftype)
17240 
      else:
17241 
        iprot.skip(ftype)
17242 
      iprot.readFieldEnd()
17243 
    iprot.readStructEnd()
17244 
 
17245 
  def write(self, oprot):
17246 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17247 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17248 
      return
17249 
    oprot.writeStructBegin('addCampaign_args')
17250 
    if self.campaign is not None:
17251 
      oprot.writeFieldBegin('campaign', TType.STRUCT, 1)
17252 
      self.campaign.write(oprot)
17253 
      oprot.writeFieldEnd()
17254 
    oprot.writeFieldStop()
17255 
    oprot.writeStructEnd()
17256 
 
17257 
  def validate(self):
17258 
    return
17259 
 
17260 
 
17261 
  def __repr__(self):
17262 
    L = ['%s=%r' % (key, value)
17263 
      for key, value in self.__dict__.iteritems()]
17264 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17265 
 
17266 
  def __eq__(self, other):
17267 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17268 
 
17269 
  def __ne__(self, other):
17270 
    return not (self == other)
17271 
 
17272 
class addCampaign_result:
17273 
 
17274 
  thrift_spec = (
17275 
  )
17276 
 
17277 
  def read(self, iprot):
17278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17280 
      return
17281 
    iprot.readStructBegin()
17282 
    while True:
17283 
      (fname, ftype, fid) = iprot.readFieldBegin()
17284 
      if ftype == TType.STOP:
17285 
        break
17286 
      else:
17287 
        iprot.skip(ftype)
17288 
      iprot.readFieldEnd()
17289 
    iprot.readStructEnd()
17290 
 
17291 
  def write(self, oprot):
17292 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17293 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17294 
      return
17295 
    oprot.writeStructBegin('addCampaign_result')
17296 
    oprot.writeFieldStop()
17297 
    oprot.writeStructEnd()
17298 
 
17299 
  def validate(self):
17300 
    return
17301 
 
17302 
 
17303 
  def __repr__(self):
17304 
    L = ['%s=%r' % (key, value)
17305 
      for key, value in self.__dict__.iteritems()]
17306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17307 
 
17308 
  def __eq__(self, other):
17309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17310 
 
17311 
  def __ne__(self, other):
17312 
    return not (self == other)
17313 
 
17314 
class getCampaigns_args:
17315 
  """
17316 
  Attributes:
17317 
   - campaignName
17318 
  """
17319 
 
17320 
  thrift_spec = (
17321 
    None, # 0
17322 
    (1, TType.STRING, 'campaignName', None, None, ), # 1
17323 
  )
17324 
 
17325 
  def __init__(self, campaignName=None,):
17326 
    self.campaignName = campaignName
17327 
 
17328 
  def read(self, iprot):
17329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17331 
      return
17332 
    iprot.readStructBegin()
17333 
    while True:
17334 
      (fname, ftype, fid) = iprot.readFieldBegin()
17335 
      if ftype == TType.STOP:
17336 
        break
17337 
      if fid == 1:
17338 
        if ftype == TType.STRING:
17339 
          self.campaignName = iprot.readString();
17340 
        else:
17341 
          iprot.skip(ftype)
17342 
      else:
17343 
        iprot.skip(ftype)
17344 
      iprot.readFieldEnd()
17345 
    iprot.readStructEnd()
17346 
 
17347 
  def write(self, oprot):
17348 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17349 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17350 
      return
17351 
    oprot.writeStructBegin('getCampaigns_args')
17352 
    if self.campaignName is not None:
17353 
      oprot.writeFieldBegin('campaignName', TType.STRING, 1)
17354 
      oprot.writeString(self.campaignName)
17355 
      oprot.writeFieldEnd()
17356 
    oprot.writeFieldStop()
17357 
    oprot.writeStructEnd()
17358 
 
17359 
  def validate(self):
17360 
    return
17361 
 
17362 
 
17363 
  def __repr__(self):
17364 
    L = ['%s=%r' % (key, value)
17365 
      for key, value in self.__dict__.iteritems()]
17366 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17367 
 
17368 
  def __eq__(self, other):
17369 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17370 
 
17371 
  def __ne__(self, other):
17372 
    return not (self == other)
17373 
 
17374 
class getCampaigns_result:
17375 
  """
17376 
  Attributes:
17377 
   - success
17378 
  """
17379 
 
17380 
  thrift_spec = (
17381 
    (0, TType.LIST, 'success', (TType.STRUCT,(Campaign, Campaign.thrift_spec)), None, ), # 0
17382 
  )
17383 
 
17384 
  def __init__(self, success=None,):
17385 
    self.success = success
17386 
 
17387 
  def read(self, iprot):
17388 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17389 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17390 
      return
17391 
    iprot.readStructBegin()
17392 
    while True:
17393 
      (fname, ftype, fid) = iprot.readFieldBegin()
17394 
      if ftype == TType.STOP:
17395 
        break
17396 
      if fid == 0:
17397 
        if ftype == TType.LIST:
17398 
          self.success = []
18719 kshitij.so 17399 
          (_etype283, _size280) = iprot.readListBegin()
17400 
          for _i284 in xrange(_size280):
17401 
            _elem285 = Campaign()
17402 
            _elem285.read(iprot)
17403 
            self.success.append(_elem285)
8579 kshitij.so 17404 
          iprot.readListEnd()
17405 
        else:
17406 
          iprot.skip(ftype)
17407 
      else:
17408 
        iprot.skip(ftype)
17409 
      iprot.readFieldEnd()
17410 
    iprot.readStructEnd()
17411 
 
17412 
  def write(self, oprot):
17413 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17414 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17415 
      return
17416 
    oprot.writeStructBegin('getCampaigns_result')
17417 
    if self.success is not None:
17418 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17419 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 17420 
      for iter286 in self.success:
17421 
        iter286.write(oprot)
8579 kshitij.so 17422 
      oprot.writeListEnd()
17423 
      oprot.writeFieldEnd()
17424 
    oprot.writeFieldStop()
17425 
    oprot.writeStructEnd()
17426 
 
17427 
  def validate(self):
17428 
    return
17429 
 
17430 
 
17431 
  def __repr__(self):
17432 
    L = ['%s=%r' % (key, value)
17433 
      for key, value in self.__dict__.iteritems()]
17434 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17435 
 
17436 
  def __eq__(self, other):
17437 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17438 
 
17439 
  def __ne__(self, other):
17440 
    return not (self == other)
17441 
 
17442 
class deleteCampaign_args:
17443 
  """
17444 
  Attributes:
17445 
   - campaignId
17446 
  """
17447 
 
17448 
  thrift_spec = (
17449 
    None, # 0
17450 
    (1, TType.I64, 'campaignId', None, None, ), # 1
17451 
  )
17452 
 
17453 
  def __init__(self, campaignId=None,):
17454 
    self.campaignId = campaignId
17455 
 
17456 
  def read(self, iprot):
17457 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17458 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17459 
      return
17460 
    iprot.readStructBegin()
17461 
    while True:
17462 
      (fname, ftype, fid) = iprot.readFieldBegin()
17463 
      if ftype == TType.STOP:
17464 
        break
17465 
      if fid == 1:
17466 
        if ftype == TType.I64:
17467 
          self.campaignId = iprot.readI64();
17468 
        else:
17469 
          iprot.skip(ftype)
17470 
      else:
17471 
        iprot.skip(ftype)
17472 
      iprot.readFieldEnd()
17473 
    iprot.readStructEnd()
17474 
 
17475 
  def write(self, oprot):
17476 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17477 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17478 
      return
17479 
    oprot.writeStructBegin('deleteCampaign_args')
17480 
    if self.campaignId is not None:
17481 
      oprot.writeFieldBegin('campaignId', TType.I64, 1)
17482 
      oprot.writeI64(self.campaignId)
17483 
      oprot.writeFieldEnd()
17484 
    oprot.writeFieldStop()
17485 
    oprot.writeStructEnd()
17486 
 
17487 
  def validate(self):
17488 
    return
17489 
 
17490 
 
17491 
  def __repr__(self):
17492 
    L = ['%s=%r' % (key, value)
17493 
      for key, value in self.__dict__.iteritems()]
17494 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17495 
 
17496 
  def __eq__(self, other):
17497 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17498 
 
17499 
  def __ne__(self, other):
17500 
    return not (self == other)
17501 
 
17502 
class deleteCampaign_result:
17503 
 
17504 
  thrift_spec = (
17505 
  )
17506 
 
17507 
  def read(self, iprot):
17508 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17509 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17510 
      return
17511 
    iprot.readStructBegin()
17512 
    while True:
17513 
      (fname, ftype, fid) = iprot.readFieldBegin()
17514 
      if ftype == TType.STOP:
17515 
        break
17516 
      else:
17517 
        iprot.skip(ftype)
17518 
      iprot.readFieldEnd()
17519 
    iprot.readStructEnd()
17520 
 
17521 
  def write(self, oprot):
17522 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17523 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17524 
      return
17525 
    oprot.writeStructBegin('deleteCampaign_result')
17526 
    oprot.writeFieldStop()
17527 
    oprot.writeStructEnd()
17528 
 
17529 
  def validate(self):
17530 
    return
17531 
 
17532 
 
17533 
  def __repr__(self):
17534 
    L = ['%s=%r' % (key, value)
17535 
      for key, value in self.__dict__.iteritems()]
17536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17537 
 
17538 
  def __eq__(self, other):
17539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17540 
 
17541 
  def __ne__(self, other):
17542 
    return not (self == other)
17543 
 
17544 
class getAllCampaigns_args:
17545 
 
17546 
  thrift_spec = (
17547 
  )
17548 
 
17549 
  def read(self, iprot):
17550 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17551 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17552 
      return
17553 
    iprot.readStructBegin()
17554 
    while True:
17555 
      (fname, ftype, fid) = iprot.readFieldBegin()
17556 
      if ftype == TType.STOP:
17557 
        break
17558 
      else:
17559 
        iprot.skip(ftype)
17560 
      iprot.readFieldEnd()
17561 
    iprot.readStructEnd()
17562 
 
17563 
  def write(self, oprot):
17564 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17565 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17566 
      return
17567 
    oprot.writeStructBegin('getAllCampaigns_args')
17568 
    oprot.writeFieldStop()
17569 
    oprot.writeStructEnd()
17570 
 
17571 
  def validate(self):
17572 
    return
17573 
 
17574 
 
17575 
  def __repr__(self):
17576 
    L = ['%s=%r' % (key, value)
17577 
      for key, value in self.__dict__.iteritems()]
17578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17579 
 
17580 
  def __eq__(self, other):
17581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17582 
 
17583 
  def __ne__(self, other):
17584 
    return not (self == other)
17585 
 
17586 
class getAllCampaigns_result:
17587 
  """
17588 
  Attributes:
17589 
   - success
17590 
  """
17591 
 
17592 
  thrift_spec = (
17593 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
17594 
  )
17595 
 
17596 
  def __init__(self, success=None,):
17597 
    self.success = success
17598 
 
17599 
  def read(self, iprot):
17600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17602 
      return
17603 
    iprot.readStructBegin()
17604 
    while True:
17605 
      (fname, ftype, fid) = iprot.readFieldBegin()
17606 
      if ftype == TType.STOP:
17607 
        break
17608 
      if fid == 0:
17609 
        if ftype == TType.LIST:
17610 
          self.success = []
18719 kshitij.so 17611 
          (_etype290, _size287) = iprot.readListBegin()
17612 
          for _i291 in xrange(_size287):
17613 
            _elem292 = iprot.readString();
17614 
            self.success.append(_elem292)
8579 kshitij.so 17615 
          iprot.readListEnd()
17616 
        else:
17617 
          iprot.skip(ftype)
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('getAllCampaigns_result')
17628 
    if self.success is not None:
17629 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17630 
      oprot.writeListBegin(TType.STRING, len(self.success))
18719 kshitij.so 17631 
      for iter293 in self.success:
17632 
        oprot.writeString(iter293)
8579 kshitij.so 17633 
      oprot.writeListEnd()
17634 
      oprot.writeFieldEnd()
17635 
    oprot.writeFieldStop()
17636 
    oprot.writeStructEnd()
17637 
 
17638 
  def validate(self):
17639 
    return
17640 
 
17641 
 
17642 
  def __repr__(self):
17643 
    L = ['%s=%r' % (key, value)
17644 
      for key, value in self.__dict__.iteritems()]
17645 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17646 
 
17647 
  def __eq__(self, other):
17648 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17649 
 
17650 
  def __ne__(self, other):
17651 
    return not (self == other)
17652 
 
9155 kshitij.so 17653 
class getActiveBannersForMobileSite_args:
17654 
 
17655 
  thrift_spec = (
17656 
  )
17657 
 
17658 
  def read(self, iprot):
17659 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17660 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17661 
      return
17662 
    iprot.readStructBegin()
17663 
    while True:
17664 
      (fname, ftype, fid) = iprot.readFieldBegin()
17665 
      if ftype == TType.STOP:
17666 
        break
17667 
      else:
17668 
        iprot.skip(ftype)
17669 
      iprot.readFieldEnd()
17670 
    iprot.readStructEnd()
17671 
 
17672 
  def write(self, oprot):
17673 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17674 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17675 
      return
17676 
    oprot.writeStructBegin('getActiveBannersForMobileSite_args')
17677 
    oprot.writeFieldStop()
17678 
    oprot.writeStructEnd()
17679 
 
17680 
  def validate(self):
17681 
    return
17682 
 
17683 
 
17684 
  def __repr__(self):
17685 
    L = ['%s=%r' % (key, value)
17686 
      for key, value in self.__dict__.iteritems()]
17687 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17688 
 
17689 
  def __eq__(self, other):
17690 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17691 
 
17692 
  def __ne__(self, other):
17693 
    return not (self == other)
17694 
 
17695 
class getActiveBannersForMobileSite_result:
17696 
  """
17697 
  Attributes:
17698 
   - success
17699 
  """
17700 
 
17701 
  thrift_spec = (
17702 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
17703 
  )
17704 
 
17705 
  def __init__(self, success=None,):
17706 
    self.success = success
17707 
 
17708 
  def read(self, iprot):
17709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17711 
      return
17712 
    iprot.readStructBegin()
17713 
    while True:
17714 
      (fname, ftype, fid) = iprot.readFieldBegin()
17715 
      if ftype == TType.STOP:
17716 
        break
17717 
      if fid == 0:
17718 
        if ftype == TType.MAP:
17719 
          self.success = {}
18719 kshitij.so 17720 
          (_ktype295, _vtype296, _size294 ) = iprot.readMapBegin()
17721 
          for _i298 in xrange(_size294):
17722 
            _key299 = iprot.readString();
17723 
            _val300 = []
17724 
            (_etype304, _size301) = iprot.readListBegin()
17725 
            for _i305 in xrange(_size301):
17726 
              _elem306 = Banner()
17727 
              _elem306.read(iprot)
17728 
              _val300.append(_elem306)
9155 kshitij.so 17729 
            iprot.readListEnd()
18719 kshitij.so 17730 
            self.success[_key299] = _val300
9155 kshitij.so 17731 
          iprot.readMapEnd()
17732 
        else:
17733 
          iprot.skip(ftype)
17734 
      else:
17735 
        iprot.skip(ftype)
17736 
      iprot.readFieldEnd()
17737 
    iprot.readStructEnd()
17738 
 
17739 
  def write(self, oprot):
17740 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17741 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17742 
      return
17743 
    oprot.writeStructBegin('getActiveBannersForMobileSite_result')
17744 
    if self.success is not None:
17745 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17746 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
18719 kshitij.so 17747 
      for kiter307,viter308 in self.success.items():
17748 
        oprot.writeString(kiter307)
17749 
        oprot.writeListBegin(TType.STRUCT, len(viter308))
17750 
        for iter309 in viter308:
17751 
          iter309.write(oprot)
9155 kshitij.so 17752 
        oprot.writeListEnd()
17753 
      oprot.writeMapEnd()
17754 
      oprot.writeFieldEnd()
17755 
    oprot.writeFieldStop()
17756 
    oprot.writeStructEnd()
17757 
 
17758 
  def validate(self):
17759 
    return
17760 
 
17761 
 
17762 
  def __repr__(self):
17763 
    L = ['%s=%r' % (key, value)
17764 
      for key, value in self.__dict__.iteritems()]
17765 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17766 
 
17767 
  def __eq__(self, other):
17768 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17769 
 
17770 
  def __ne__(self, other):
17771 
    return not (self == other)
17772 
 
5944 mandeep.dh 17773 
class deleteSimilarItem_args:
17774 
  """
17775 
  Attributes:
17776 
   - itemId
17777 
   - catalogItemId
17778 
  """
17779 
 
17780 
  thrift_spec = (
17781 
    None, # 0
17782 
    (1, TType.I64, 'itemId', None, None, ), # 1
17783 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
17784 
  )
17785 
 
17786 
  def __init__(self, itemId=None, catalogItemId=None,):
17787 
    self.itemId = itemId
17788 
    self.catalogItemId = catalogItemId
17789 
 
17790 
  def read(self, iprot):
17791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17793 
      return
17794 
    iprot.readStructBegin()
17795 
    while True:
17796 
      (fname, ftype, fid) = iprot.readFieldBegin()
17797 
      if ftype == TType.STOP:
17798 
        break
17799 
      if fid == 1:
17800 
        if ftype == TType.I64:
17801 
          self.itemId = iprot.readI64();
17802 
        else:
17803 
          iprot.skip(ftype)
17804 
      elif fid == 2:
17805 
        if ftype == TType.I64:
17806 
          self.catalogItemId = iprot.readI64();
17807 
        else:
17808 
          iprot.skip(ftype)
17809 
      else:
17810 
        iprot.skip(ftype)
17811 
      iprot.readFieldEnd()
17812 
    iprot.readStructEnd()
17813 
 
17814 
  def write(self, oprot):
17815 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17816 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17817 
      return
17818 
    oprot.writeStructBegin('deleteSimilarItem_args')
17819 
    if self.itemId is not None:
17820 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17821 
      oprot.writeI64(self.itemId)
17822 
      oprot.writeFieldEnd()
17823 
    if self.catalogItemId is not None:
17824 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
17825 
      oprot.writeI64(self.catalogItemId)
17826 
      oprot.writeFieldEnd()
17827 
    oprot.writeFieldStop()
17828 
    oprot.writeStructEnd()
17829 
 
17830 
  def validate(self):
17831 
    return
17832 
 
17833 
 
17834 
  def __repr__(self):
17835 
    L = ['%s=%r' % (key, value)
17836 
      for key, value in self.__dict__.iteritems()]
17837 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17838 
 
17839 
  def __eq__(self, other):
17840 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17841 
 
17842 
  def __ne__(self, other):
17843 
    return not (self == other)
17844 
 
17845 
class deleteSimilarItem_result:
17846 
  """
17847 
  Attributes:
17848 
   - success
17849 
   - cex
17850 
  """
17851 
 
17852 
  thrift_spec = (
17853 
    (0, TType.BOOL, 'success', None, None, ), # 0
17854 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17855 
  )
17856 
 
17857 
  def __init__(self, success=None, cex=None,):
17858 
    self.success = success
17859 
    self.cex = cex
17860 
 
17861 
  def read(self, iprot):
17862 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17863 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17864 
      return
17865 
    iprot.readStructBegin()
17866 
    while True:
17867 
      (fname, ftype, fid) = iprot.readFieldBegin()
17868 
      if ftype == TType.STOP:
17869 
        break
17870 
      if fid == 0:
17871 
        if ftype == TType.BOOL:
17872 
          self.success = iprot.readBool();
17873 
        else:
17874 
          iprot.skip(ftype)
17875 
      elif fid == 1:
17876 
        if ftype == TType.STRUCT:
17877 
          self.cex = CatalogServiceException()
17878 
          self.cex.read(iprot)
17879 
        else:
17880 
          iprot.skip(ftype)
17881 
      else:
17882 
        iprot.skip(ftype)
17883 
      iprot.readFieldEnd()
17884 
    iprot.readStructEnd()
17885 
 
17886 
  def write(self, oprot):
17887 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17888 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17889 
      return
17890 
    oprot.writeStructBegin('deleteSimilarItem_result')
17891 
    if self.success is not None:
17892 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17893 
      oprot.writeBool(self.success)
17894 
      oprot.writeFieldEnd()
17895 
    if self.cex is not None:
17896 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17897 
      self.cex.write(oprot)
17898 
      oprot.writeFieldEnd()
17899 
    oprot.writeFieldStop()
17900 
    oprot.writeStructEnd()
17901 
 
17902 
  def validate(self):
17903 
    return
17904 
 
17905 
 
17906 
  def __repr__(self):
17907 
    L = ['%s=%r' % (key, value)
17908 
      for key, value in self.__dict__.iteritems()]
17909 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17910 
 
17911 
  def __eq__(self, other):
17912 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17913 
 
17914 
  def __ne__(self, other):
17915 
    return not (self == other)
17916 
 
17917 
class checkSimilarItem_args:
17918 
  """
17919 
  Attributes:
17920 
   - brand
17921 
   - modelNumber
17922 
   - modelName
17923 
   - color
17924 
  """
17925 
 
17926 
  thrift_spec = (
17927 
    None, # 0
17928 
    (1, TType.STRING, 'brand', None, None, ), # 1
17929 
    (2, TType.STRING, 'modelNumber', None, None, ), # 2
17930 
    (3, TType.STRING, 'modelName', None, None, ), # 3
17931 
    (4, TType.STRING, 'color', None, None, ), # 4
17932 
  )
17933 
 
17934 
  def __init__(self, brand=None, modelNumber=None, modelName=None, color=None,):
17935 
    self.brand = brand
17936 
    self.modelNumber = modelNumber
17937 
    self.modelName = modelName
17938 
    self.color = color
17939 
 
17940 
  def read(self, iprot):
17941 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17942 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17943 
      return
17944 
    iprot.readStructBegin()
17945 
    while True:
17946 
      (fname, ftype, fid) = iprot.readFieldBegin()
17947 
      if ftype == TType.STOP:
17948 
        break
17949 
      if fid == 1:
17950 
        if ftype == TType.STRING:
17951 
          self.brand = iprot.readString();
17952 
        else:
17953 
          iprot.skip(ftype)
17954 
      elif fid == 2:
17955 
        if ftype == TType.STRING:
17956 
          self.modelNumber = iprot.readString();
17957 
        else:
17958 
          iprot.skip(ftype)
17959 
      elif fid == 3:
17960 
        if ftype == TType.STRING:
17961 
          self.modelName = iprot.readString();
17962 
        else:
17963 
          iprot.skip(ftype)
17964 
      elif fid == 4:
17965 
        if ftype == TType.STRING:
17966 
          self.color = iprot.readString();
17967 
        else:
17968 
          iprot.skip(ftype)
17969 
      else:
17970 
        iprot.skip(ftype)
17971 
      iprot.readFieldEnd()
17972 
    iprot.readStructEnd()
17973 
 
17974 
  def write(self, oprot):
17975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17977 
      return
17978 
    oprot.writeStructBegin('checkSimilarItem_args')
17979 
    if self.brand is not None:
17980 
      oprot.writeFieldBegin('brand', TType.STRING, 1)
17981 
      oprot.writeString(self.brand)
17982 
      oprot.writeFieldEnd()
17983 
    if self.modelNumber is not None:
17984 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 2)
17985 
      oprot.writeString(self.modelNumber)
17986 
      oprot.writeFieldEnd()
17987 
    if self.modelName is not None:
17988 
      oprot.writeFieldBegin('modelName', TType.STRING, 3)
17989 
      oprot.writeString(self.modelName)
17990 
      oprot.writeFieldEnd()
17991 
    if self.color is not None:
17992 
      oprot.writeFieldBegin('color', TType.STRING, 4)
17993 
      oprot.writeString(self.color)
17994 
      oprot.writeFieldEnd()
17995 
    oprot.writeFieldStop()
17996 
    oprot.writeStructEnd()
17997 
 
17998 
  def validate(self):
17999 
    return
18000 
 
18001 
 
18002 
  def __repr__(self):
18003 
    L = ['%s=%r' % (key, value)
18004 
      for key, value in self.__dict__.iteritems()]
18005 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18006 
 
18007 
  def __eq__(self, other):
18008 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18009 
 
18010 
  def __ne__(self, other):
18011 
    return not (self == other)
18012 
 
18013 
class checkSimilarItem_result:
18014 
  """
18015 
  Attributes:
18016 
   - success
18017 
  """
18018 
 
18019 
  thrift_spec = (
18020 
    (0, TType.I64, 'success', None, None, ), # 0
18021 
  )
18022 
 
18023 
  def __init__(self, success=None,):
18024 
    self.success = success
18025 
 
18026 
  def read(self, iprot):
18027 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18028 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18029 
      return
18030 
    iprot.readStructBegin()
18031 
    while True:
18032 
      (fname, ftype, fid) = iprot.readFieldBegin()
18033 
      if ftype == TType.STOP:
18034 
        break
18035 
      if fid == 0:
18036 
        if ftype == TType.I64:
18037 
          self.success = iprot.readI64();
18038 
        else:
18039 
          iprot.skip(ftype)
18040 
      else:
18041 
        iprot.skip(ftype)
18042 
      iprot.readFieldEnd()
18043 
    iprot.readStructEnd()
18044 
 
18045 
  def write(self, oprot):
18046 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18047 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18048 
      return
18049 
    oprot.writeStructBegin('checkSimilarItem_result')
18050 
    if self.success is not None:
18051 
      oprot.writeFieldBegin('success', TType.I64, 0)
18052 
      oprot.writeI64(self.success)
18053 
      oprot.writeFieldEnd()
18054 
    oprot.writeFieldStop()
18055 
    oprot.writeStructEnd()
18056 
 
18057 
  def validate(self):
18058 
    return
18059 
 
18060 
 
18061 
  def __repr__(self):
18062 
    L = ['%s=%r' % (key, value)
18063 
      for key, value in self.__dict__.iteritems()]
18064 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18065 
 
18066 
  def __eq__(self, other):
18067 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18068 
 
18069 
  def __ne__(self, other):
18070 
    return not (self == other)
18071 
 
18072 
class validateRiskyStatus_args:
18073 
  """
18074 
  Attributes:
18075 
   - itemId
18076 
  """
18077 
 
18078 
  thrift_spec = (
18079 
    None, # 0
18080 
    (1, TType.I64, 'itemId', None, None, ), # 1
18081 
  )
18082 
 
18083 
  def __init__(self, itemId=None,):
18084 
    self.itemId = itemId
18085 
 
18086 
  def read(self, iprot):
18087 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18088 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18089 
      return
18090 
    iprot.readStructBegin()
18091 
    while True:
18092 
      (fname, ftype, fid) = iprot.readFieldBegin()
18093 
      if ftype == TType.STOP:
18094 
        break
18095 
      if fid == 1:
18096 
        if ftype == TType.I64:
18097 
          self.itemId = iprot.readI64();
18098 
        else:
18099 
          iprot.skip(ftype)
18100 
      else:
18101 
        iprot.skip(ftype)
18102 
      iprot.readFieldEnd()
18103 
    iprot.readStructEnd()
18104 
 
18105 
  def write(self, oprot):
18106 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18107 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18108 
      return
18109 
    oprot.writeStructBegin('validateRiskyStatus_args')
18110 
    if self.itemId is not None:
18111 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18112 
      oprot.writeI64(self.itemId)
18113 
      oprot.writeFieldEnd()
18114 
    oprot.writeFieldStop()
18115 
    oprot.writeStructEnd()
18116 
 
18117 
  def validate(self):
18118 
    return
18119 
 
18120 
 
18121 
  def __repr__(self):
18122 
    L = ['%s=%r' % (key, value)
18123 
      for key, value in self.__dict__.iteritems()]
18124 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18125 
 
18126 
  def __eq__(self, other):
18127 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18128 
 
18129 
  def __ne__(self, other):
18130 
    return not (self == other)
18131 
 
18132 
class validateRiskyStatus_result:
18133 
 
18134 
  thrift_spec = (
18135 
  )
18136 
 
18137 
  def read(self, iprot):
18138 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18139 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18140 
      return
18141 
    iprot.readStructBegin()
18142 
    while True:
18143 
      (fname, ftype, fid) = iprot.readFieldBegin()
18144 
      if ftype == TType.STOP:
18145 
        break
18146 
      else:
18147 
        iprot.skip(ftype)
18148 
      iprot.readFieldEnd()
18149 
    iprot.readStructEnd()
18150 
 
18151 
  def write(self, oprot):
18152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18154 
      return
18155 
    oprot.writeStructBegin('validateRiskyStatus_result')
18156 
    oprot.writeFieldStop()
18157 
    oprot.writeStructEnd()
18158 
 
18159 
  def validate(self):
18160 
    return
18161 
 
18162 
 
18163 
  def __repr__(self):
18164 
    L = ['%s=%r' % (key, value)
18165 
      for key, value in self.__dict__.iteritems()]
18166 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18167 
 
18168 
  def __eq__(self, other):
18169 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18170 
 
18171 
  def __ne__(self, other):
18172 
    return not (self == other)
18173 
 
18174 
class changeItemRiskyFlag_args:
18175 
  """
18176 
  Attributes:
18177 
   - itemId
18178 
   - risky
18179 
  """
18180 
 
18181 
  thrift_spec = (
18182 
    None, # 0
18183 
    (1, TType.I64, 'itemId', None, None, ), # 1
18184 
    (2, TType.BOOL, 'risky', None, None, ), # 2
18185 
  )
18186 
 
18187 
  def __init__(self, itemId=None, risky=None,):
18188 
    self.itemId = itemId
18189 
    self.risky = risky
18190 
 
18191 
  def read(self, iprot):
18192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18194 
      return
18195 
    iprot.readStructBegin()
18196 
    while True:
18197 
      (fname, ftype, fid) = iprot.readFieldBegin()
18198 
      if ftype == TType.STOP:
18199 
        break
18200 
      if fid == 1:
18201 
        if ftype == TType.I64:
18202 
          self.itemId = iprot.readI64();
18203 
        else:
18204 
          iprot.skip(ftype)
18205 
      elif fid == 2:
18206 
        if ftype == TType.BOOL:
18207 
          self.risky = iprot.readBool();
18208 
        else:
18209 
          iprot.skip(ftype)
18210 
      else:
18211 
        iprot.skip(ftype)
18212 
      iprot.readFieldEnd()
18213 
    iprot.readStructEnd()
18214 
 
18215 
  def write(self, oprot):
18216 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18217 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18218 
      return
18219 
    oprot.writeStructBegin('changeItemRiskyFlag_args')
18220 
    if self.itemId is not None:
18221 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18222 
      oprot.writeI64(self.itemId)
18223 
      oprot.writeFieldEnd()
18224 
    if self.risky is not None:
18225 
      oprot.writeFieldBegin('risky', TType.BOOL, 2)
18226 
      oprot.writeBool(self.risky)
18227 
      oprot.writeFieldEnd()
18228 
    oprot.writeFieldStop()
18229 
    oprot.writeStructEnd()
18230 
 
18231 
  def validate(self):
18232 
    return
18233 
 
18234 
 
18235 
  def __repr__(self):
18236 
    L = ['%s=%r' % (key, value)
18237 
      for key, value in self.__dict__.iteritems()]
18238 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18239 
 
18240 
  def __eq__(self, other):
18241 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18242 
 
18243 
  def __ne__(self, other):
18244 
    return not (self == other)
18245 
 
18246 
class changeItemRiskyFlag_result:
18247 
 
18248 
  thrift_spec = (
18249 
  )
18250 
 
18251 
  def read(self, iprot):
18252 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18253 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18254 
      return
18255 
    iprot.readStructBegin()
18256 
    while True:
18257 
      (fname, ftype, fid) = iprot.readFieldBegin()
18258 
      if ftype == TType.STOP:
18259 
        break
18260 
      else:
18261 
        iprot.skip(ftype)
18262 
      iprot.readFieldEnd()
18263 
    iprot.readStructEnd()
18264 
 
18265 
  def write(self, oprot):
18266 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18267 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18268 
      return
18269 
    oprot.writeStructBegin('changeItemRiskyFlag_result')
18270 
    oprot.writeFieldStop()
18271 
    oprot.writeStructEnd()
18272 
 
18273 
  def validate(self):
18274 
    return
18275 
 
18276 
 
18277 
  def __repr__(self):
18278 
    L = ['%s=%r' % (key, value)
18279 
      for key, value in self.__dict__.iteritems()]
18280 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18281 
 
18282 
  def __eq__(self, other):
18283 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18284 
 
18285 
  def __ne__(self, other):
18286 
    return not (self == other)
18287 
 
18288 
class getItemsByRiskyFlag_args:
18289 
 
18290 
  thrift_spec = (
18291 
  )
18292 
 
18293 
  def read(self, iprot):
18294 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18295 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18296 
      return
18297 
    iprot.readStructBegin()
18298 
    while True:
18299 
      (fname, ftype, fid) = iprot.readFieldBegin()
18300 
      if ftype == TType.STOP:
18301 
        break
18302 
      else:
18303 
        iprot.skip(ftype)
18304 
      iprot.readFieldEnd()
18305 
    iprot.readStructEnd()
18306 
 
18307 
  def write(self, oprot):
18308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18310 
      return
18311 
    oprot.writeStructBegin('getItemsByRiskyFlag_args')
18312 
    oprot.writeFieldStop()
18313 
    oprot.writeStructEnd()
18314 
 
18315 
  def validate(self):
18316 
    return
18317 
 
18318 
 
18319 
  def __repr__(self):
18320 
    L = ['%s=%r' % (key, value)
18321 
      for key, value in self.__dict__.iteritems()]
18322 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18323 
 
18324 
  def __eq__(self, other):
18325 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18326 
 
18327 
  def __ne__(self, other):
18328 
    return not (self == other)
18329 
 
18330 
class getItemsByRiskyFlag_result:
18331 
  """
18332 
  Attributes:
18333 
   - success
18334 
  """
18335 
 
18336 
  thrift_spec = (
18337 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
18338 
  )
18339 
 
18340 
  def __init__(self, success=None,):
18341 
    self.success = success
18342 
 
18343 
  def read(self, iprot):
18344 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18345 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18346 
      return
18347 
    iprot.readStructBegin()
18348 
    while True:
18349 
      (fname, ftype, fid) = iprot.readFieldBegin()
18350 
      if ftype == TType.STOP:
18351 
        break
18352 
      if fid == 0:
18353 
        if ftype == TType.LIST:
18354 
          self.success = []
18719 kshitij.so 18355 
          (_etype313, _size310) = iprot.readListBegin()
18356 
          for _i314 in xrange(_size310):
18357 
            _elem315 = Item()
18358 
            _elem315.read(iprot)
18359 
            self.success.append(_elem315)
5944 mandeep.dh 18360 
          iprot.readListEnd()
18361 
        else:
18362 
          iprot.skip(ftype)
18363 
      else:
18364 
        iprot.skip(ftype)
18365 
      iprot.readFieldEnd()
18366 
    iprot.readStructEnd()
18367 
 
18368 
  def write(self, oprot):
18369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18371 
      return
18372 
    oprot.writeStructBegin('getItemsByRiskyFlag_result')
18373 
    if self.success is not None:
18374 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18375 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 18376 
      for iter316 in self.success:
18377 
        iter316.write(oprot)
5944 mandeep.dh 18378 
      oprot.writeListEnd()
18379 
      oprot.writeFieldEnd()
18380 
    oprot.writeFieldStop()
18381 
    oprot.writeStructEnd()
18382 
 
18383 
  def validate(self):
18384 
    return
18385 
 
18386 
 
18387 
  def __repr__(self):
18388 
    L = ['%s=%r' % (key, value)
18389 
      for key, value in self.__dict__.iteritems()]
18390 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18391 
 
18392 
  def __eq__(self, other):
18393 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18394 
 
18395 
  def __ne__(self, other):
18396 
    return not (self == other)
18397 
 
18398 
class getItemsForMasterSheet_args:
18399 
  """
18400 
  Attributes:
18401 
   - category
18402 
   - brand
18403 
  """
18404 
 
18405 
  thrift_spec = (
18406 
    None, # 0
18407 
    (1, TType.STRING, 'category', None, None, ), # 1
18408 
    (2, TType.STRING, 'brand', None, None, ), # 2
18409 
  )
18410 
 
18411 
  def __init__(self, category=None, brand=None,):
18412 
    self.category = category
18413 
    self.brand = brand
18414 
 
18415 
  def read(self, iprot):
18416 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18417 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18418 
      return
18419 
    iprot.readStructBegin()
18420 
    while True:
18421 
      (fname, ftype, fid) = iprot.readFieldBegin()
18422 
      if ftype == TType.STOP:
18423 
        break
18424 
      if fid == 1:
18425 
        if ftype == TType.STRING:
18426 
          self.category = iprot.readString();
18427 
        else:
18428 
          iprot.skip(ftype)
18429 
      elif fid == 2:
18430 
        if ftype == TType.STRING:
18431 
          self.brand = iprot.readString();
18432 
        else:
18433 
          iprot.skip(ftype)
18434 
      else:
18435 
        iprot.skip(ftype)
18436 
      iprot.readFieldEnd()
18437 
    iprot.readStructEnd()
18438 
 
18439 
  def write(self, oprot):
18440 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18441 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18442 
      return
18443 
    oprot.writeStructBegin('getItemsForMasterSheet_args')
18444 
    if self.category is not None:
18445 
      oprot.writeFieldBegin('category', TType.STRING, 1)
18446 
      oprot.writeString(self.category)
18447 
      oprot.writeFieldEnd()
18448 
    if self.brand is not None:
18449 
      oprot.writeFieldBegin('brand', TType.STRING, 2)
18450 
      oprot.writeString(self.brand)
18451 
      oprot.writeFieldEnd()
18452 
    oprot.writeFieldStop()
18453 
    oprot.writeStructEnd()
18454 
 
18455 
  def validate(self):
18456 
    return
18457 
 
18458 
 
18459 
  def __repr__(self):
18460 
    L = ['%s=%r' % (key, value)
18461 
      for key, value in self.__dict__.iteritems()]
18462 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18463 
 
18464 
  def __eq__(self, other):
18465 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18466 
 
18467 
  def __ne__(self, other):
18468 
    return not (self == other)
18469 
 
18470 
class getItemsForMasterSheet_result:
18471 
  """
18472 
  Attributes:
18473 
   - success
18474 
  """
18475 
 
18476 
  thrift_spec = (
18477 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
18478 
  )
18479 
 
18480 
  def __init__(self, success=None,):
18481 
    self.success = success
18482 
 
18483 
  def read(self, iprot):
18484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18486 
      return
18487 
    iprot.readStructBegin()
18488 
    while True:
18489 
      (fname, ftype, fid) = iprot.readFieldBegin()
18490 
      if ftype == TType.STOP:
18491 
        break
18492 
      if fid == 0:
18493 
        if ftype == TType.LIST:
18494 
          self.success = []
18719 kshitij.so 18495 
          (_etype320, _size317) = iprot.readListBegin()
18496 
          for _i321 in xrange(_size317):
18497 
            _elem322 = Item()
18498 
            _elem322.read(iprot)
18499 
            self.success.append(_elem322)
5944 mandeep.dh 18500 
          iprot.readListEnd()
18501 
        else:
18502 
          iprot.skip(ftype)
18503 
      else:
18504 
        iprot.skip(ftype)
18505 
      iprot.readFieldEnd()
18506 
    iprot.readStructEnd()
18507 
 
18508 
  def write(self, oprot):
18509 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18510 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18511 
      return
18512 
    oprot.writeStructBegin('getItemsForMasterSheet_result')
18513 
    if self.success is not None:
18514 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18515 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 18516 
      for iter323 in self.success:
18517 
        iter323.write(oprot)
5944 mandeep.dh 18518 
      oprot.writeListEnd()
18519 
      oprot.writeFieldEnd()
18520 
    oprot.writeFieldStop()
18521 
    oprot.writeStructEnd()
18522 
 
18523 
  def validate(self):
18524 
    return
18525 
 
18526 
 
18527 
  def __repr__(self):
18528 
    L = ['%s=%r' % (key, value)
18529 
      for key, value in self.__dict__.iteritems()]
18530 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18531 
 
18532 
  def __eq__(self, other):
18533 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18534 
 
18535 
  def __ne__(self, other):
18536 
    return not (self == other)
18537 
 
18538 
class getSimilarItemsCatalogIds_args:
18539 
  """
18540 
  Attributes:
18541 
   - beginIndex
18542 
   - totalItems
18543 
   - itemId
18544 
  """
18545 
 
18546 
  thrift_spec = (
18547 
    None, # 0
18548 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
18549 
    (2, TType.I64, 'totalItems', None, None, ), # 2
18550 
    (3, TType.I64, 'itemId', None, None, ), # 3
18551 
  )
18552 
 
18553 
  def __init__(self, beginIndex=None, totalItems=None, itemId=None,):
18554 
    self.beginIndex = beginIndex
18555 
    self.totalItems = totalItems
18556 
    self.itemId = itemId
18557 
 
18558 
  def read(self, iprot):
18559 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18560 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18561 
      return
18562 
    iprot.readStructBegin()
18563 
    while True:
18564 
      (fname, ftype, fid) = iprot.readFieldBegin()
18565 
      if ftype == TType.STOP:
18566 
        break
18567 
      if fid == 1:
18568 
        if ftype == TType.I64:
18569 
          self.beginIndex = iprot.readI64();
18570 
        else:
18571 
          iprot.skip(ftype)
18572 
      elif fid == 2:
18573 
        if ftype == TType.I64:
18574 
          self.totalItems = iprot.readI64();
18575 
        else:
18576 
          iprot.skip(ftype)
18577 
      elif fid == 3:
18578 
        if ftype == TType.I64:
18579 
          self.itemId = iprot.readI64();
18580 
        else:
18581 
          iprot.skip(ftype)
18582 
      else:
18583 
        iprot.skip(ftype)
18584 
      iprot.readFieldEnd()
18585 
    iprot.readStructEnd()
18586 
 
18587 
  def write(self, oprot):
18588 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18589 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18590 
      return
18591 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_args')
18592 
    if self.beginIndex is not None:
18593 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
18594 
      oprot.writeI64(self.beginIndex)
18595 
      oprot.writeFieldEnd()
18596 
    if self.totalItems is not None:
18597 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
18598 
      oprot.writeI64(self.totalItems)
18599 
      oprot.writeFieldEnd()
18600 
    if self.itemId is not None:
18601 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
18602 
      oprot.writeI64(self.itemId)
18603 
      oprot.writeFieldEnd()
18604 
    oprot.writeFieldStop()
18605 
    oprot.writeStructEnd()
18606 
 
18607 
  def validate(self):
18608 
    return
18609 
 
18610 
 
18611 
  def __repr__(self):
18612 
    L = ['%s=%r' % (key, value)
18613 
      for key, value in self.__dict__.iteritems()]
18614 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18615 
 
18616 
  def __eq__(self, other):
18617 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18618 
 
18619 
  def __ne__(self, other):
18620 
    return not (self == other)
18621 
 
18622 
class getSimilarItemsCatalogIds_result:
18623 
  """
18624 
  Attributes:
18625 
   - success
18626 
  """
18627 
 
18628 
  thrift_spec = (
18629 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
18630 
  )
18631 
 
18632 
  def __init__(self, success=None,):
18633 
    self.success = success
18634 
 
18635 
  def read(self, iprot):
18636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18638 
      return
18639 
    iprot.readStructBegin()
18640 
    while True:
18641 
      (fname, ftype, fid) = iprot.readFieldBegin()
18642 
      if ftype == TType.STOP:
18643 
        break
18644 
      if fid == 0:
18645 
        if ftype == TType.LIST:
18646 
          self.success = []
18719 kshitij.so 18647 
          (_etype327, _size324) = iprot.readListBegin()
18648 
          for _i328 in xrange(_size324):
18649 
            _elem329 = iprot.readI64();
18650 
            self.success.append(_elem329)
5944 mandeep.dh 18651 
          iprot.readListEnd()
18652 
        else:
18653 
          iprot.skip(ftype)
18654 
      else:
18655 
        iprot.skip(ftype)
18656 
      iprot.readFieldEnd()
18657 
    iprot.readStructEnd()
18658 
 
18659 
  def write(self, oprot):
18660 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18661 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18662 
      return
18663 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_result')
18664 
    if self.success is not None:
18665 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18666 
      oprot.writeListBegin(TType.I64, len(self.success))
18719 kshitij.so 18667 
      for iter330 in self.success:
18668 
        oprot.writeI64(iter330)
5944 mandeep.dh 18669 
      oprot.writeListEnd()
18670 
      oprot.writeFieldEnd()
18671 
    oprot.writeFieldStop()
18672 
    oprot.writeStructEnd()
18673 
 
18674 
  def validate(self):
18675 
    return
18676 
 
18677 
 
18678 
  def __repr__(self):
18679 
    L = ['%s=%r' % (key, value)
18680 
      for key, value in self.__dict__.iteritems()]
18681 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18682 
 
18683 
  def __eq__(self, other):
18684 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18685 
 
18686 
  def __ne__(self, other):
18687 
    return not (self == other)
18688 
 
18689 
class addProductNotification_args:
18690 
  """
18691 
  Attributes:
18692 
   - itemId
18693 
   - email
18694 
  """
18695 
 
18696 
  thrift_spec = None
18697 
  def __init__(self, itemId=None, email=None,):
18698 
    self.itemId = itemId
18699 
    self.email = email
18700 
 
18701 
  def read(self, iprot):
18702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18704 
      return
18705 
    iprot.readStructBegin()
18706 
    while True:
18707 
      (fname, ftype, fid) = iprot.readFieldBegin()
18708 
      if ftype == TType.STOP:
18709 
        break
18710 
      if fid == -1:
18711 
        if ftype == TType.I64:
18712 
          self.itemId = iprot.readI64();
18713 
        else:
18714 
          iprot.skip(ftype)
18715 
      elif fid == -2:
18716 
        if ftype == TType.STRING:
18717 
          self.email = iprot.readString();
18718 
        else:
18719 
          iprot.skip(ftype)
18720 
      else:
18721 
        iprot.skip(ftype)
18722 
      iprot.readFieldEnd()
18723 
    iprot.readStructEnd()
18724 
 
18725 
  def write(self, oprot):
18726 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18727 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18728 
      return
18729 
    oprot.writeStructBegin('addProductNotification_args')
18730 
    if self.email is not None:
18731 
      oprot.writeFieldBegin('email', TType.STRING, -2)
18732 
      oprot.writeString(self.email)
18733 
      oprot.writeFieldEnd()
18734 
    if self.itemId is not None:
18735 
      oprot.writeFieldBegin('itemId', TType.I64, -1)
18736 
      oprot.writeI64(self.itemId)
18737 
      oprot.writeFieldEnd()
18738 
    oprot.writeFieldStop()
18739 
    oprot.writeStructEnd()
18740 
 
18741 
  def validate(self):
18742 
    return
18743 
 
18744 
 
18745 
  def __repr__(self):
18746 
    L = ['%s=%r' % (key, value)
18747 
      for key, value in self.__dict__.iteritems()]
18748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18749 
 
18750 
  def __eq__(self, other):
18751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18752 
 
18753 
  def __ne__(self, other):
18754 
    return not (self == other)
18755 
 
18756 
class addProductNotification_result:
18757 
  """
18758 
  Attributes:
18759 
   - success
18760 
  """
18761 
 
18762 
  thrift_spec = (
18763 
    (0, TType.BOOL, 'success', None, None, ), # 0
18764 
  )
18765 
 
18766 
  def __init__(self, success=None,):
18767 
    self.success = success
18768 
 
18769 
  def read(self, iprot):
18770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18772 
      return
18773 
    iprot.readStructBegin()
18774 
    while True:
18775 
      (fname, ftype, fid) = iprot.readFieldBegin()
18776 
      if ftype == TType.STOP:
18777 
        break
18778 
      if fid == 0:
18779 
        if ftype == TType.BOOL:
18780 
          self.success = iprot.readBool();
18781 
        else:
18782 
          iprot.skip(ftype)
18783 
      else:
18784 
        iprot.skip(ftype)
18785 
      iprot.readFieldEnd()
18786 
    iprot.readStructEnd()
18787 
 
18788 
  def write(self, oprot):
18789 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18790 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18791 
      return
18792 
    oprot.writeStructBegin('addProductNotification_result')
18793 
    if self.success is not None:
18794 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18795 
      oprot.writeBool(self.success)
18796 
      oprot.writeFieldEnd()
18797 
    oprot.writeFieldStop()
18798 
    oprot.writeStructEnd()
18799 
 
18800 
  def validate(self):
18801 
    return
18802 
 
18803 
 
18804 
  def __repr__(self):
18805 
    L = ['%s=%r' % (key, value)
18806 
      for key, value in self.__dict__.iteritems()]
18807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18808 
 
18809 
  def __eq__(self, other):
18810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18811 
 
18812 
  def __ne__(self, other):
18813 
    return not (self == other)
18814 
 
18815 
class sendProductNotifications_args:
18816 
 
18817 
  thrift_spec = (
18818 
  )
18819 
 
18820 
  def read(self, iprot):
18821 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18822 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18823 
      return
18824 
    iprot.readStructBegin()
18825 
    while True:
18826 
      (fname, ftype, fid) = iprot.readFieldBegin()
18827 
      if ftype == TType.STOP:
18828 
        break
18829 
      else:
18830 
        iprot.skip(ftype)
18831 
      iprot.readFieldEnd()
18832 
    iprot.readStructEnd()
18833 
 
18834 
  def write(self, oprot):
18835 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18836 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18837 
      return
18838 
    oprot.writeStructBegin('sendProductNotifications_args')
18839 
    oprot.writeFieldStop()
18840 
    oprot.writeStructEnd()
18841 
 
18842 
  def validate(self):
18843 
    return
18844 
 
18845 
 
18846 
  def __repr__(self):
18847 
    L = ['%s=%r' % (key, value)
18848 
      for key, value in self.__dict__.iteritems()]
18849 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18850 
 
18851 
  def __eq__(self, other):
18852 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18853 
 
18854 
  def __ne__(self, other):
18855 
    return not (self == other)
18856 
 
18857 
class sendProductNotifications_result:
18858 
  """
18859 
  Attributes:
18860 
   - success
18861 
  """
18862 
 
18863 
  thrift_spec = (
18864 
    (0, TType.BOOL, 'success', None, None, ), # 0
18865 
  )
18866 
 
18867 
  def __init__(self, success=None,):
18868 
    self.success = success
18869 
 
18870 
  def read(self, iprot):
18871 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18872 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18873 
      return
18874 
    iprot.readStructBegin()
18875 
    while True:
18876 
      (fname, ftype, fid) = iprot.readFieldBegin()
18877 
      if ftype == TType.STOP:
18878 
        break
18879 
      if fid == 0:
18880 
        if ftype == TType.BOOL:
18881 
          self.success = iprot.readBool();
18882 
        else:
18883 
          iprot.skip(ftype)
18884 
      else:
18885 
        iprot.skip(ftype)
18886 
      iprot.readFieldEnd()
18887 
    iprot.readStructEnd()
18888 
 
18889 
  def write(self, oprot):
18890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18892 
      return
18893 
    oprot.writeStructBegin('sendProductNotifications_result')
18894 
    if self.success is not None:
18895 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18896 
      oprot.writeBool(self.success)
18897 
      oprot.writeFieldEnd()
18898 
    oprot.writeFieldStop()
18899 
    oprot.writeStructEnd()
18900 
 
18901 
  def validate(self):
18902 
    return
18903 
 
18904 
 
18905 
  def __repr__(self):
18906 
    L = ['%s=%r' % (key, value)
18907 
      for key, value in self.__dict__.iteritems()]
18908 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18909 
 
18910 
  def __eq__(self, other):
18911 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18912 
 
18913 
  def __ne__(self, other):
18914 
    return not (self == other)
18915 
 
18916 
class getAllBrandsByCategory_args:
18917 
  """
18918 
  Attributes:
18919 
   - categoryId
18920 
  """
18921 
 
18922 
  thrift_spec = (
18923 
    None, # 0
18924 
    (1, TType.I64, 'categoryId', None, None, ), # 1
18925 
  )
18926 
 
18927 
  def __init__(self, categoryId=None,):
18928 
    self.categoryId = categoryId
18929 
 
18930 
  def read(self, iprot):
18931 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18932 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18933 
      return
18934 
    iprot.readStructBegin()
18935 
    while True:
18936 
      (fname, ftype, fid) = iprot.readFieldBegin()
18937 
      if ftype == TType.STOP:
18938 
        break
18939 
      if fid == 1:
18940 
        if ftype == TType.I64:
18941 
          self.categoryId = iprot.readI64();
18942 
        else:
18943 
          iprot.skip(ftype)
18944 
      else:
18945 
        iprot.skip(ftype)
18946 
      iprot.readFieldEnd()
18947 
    iprot.readStructEnd()
18948 
 
18949 
  def write(self, oprot):
18950 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18951 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18952 
      return
18953 
    oprot.writeStructBegin('getAllBrandsByCategory_args')
18954 
    if self.categoryId is not None:
18955 
      oprot.writeFieldBegin('categoryId', TType.I64, 1)
18956 
      oprot.writeI64(self.categoryId)
18957 
      oprot.writeFieldEnd()
18958 
    oprot.writeFieldStop()
18959 
    oprot.writeStructEnd()
18960 
 
18961 
  def validate(self):
18962 
    return
18963 
 
18964 
 
18965 
  def __repr__(self):
18966 
    L = ['%s=%r' % (key, value)
18967 
      for key, value in self.__dict__.iteritems()]
18968 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18969 
 
18970 
  def __eq__(self, other):
18971 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18972 
 
18973 
  def __ne__(self, other):
18974 
    return not (self == other)
18975 
 
18976 
class getAllBrandsByCategory_result:
18977 
  """
18978 
  Attributes:
18979 
   - success
18980 
  """
18981 
 
18982 
  thrift_spec = (
18983 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
18984 
  )
18985 
 
18986 
  def __init__(self, success=None,):
18987 
    self.success = success
18988 
 
18989 
  def read(self, iprot):
18990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18992 
      return
18993 
    iprot.readStructBegin()
18994 
    while True:
18995 
      (fname, ftype, fid) = iprot.readFieldBegin()
18996 
      if ftype == TType.STOP:
18997 
        break
18998 
      if fid == 0:
18999 
        if ftype == TType.LIST:
19000 
          self.success = []
18719 kshitij.so 19001 
          (_etype334, _size331) = iprot.readListBegin()
19002 
          for _i335 in xrange(_size331):
19003 
            _elem336 = iprot.readString();
19004 
            self.success.append(_elem336)
5944 mandeep.dh 19005 
          iprot.readListEnd()
19006 
        else:
19007 
          iprot.skip(ftype)
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('getAllBrandsByCategory_result')
19018 
    if self.success is not None:
19019 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19020 
      oprot.writeListBegin(TType.STRING, len(self.success))
18719 kshitij.so 19021 
      for iter337 in self.success:
19022 
        oprot.writeString(iter337)
5944 mandeep.dh 19023 
      oprot.writeListEnd()
19024 
      oprot.writeFieldEnd()
19025 
    oprot.writeFieldStop()
19026 
    oprot.writeStructEnd()
19027 
 
19028 
  def validate(self):
19029 
    return
19030 
 
19031 
 
19032 
  def __repr__(self):
19033 
    L = ['%s=%r' % (key, value)
19034 
      for key, value in self.__dict__.iteritems()]
19035 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19036 
 
19037 
  def __eq__(self, other):
19038 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19039 
 
19040 
  def __ne__(self, other):
19041 
    return not (self == other)
19042 
 
19043 
class getAllBrands_args:
19044 
 
19045 
  thrift_spec = (
19046 
  )
19047 
 
19048 
  def read(self, iprot):
19049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19051 
      return
19052 
    iprot.readStructBegin()
19053 
    while True:
19054 
      (fname, ftype, fid) = iprot.readFieldBegin()
19055 
      if ftype == TType.STOP:
19056 
        break
19057 
      else:
19058 
        iprot.skip(ftype)
19059 
      iprot.readFieldEnd()
19060 
    iprot.readStructEnd()
19061 
 
19062 
  def write(self, oprot):
19063 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19064 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19065 
      return
19066 
    oprot.writeStructBegin('getAllBrands_args')
19067 
    oprot.writeFieldStop()
19068 
    oprot.writeStructEnd()
19069 
 
19070 
  def validate(self):
19071 
    return
19072 
 
19073 
 
19074 
  def __repr__(self):
19075 
    L = ['%s=%r' % (key, value)
19076 
      for key, value in self.__dict__.iteritems()]
19077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19078 
 
19079 
  def __eq__(self, other):
19080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19081 
 
19082 
  def __ne__(self, other):
19083 
    return not (self == other)
19084 
 
19085 
class getAllBrands_result:
19086 
  """
19087 
  Attributes:
19088 
   - success
19089 
  """
19090 
 
19091 
  thrift_spec = (
19092 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
19093 
  )
19094 
 
19095 
  def __init__(self, success=None,):
19096 
    self.success = success
19097 
 
19098 
  def read(self, iprot):
19099 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19100 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19101 
      return
19102 
    iprot.readStructBegin()
19103 
    while True:
19104 
      (fname, ftype, fid) = iprot.readFieldBegin()
19105 
      if ftype == TType.STOP:
19106 
        break
19107 
      if fid == 0:
19108 
        if ftype == TType.LIST:
19109 
          self.success = []
18719 kshitij.so 19110 
          (_etype341, _size338) = iprot.readListBegin()
19111 
          for _i342 in xrange(_size338):
19112 
            _elem343 = iprot.readString();
19113 
            self.success.append(_elem343)
5944 mandeep.dh 19114 
          iprot.readListEnd()
19115 
        else:
19116 
          iprot.skip(ftype)
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('getAllBrands_result')
19127 
    if self.success is not None:
19128 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19129 
      oprot.writeListBegin(TType.STRING, len(self.success))
18719 kshitij.so 19130 
      for iter344 in self.success:
19131 
        oprot.writeString(iter344)
5944 mandeep.dh 19132 
      oprot.writeListEnd()
19133 
      oprot.writeFieldEnd()
19134 
    oprot.writeFieldStop()
19135 
    oprot.writeStructEnd()
19136 
 
19137 
  def validate(self):
19138 
    return
19139 
 
19140 
 
19141 
  def __repr__(self):
19142 
    L = ['%s=%r' % (key, value)
19143 
      for key, value in self.__dict__.iteritems()]
19144 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19145 
 
19146 
  def __eq__(self, other):
19147 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19148 
 
19149 
  def __ne__(self, other):
19150 
    return not (self == other)
19151 
 
19152 
class getAllSources_args:
19153 
 
19154 
  thrift_spec = (
19155 
  )
19156 
 
19157 
  def read(self, iprot):
19158 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19159 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19160 
      return
19161 
    iprot.readStructBegin()
19162 
    while True:
19163 
      (fname, ftype, fid) = iprot.readFieldBegin()
19164 
      if ftype == TType.STOP:
19165 
        break
19166 
      else:
19167 
        iprot.skip(ftype)
19168 
      iprot.readFieldEnd()
19169 
    iprot.readStructEnd()
19170 
 
19171 
  def write(self, oprot):
19172 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19173 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19174 
      return
19175 
    oprot.writeStructBegin('getAllSources_args')
19176 
    oprot.writeFieldStop()
19177 
    oprot.writeStructEnd()
19178 
 
19179 
  def validate(self):
19180 
    return
19181 
 
19182 
 
19183 
  def __repr__(self):
19184 
    L = ['%s=%r' % (key, value)
19185 
      for key, value in self.__dict__.iteritems()]
19186 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19187 
 
19188 
  def __eq__(self, other):
19189 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19190 
 
19191 
  def __ne__(self, other):
19192 
    return not (self == other)
19193 
 
19194 
class getAllSources_result:
19195 
  """
19196 
  Attributes:
19197 
   - success
19198 
  """
19199 
 
19200 
  thrift_spec = (
19201 
    (0, TType.LIST, 'success', (TType.STRUCT,(Source, Source.thrift_spec)), None, ), # 0
19202 
  )
19203 
 
19204 
  def __init__(self, success=None,):
19205 
    self.success = success
19206 
 
19207 
  def read(self, iprot):
19208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19210 
      return
19211 
    iprot.readStructBegin()
19212 
    while True:
19213 
      (fname, ftype, fid) = iprot.readFieldBegin()
19214 
      if ftype == TType.STOP:
19215 
        break
19216 
      if fid == 0:
19217 
        if ftype == TType.LIST:
19218 
          self.success = []
18719 kshitij.so 19219 
          (_etype348, _size345) = iprot.readListBegin()
19220 
          for _i349 in xrange(_size345):
19221 
            _elem350 = Source()
19222 
            _elem350.read(iprot)
19223 
            self.success.append(_elem350)
5944 mandeep.dh 19224 
          iprot.readListEnd()
19225 
        else:
19226 
          iprot.skip(ftype)
19227 
      else:
19228 
        iprot.skip(ftype)
19229 
      iprot.readFieldEnd()
19230 
    iprot.readStructEnd()
19231 
 
19232 
  def write(self, oprot):
19233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19235 
      return
19236 
    oprot.writeStructBegin('getAllSources_result')
19237 
    if self.success is not None:
19238 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19239 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 19240 
      for iter351 in self.success:
19241 
        iter351.write(oprot)
5944 mandeep.dh 19242 
      oprot.writeListEnd()
19243 
      oprot.writeFieldEnd()
19244 
    oprot.writeFieldStop()
19245 
    oprot.writeStructEnd()
19246 
 
19247 
  def validate(self):
19248 
    return
19249 
 
19250 
 
19251 
  def __repr__(self):
19252 
    L = ['%s=%r' % (key, value)
19253 
      for key, value in self.__dict__.iteritems()]
19254 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19255 
 
19256 
  def __eq__(self, other):
19257 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19258 
 
19259 
  def __ne__(self, other):
19260 
    return not (self == other)
19261 
 
19262 
class getItemPricingBySource_args:
19263 
  """
19264 
  Attributes:
19265 
   - itemId
19266 
   - sourceId
19267 
  """
19268 
 
19269 
  thrift_spec = (
19270 
    None, # 0
19271 
    (1, TType.I64, 'itemId', None, None, ), # 1
19272 
    (2, TType.I64, 'sourceId', None, None, ), # 2
19273 
  )
19274 
 
19275 
  def __init__(self, itemId=None, sourceId=None,):
19276 
    self.itemId = itemId
19277 
    self.sourceId = sourceId
19278 
 
19279 
  def read(self, iprot):
19280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19282 
      return
19283 
    iprot.readStructBegin()
19284 
    while True:
19285 
      (fname, ftype, fid) = iprot.readFieldBegin()
19286 
      if ftype == TType.STOP:
19287 
        break
19288 
      if fid == 1:
19289 
        if ftype == TType.I64:
19290 
          self.itemId = iprot.readI64();
19291 
        else:
19292 
          iprot.skip(ftype)
19293 
      elif fid == 2:
19294 
        if ftype == TType.I64:
19295 
          self.sourceId = iprot.readI64();
19296 
        else:
19297 
          iprot.skip(ftype)
19298 
      else:
19299 
        iprot.skip(ftype)
19300 
      iprot.readFieldEnd()
19301 
    iprot.readStructEnd()
19302 
 
19303 
  def write(self, oprot):
19304 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19305 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19306 
      return
19307 
    oprot.writeStructBegin('getItemPricingBySource_args')
19308 
    if self.itemId is not None:
19309 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19310 
      oprot.writeI64(self.itemId)
19311 
      oprot.writeFieldEnd()
19312 
    if self.sourceId is not None:
19313 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
19314 
      oprot.writeI64(self.sourceId)
19315 
      oprot.writeFieldEnd()
19316 
    oprot.writeFieldStop()
19317 
    oprot.writeStructEnd()
19318 
 
19319 
  def validate(self):
19320 
    return
19321 
 
19322 
 
19323 
  def __repr__(self):
19324 
    L = ['%s=%r' % (key, value)
19325 
      for key, value in self.__dict__.iteritems()]
19326 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19327 
 
19328 
  def __eq__(self, other):
19329 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19330 
 
19331 
  def __ne__(self, other):
19332 
    return not (self == other)
19333 
 
19334 
class getItemPricingBySource_result:
19335 
  """
19336 
  Attributes:
19337 
   - success
19338 
   - cex
19339 
  """
19340 
 
19341 
  thrift_spec = (
19342 
    (0, TType.STRUCT, 'success', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 0
19343 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
19344 
  )
19345 
 
19346 
  def __init__(self, success=None, cex=None,):
19347 
    self.success = success
19348 
    self.cex = cex
19349 
 
19350 
  def read(self, iprot):
19351 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19352 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19353 
      return
19354 
    iprot.readStructBegin()
19355 
    while True:
19356 
      (fname, ftype, fid) = iprot.readFieldBegin()
19357 
      if ftype == TType.STOP:
19358 
        break
19359 
      if fid == 0:
19360 
        if ftype == TType.STRUCT:
19361 
          self.success = SourceItemPricing()
19362 
          self.success.read(iprot)
19363 
        else:
19364 
          iprot.skip(ftype)
19365 
      elif fid == 1:
19366 
        if ftype == TType.STRUCT:
19367 
          self.cex = CatalogServiceException()
19368 
          self.cex.read(iprot)
19369 
        else:
19370 
          iprot.skip(ftype)
19371 
      else:
19372 
        iprot.skip(ftype)
19373 
      iprot.readFieldEnd()
19374 
    iprot.readStructEnd()
19375 
 
19376 
  def write(self, oprot):
19377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19379 
      return
19380 
    oprot.writeStructBegin('getItemPricingBySource_result')
19381 
    if self.success is not None:
19382 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19383 
      self.success.write(oprot)
19384 
      oprot.writeFieldEnd()
19385 
    if self.cex is not None:
19386 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
19387 
      self.cex.write(oprot)
19388 
      oprot.writeFieldEnd()
19389 
    oprot.writeFieldStop()
19390 
    oprot.writeStructEnd()
19391 
 
19392 
  def validate(self):
19393 
    return
19394 
 
19395 
 
19396 
  def __repr__(self):
19397 
    L = ['%s=%r' % (key, value)
19398 
      for key, value in self.__dict__.iteritems()]
19399 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19400 
 
19401 
  def __eq__(self, other):
19402 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19403 
 
19404 
  def __ne__(self, other):
19405 
    return not (self == other)
19406 
 
19407 
class addSourceItemPricing_args:
19408 
  """
19409 
  Attributes:
19410 
   - sourceItemPricing
19411 
  """
19412 
 
19413 
  thrift_spec = (
19414 
    None, # 0
19415 
    (1, TType.STRUCT, 'sourceItemPricing', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 1
19416 
  )
19417 
 
19418 
  def __init__(self, sourceItemPricing=None,):
19419 
    self.sourceItemPricing = sourceItemPricing
19420 
 
19421 
  def read(self, iprot):
19422 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19423 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19424 
      return
19425 
    iprot.readStructBegin()
19426 
    while True:
19427 
      (fname, ftype, fid) = iprot.readFieldBegin()
19428 
      if ftype == TType.STOP:
19429 
        break
19430 
      if fid == 1:
19431 
        if ftype == TType.STRUCT:
19432 
          self.sourceItemPricing = SourceItemPricing()
19433 
          self.sourceItemPricing.read(iprot)
19434 
        else:
19435 
          iprot.skip(ftype)
19436 
      else:
19437 
        iprot.skip(ftype)
19438 
      iprot.readFieldEnd()
19439 
    iprot.readStructEnd()
19440 
 
19441 
  def write(self, oprot):
19442 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19443 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19444 
      return
19445 
    oprot.writeStructBegin('addSourceItemPricing_args')
19446 
    if self.sourceItemPricing is not None:
19447 
      oprot.writeFieldBegin('sourceItemPricing', TType.STRUCT, 1)
19448 
      self.sourceItemPricing.write(oprot)
19449 
      oprot.writeFieldEnd()
19450 
    oprot.writeFieldStop()
19451 
    oprot.writeStructEnd()
19452 
 
19453 
  def validate(self):
19454 
    return
19455 
 
19456 
 
19457 
  def __repr__(self):
19458 
    L = ['%s=%r' % (key, value)
19459 
      for key, value in self.__dict__.iteritems()]
19460 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19461 
 
19462 
  def __eq__(self, other):
19463 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19464 
 
19465 
  def __ne__(self, other):
19466 
    return not (self == other)
19467 
 
19468 
class addSourceItemPricing_result:
19469 
  """
19470 
  Attributes:
19471 
   - cex
19472 
  """
19473 
 
19474 
  thrift_spec = (
19475 
    None, # 0
19476 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
19477 
  )
19478 
 
19479 
  def __init__(self, cex=None,):
19480 
    self.cex = cex
19481 
 
19482 
  def read(self, iprot):
19483 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19484 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19485 
      return
19486 
    iprot.readStructBegin()
19487 
    while True:
19488 
      (fname, ftype, fid) = iprot.readFieldBegin()
19489 
      if ftype == TType.STOP:
19490 
        break
19491 
      if fid == 1:
19492 
        if ftype == TType.STRUCT:
19493 
          self.cex = CatalogServiceException()
19494 
          self.cex.read(iprot)
19495 
        else:
19496 
          iprot.skip(ftype)
19497 
      else:
19498 
        iprot.skip(ftype)
19499 
      iprot.readFieldEnd()
19500 
    iprot.readStructEnd()
19501 
 
19502 
  def write(self, oprot):
19503 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19504 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19505 
      return
19506 
    oprot.writeStructBegin('addSourceItemPricing_result')
19507 
    if self.cex is not None:
19508 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
19509 
      self.cex.write(oprot)
19510 
      oprot.writeFieldEnd()
19511 
    oprot.writeFieldStop()
19512 
    oprot.writeStructEnd()
19513 
 
19514 
  def validate(self):
19515 
    return
19516 
 
19517 
 
19518 
  def __repr__(self):
19519 
    L = ['%s=%r' % (key, value)
19520 
      for key, value in self.__dict__.iteritems()]
19521 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19522 
 
19523 
  def __eq__(self, other):
19524 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19525 
 
19526 
  def __ne__(self, other):
19527 
    return not (self == other)
19528 
 
19529 
class getAllSourcePricing_args:
19530 
  """
19531 
  Attributes:
19532 
   - itemId
19533 
  """
19534 
 
19535 
  thrift_spec = (
19536 
    None, # 0
19537 
    (1, TType.I64, 'itemId', None, None, ), # 1
19538 
  )
19539 
 
19540 
  def __init__(self, itemId=None,):
19541 
    self.itemId = itemId
19542 
 
19543 
  def read(self, iprot):
19544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19546 
      return
19547 
    iprot.readStructBegin()
19548 
    while True:
19549 
      (fname, ftype, fid) = iprot.readFieldBegin()
19550 
      if ftype == TType.STOP:
19551 
        break
19552 
      if fid == 1:
19553 
        if ftype == TType.I64:
19554 
          self.itemId = iprot.readI64();
19555 
        else:
19556 
          iprot.skip(ftype)
19557 
      else:
19558 
        iprot.skip(ftype)
19559 
      iprot.readFieldEnd()
19560 
    iprot.readStructEnd()
19561 
 
19562 
  def write(self, oprot):
19563 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19564 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19565 
      return
19566 
    oprot.writeStructBegin('getAllSourcePricing_args')
19567 
    if self.itemId is not None:
19568 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19569 
      oprot.writeI64(self.itemId)
19570 
      oprot.writeFieldEnd()
19571 
    oprot.writeFieldStop()
19572 
    oprot.writeStructEnd()
19573 
 
19574 
  def validate(self):
19575 
    return
19576 
 
19577 
 
19578 
  def __repr__(self):
19579 
    L = ['%s=%r' % (key, value)
19580 
      for key, value in self.__dict__.iteritems()]
19581 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19582 
 
19583 
  def __eq__(self, other):
19584 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19585 
 
19586 
  def __ne__(self, other):
19587 
    return not (self == other)
19588 
 
19589 
class getAllSourcePricing_result:
19590 
  """
19591 
  Attributes:
19592 
   - success
19593 
   - cex
19594 
  """
19595 
 
19596 
  thrift_spec = (
19597 
    (0, TType.LIST, 'success', (TType.STRUCT,(SourceItemPricing, SourceItemPricing.thrift_spec)), None, ), # 0
19598 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
19599 
  )
19600 
 
19601 
  def __init__(self, success=None, cex=None,):
19602 
    self.success = success
19603 
    self.cex = cex
19604 
 
19605 
  def read(self, iprot):
19606 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19607 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19608 
      return
19609 
    iprot.readStructBegin()
19610 
    while True:
19611 
      (fname, ftype, fid) = iprot.readFieldBegin()
19612 
      if ftype == TType.STOP:
19613 
        break
19614 
      if fid == 0:
19615 
        if ftype == TType.LIST:
19616 
          self.success = []
18719 kshitij.so 19617 
          (_etype355, _size352) = iprot.readListBegin()
19618 
          for _i356 in xrange(_size352):
19619 
            _elem357 = SourceItemPricing()
19620 
            _elem357.read(iprot)
19621 
            self.success.append(_elem357)
5944 mandeep.dh 19622 
          iprot.readListEnd()
19623 
        else:
19624 
          iprot.skip(ftype)
19625 
      elif fid == 1:
19626 
        if ftype == TType.STRUCT:
19627 
          self.cex = CatalogServiceException()
19628 
          self.cex.read(iprot)
19629 
        else:
19630 
          iprot.skip(ftype)
19631 
      else:
19632 
        iprot.skip(ftype)
19633 
      iprot.readFieldEnd()
19634 
    iprot.readStructEnd()
19635 
 
19636 
  def write(self, oprot):
19637 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19638 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19639 
      return
19640 
    oprot.writeStructBegin('getAllSourcePricing_result')
19641 
    if self.success is not None:
19642 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19643 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 19644 
      for iter358 in self.success:
19645 
        iter358.write(oprot)
5944 mandeep.dh 19646 
      oprot.writeListEnd()
19647 
      oprot.writeFieldEnd()
19648 
    if self.cex is not None:
19649 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
19650 
      self.cex.write(oprot)
19651 
      oprot.writeFieldEnd()
19652 
    oprot.writeFieldStop()
19653 
    oprot.writeStructEnd()
19654 
 
19655 
  def validate(self):
19656 
    return
19657 
 
19658 
 
19659 
  def __repr__(self):
19660 
    L = ['%s=%r' % (key, value)
19661 
      for key, value in self.__dict__.iteritems()]
19662 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19663 
 
19664 
  def __eq__(self, other):
19665 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19666 
 
19667 
  def __ne__(self, other):
19668 
    return not (self == other)
19669 
 
19670 
class getItemForSource_args:
19671 
  """
19672 
  Attributes:
19673 
   - item_id
19674 
   - sourceId
19675 
  """
19676 
 
19677 
  thrift_spec = (
19678 
    None, # 0
19679 
    (1, TType.I64, 'item_id', None, None, ), # 1
19680 
    (2, TType.I64, 'sourceId', None, None, ), # 2
19681 
  )
19682 
 
19683 
  def __init__(self, item_id=None, sourceId=None,):
19684 
    self.item_id = item_id
19685 
    self.sourceId = sourceId
19686 
 
19687 
  def read(self, iprot):
19688 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19689 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19690 
      return
19691 
    iprot.readStructBegin()
19692 
    while True:
19693 
      (fname, ftype, fid) = iprot.readFieldBegin()
19694 
      if ftype == TType.STOP:
19695 
        break
19696 
      if fid == 1:
19697 
        if ftype == TType.I64:
19698 
          self.item_id = iprot.readI64();
19699 
        else:
19700 
          iprot.skip(ftype)
19701 
      elif fid == 2:
19702 
        if ftype == TType.I64:
19703 
          self.sourceId = iprot.readI64();
19704 
        else:
19705 
          iprot.skip(ftype)
19706 
      else:
19707 
        iprot.skip(ftype)
19708 
      iprot.readFieldEnd()
19709 
    iprot.readStructEnd()
19710 
 
19711 
  def write(self, oprot):
19712 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19713 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19714 
      return
19715 
    oprot.writeStructBegin('getItemForSource_args')
19716 
    if self.item_id is not None:
19717 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
19718 
      oprot.writeI64(self.item_id)
19719 
      oprot.writeFieldEnd()
19720 
    if self.sourceId is not None:
19721 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
19722 
      oprot.writeI64(self.sourceId)
19723 
      oprot.writeFieldEnd()
19724 
    oprot.writeFieldStop()
19725 
    oprot.writeStructEnd()
19726 
 
19727 
  def validate(self):
19728 
    return
19729 
 
19730 
 
19731 
  def __repr__(self):
19732 
    L = ['%s=%r' % (key, value)
19733 
      for key, value in self.__dict__.iteritems()]
19734 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19735 
 
19736 
  def __eq__(self, other):
19737 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19738 
 
19739 
  def __ne__(self, other):
19740 
    return not (self == other)
19741 
 
19742 
class getItemForSource_result:
19743 
  """
19744 
  Attributes:
19745 
   - success
19746 
   - cex
19747 
  """
19748 
 
19749 
  thrift_spec = (
19750 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
19751 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
19752 
  )
19753 
 
19754 
  def __init__(self, success=None, cex=None,):
19755 
    self.success = success
19756 
    self.cex = cex
19757 
 
19758 
  def read(self, iprot):
19759 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19760 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19761 
      return
19762 
    iprot.readStructBegin()
19763 
    while True:
19764 
      (fname, ftype, fid) = iprot.readFieldBegin()
19765 
      if ftype == TType.STOP:
19766 
        break
19767 
      if fid == 0:
19768 
        if ftype == TType.STRUCT:
19769 
          self.success = Item()
19770 
          self.success.read(iprot)
19771 
        else:
19772 
          iprot.skip(ftype)
19773 
      elif fid == 1:
19774 
        if ftype == TType.STRUCT:
19775 
          self.cex = CatalogServiceException()
19776 
          self.cex.read(iprot)
19777 
        else:
19778 
          iprot.skip(ftype)
19779 
      else:
19780 
        iprot.skip(ftype)
19781 
      iprot.readFieldEnd()
19782 
    iprot.readStructEnd()
19783 
 
19784 
  def write(self, oprot):
19785 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19786 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19787 
      return
19788 
    oprot.writeStructBegin('getItemForSource_result')
19789 
    if self.success is not None:
19790 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19791 
      self.success.write(oprot)
19792 
      oprot.writeFieldEnd()
19793 
    if self.cex is not None:
19794 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
19795 
      self.cex.write(oprot)
19796 
      oprot.writeFieldEnd()
19797 
    oprot.writeFieldStop()
19798 
    oprot.writeStructEnd()
19799 
 
19800 
  def validate(self):
19801 
    return
19802 
 
19803 
 
19804 
  def __repr__(self):
19805 
    L = ['%s=%r' % (key, value)
19806 
      for key, value in self.__dict__.iteritems()]
19807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19808 
 
19809 
  def __eq__(self, other):
19810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19811 
 
19812 
  def __ne__(self, other):
19813 
    return not (self == other)
19814 
 
19815 
class searchItemsInRange_args:
19816 
  """
19817 
  Attributes:
19818 
   - searchTerms
19819 
   - offset
19820 
   - limit
19821 
  """
19822 
 
19823 
  thrift_spec = (
19824 
    None, # 0
19825 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
19826 
    (2, TType.I64, 'offset', None, None, ), # 2
19827 
    (3, TType.I64, 'limit', None, None, ), # 3
19828 
  )
19829 
 
19830 
  def __init__(self, searchTerms=None, offset=None, limit=None,):
19831 
    self.searchTerms = searchTerms
19832 
    self.offset = offset
19833 
    self.limit = limit
19834 
 
19835 
  def read(self, iprot):
19836 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19837 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19838 
      return
19839 
    iprot.readStructBegin()
19840 
    while True:
19841 
      (fname, ftype, fid) = iprot.readFieldBegin()
19842 
      if ftype == TType.STOP:
19843 
        break
19844 
      if fid == 1:
19845 
        if ftype == TType.LIST:
19846 
          self.searchTerms = []
18719 kshitij.so 19847 
          (_etype362, _size359) = iprot.readListBegin()
19848 
          for _i363 in xrange(_size359):
19849 
            _elem364 = iprot.readString();
19850 
            self.searchTerms.append(_elem364)
5944 mandeep.dh 19851 
          iprot.readListEnd()
19852 
        else:
19853 
          iprot.skip(ftype)
19854 
      elif fid == 2:
19855 
        if ftype == TType.I64:
19856 
          self.offset = iprot.readI64();
19857 
        else:
19858 
          iprot.skip(ftype)
19859 
      elif fid == 3:
19860 
        if ftype == TType.I64:
19861 
          self.limit = iprot.readI64();
19862 
        else:
19863 
          iprot.skip(ftype)
19864 
      else:
19865 
        iprot.skip(ftype)
19866 
      iprot.readFieldEnd()
19867 
    iprot.readStructEnd()
19868 
 
19869 
  def write(self, oprot):
19870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19872 
      return
19873 
    oprot.writeStructBegin('searchItemsInRange_args')
19874 
    if self.searchTerms is not None:
19875 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
19876 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
18719 kshitij.so 19877 
      for iter365 in self.searchTerms:
19878 
        oprot.writeString(iter365)
5944 mandeep.dh 19879 
      oprot.writeListEnd()
19880 
      oprot.writeFieldEnd()
19881 
    if self.offset is not None:
19882 
      oprot.writeFieldBegin('offset', TType.I64, 2)
19883 
      oprot.writeI64(self.offset)
19884 
      oprot.writeFieldEnd()
19885 
    if self.limit is not None:
19886 
      oprot.writeFieldBegin('limit', TType.I64, 3)
19887 
      oprot.writeI64(self.limit)
19888 
      oprot.writeFieldEnd()
19889 
    oprot.writeFieldStop()
19890 
    oprot.writeStructEnd()
19891 
 
19892 
  def validate(self):
19893 
    return
19894 
 
19895 
 
19896 
  def __repr__(self):
19897 
    L = ['%s=%r' % (key, value)
19898 
      for key, value in self.__dict__.iteritems()]
19899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19900 
 
19901 
  def __eq__(self, other):
19902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19903 
 
19904 
  def __ne__(self, other):
19905 
    return not (self == other)
19906 
 
19907 
class searchItemsInRange_result:
19908 
  """
19909 
  Attributes:
19910 
   - success
19911 
  """
19912 
 
19913 
  thrift_spec = (
19914 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
19915 
  )
19916 
 
19917 
  def __init__(self, success=None,):
19918 
    self.success = success
19919 
 
19920 
  def read(self, iprot):
19921 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19922 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19923 
      return
19924 
    iprot.readStructBegin()
19925 
    while True:
19926 
      (fname, ftype, fid) = iprot.readFieldBegin()
19927 
      if ftype == TType.STOP:
19928 
        break
19929 
      if fid == 0:
19930 
        if ftype == TType.LIST:
19931 
          self.success = []
18719 kshitij.so 19932 
          (_etype369, _size366) = iprot.readListBegin()
19933 
          for _i370 in xrange(_size366):
19934 
            _elem371 = Item()
19935 
            _elem371.read(iprot)
19936 
            self.success.append(_elem371)
5944 mandeep.dh 19937 
          iprot.readListEnd()
19938 
        else:
19939 
          iprot.skip(ftype)
19940 
      else:
19941 
        iprot.skip(ftype)
19942 
      iprot.readFieldEnd()
19943 
    iprot.readStructEnd()
19944 
 
19945 
  def write(self, oprot):
19946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19948 
      return
19949 
    oprot.writeStructBegin('searchItemsInRange_result')
19950 
    if self.success is not None:
19951 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19952 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 19953 
      for iter372 in self.success:
19954 
        iter372.write(oprot)
5944 mandeep.dh 19955 
      oprot.writeListEnd()
19956 
      oprot.writeFieldEnd()
19957 
    oprot.writeFieldStop()
19958 
    oprot.writeStructEnd()
19959 
 
19960 
  def validate(self):
19961 
    return
19962 
 
19963 
 
19964 
  def __repr__(self):
19965 
    L = ['%s=%r' % (key, value)
19966 
      for key, value in self.__dict__.iteritems()]
19967 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19968 
 
19969 
  def __eq__(self, other):
19970 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19971 
 
19972 
  def __ne__(self, other):
19973 
    return not (self == other)
19974 
 
19975 
class getSearchResultCount_args:
19976 
  """
19977 
  Attributes:
19978 
   - searchTerms
19979 
  """
19980 
 
19981 
  thrift_spec = (
19982 
    None, # 0
19983 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
19984 
  )
19985 
 
19986 
  def __init__(self, searchTerms=None,):
19987 
    self.searchTerms = searchTerms
19988 
 
19989 
  def read(self, iprot):
19990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19992 
      return
19993 
    iprot.readStructBegin()
19994 
    while True:
19995 
      (fname, ftype, fid) = iprot.readFieldBegin()
19996 
      if ftype == TType.STOP:
19997 
        break
19998 
      if fid == 1:
19999 
        if ftype == TType.LIST:
20000 
          self.searchTerms = []
18719 kshitij.so 20001 
          (_etype376, _size373) = iprot.readListBegin()
20002 
          for _i377 in xrange(_size373):
20003 
            _elem378 = iprot.readString();
20004 
            self.searchTerms.append(_elem378)
5944 mandeep.dh 20005 
          iprot.readListEnd()
20006 
        else:
20007 
          iprot.skip(ftype)
20008 
      else:
20009 
        iprot.skip(ftype)
20010 
      iprot.readFieldEnd()
20011 
    iprot.readStructEnd()
20012 
 
20013 
  def write(self, oprot):
20014 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20015 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20016 
      return
20017 
    oprot.writeStructBegin('getSearchResultCount_args')
20018 
    if self.searchTerms is not None:
20019 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
20020 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
18719 kshitij.so 20021 
      for iter379 in self.searchTerms:
20022 
        oprot.writeString(iter379)
5944 mandeep.dh 20023 
      oprot.writeListEnd()
20024 
      oprot.writeFieldEnd()
20025 
    oprot.writeFieldStop()
20026 
    oprot.writeStructEnd()
20027 
 
20028 
  def validate(self):
20029 
    return
20030 
 
20031 
 
20032 
  def __repr__(self):
20033 
    L = ['%s=%r' % (key, value)
20034 
      for key, value in self.__dict__.iteritems()]
20035 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20036 
 
20037 
  def __eq__(self, other):
20038 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20039 
 
20040 
  def __ne__(self, other):
20041 
    return not (self == other)
20042 
 
20043 
class getSearchResultCount_result:
20044 
  """
20045 
  Attributes:
20046 
   - success
20047 
  """
20048 
 
20049 
  thrift_spec = (
20050 
    (0, TType.I32, 'success', None, None, ), # 0
20051 
  )
20052 
 
20053 
  def __init__(self, success=None,):
20054 
    self.success = success
20055 
 
20056 
  def read(self, iprot):
20057 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20058 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20059 
      return
20060 
    iprot.readStructBegin()
20061 
    while True:
20062 
      (fname, ftype, fid) = iprot.readFieldBegin()
20063 
      if ftype == TType.STOP:
20064 
        break
20065 
      if fid == 0:
20066 
        if ftype == TType.I32:
20067 
          self.success = iprot.readI32();
20068 
        else:
20069 
          iprot.skip(ftype)
20070 
      else:
20071 
        iprot.skip(ftype)
20072 
      iprot.readFieldEnd()
20073 
    iprot.readStructEnd()
20074 
 
20075 
  def write(self, oprot):
20076 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20077 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20078 
      return
20079 
    oprot.writeStructBegin('getSearchResultCount_result')
20080 
    if self.success is not None:
20081 
      oprot.writeFieldBegin('success', TType.I32, 0)
20082 
      oprot.writeI32(self.success)
20083 
      oprot.writeFieldEnd()
20084 
    oprot.writeFieldStop()
20085 
    oprot.writeStructEnd()
20086 
 
20087 
  def validate(self):
20088 
    return
20089 
 
20090 
 
20091 
  def __repr__(self):
20092 
    L = ['%s=%r' % (key, value)
20093 
      for key, value in self.__dict__.iteritems()]
20094 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20095 
 
20096 
  def __eq__(self, other):
20097 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20098 
 
20099 
  def __ne__(self, other):
20100 
    return not (self == other)
20101 
 
20102 
class getProductNotifications_args:
20103 
  """
20104 
  Attributes:
20105 
   - startDateTime
20106 
  """
20107 
 
20108 
  thrift_spec = (
20109 
    None, # 0
20110 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
20111 
  )
20112 
 
20113 
  def __init__(self, startDateTime=None,):
20114 
    self.startDateTime = startDateTime
20115 
 
20116 
  def read(self, iprot):
20117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20119 
      return
20120 
    iprot.readStructBegin()
20121 
    while True:
20122 
      (fname, ftype, fid) = iprot.readFieldBegin()
20123 
      if ftype == TType.STOP:
20124 
        break
20125 
      if fid == 1:
20126 
        if ftype == TType.I64:
20127 
          self.startDateTime = iprot.readI64();
20128 
        else:
20129 
          iprot.skip(ftype)
20130 
      else:
20131 
        iprot.skip(ftype)
20132 
      iprot.readFieldEnd()
20133 
    iprot.readStructEnd()
20134 
 
20135 
  def write(self, oprot):
20136 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20137 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20138 
      return
20139 
    oprot.writeStructBegin('getProductNotifications_args')
20140 
    if self.startDateTime is not None:
20141 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
20142 
      oprot.writeI64(self.startDateTime)
20143 
      oprot.writeFieldEnd()
20144 
    oprot.writeFieldStop()
20145 
    oprot.writeStructEnd()
20146 
 
20147 
  def validate(self):
20148 
    return
20149 
 
20150 
 
20151 
  def __repr__(self):
20152 
    L = ['%s=%r' % (key, value)
20153 
      for key, value in self.__dict__.iteritems()]
20154 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20155 
 
20156 
  def __eq__(self, other):
20157 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20158 
 
20159 
  def __ne__(self, other):
20160 
    return not (self == other)
20161 
 
20162 
class getProductNotifications_result:
20163 
  """
20164 
  Attributes:
20165 
   - success
20166 
  """
20167 
 
20168 
  thrift_spec = (
20169 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequest, ProductNotificationRequest.thrift_spec)), None, ), # 0
20170 
  )
20171 
 
20172 
  def __init__(self, success=None,):
20173 
    self.success = success
20174 
 
20175 
  def read(self, iprot):
20176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20178 
      return
20179 
    iprot.readStructBegin()
20180 
    while True:
20181 
      (fname, ftype, fid) = iprot.readFieldBegin()
20182 
      if ftype == TType.STOP:
20183 
        break
20184 
      if fid == 0:
20185 
        if ftype == TType.LIST:
20186 
          self.success = []
18719 kshitij.so 20187 
          (_etype383, _size380) = iprot.readListBegin()
20188 
          for _i384 in xrange(_size380):
20189 
            _elem385 = ProductNotificationRequest()
20190 
            _elem385.read(iprot)
20191 
            self.success.append(_elem385)
5944 mandeep.dh 20192 
          iprot.readListEnd()
20193 
        else:
20194 
          iprot.skip(ftype)
20195 
      else:
20196 
        iprot.skip(ftype)
20197 
      iprot.readFieldEnd()
20198 
    iprot.readStructEnd()
20199 
 
20200 
  def write(self, oprot):
20201 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20202 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20203 
      return
20204 
    oprot.writeStructBegin('getProductNotifications_result')
20205 
    if self.success is not None:
20206 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20207 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 20208 
      for iter386 in self.success:
20209 
        iter386.write(oprot)
5944 mandeep.dh 20210 
      oprot.writeListEnd()
20211 
      oprot.writeFieldEnd()
20212 
    oprot.writeFieldStop()
20213 
    oprot.writeStructEnd()
20214 
 
20215 
  def validate(self):
20216 
    return
20217 
 
20218 
 
20219 
  def __repr__(self):
20220 
    L = ['%s=%r' % (key, value)
20221 
      for key, value in self.__dict__.iteritems()]
20222 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20223 
 
20224 
  def __eq__(self, other):
20225 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20226 
 
20227 
  def __ne__(self, other):
20228 
    return not (self == other)
20229 
 
20230 
class getProductNotificationRequestCount_args:
20231 
  """
20232 
  Attributes:
20233 
   - startDateTime
7897 amar.kumar 20234 
   - categoryId
5944 mandeep.dh 20235 
  """
20236 
 
20237 
  thrift_spec = (
20238 
    None, # 0
20239 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
7897 amar.kumar 20240 
    (2, TType.I64, 'categoryId', None, None, ), # 2
5944 mandeep.dh 20241 
  )
20242 
 
7897 amar.kumar 20243 
  def __init__(self, startDateTime=None, categoryId=None,):
5944 mandeep.dh 20244 
    self.startDateTime = startDateTime
7897 amar.kumar 20245 
    self.categoryId = categoryId
5944 mandeep.dh 20246 
 
20247 
  def read(self, iprot):
20248 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20249 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20250 
      return
20251 
    iprot.readStructBegin()
20252 
    while True:
20253 
      (fname, ftype, fid) = iprot.readFieldBegin()
20254 
      if ftype == TType.STOP:
20255 
        break
20256 
      if fid == 1:
20257 
        if ftype == TType.I64:
20258 
          self.startDateTime = iprot.readI64();
20259 
        else:
20260 
          iprot.skip(ftype)
7897 amar.kumar 20261 
      elif fid == 2:
20262 
        if ftype == TType.I64:
20263 
          self.categoryId = iprot.readI64();
20264 
        else:
20265 
          iprot.skip(ftype)
5944 mandeep.dh 20266 
      else:
20267 
        iprot.skip(ftype)
20268 
      iprot.readFieldEnd()
20269 
    iprot.readStructEnd()
20270 
 
20271 
  def write(self, oprot):
20272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20274 
      return
20275 
    oprot.writeStructBegin('getProductNotificationRequestCount_args')
20276 
    if self.startDateTime is not None:
20277 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
20278 
      oprot.writeI64(self.startDateTime)
20279 
      oprot.writeFieldEnd()
7897 amar.kumar 20280 
    if self.categoryId is not None:
20281 
      oprot.writeFieldBegin('categoryId', TType.I64, 2)
20282 
      oprot.writeI64(self.categoryId)
20283 
      oprot.writeFieldEnd()
5944 mandeep.dh 20284 
    oprot.writeFieldStop()
20285 
    oprot.writeStructEnd()
20286 
 
20287 
  def validate(self):
20288 
    return
20289 
 
20290 
 
20291 
  def __repr__(self):
20292 
    L = ['%s=%r' % (key, value)
20293 
      for key, value in self.__dict__.iteritems()]
20294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20295 
 
20296 
  def __eq__(self, other):
20297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20298 
 
20299 
  def __ne__(self, other):
20300 
    return not (self == other)
20301 
 
20302 
class getProductNotificationRequestCount_result:
20303 
  """
20304 
  Attributes:
20305 
   - success
20306 
  """
20307 
 
20308 
  thrift_spec = (
20309 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequestCount, ProductNotificationRequestCount.thrift_spec)), None, ), # 0
20310 
  )
20311 
 
20312 
  def __init__(self, success=None,):
20313 
    self.success = success
20314 
 
20315 
  def read(self, iprot):
20316 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20317 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20318 
      return
20319 
    iprot.readStructBegin()
20320 
    while True:
20321 
      (fname, ftype, fid) = iprot.readFieldBegin()
20322 
      if ftype == TType.STOP:
20323 
        break
20324 
      if fid == 0:
20325 
        if ftype == TType.LIST:
20326 
          self.success = []
18719 kshitij.so 20327 
          (_etype390, _size387) = iprot.readListBegin()
20328 
          for _i391 in xrange(_size387):
20329 
            _elem392 = ProductNotificationRequestCount()
20330 
            _elem392.read(iprot)
20331 
            self.success.append(_elem392)
5944 mandeep.dh 20332 
          iprot.readListEnd()
20333 
        else:
20334 
          iprot.skip(ftype)
20335 
      else:
20336 
        iprot.skip(ftype)
20337 
      iprot.readFieldEnd()
20338 
    iprot.readStructEnd()
20339 
 
20340 
  def write(self, oprot):
20341 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20342 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20343 
      return
20344 
    oprot.writeStructBegin('getProductNotificationRequestCount_result')
20345 
    if self.success is not None:
20346 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20347 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 20348 
      for iter393 in self.success:
20349 
        iter393.write(oprot)
5944 mandeep.dh 20350 
      oprot.writeListEnd()
20351 
      oprot.writeFieldEnd()
20352 
    oprot.writeFieldStop()
20353 
    oprot.writeStructEnd()
20354 
 
20355 
  def validate(self):
20356 
    return
20357 
 
20358 
 
20359 
  def __repr__(self):
20360 
    L = ['%s=%r' % (key, value)
20361 
      for key, value in self.__dict__.iteritems()]
20362 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20363 
 
20364 
  def __eq__(self, other):
20365 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20366 
 
20367 
  def __ne__(self, other):
20368 
    return not (self == other)
20369 
 
20370 
class addAuthorizationLog_args:
20371 
  """
20372 
  Attributes:
20373 
   - itemId
20374 
   - username
20375 
   - reason
20376 
  """
20377 
 
20378 
  thrift_spec = (
20379 
    None, # 0
20380 
    (1, TType.I64, 'itemId', None, None, ), # 1
20381 
    (2, TType.STRING, 'username', None, None, ), # 2
20382 
    (3, TType.STRING, 'reason', None, None, ), # 3
20383 
  )
20384 
 
20385 
  def __init__(self, itemId=None, username=None, reason=None,):
20386 
    self.itemId = itemId
20387 
    self.username = username
20388 
    self.reason = reason
20389 
 
20390 
  def read(self, iprot):
20391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20393 
      return
20394 
    iprot.readStructBegin()
20395 
    while True:
20396 
      (fname, ftype, fid) = iprot.readFieldBegin()
20397 
      if ftype == TType.STOP:
20398 
        break
20399 
      if fid == 1:
20400 
        if ftype == TType.I64:
20401 
          self.itemId = iprot.readI64();
20402 
        else:
20403 
          iprot.skip(ftype)
20404 
      elif fid == 2:
20405 
        if ftype == TType.STRING:
20406 
          self.username = iprot.readString();
20407 
        else:
20408 
          iprot.skip(ftype)
20409 
      elif fid == 3:
20410 
        if ftype == TType.STRING:
20411 
          self.reason = iprot.readString();
20412 
        else:
20413 
          iprot.skip(ftype)
20414 
      else:
20415 
        iprot.skip(ftype)
20416 
      iprot.readFieldEnd()
20417 
    iprot.readStructEnd()
20418 
 
20419 
  def write(self, oprot):
20420 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20421 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20422 
      return
20423 
    oprot.writeStructBegin('addAuthorizationLog_args')
20424 
    if self.itemId is not None:
20425 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20426 
      oprot.writeI64(self.itemId)
20427 
      oprot.writeFieldEnd()
20428 
    if self.username is not None:
20429 
      oprot.writeFieldBegin('username', TType.STRING, 2)
20430 
      oprot.writeString(self.username)
20431 
      oprot.writeFieldEnd()
20432 
    if self.reason is not None:
20433 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
20434 
      oprot.writeString(self.reason)
20435 
      oprot.writeFieldEnd()
20436 
    oprot.writeFieldStop()
20437 
    oprot.writeStructEnd()
20438 
 
20439 
  def validate(self):
20440 
    return
20441 
 
20442 
 
20443 
  def __repr__(self):
20444 
    L = ['%s=%r' % (key, value)
20445 
      for key, value in self.__dict__.iteritems()]
20446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20447 
 
20448 
  def __eq__(self, other):
20449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20450 
 
20451 
  def __ne__(self, other):
20452 
    return not (self == other)
20453 
 
20454 
class addAuthorizationLog_result:
20455 
  """
20456 
  Attributes:
20457 
   - success
20458 
   - cex
20459 
  """
20460 
 
20461 
  thrift_spec = (
20462 
    (0, TType.BOOL, 'success', None, None, ), # 0
20463 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
20464 
  )
20465 
 
20466 
  def __init__(self, success=None, cex=None,):
20467 
    self.success = success
20468 
    self.cex = cex
20469 
 
20470 
  def read(self, iprot):
20471 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20472 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20473 
      return
20474 
    iprot.readStructBegin()
20475 
    while True:
20476 
      (fname, ftype, fid) = iprot.readFieldBegin()
20477 
      if ftype == TType.STOP:
20478 
        break
20479 
      if fid == 0:
20480 
        if ftype == TType.BOOL:
20481 
          self.success = iprot.readBool();
20482 
        else:
20483 
          iprot.skip(ftype)
20484 
      elif fid == 1:
20485 
        if ftype == TType.STRUCT:
20486 
          self.cex = CatalogServiceException()
20487 
          self.cex.read(iprot)
20488 
        else:
20489 
          iprot.skip(ftype)
20490 
      else:
20491 
        iprot.skip(ftype)
20492 
      iprot.readFieldEnd()
20493 
    iprot.readStructEnd()
20494 
 
20495 
  def write(self, oprot):
20496 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20497 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20498 
      return
20499 
    oprot.writeStructBegin('addAuthorizationLog_result')
20500 
    if self.success is not None:
20501 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20502 
      oprot.writeBool(self.success)
20503 
      oprot.writeFieldEnd()
20504 
    if self.cex is not None:
20505 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
20506 
      self.cex.write(oprot)
20507 
      oprot.writeFieldEnd()
20508 
    oprot.writeFieldStop()
20509 
    oprot.writeStructEnd()
20510 
 
20511 
  def validate(self):
20512 
    return
20513 
 
20514 
 
20515 
  def __repr__(self):
20516 
    L = ['%s=%r' % (key, value)
20517 
      for key, value in self.__dict__.iteritems()]
20518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20519 
 
20520 
  def __eq__(self, other):
20521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20522 
 
20523 
  def __ne__(self, other):
20524 
    return not (self == other)
20525 
 
20526 
class addupdateVoucherForItem_args:
20527 
  """
20528 
  Attributes:
20529 
   - catalog_item_id
20530 
   - voucherType
20531 
   - voucherAmount
20532 
  """
20533 
 
20534 
  thrift_spec = (
20535 
    None, # 0
20536 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
20537 
    (2, TType.I64, 'voucherType', None, None, ), # 2
20538 
    (3, TType.I64, 'voucherAmount', None, None, ), # 3
20539 
  )
20540 
 
20541 
  def __init__(self, catalog_item_id=None, voucherType=None, voucherAmount=None,):
20542 
    self.catalog_item_id = catalog_item_id
20543 
    self.voucherType = voucherType
20544 
    self.voucherAmount = voucherAmount
20545 
 
20546 
  def read(self, iprot):
20547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20549 
      return
20550 
    iprot.readStructBegin()
20551 
    while True:
20552 
      (fname, ftype, fid) = iprot.readFieldBegin()
20553 
      if ftype == TType.STOP:
20554 
        break
20555 
      if fid == 1:
20556 
        if ftype == TType.I64:
20557 
          self.catalog_item_id = iprot.readI64();
20558 
        else:
20559 
          iprot.skip(ftype)
20560 
      elif fid == 2:
20561 
        if ftype == TType.I64:
20562 
          self.voucherType = iprot.readI64();
20563 
        else:
20564 
          iprot.skip(ftype)
20565 
      elif fid == 3:
20566 
        if ftype == TType.I64:
20567 
          self.voucherAmount = iprot.readI64();
20568 
        else:
20569 
          iprot.skip(ftype)
20570 
      else:
20571 
        iprot.skip(ftype)
20572 
      iprot.readFieldEnd()
20573 
    iprot.readStructEnd()
20574 
 
20575 
  def write(self, oprot):
20576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20578 
      return
20579 
    oprot.writeStructBegin('addupdateVoucherForItem_args')
20580 
    if self.catalog_item_id is not None:
20581 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
20582 
      oprot.writeI64(self.catalog_item_id)
20583 
      oprot.writeFieldEnd()
20584 
    if self.voucherType is not None:
20585 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
20586 
      oprot.writeI64(self.voucherType)
20587 
      oprot.writeFieldEnd()
20588 
    if self.voucherAmount is not None:
20589 
      oprot.writeFieldBegin('voucherAmount', TType.I64, 3)
20590 
      oprot.writeI64(self.voucherAmount)
20591 
      oprot.writeFieldEnd()
20592 
    oprot.writeFieldStop()
20593 
    oprot.writeStructEnd()
20594 
 
20595 
  def validate(self):
20596 
    return
20597 
 
20598 
 
20599 
  def __repr__(self):
20600 
    L = ['%s=%r' % (key, value)
20601 
      for key, value in self.__dict__.iteritems()]
20602 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20603 
 
20604 
  def __eq__(self, other):
20605 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20606 
 
20607 
  def __ne__(self, other):
20608 
    return not (self == other)
20609 
 
20610 
class addupdateVoucherForItem_result:
20611 
  """
20612 
  Attributes:
20613 
   - success
20614 
   - cex
20615 
  """
20616 
 
20617 
  thrift_spec = (
20618 
    (0, TType.BOOL, 'success', None, None, ), # 0
20619 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
20620 
  )
20621 
 
20622 
  def __init__(self, success=None, cex=None,):
20623 
    self.success = success
20624 
    self.cex = cex
20625 
 
20626 
  def read(self, iprot):
20627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20629 
      return
20630 
    iprot.readStructBegin()
20631 
    while True:
20632 
      (fname, ftype, fid) = iprot.readFieldBegin()
20633 
      if ftype == TType.STOP:
20634 
        break
20635 
      if fid == 0:
20636 
        if ftype == TType.BOOL:
20637 
          self.success = iprot.readBool();
20638 
        else:
20639 
          iprot.skip(ftype)
20640 
      elif fid == 1:
20641 
        if ftype == TType.STRUCT:
20642 
          self.cex = CatalogServiceException()
20643 
          self.cex.read(iprot)
20644 
        else:
20645 
          iprot.skip(ftype)
20646 
      else:
20647 
        iprot.skip(ftype)
20648 
      iprot.readFieldEnd()
20649 
    iprot.readStructEnd()
20650 
 
20651 
  def write(self, oprot):
20652 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20653 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20654 
      return
20655 
    oprot.writeStructBegin('addupdateVoucherForItem_result')
20656 
    if self.success is not None:
20657 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20658 
      oprot.writeBool(self.success)
20659 
      oprot.writeFieldEnd()
20660 
    if self.cex is not None:
20661 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
20662 
      self.cex.write(oprot)
20663 
      oprot.writeFieldEnd()
20664 
    oprot.writeFieldStop()
20665 
    oprot.writeStructEnd()
20666 
 
20667 
  def validate(self):
20668 
    return
20669 
 
20670 
 
20671 
  def __repr__(self):
20672 
    L = ['%s=%r' % (key, value)
20673 
      for key, value in self.__dict__.iteritems()]
20674 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20675 
 
20676 
  def __eq__(self, other):
20677 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20678 
 
20679 
  def __ne__(self, other):
20680 
    return not (self == other)
20681 
 
20682 
class deleteVoucherForItem_args:
20683 
  """
20684 
  Attributes:
20685 
   - catalog_item_id
20686 
   - voucherType
20687 
  """
20688 
 
20689 
  thrift_spec = (
20690 
    None, # 0
20691 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
20692 
    (2, TType.I64, 'voucherType', None, None, ), # 2
20693 
  )
20694 
 
20695 
  def __init__(self, catalog_item_id=None, voucherType=None,):
20696 
    self.catalog_item_id = catalog_item_id
20697 
    self.voucherType = voucherType
20698 
 
20699 
  def read(self, iprot):
20700 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20701 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20702 
      return
20703 
    iprot.readStructBegin()
20704 
    while True:
20705 
      (fname, ftype, fid) = iprot.readFieldBegin()
20706 
      if ftype == TType.STOP:
20707 
        break
20708 
      if fid == 1:
20709 
        if ftype == TType.I64:
20710 
          self.catalog_item_id = iprot.readI64();
20711 
        else:
20712 
          iprot.skip(ftype)
20713 
      elif fid == 2:
20714 
        if ftype == TType.I64:
20715 
          self.voucherType = iprot.readI64();
20716 
        else:
20717 
          iprot.skip(ftype)
20718 
      else:
20719 
        iprot.skip(ftype)
20720 
      iprot.readFieldEnd()
20721 
    iprot.readStructEnd()
20722 
 
20723 
  def write(self, oprot):
20724 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20725 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20726 
      return
20727 
    oprot.writeStructBegin('deleteVoucherForItem_args')
20728 
    if self.catalog_item_id is not None:
20729 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
20730 
      oprot.writeI64(self.catalog_item_id)
20731 
      oprot.writeFieldEnd()
20732 
    if self.voucherType is not None:
20733 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
20734 
      oprot.writeI64(self.voucherType)
20735 
      oprot.writeFieldEnd()
20736 
    oprot.writeFieldStop()
20737 
    oprot.writeStructEnd()
20738 
 
20739 
  def validate(self):
20740 
    return
20741 
 
20742 
 
20743 
  def __repr__(self):
20744 
    L = ['%s=%r' % (key, value)
20745 
      for key, value in self.__dict__.iteritems()]
20746 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20747 
 
20748 
  def __eq__(self, other):
20749 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20750 
 
20751 
  def __ne__(self, other):
20752 
    return not (self == other)
20753 
 
20754 
class deleteVoucherForItem_result:
20755 
  """
20756 
  Attributes:
20757 
   - success
20758 
   - cex
20759 
  """
20760 
 
20761 
  thrift_spec = (
20762 
    (0, TType.BOOL, 'success', None, None, ), # 0
20763 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
20764 
  )
20765 
 
20766 
  def __init__(self, success=None, cex=None,):
20767 
    self.success = success
20768 
    self.cex = cex
20769 
 
20770 
  def read(self, iprot):
20771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20773 
      return
20774 
    iprot.readStructBegin()
20775 
    while True:
20776 
      (fname, ftype, fid) = iprot.readFieldBegin()
20777 
      if ftype == TType.STOP:
20778 
        break
20779 
      if fid == 0:
20780 
        if ftype == TType.BOOL:
20781 
          self.success = iprot.readBool();
20782 
        else:
20783 
          iprot.skip(ftype)
20784 
      elif fid == 1:
20785 
        if ftype == TType.STRUCT:
20786 
          self.cex = CatalogServiceException()
20787 
          self.cex.read(iprot)
20788 
        else:
20789 
          iprot.skip(ftype)
20790 
      else:
20791 
        iprot.skip(ftype)
20792 
      iprot.readFieldEnd()
20793 
    iprot.readStructEnd()
20794 
 
20795 
  def write(self, oprot):
20796 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20797 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20798 
      return
20799 
    oprot.writeStructBegin('deleteVoucherForItem_result')
20800 
    if self.success is not None:
20801 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20802 
      oprot.writeBool(self.success)
20803 
      oprot.writeFieldEnd()
20804 
    if self.cex is not None:
20805 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
20806 
      self.cex.write(oprot)
20807 
      oprot.writeFieldEnd()
20808 
    oprot.writeFieldStop()
20809 
    oprot.writeStructEnd()
20810 
 
20811 
  def validate(self):
20812 
    return
20813 
 
20814 
 
20815 
  def __repr__(self):
20816 
    L = ['%s=%r' % (key, value)
20817 
      for key, value in self.__dict__.iteritems()]
20818 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20819 
 
20820 
  def __eq__(self, other):
20821 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20822 
 
20823 
  def __ne__(self, other):
20824 
    return not (self == other)
20825 
 
20826 
class getVoucherAmount_args:
20827 
  """
20828 
  Attributes:
20829 
   - itemId
20830 
   - voucherType
20831 
  """
20832 
 
20833 
  thrift_spec = (
20834 
    None, # 0
20835 
    (1, TType.I64, 'itemId', None, None, ), # 1
20836 
    (2, TType.I64, 'voucherType', None, None, ), # 2
20837 
  )
20838 
 
20839 
  def __init__(self, itemId=None, voucherType=None,):
20840 
    self.itemId = itemId
20841 
    self.voucherType = voucherType
20842 
 
20843 
  def read(self, iprot):
20844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20846 
      return
20847 
    iprot.readStructBegin()
20848 
    while True:
20849 
      (fname, ftype, fid) = iprot.readFieldBegin()
20850 
      if ftype == TType.STOP:
20851 
        break
20852 
      if fid == 1:
20853 
        if ftype == TType.I64:
20854 
          self.itemId = iprot.readI64();
20855 
        else:
20856 
          iprot.skip(ftype)
20857 
      elif fid == 2:
20858 
        if ftype == TType.I64:
20859 
          self.voucherType = iprot.readI64();
20860 
        else:
20861 
          iprot.skip(ftype)
20862 
      else:
20863 
        iprot.skip(ftype)
20864 
      iprot.readFieldEnd()
20865 
    iprot.readStructEnd()
20866 
 
20867 
  def write(self, oprot):
20868 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20869 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20870 
      return
20871 
    oprot.writeStructBegin('getVoucherAmount_args')
20872 
    if self.itemId is not None:
20873 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20874 
      oprot.writeI64(self.itemId)
20875 
      oprot.writeFieldEnd()
20876 
    if self.voucherType is not None:
20877 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
20878 
      oprot.writeI64(self.voucherType)
20879 
      oprot.writeFieldEnd()
20880 
    oprot.writeFieldStop()
20881 
    oprot.writeStructEnd()
20882 
 
20883 
  def validate(self):
20884 
    return
20885 
 
20886 
 
20887 
  def __repr__(self):
20888 
    L = ['%s=%r' % (key, value)
20889 
      for key, value in self.__dict__.iteritems()]
20890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20891 
 
20892 
  def __eq__(self, other):
20893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20894 
 
20895 
  def __ne__(self, other):
20896 
    return not (self == other)
20897 
 
20898 
class getVoucherAmount_result:
20899 
  """
20900 
  Attributes:
20901 
   - success
20902 
  """
20903 
 
20904 
  thrift_spec = (
20905 
    (0, TType.I64, 'success', None, None, ), # 0
20906 
  )
20907 
 
20908 
  def __init__(self, success=None,):
20909 
    self.success = success
20910 
 
20911 
  def read(self, iprot):
20912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20914 
      return
20915 
    iprot.readStructBegin()
20916 
    while True:
20917 
      (fname, ftype, fid) = iprot.readFieldBegin()
20918 
      if ftype == TType.STOP:
20919 
        break
20920 
      if fid == 0:
20921 
        if ftype == TType.I64:
20922 
          self.success = iprot.readI64();
20923 
        else:
20924 
          iprot.skip(ftype)
20925 
      else:
20926 
        iprot.skip(ftype)
20927 
      iprot.readFieldEnd()
20928 
    iprot.readStructEnd()
20929 
 
20930 
  def write(self, oprot):
20931 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20932 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20933 
      return
20934 
    oprot.writeStructBegin('getVoucherAmount_result')
20935 
    if self.success is not None:
20936 
      oprot.writeFieldBegin('success', TType.I64, 0)
20937 
      oprot.writeI64(self.success)
20938 
      oprot.writeFieldEnd()
20939 
    oprot.writeFieldStop()
20940 
    oprot.writeStructEnd()
20941 
 
20942 
  def validate(self):
20943 
    return
20944 
 
20945 
 
20946 
  def __repr__(self):
20947 
    L = ['%s=%r' % (key, value)
20948 
      for key, value in self.__dict__.iteritems()]
20949 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20950 
 
20951 
  def __eq__(self, other):
20952 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20953 
 
20954 
  def __ne__(self, other):
20955 
    return not (self == other)
20956 
 
20957 
class getAllItemVouchers_args:
20958 
  """
20959 
  Attributes:
20960 
   - itemId
20961 
  """
20962 
 
20963 
  thrift_spec = (
20964 
    None, # 0
20965 
    (1, TType.I64, 'itemId', None, None, ), # 1
20966 
  )
20967 
 
20968 
  def __init__(self, itemId=None,):
20969 
    self.itemId = itemId
20970 
 
20971 
  def read(self, iprot):
20972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20974 
      return
20975 
    iprot.readStructBegin()
20976 
    while True:
20977 
      (fname, ftype, fid) = iprot.readFieldBegin()
20978 
      if ftype == TType.STOP:
20979 
        break
20980 
      if fid == 1:
20981 
        if ftype == TType.I64:
20982 
          self.itemId = iprot.readI64();
20983 
        else:
20984 
          iprot.skip(ftype)
20985 
      else:
20986 
        iprot.skip(ftype)
20987 
      iprot.readFieldEnd()
20988 
    iprot.readStructEnd()
20989 
 
20990 
  def write(self, oprot):
20991 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20992 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20993 
      return
20994 
    oprot.writeStructBegin('getAllItemVouchers_args')
20995 
    if self.itemId is not None:
20996 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20997 
      oprot.writeI64(self.itemId)
20998 
      oprot.writeFieldEnd()
20999 
    oprot.writeFieldStop()
21000 
    oprot.writeStructEnd()
21001 
 
21002 
  def validate(self):
21003 
    return
21004 
 
21005 
 
21006 
  def __repr__(self):
21007 
    L = ['%s=%r' % (key, value)
21008 
      for key, value in self.__dict__.iteritems()]
21009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21010 
 
21011 
  def __eq__(self, other):
21012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21013 
 
21014 
  def __ne__(self, other):
21015 
    return not (self == other)
21016 
 
21017 
class getAllItemVouchers_result:
21018 
  """
21019 
  Attributes:
21020 
   - success
21021 
  """
21022 
 
21023 
  thrift_spec = (
21024 
    (0, TType.LIST, 'success', (TType.STRUCT,(VoucherItemMapping, VoucherItemMapping.thrift_spec)), None, ), # 0
21025 
  )
21026 
 
21027 
  def __init__(self, success=None,):
21028 
    self.success = success
21029 
 
21030 
  def read(self, iprot):
21031 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21032 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21033 
      return
21034 
    iprot.readStructBegin()
21035 
    while True:
21036 
      (fname, ftype, fid) = iprot.readFieldBegin()
21037 
      if ftype == TType.STOP:
21038 
        break
21039 
      if fid == 0:
21040 
        if ftype == TType.LIST:
21041 
          self.success = []
18719 kshitij.so 21042 
          (_etype397, _size394) = iprot.readListBegin()
21043 
          for _i398 in xrange(_size394):
21044 
            _elem399 = VoucherItemMapping()
21045 
            _elem399.read(iprot)
21046 
            self.success.append(_elem399)
5944 mandeep.dh 21047 
          iprot.readListEnd()
21048 
        else:
21049 
          iprot.skip(ftype)
21050 
      else:
21051 
        iprot.skip(ftype)
21052 
      iprot.readFieldEnd()
21053 
    iprot.readStructEnd()
21054 
 
21055 
  def write(self, oprot):
21056 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21057 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21058 
      return
21059 
    oprot.writeStructBegin('getAllItemVouchers_result')
21060 
    if self.success is not None:
21061 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21062 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 21063 
      for iter400 in self.success:
21064 
        iter400.write(oprot)
5944 mandeep.dh 21065 
      oprot.writeListEnd()
21066 
      oprot.writeFieldEnd()
21067 
    oprot.writeFieldStop()
21068 
    oprot.writeStructEnd()
21069 
 
21070 
  def validate(self):
21071 
    return
21072 
 
21073 
 
21074 
  def __repr__(self):
21075 
    L = ['%s=%r' % (key, value)
21076 
      for key, value in self.__dict__.iteritems()]
21077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21078 
 
21079 
  def __eq__(self, other):
21080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21081 
 
21082 
  def __ne__(self, other):
21083 
    return not (self == other)
21084 
 
21085 
class isValidCatalogItemId_args:
21086 
  """
21087 
  Attributes:
21088 
   - catalog_item_id
21089 
  """
21090 
 
21091 
  thrift_spec = (
21092 
    None, # 0
21093 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
21094 
  )
21095 
 
21096 
  def __init__(self, catalog_item_id=None,):
21097 
    self.catalog_item_id = catalog_item_id
21098 
 
21099 
  def read(self, iprot):
21100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21102 
      return
21103 
    iprot.readStructBegin()
21104 
    while True:
21105 
      (fname, ftype, fid) = iprot.readFieldBegin()
21106 
      if ftype == TType.STOP:
21107 
        break
21108 
      if fid == 1:
21109 
        if ftype == TType.I64:
21110 
          self.catalog_item_id = iprot.readI64();
21111 
        else:
21112 
          iprot.skip(ftype)
21113 
      else:
21114 
        iprot.skip(ftype)
21115 
      iprot.readFieldEnd()
21116 
    iprot.readStructEnd()
21117 
 
21118 
  def write(self, oprot):
21119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21121 
      return
21122 
    oprot.writeStructBegin('isValidCatalogItemId_args')
21123 
    if self.catalog_item_id is not None:
21124 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
21125 
      oprot.writeI64(self.catalog_item_id)
21126 
      oprot.writeFieldEnd()
21127 
    oprot.writeFieldStop()
21128 
    oprot.writeStructEnd()
21129 
 
21130 
  def validate(self):
21131 
    return
21132 
 
21133 
 
21134 
  def __repr__(self):
21135 
    L = ['%s=%r' % (key, value)
21136 
      for key, value in self.__dict__.iteritems()]
21137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21138 
 
21139 
  def __eq__(self, other):
21140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21141 
 
21142 
  def __ne__(self, other):
21143 
    return not (self == other)
21144 
 
21145 
class isValidCatalogItemId_result:
21146 
  """
21147 
  Attributes:
21148 
   - success
21149 
  """
21150 
 
21151 
  thrift_spec = (
21152 
    (0, TType.BOOL, 'success', None, None, ), # 0
21153 
  )
21154 
 
21155 
  def __init__(self, success=None,):
21156 
    self.success = success
21157 
 
21158 
  def read(self, iprot):
21159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21161 
      return
21162 
    iprot.readStructBegin()
21163 
    while True:
21164 
      (fname, ftype, fid) = iprot.readFieldBegin()
21165 
      if ftype == TType.STOP:
21166 
        break
21167 
      if fid == 0:
21168 
        if ftype == TType.BOOL:
21169 
          self.success = iprot.readBool();
21170 
        else:
21171 
          iprot.skip(ftype)
21172 
      else:
21173 
        iprot.skip(ftype)
21174 
      iprot.readFieldEnd()
21175 
    iprot.readStructEnd()
21176 
 
21177 
  def write(self, oprot):
21178 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21179 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21180 
      return
21181 
    oprot.writeStructBegin('isValidCatalogItemId_result')
21182 
    if self.success is not None:
21183 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21184 
      oprot.writeBool(self.success)
21185 
      oprot.writeFieldEnd()
21186 
    oprot.writeFieldStop()
21187 
    oprot.writeStructEnd()
21188 
 
21189 
  def validate(self):
21190 
    return
21191 
 
21192 
 
21193 
  def __repr__(self):
21194 
    L = ['%s=%r' % (key, value)
21195 
      for key, value in self.__dict__.iteritems()]
21196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21197 
 
21198 
  def __eq__(self, other):
21199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21200 
 
21201 
  def __ne__(self, other):
21202 
    return not (self == other)
6039 amit.gupta 21203 
 
21204 
class getVatPercentageForItem_args:
21205 
  """
21206 
  Attributes:
21207 
   - itemId
7330 amit.gupta 21208 
   - stateId
6039 amit.gupta 21209 
   - price
21210 
  """
21211 
 
21212 
  thrift_spec = (
21213 
    None, # 0
21214 
    (1, TType.I64, 'itemId', None, None, ), # 1
7330 amit.gupta 21215 
    (2, TType.I64, 'stateId', None, None, ), # 2
21216 
    (3, TType.DOUBLE, 'price', None, None, ), # 3
6039 amit.gupta 21217 
  )
21218 
 
7330 amit.gupta 21219 
  def __init__(self, itemId=None, stateId=None, price=None,):
6039 amit.gupta 21220 
    self.itemId = itemId
7330 amit.gupta 21221 
    self.stateId = stateId
6039 amit.gupta 21222 
    self.price = price
21223 
 
21224 
  def read(self, iprot):
21225 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21226 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21227 
      return
21228 
    iprot.readStructBegin()
21229 
    while True:
21230 
      (fname, ftype, fid) = iprot.readFieldBegin()
21231 
      if ftype == TType.STOP:
21232 
        break
21233 
      if fid == 1:
21234 
        if ftype == TType.I64:
21235 
          self.itemId = iprot.readI64();
21236 
        else:
21237 
          iprot.skip(ftype)
21238 
      elif fid == 2:
7330 amit.gupta 21239 
        if ftype == TType.I64:
21240 
          self.stateId = iprot.readI64();
21241 
        else:
21242 
          iprot.skip(ftype)
21243 
      elif fid == 3:
6039 amit.gupta 21244 
        if ftype == TType.DOUBLE:
21245 
          self.price = iprot.readDouble();
21246 
        else:
21247 
          iprot.skip(ftype)
21248 
      else:
21249 
        iprot.skip(ftype)
21250 
      iprot.readFieldEnd()
21251 
    iprot.readStructEnd()
21252 
 
21253 
  def write(self, oprot):
21254 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21255 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21256 
      return
21257 
    oprot.writeStructBegin('getVatPercentageForItem_args')
21258 
    if self.itemId is not None:
21259 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
21260 
      oprot.writeI64(self.itemId)
21261 
      oprot.writeFieldEnd()
7330 amit.gupta 21262 
    if self.stateId is not None:
21263 
      oprot.writeFieldBegin('stateId', TType.I64, 2)
21264 
      oprot.writeI64(self.stateId)
21265 
      oprot.writeFieldEnd()
6039 amit.gupta 21266 
    if self.price is not None:
7330 amit.gupta 21267 
      oprot.writeFieldBegin('price', TType.DOUBLE, 3)
6039 amit.gupta 21268 
      oprot.writeDouble(self.price)
21269 
      oprot.writeFieldEnd()
21270 
    oprot.writeFieldStop()
21271 
    oprot.writeStructEnd()
21272 
 
21273 
  def validate(self):
21274 
    return
21275 
 
21276 
 
21277 
  def __repr__(self):
21278 
    L = ['%s=%r' % (key, value)
21279 
      for key, value in self.__dict__.iteritems()]
21280 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21281 
 
21282 
  def __eq__(self, other):
21283 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21284 
 
21285 
  def __ne__(self, other):
21286 
    return not (self == other)
21287 
 
21288 
class getVatPercentageForItem_result:
21289 
  """
21290 
  Attributes:
21291 
   - success
7340 amit.gupta 21292 
   - cex
6039 amit.gupta 21293 
  """
21294 
 
21295 
  thrift_spec = (
21296 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
7340 amit.gupta 21297 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6039 amit.gupta 21298 
  )
21299 
 
7340 amit.gupta 21300 
  def __init__(self, success=None, cex=None,):
6039 amit.gupta 21301 
    self.success = success
7340 amit.gupta 21302 
    self.cex = cex
6039 amit.gupta 21303 
 
21304 
  def read(self, iprot):
21305 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21306 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21307 
      return
21308 
    iprot.readStructBegin()
21309 
    while True:
21310 
      (fname, ftype, fid) = iprot.readFieldBegin()
21311 
      if ftype == TType.STOP:
21312 
        break
21313 
      if fid == 0:
21314 
        if ftype == TType.DOUBLE:
21315 
          self.success = iprot.readDouble();
21316 
        else:
21317 
          iprot.skip(ftype)
7340 amit.gupta 21318 
      elif fid == 1:
21319 
        if ftype == TType.STRUCT:
21320 
          self.cex = CatalogServiceException()
21321 
          self.cex.read(iprot)
21322 
        else:
21323 
          iprot.skip(ftype)
6039 amit.gupta 21324 
      else:
21325 
        iprot.skip(ftype)
21326 
      iprot.readFieldEnd()
21327 
    iprot.readStructEnd()
21328 
 
21329 
  def write(self, oprot):
21330 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21331 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21332 
      return
21333 
    oprot.writeStructBegin('getVatPercentageForItem_result')
21334 
    if self.success is not None:
21335 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
21336 
      oprot.writeDouble(self.success)
21337 
      oprot.writeFieldEnd()
7340 amit.gupta 21338 
    if self.cex is not None:
21339 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
21340 
      self.cex.write(oprot)
21341 
      oprot.writeFieldEnd()
6039 amit.gupta 21342 
    oprot.writeFieldStop()
21343 
    oprot.writeStructEnd()
21344 
 
21345 
  def validate(self):
21346 
    return
21347 
 
21348 
 
21349 
  def __repr__(self):
21350 
    L = ['%s=%r' % (key, value)
21351 
      for key, value in self.__dict__.iteritems()]
21352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21353 
 
21354 
  def __eq__(self, other):
21355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21356 
 
21357 
  def __ne__(self, other):
21358 
    return not (self == other)
21359 
 
21360 
class getVatAmountForItem_args:
21361 
  """
21362 
  Attributes:
21363 
   - itemId
21364 
   - price
21365 
  """
21366 
 
21367 
  thrift_spec = (
21368 
    None, # 0
21369 
    (1, TType.I64, 'itemId', None, None, ), # 1
21370 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
21371 
  )
21372 
 
21373 
  def __init__(self, itemId=None, price=None,):
21374 
    self.itemId = itemId
21375 
    self.price = price
21376 
 
21377 
  def read(self, iprot):
21378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21380 
      return
21381 
    iprot.readStructBegin()
21382 
    while True:
21383 
      (fname, ftype, fid) = iprot.readFieldBegin()
21384 
      if ftype == TType.STOP:
21385 
        break
21386 
      if fid == 1:
21387 
        if ftype == TType.I64:
21388 
          self.itemId = iprot.readI64();
21389 
        else:
21390 
          iprot.skip(ftype)
21391 
      elif fid == 2:
21392 
        if ftype == TType.DOUBLE:
21393 
          self.price = iprot.readDouble();
21394 
        else:
21395 
          iprot.skip(ftype)
21396 
      else:
21397 
        iprot.skip(ftype)
21398 
      iprot.readFieldEnd()
21399 
    iprot.readStructEnd()
21400 
 
21401 
  def write(self, oprot):
21402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21404 
      return
21405 
    oprot.writeStructBegin('getVatAmountForItem_args')
21406 
    if self.itemId is not None:
21407 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
21408 
      oprot.writeI64(self.itemId)
21409 
      oprot.writeFieldEnd()
21410 
    if self.price is not None:
21411 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
21412 
      oprot.writeDouble(self.price)
21413 
      oprot.writeFieldEnd()
21414 
    oprot.writeFieldStop()
21415 
    oprot.writeStructEnd()
21416 
 
21417 
  def validate(self):
21418 
    return
21419 
 
21420 
 
21421 
  def __repr__(self):
21422 
    L = ['%s=%r' % (key, value)
21423 
      for key, value in self.__dict__.iteritems()]
21424 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21425 
 
21426 
  def __eq__(self, other):
21427 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21428 
 
21429 
  def __ne__(self, other):
21430 
    return not (self == other)
21431 
 
21432 
class getVatAmountForItem_result:
21433 
  """
21434 
  Attributes:
21435 
   - success
21436 
  """
21437 
 
21438 
  thrift_spec = (
21439 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
21440 
  )
21441 
 
21442 
  def __init__(self, success=None,):
21443 
    self.success = success
21444 
 
21445 
  def read(self, iprot):
21446 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21447 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21448 
      return
21449 
    iprot.readStructBegin()
21450 
    while True:
21451 
      (fname, ftype, fid) = iprot.readFieldBegin()
21452 
      if ftype == TType.STOP:
21453 
        break
21454 
      if fid == 0:
21455 
        if ftype == TType.DOUBLE:
21456 
          self.success = iprot.readDouble();
21457 
        else:
21458 
          iprot.skip(ftype)
21459 
      else:
21460 
        iprot.skip(ftype)
21461 
      iprot.readFieldEnd()
21462 
    iprot.readStructEnd()
21463 
 
21464 
  def write(self, oprot):
21465 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21466 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21467 
      return
21468 
    oprot.writeStructBegin('getVatAmountForItem_result')
21469 
    if self.success is not None:
21470 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
21471 
      oprot.writeDouble(self.success)
21472 
      oprot.writeFieldEnd()
21473 
    oprot.writeFieldStop()
21474 
    oprot.writeStructEnd()
21475 
 
21476 
  def validate(self):
21477 
    return
21478 
 
21479 
 
21480 
  def __repr__(self):
21481 
    L = ['%s=%r' % (key, value)
21482 
      for key, value in self.__dict__.iteritems()]
21483 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21484 
 
21485 
  def __eq__(self, other):
21486 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21487 
 
21488 
  def __ne__(self, other):
21489 
    return not (self == other)
6531 vikram.rag 21490 
 
21491 
class getAllIgnoredInventoryUpdateItemsList_args:
21492 
  """
21493 
  Attributes:
21494 
   - offset
21495 
   - limit
21496 
  """
21497 
 
21498 
  thrift_spec = (
21499 
    None, # 0
21500 
    (1, TType.I32, 'offset', None, None, ), # 1
21501 
    (2, TType.I32, 'limit', None, None, ), # 2
21502 
  )
21503 
 
21504 
  def __init__(self, offset=None, limit=None,):
21505 
    self.offset = offset
21506 
    self.limit = limit
21507 
 
21508 
  def read(self, iprot):
21509 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21510 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21511 
      return
21512 
    iprot.readStructBegin()
21513 
    while True:
21514 
      (fname, ftype, fid) = iprot.readFieldBegin()
21515 
      if ftype == TType.STOP:
21516 
        break
21517 
      if fid == 1:
21518 
        if ftype == TType.I32:
21519 
          self.offset = iprot.readI32();
21520 
        else:
21521 
          iprot.skip(ftype)
21522 
      elif fid == 2:
21523 
        if ftype == TType.I32:
21524 
          self.limit = iprot.readI32();
21525 
        else:
21526 
          iprot.skip(ftype)
21527 
      else:
21528 
        iprot.skip(ftype)
21529 
      iprot.readFieldEnd()
21530 
    iprot.readStructEnd()
21531 
 
21532 
  def write(self, oprot):
21533 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21534 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21535 
      return
21536 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_args')
21537 
    if self.offset is not None:
21538 
      oprot.writeFieldBegin('offset', TType.I32, 1)
21539 
      oprot.writeI32(self.offset)
21540 
      oprot.writeFieldEnd()
21541 
    if self.limit is not None:
21542 
      oprot.writeFieldBegin('limit', TType.I32, 2)
21543 
      oprot.writeI32(self.limit)
21544 
      oprot.writeFieldEnd()
21545 
    oprot.writeFieldStop()
21546 
    oprot.writeStructEnd()
21547 
 
21548 
  def validate(self):
21549 
    return
21550 
 
21551 
 
21552 
  def __repr__(self):
21553 
    L = ['%s=%r' % (key, value)
21554 
      for key, value in self.__dict__.iteritems()]
21555 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21556 
 
21557 
  def __eq__(self, other):
21558 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21559 
 
21560 
  def __ne__(self, other):
21561 
    return not (self == other)
21562 
 
21563 
class getAllIgnoredInventoryUpdateItemsList_result:
21564 
  """
21565 
  Attributes:
21566 
   - success
21567 
  """
21568 
 
21569 
  thrift_spec = (
21570 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
21571 
  )
21572 
 
21573 
  def __init__(self, success=None,):
21574 
    self.success = success
21575 
 
21576 
  def read(self, iprot):
21577 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21578 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21579 
      return
21580 
    iprot.readStructBegin()
21581 
    while True:
21582 
      (fname, ftype, fid) = iprot.readFieldBegin()
21583 
      if ftype == TType.STOP:
21584 
        break
21585 
      if fid == 0:
21586 
        if ftype == TType.LIST:
21587 
          self.success = []
18719 kshitij.so 21588 
          (_etype404, _size401) = iprot.readListBegin()
21589 
          for _i405 in xrange(_size401):
21590 
            _elem406 = Item()
21591 
            _elem406.read(iprot)
21592 
            self.success.append(_elem406)
6531 vikram.rag 21593 
          iprot.readListEnd()
21594 
        else:
21595 
          iprot.skip(ftype)
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('getAllIgnoredInventoryUpdateItemsList_result')
21606 
    if self.success is not None:
21607 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21608 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 21609 
      for iter407 in self.success:
21610 
        iter407.write(oprot)
6531 vikram.rag 21611 
      oprot.writeListEnd()
21612 
      oprot.writeFieldEnd()
21613 
    oprot.writeFieldStop()
21614 
    oprot.writeStructEnd()
21615 
 
21616 
  def validate(self):
21617 
    return
21618 
 
21619 
 
21620 
  def __repr__(self):
21621 
    L = ['%s=%r' % (key, value)
21622 
      for key, value in self.__dict__.iteritems()]
21623 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21624 
 
21625 
  def __eq__(self, other):
21626 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21627 
 
21628 
  def __ne__(self, other):
21629 
    return not (self == other)
6805 anupam.sin 21630 
 
6821 amar.kumar 21631 
class getAllAliveItems_args:
21632 
 
21633 
  thrift_spec = (
21634 
  )
21635 
 
21636 
  def read(self, iprot):
21637 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21638 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21639 
      return
21640 
    iprot.readStructBegin()
21641 
    while True:
21642 
      (fname, ftype, fid) = iprot.readFieldBegin()
21643 
      if ftype == TType.STOP:
21644 
        break
21645 
      else:
21646 
        iprot.skip(ftype)
21647 
      iprot.readFieldEnd()
21648 
    iprot.readStructEnd()
21649 
 
21650 
  def write(self, oprot):
21651 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21652 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21653 
      return
21654 
    oprot.writeStructBegin('getAllAliveItems_args')
21655 
    oprot.writeFieldStop()
21656 
    oprot.writeStructEnd()
21657 
 
21658 
  def validate(self):
21659 
    return
21660 
 
21661 
 
21662 
  def __repr__(self):
21663 
    L = ['%s=%r' % (key, value)
21664 
      for key, value in self.__dict__.iteritems()]
21665 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21666 
 
21667 
  def __eq__(self, other):
21668 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21669 
 
21670 
  def __ne__(self, other):
21671 
    return not (self == other)
21672 
 
21673 
class getAllAliveItems_result:
21674 
  """
21675 
  Attributes:
21676 
   - success
21677 
  """
21678 
 
21679 
  thrift_spec = (
21680 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
21681 
  )
21682 
 
21683 
  def __init__(self, success=None,):
21684 
    self.success = success
21685 
 
21686 
  def read(self, iprot):
21687 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21688 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21689 
      return
21690 
    iprot.readStructBegin()
21691 
    while True:
21692 
      (fname, ftype, fid) = iprot.readFieldBegin()
21693 
      if ftype == TType.STOP:
21694 
        break
21695 
      if fid == 0:
21696 
        if ftype == TType.LIST:
21697 
          self.success = []
18719 kshitij.so 21698 
          (_etype411, _size408) = iprot.readListBegin()
21699 
          for _i412 in xrange(_size408):
21700 
            _elem413 = Item()
21701 
            _elem413.read(iprot)
21702 
            self.success.append(_elem413)
6821 amar.kumar 21703 
          iprot.readListEnd()
21704 
        else:
21705 
          iprot.skip(ftype)
21706 
      else:
21707 
        iprot.skip(ftype)
21708 
      iprot.readFieldEnd()
21709 
    iprot.readStructEnd()
21710 
 
21711 
  def write(self, oprot):
21712 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21713 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21714 
      return
21715 
    oprot.writeStructBegin('getAllAliveItems_result')
21716 
    if self.success is not None:
21717 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21718 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 21719 
      for iter414 in self.success:
21720 
        iter414.write(oprot)
6821 amar.kumar 21721 
      oprot.writeListEnd()
21722 
      oprot.writeFieldEnd()
21723 
    oprot.writeFieldStop()
21724 
    oprot.writeStructEnd()
21725 
 
21726 
  def validate(self):
21727 
    return
21728 
 
21729 
 
21730 
  def __repr__(self):
21731 
    L = ['%s=%r' % (key, value)
21732 
      for key, value in self.__dict__.iteritems()]
21733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21734 
 
21735 
  def __eq__(self, other):
21736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21737 
 
21738 
  def __ne__(self, other):
21739 
    return not (self == other)
21740 
 
6805 anupam.sin 21741 
class getInsuranceAmount_args:
21742 
  """
21743 
  Attributes:
21744 
   - itemId
6921 anupam.sin 21745 
   - price
6805 anupam.sin 21746 
   - insurerId
21747 
   - quantity
21748 
  """
21749 
 
21750 
  thrift_spec = (
21751 
    None, # 0
21752 
    (1, TType.I64, 'itemId', None, None, ), # 1
6921 anupam.sin 21753 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
21754 
    (3, TType.I64, 'insurerId', None, None, ), # 3
21755 
    (4, TType.I64, 'quantity', None, None, ), # 4
6805 anupam.sin 21756 
  )
21757 
 
6921 anupam.sin 21758 
  def __init__(self, itemId=None, price=None, insurerId=None, quantity=None,):
6805 anupam.sin 21759 
    self.itemId = itemId
6921 anupam.sin 21760 
    self.price = price
6805 anupam.sin 21761 
    self.insurerId = insurerId
21762 
    self.quantity = quantity
21763 
 
21764 
  def read(self, iprot):
21765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21767 
      return
21768 
    iprot.readStructBegin()
21769 
    while True:
21770 
      (fname, ftype, fid) = iprot.readFieldBegin()
21771 
      if ftype == TType.STOP:
21772 
        break
21773 
      if fid == 1:
21774 
        if ftype == TType.I64:
21775 
          self.itemId = iprot.readI64();
21776 
        else:
21777 
          iprot.skip(ftype)
21778 
      elif fid == 2:
6921 anupam.sin 21779 
        if ftype == TType.DOUBLE:
21780 
          self.price = iprot.readDouble();
21781 
        else:
21782 
          iprot.skip(ftype)
21783 
      elif fid == 3:
6805 anupam.sin 21784 
        if ftype == TType.I64:
21785 
          self.insurerId = iprot.readI64();
21786 
        else:
21787 
          iprot.skip(ftype)
6921 anupam.sin 21788 
      elif fid == 4:
6805 anupam.sin 21789 
        if ftype == TType.I64:
21790 
          self.quantity = iprot.readI64();
21791 
        else:
21792 
          iprot.skip(ftype)
21793 
      else:
21794 
        iprot.skip(ftype)
21795 
      iprot.readFieldEnd()
21796 
    iprot.readStructEnd()
21797 
 
21798 
  def write(self, oprot):
21799 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21800 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21801 
      return
21802 
    oprot.writeStructBegin('getInsuranceAmount_args')
21803 
    if self.itemId is not None:
21804 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
21805 
      oprot.writeI64(self.itemId)
21806 
      oprot.writeFieldEnd()
6921 anupam.sin 21807 
    if self.price is not None:
21808 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
21809 
      oprot.writeDouble(self.price)
21810 
      oprot.writeFieldEnd()
6805 anupam.sin 21811 
    if self.insurerId is not None:
6921 anupam.sin 21812 
      oprot.writeFieldBegin('insurerId', TType.I64, 3)
6805 anupam.sin 21813 
      oprot.writeI64(self.insurerId)
21814 
      oprot.writeFieldEnd()
21815 
    if self.quantity is not None:
6921 anupam.sin 21816 
      oprot.writeFieldBegin('quantity', TType.I64, 4)
6805 anupam.sin 21817 
      oprot.writeI64(self.quantity)
21818 
      oprot.writeFieldEnd()
21819 
    oprot.writeFieldStop()
21820 
    oprot.writeStructEnd()
21821 
 
21822 
  def validate(self):
21823 
    return
21824 
 
21825 
 
21826 
  def __repr__(self):
21827 
    L = ['%s=%r' % (key, value)
21828 
      for key, value in self.__dict__.iteritems()]
21829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21830 
 
21831 
  def __eq__(self, other):
21832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21833 
 
21834 
  def __ne__(self, other):
21835 
    return not (self == other)
21836 
 
21837 
class getInsuranceAmount_result:
21838 
  """
21839 
  Attributes:
21840 
   - success
21841 
  """
21842 
 
21843 
  thrift_spec = (
21844 
    (0, TType.I64, 'success', None, None, ), # 0
21845 
  )
21846 
 
21847 
  def __init__(self, success=None,):
21848 
    self.success = success
21849 
 
21850 
  def read(self, iprot):
21851 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21852 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21853 
      return
21854 
    iprot.readStructBegin()
21855 
    while True:
21856 
      (fname, ftype, fid) = iprot.readFieldBegin()
21857 
      if ftype == TType.STOP:
21858 
        break
21859 
      if fid == 0:
21860 
        if ftype == TType.I64:
21861 
          self.success = iprot.readI64();
21862 
        else:
21863 
          iprot.skip(ftype)
21864 
      else:
21865 
        iprot.skip(ftype)
21866 
      iprot.readFieldEnd()
21867 
    iprot.readStructEnd()
21868 
 
21869 
  def write(self, oprot):
21870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21872 
      return
21873 
    oprot.writeStructBegin('getInsuranceAmount_result')
21874 
    if self.success is not None:
21875 
      oprot.writeFieldBegin('success', TType.I64, 0)
21876 
      oprot.writeI64(self.success)
21877 
      oprot.writeFieldEnd()
21878 
    oprot.writeFieldStop()
21879 
    oprot.writeStructEnd()
21880 
 
21881 
  def validate(self):
21882 
    return
21883 
 
21884 
 
21885 
  def __repr__(self):
21886 
    L = ['%s=%r' % (key, value)
21887 
      for key, value in self.__dict__.iteritems()]
21888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21889 
 
21890 
  def __eq__(self, other):
21891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21892 
 
21893 
  def __ne__(self, other):
21894 
    return not (self == other)
21895 
 
21896 
class getInsurer_args:
21897 
  """
21898 
  Attributes:
21899 
   - insurerId
21900 
  """
21901 
 
21902 
  thrift_spec = (
21903 
    None, # 0
21904 
    (1, TType.I64, 'insurerId', None, None, ), # 1
21905 
  )
21906 
 
21907 
  def __init__(self, insurerId=None,):
21908 
    self.insurerId = insurerId
21909 
 
21910 
  def read(self, iprot):
21911 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21912 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21913 
      return
21914 
    iprot.readStructBegin()
21915 
    while True:
21916 
      (fname, ftype, fid) = iprot.readFieldBegin()
21917 
      if ftype == TType.STOP:
21918 
        break
21919 
      if fid == 1:
21920 
        if ftype == TType.I64:
21921 
          self.insurerId = iprot.readI64();
21922 
        else:
21923 
          iprot.skip(ftype)
21924 
      else:
21925 
        iprot.skip(ftype)
21926 
      iprot.readFieldEnd()
21927 
    iprot.readStructEnd()
21928 
 
21929 
  def write(self, oprot):
21930 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21931 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21932 
      return
21933 
    oprot.writeStructBegin('getInsurer_args')
21934 
    if self.insurerId is not None:
21935 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
21936 
      oprot.writeI64(self.insurerId)
21937 
      oprot.writeFieldEnd()
21938 
    oprot.writeFieldStop()
21939 
    oprot.writeStructEnd()
21940 
 
21941 
  def validate(self):
21942 
    return
21943 
 
21944 
 
21945 
  def __repr__(self):
21946 
    L = ['%s=%r' % (key, value)
21947 
      for key, value in self.__dict__.iteritems()]
21948 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21949 
 
21950 
  def __eq__(self, other):
21951 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21952 
 
21953 
  def __ne__(self, other):
21954 
    return not (self == other)
21955 
 
21956 
class getInsurer_result:
21957 
  """
21958 
  Attributes:
21959 
   - success
21960 
  """
21961 
 
21962 
  thrift_spec = (
21963 
    (0, TType.STRUCT, 'success', (Insurer, Insurer.thrift_spec), None, ), # 0
21964 
  )
21965 
 
21966 
  def __init__(self, success=None,):
21967 
    self.success = success
21968 
 
21969 
  def read(self, iprot):
21970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21972 
      return
21973 
    iprot.readStructBegin()
21974 
    while True:
21975 
      (fname, ftype, fid) = iprot.readFieldBegin()
21976 
      if ftype == TType.STOP:
21977 
        break
21978 
      if fid == 0:
21979 
        if ftype == TType.STRUCT:
21980 
          self.success = Insurer()
21981 
          self.success.read(iprot)
21982 
        else:
21983 
          iprot.skip(ftype)
21984 
      else:
21985 
        iprot.skip(ftype)
21986 
      iprot.readFieldEnd()
21987 
    iprot.readStructEnd()
21988 
 
21989 
  def write(self, oprot):
21990 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21991 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21992 
      return
21993 
    oprot.writeStructBegin('getInsurer_result')
21994 
    if self.success is not None:
21995 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21996 
      self.success.write(oprot)
21997 
      oprot.writeFieldEnd()
21998 
    oprot.writeFieldStop()
21999 
    oprot.writeStructEnd()
22000 
 
22001 
  def validate(self):
22002 
    return
22003 
 
22004 
 
22005 
  def __repr__(self):
22006 
    L = ['%s=%r' % (key, value)
22007 
      for key, value in self.__dict__.iteritems()]
22008 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22009 
 
22010 
  def __eq__(self, other):
22011 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22012 
 
22013 
  def __ne__(self, other):
22014 
    return not (self == other)
6838 vikram.rag 22015 
 
22016 
class getAllInsurers_args:
22017 
 
22018 
  thrift_spec = (
22019 
  )
22020 
 
22021 
  def read(self, iprot):
22022 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22023 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22024 
      return
22025 
    iprot.readStructBegin()
22026 
    while True:
22027 
      (fname, ftype, fid) = iprot.readFieldBegin()
22028 
      if ftype == TType.STOP:
22029 
        break
22030 
      else:
22031 
        iprot.skip(ftype)
22032 
      iprot.readFieldEnd()
22033 
    iprot.readStructEnd()
22034 
 
22035 
  def write(self, oprot):
22036 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22037 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22038 
      return
22039 
    oprot.writeStructBegin('getAllInsurers_args')
22040 
    oprot.writeFieldStop()
22041 
    oprot.writeStructEnd()
22042 
 
22043 
  def validate(self):
22044 
    return
22045 
 
22046 
 
22047 
  def __repr__(self):
22048 
    L = ['%s=%r' % (key, value)
22049 
      for key, value in self.__dict__.iteritems()]
22050 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22051 
 
22052 
  def __eq__(self, other):
22053 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22054 
 
22055 
  def __ne__(self, other):
22056 
    return not (self == other)
22057 
 
22058 
class getAllInsurers_result:
22059 
  """
22060 
  Attributes:
22061 
   - success
22062 
  """
22063 
 
22064 
  thrift_spec = (
22065 
    (0, TType.LIST, 'success', (TType.STRUCT,(Insurer, Insurer.thrift_spec)), None, ), # 0
22066 
  )
22067 
 
22068 
  def __init__(self, success=None,):
22069 
    self.success = success
22070 
 
22071 
  def read(self, iprot):
22072 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22073 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22074 
      return
22075 
    iprot.readStructBegin()
22076 
    while True:
22077 
      (fname, ftype, fid) = iprot.readFieldBegin()
22078 
      if ftype == TType.STOP:
22079 
        break
22080 
      if fid == 0:
22081 
        if ftype == TType.LIST:
22082 
          self.success = []
18719 kshitij.so 22083 
          (_etype418, _size415) = iprot.readListBegin()
22084 
          for _i419 in xrange(_size415):
22085 
            _elem420 = Insurer()
22086 
            _elem420.read(iprot)
22087 
            self.success.append(_elem420)
6838 vikram.rag 22088 
          iprot.readListEnd()
22089 
        else:
22090 
          iprot.skip(ftype)
22091 
      else:
22092 
        iprot.skip(ftype)
22093 
      iprot.readFieldEnd()
22094 
    iprot.readStructEnd()
22095 
 
22096 
  def write(self, oprot):
22097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22099 
      return
22100 
    oprot.writeStructBegin('getAllInsurers_result')
22101 
    if self.success is not None:
22102 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22103 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 22104 
      for iter421 in self.success:
22105 
        iter421.write(oprot)
6838 vikram.rag 22106 
      oprot.writeListEnd()
22107 
      oprot.writeFieldEnd()
22108 
    oprot.writeFieldStop()
22109 
    oprot.writeStructEnd()
22110 
 
22111 
  def validate(self):
22112 
    return
22113 
 
22114 
 
22115 
  def __repr__(self):
22116 
    L = ['%s=%r' % (key, value)
22117 
      for key, value in self.__dict__.iteritems()]
22118 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22119 
 
22120 
  def __eq__(self, other):
22121 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22122 
 
22123 
  def __ne__(self, other):
22124 
    return not (self == other)
6962 rajveer 22125 
 
22126 
class updateInsuranceDeclaredAmount_args:
22127 
  """
22128 
  Attributes:
22129 
   - insurerId
22130 
   - amount
22131 
  """
22132 
 
22133 
  thrift_spec = (
22134 
    None, # 0
22135 
    (1, TType.I64, 'insurerId', None, None, ), # 1
22136 
    (2, TType.DOUBLE, 'amount', None, None, ), # 2
22137 
  )
22138 
 
22139 
  def __init__(self, insurerId=None, amount=None,):
22140 
    self.insurerId = insurerId
22141 
    self.amount = amount
22142 
 
22143 
  def read(self, iprot):
22144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22146 
      return
22147 
    iprot.readStructBegin()
22148 
    while True:
22149 
      (fname, ftype, fid) = iprot.readFieldBegin()
22150 
      if ftype == TType.STOP:
22151 
        break
22152 
      if fid == 1:
22153 
        if ftype == TType.I64:
22154 
          self.insurerId = iprot.readI64();
22155 
        else:
22156 
          iprot.skip(ftype)
22157 
      elif fid == 2:
22158 
        if ftype == TType.DOUBLE:
22159 
          self.amount = iprot.readDouble();
22160 
        else:
22161 
          iprot.skip(ftype)
22162 
      else:
22163 
        iprot.skip(ftype)
22164 
      iprot.readFieldEnd()
22165 
    iprot.readStructEnd()
22166 
 
22167 
  def write(self, oprot):
22168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22170 
      return
22171 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_args')
22172 
    if self.insurerId is not None:
22173 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
22174 
      oprot.writeI64(self.insurerId)
22175 
      oprot.writeFieldEnd()
22176 
    if self.amount is not None:
22177 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 2)
22178 
      oprot.writeDouble(self.amount)
22179 
      oprot.writeFieldEnd()
22180 
    oprot.writeFieldStop()
22181 
    oprot.writeStructEnd()
22182 
 
22183 
  def validate(self):
22184 
    return
22185 
 
22186 
 
22187 
  def __repr__(self):
22188 
    L = ['%s=%r' % (key, value)
22189 
      for key, value in self.__dict__.iteritems()]
22190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22191 
 
22192 
  def __eq__(self, other):
22193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22194 
 
22195 
  def __ne__(self, other):
22196 
    return not (self == other)
22197 
 
22198 
class updateInsuranceDeclaredAmount_result:
22199 
 
22200 
  thrift_spec = (
22201 
  )
22202 
 
22203 
  def read(self, iprot):
22204 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22205 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22206 
      return
22207 
    iprot.readStructBegin()
22208 
    while True:
22209 
      (fname, ftype, fid) = iprot.readFieldBegin()
22210 
      if ftype == TType.STOP:
22211 
        break
22212 
      else:
22213 
        iprot.skip(ftype)
22214 
      iprot.readFieldEnd()
22215 
    iprot.readStructEnd()
22216 
 
22217 
  def write(self, oprot):
22218 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22219 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22220 
      return
22221 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_result')
22222 
    oprot.writeFieldStop()
22223 
    oprot.writeStructEnd()
22224 
 
22225 
  def validate(self):
22226 
    return
22227 
 
22228 
 
22229 
  def __repr__(self):
22230 
    L = ['%s=%r' % (key, value)
22231 
      for key, value in self.__dict__.iteritems()]
22232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22233 
 
22234 
  def __eq__(self, other):
22235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22236 
 
22237 
  def __ne__(self, other):
22238 
    return not (self == other)
7190 amar.kumar 22239 
 
22240 
class getFreebieForItem_args:
22241 
  """
22242 
  Attributes:
22243 
   - itemId
22244 
  """
22245 
 
22246 
  thrift_spec = (
22247 
    None, # 0
22248 
    (1, TType.I64, 'itemId', None, None, ), # 1
22249 
  )
22250 
 
22251 
  def __init__(self, itemId=None,):
22252 
    self.itemId = itemId
22253 
 
22254 
  def read(self, iprot):
22255 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22256 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22257 
      return
22258 
    iprot.readStructBegin()
22259 
    while True:
22260 
      (fname, ftype, fid) = iprot.readFieldBegin()
22261 
      if ftype == TType.STOP:
22262 
        break
22263 
      if fid == 1:
22264 
        if ftype == TType.I64:
22265 
          self.itemId = iprot.readI64();
22266 
        else:
22267 
          iprot.skip(ftype)
22268 
      else:
22269 
        iprot.skip(ftype)
22270 
      iprot.readFieldEnd()
22271 
    iprot.readStructEnd()
22272 
 
22273 
  def write(self, oprot):
22274 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22275 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22276 
      return
22277 
    oprot.writeStructBegin('getFreebieForItem_args')
22278 
    if self.itemId is not None:
22279 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
22280 
      oprot.writeI64(self.itemId)
22281 
      oprot.writeFieldEnd()
22282 
    oprot.writeFieldStop()
22283 
    oprot.writeStructEnd()
22284 
 
22285 
  def validate(self):
22286 
    return
22287 
 
22288 
 
22289 
  def __repr__(self):
22290 
    L = ['%s=%r' % (key, value)
22291 
      for key, value in self.__dict__.iteritems()]
22292 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22293 
 
22294 
  def __eq__(self, other):
22295 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22296 
 
22297 
  def __ne__(self, other):
22298 
    return not (self == other)
22299 
 
22300 
class getFreebieForItem_result:
22301 
  """
22302 
  Attributes:
22303 
   - success
22304 
  """
22305 
 
22306 
  thrift_spec = (
22307 
    (0, TType.I64, 'success', None, None, ), # 0
22308 
  )
22309 
 
22310 
  def __init__(self, success=None,):
22311 
    self.success = success
22312 
 
22313 
  def read(self, iprot):
22314 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22315 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22316 
      return
22317 
    iprot.readStructBegin()
22318 
    while True:
22319 
      (fname, ftype, fid) = iprot.readFieldBegin()
22320 
      if ftype == TType.STOP:
22321 
        break
22322 
      if fid == 0:
22323 
        if ftype == TType.I64:
22324 
          self.success = iprot.readI64();
22325 
        else:
22326 
          iprot.skip(ftype)
22327 
      else:
22328 
        iprot.skip(ftype)
22329 
      iprot.readFieldEnd()
22330 
    iprot.readStructEnd()
22331 
 
22332 
  def write(self, oprot):
22333 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22334 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22335 
      return
22336 
    oprot.writeStructBegin('getFreebieForItem_result')
22337 
    if self.success is not None:
22338 
      oprot.writeFieldBegin('success', TType.I64, 0)
22339 
      oprot.writeI64(self.success)
22340 
      oprot.writeFieldEnd()
22341 
    oprot.writeFieldStop()
22342 
    oprot.writeStructEnd()
22343 
 
22344 
  def validate(self):
22345 
    return
22346 
 
22347 
 
22348 
  def __repr__(self):
22349 
    L = ['%s=%r' % (key, value)
22350 
      for key, value in self.__dict__.iteritems()]
22351 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22352 
 
22353 
  def __eq__(self, other):
22354 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22355 
 
22356 
  def __ne__(self, other):
22357 
    return not (self == other)
22358 
 
22359 
class addOrUpdateFreebieForItem_args:
22360 
  """
22361 
  Attributes:
22362 
   - freebieItem
22363 
  """
22364 
 
22365 
  thrift_spec = (
22366 
    None, # 0
22367 
    (1, TType.STRUCT, 'freebieItem', (FreebieItem, FreebieItem.thrift_spec), None, ), # 1
22368 
  )
22369 
 
22370 
  def __init__(self, freebieItem=None,):
22371 
    self.freebieItem = freebieItem
22372 
 
22373 
  def read(self, iprot):
22374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22376 
      return
22377 
    iprot.readStructBegin()
22378 
    while True:
22379 
      (fname, ftype, fid) = iprot.readFieldBegin()
22380 
      if ftype == TType.STOP:
22381 
        break
22382 
      if fid == 1:
22383 
        if ftype == TType.STRUCT:
22384 
          self.freebieItem = FreebieItem()
22385 
          self.freebieItem.read(iprot)
22386 
        else:
22387 
          iprot.skip(ftype)
22388 
      else:
22389 
        iprot.skip(ftype)
22390 
      iprot.readFieldEnd()
22391 
    iprot.readStructEnd()
22392 
 
22393 
  def write(self, oprot):
22394 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22395 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22396 
      return
22397 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_args')
22398 
    if self.freebieItem is not None:
22399 
      oprot.writeFieldBegin('freebieItem', TType.STRUCT, 1)
22400 
      self.freebieItem.write(oprot)
22401 
      oprot.writeFieldEnd()
22402 
    oprot.writeFieldStop()
22403 
    oprot.writeStructEnd()
22404 
 
22405 
  def validate(self):
22406 
    return
22407 
 
22408 
 
22409 
  def __repr__(self):
22410 
    L = ['%s=%r' % (key, value)
22411 
      for key, value in self.__dict__.iteritems()]
22412 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22413 
 
22414 
  def __eq__(self, other):
22415 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22416 
 
22417 
  def __ne__(self, other):
22418 
    return not (self == other)
22419 
 
22420 
class addOrUpdateFreebieForItem_result:
22421 
 
22422 
  thrift_spec = (
22423 
  )
22424 
 
22425 
  def read(self, iprot):
22426 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22427 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22428 
      return
22429 
    iprot.readStructBegin()
22430 
    while True:
22431 
      (fname, ftype, fid) = iprot.readFieldBegin()
22432 
      if ftype == TType.STOP:
22433 
        break
22434 
      else:
22435 
        iprot.skip(ftype)
22436 
      iprot.readFieldEnd()
22437 
    iprot.readStructEnd()
22438 
 
22439 
  def write(self, oprot):
22440 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22441 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22442 
      return
22443 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_result')
22444 
    oprot.writeFieldStop()
22445 
    oprot.writeStructEnd()
22446 
 
22447 
  def validate(self):
22448 
    return
22449 
 
22450 
 
22451 
  def __repr__(self):
22452 
    L = ['%s=%r' % (key, value)
22453 
      for key, value in self.__dict__.iteritems()]
22454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22455 
 
22456 
  def __eq__(self, other):
22457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22458 
 
22459 
  def __ne__(self, other):
22460 
    return not (self == other)
7256 rajveer 22461 
 
7272 amit.gupta 22462 
class addOrUpdateBrandInfo_args:
22463 
  """
22464 
  Attributes:
22465 
   - brandInfo
22466 
  """
22467 
 
22468 
  thrift_spec = (
22469 
    None, # 0
22470 
    (1, TType.STRUCT, 'brandInfo', (BrandInfo, BrandInfo.thrift_spec), None, ), # 1
22471 
  )
22472 
 
22473 
  def __init__(self, brandInfo=None,):
22474 
    self.brandInfo = brandInfo
22475 
 
22476 
  def read(self, iprot):
22477 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22478 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22479 
      return
22480 
    iprot.readStructBegin()
22481 
    while True:
22482 
      (fname, ftype, fid) = iprot.readFieldBegin()
22483 
      if ftype == TType.STOP:
22484 
        break
22485 
      if fid == 1:
22486 
        if ftype == TType.STRUCT:
22487 
          self.brandInfo = BrandInfo()
22488 
          self.brandInfo.read(iprot)
22489 
        else:
22490 
          iprot.skip(ftype)
22491 
      else:
22492 
        iprot.skip(ftype)
22493 
      iprot.readFieldEnd()
22494 
    iprot.readStructEnd()
22495 
 
22496 
  def write(self, oprot):
22497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22499 
      return
22500 
    oprot.writeStructBegin('addOrUpdateBrandInfo_args')
22501 
    if self.brandInfo is not None:
22502 
      oprot.writeFieldBegin('brandInfo', TType.STRUCT, 1)
22503 
      self.brandInfo.write(oprot)
22504 
      oprot.writeFieldEnd()
22505 
    oprot.writeFieldStop()
22506 
    oprot.writeStructEnd()
22507 
 
22508 
  def validate(self):
22509 
    return
22510 
 
22511 
 
22512 
  def __repr__(self):
22513 
    L = ['%s=%r' % (key, value)
22514 
      for key, value in self.__dict__.iteritems()]
22515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22516 
 
22517 
  def __eq__(self, other):
22518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22519 
 
22520 
  def __ne__(self, other):
22521 
    return not (self == other)
22522 
 
22523 
class addOrUpdateBrandInfo_result:
22524 
 
22525 
  thrift_spec = (
22526 
  )
22527 
 
22528 
  def read(self, iprot):
22529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22531 
      return
22532 
    iprot.readStructBegin()
22533 
    while True:
22534 
      (fname, ftype, fid) = iprot.readFieldBegin()
22535 
      if ftype == TType.STOP:
22536 
        break
22537 
      else:
22538 
        iprot.skip(ftype)
22539 
      iprot.readFieldEnd()
22540 
    iprot.readStructEnd()
22541 
 
22542 
  def write(self, oprot):
22543 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22544 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22545 
      return
22546 
    oprot.writeStructBegin('addOrUpdateBrandInfo_result')
22547 
    oprot.writeFieldStop()
22548 
    oprot.writeStructEnd()
22549 
 
22550 
  def validate(self):
22551 
    return
22552 
 
22553 
 
22554 
  def __repr__(self):
22555 
    L = ['%s=%r' % (key, value)
22556 
      for key, value in self.__dict__.iteritems()]
22557 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22558 
 
22559 
  def __eq__(self, other):
22560 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22561 
 
22562 
  def __ne__(self, other):
22563 
    return not (self == other)
22564 
 
22565 
class getBrandInfo_args:
22566 
 
22567 
  thrift_spec = (
22568 
  )
22569 
 
22570 
  def read(self, iprot):
22571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22573 
      return
22574 
    iprot.readStructBegin()
22575 
    while True:
22576 
      (fname, ftype, fid) = iprot.readFieldBegin()
22577 
      if ftype == TType.STOP:
22578 
        break
22579 
      else:
22580 
        iprot.skip(ftype)
22581 
      iprot.readFieldEnd()
22582 
    iprot.readStructEnd()
22583 
 
22584 
  def write(self, oprot):
22585 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22586 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22587 
      return
22588 
    oprot.writeStructBegin('getBrandInfo_args')
22589 
    oprot.writeFieldStop()
22590 
    oprot.writeStructEnd()
22591 
 
22592 
  def validate(self):
22593 
    return
22594 
 
22595 
 
22596 
  def __repr__(self):
22597 
    L = ['%s=%r' % (key, value)
22598 
      for key, value in self.__dict__.iteritems()]
22599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22600 
 
22601 
  def __eq__(self, other):
22602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22603 
 
22604 
  def __ne__(self, other):
22605 
    return not (self == other)
22606 
 
22607 
class getBrandInfo_result:
22608 
  """
22609 
  Attributes:
22610 
   - success
22611 
  """
22612 
 
22613 
  thrift_spec = (
22614 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(BrandInfo, BrandInfo.thrift_spec)), None, ), # 0
22615 
  )
22616 
 
22617 
  def __init__(self, success=None,):
22618 
    self.success = success
22619 
 
22620 
  def read(self, iprot):
22621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22623 
      return
22624 
    iprot.readStructBegin()
22625 
    while True:
22626 
      (fname, ftype, fid) = iprot.readFieldBegin()
22627 
      if ftype == TType.STOP:
22628 
        break
22629 
      if fid == 0:
22630 
        if ftype == TType.MAP:
22631 
          self.success = {}
18719 kshitij.so 22632 
          (_ktype423, _vtype424, _size422 ) = iprot.readMapBegin()
22633 
          for _i426 in xrange(_size422):
22634 
            _key427 = iprot.readString();
22635 
            _val428 = BrandInfo()
22636 
            _val428.read(iprot)
22637 
            self.success[_key427] = _val428
7272 amit.gupta 22638 
          iprot.readMapEnd()
22639 
        else:
22640 
          iprot.skip(ftype)
22641 
      else:
22642 
        iprot.skip(ftype)
22643 
      iprot.readFieldEnd()
22644 
    iprot.readStructEnd()
22645 
 
22646 
  def write(self, oprot):
22647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22649 
      return
22650 
    oprot.writeStructBegin('getBrandInfo_result')
22651 
    if self.success is not None:
22652 
      oprot.writeFieldBegin('success', TType.MAP, 0)
22653 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
18719 kshitij.so 22654 
      for kiter429,viter430 in self.success.items():
22655 
        oprot.writeString(kiter429)
22656 
        viter430.write(oprot)
7272 amit.gupta 22657 
      oprot.writeMapEnd()
22658 
      oprot.writeFieldEnd()
22659 
    oprot.writeFieldStop()
22660 
    oprot.writeStructEnd()
22661 
 
22662 
  def validate(self):
22663 
    return
22664 
 
22665 
 
22666 
  def __repr__(self):
22667 
    L = ['%s=%r' % (key, value)
22668 
      for key, value in self.__dict__.iteritems()]
22669 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22670 
 
22671 
  def __eq__(self, other):
22672 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22673 
 
22674 
  def __ne__(self, other):
22675 
    return not (self == other)
22676 
 
7256 rajveer 22677 
class getStorePricing_args:
22678 
  """
22679 
  Attributes:
22680 
   - itemId
22681 
  """
22682 
 
22683 
  thrift_spec = (
22684 
    None, # 0
22685 
    (1, TType.I64, 'itemId', None, None, ), # 1
22686 
  )
22687 
 
22688 
  def __init__(self, itemId=None,):
22689 
    self.itemId = itemId
22690 
 
22691 
  def read(self, iprot):
22692 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22693 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22694 
      return
22695 
    iprot.readStructBegin()
22696 
    while True:
22697 
      (fname, ftype, fid) = iprot.readFieldBegin()
22698 
      if ftype == TType.STOP:
22699 
        break
22700 
      if fid == 1:
22701 
        if ftype == TType.I64:
22702 
          self.itemId = iprot.readI64();
22703 
        else:
22704 
          iprot.skip(ftype)
22705 
      else:
22706 
        iprot.skip(ftype)
22707 
      iprot.readFieldEnd()
22708 
    iprot.readStructEnd()
22709 
 
22710 
  def write(self, oprot):
22711 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22712 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22713 
      return
22714 
    oprot.writeStructBegin('getStorePricing_args')
22715 
    if self.itemId is not None:
22716 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
22717 
      oprot.writeI64(self.itemId)
22718 
      oprot.writeFieldEnd()
22719 
    oprot.writeFieldStop()
22720 
    oprot.writeStructEnd()
22721 
 
22722 
  def validate(self):
22723 
    return
22724 
 
22725 
 
22726 
  def __repr__(self):
22727 
    L = ['%s=%r' % (key, value)
22728 
      for key, value in self.__dict__.iteritems()]
22729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22730 
 
22731 
  def __eq__(self, other):
22732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22733 
 
22734 
  def __ne__(self, other):
22735 
    return not (self == other)
22736 
 
22737 
class getStorePricing_result:
22738 
  """
22739 
  Attributes:
22740 
   - success
22741 
  """
22742 
 
22743 
  thrift_spec = (
22744 
    (0, TType.STRUCT, 'success', (StorePricing, StorePricing.thrift_spec), None, ), # 0
22745 
  )
22746 
 
22747 
  def __init__(self, success=None,):
22748 
    self.success = success
22749 
 
22750 
  def read(self, iprot):
22751 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22752 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22753 
      return
22754 
    iprot.readStructBegin()
22755 
    while True:
22756 
      (fname, ftype, fid) = iprot.readFieldBegin()
22757 
      if ftype == TType.STOP:
22758 
        break
22759 
      if fid == 0:
22760 
        if ftype == TType.STRUCT:
22761 
          self.success = StorePricing()
22762 
          self.success.read(iprot)
22763 
        else:
22764 
          iprot.skip(ftype)
22765 
      else:
22766 
        iprot.skip(ftype)
22767 
      iprot.readFieldEnd()
22768 
    iprot.readStructEnd()
22769 
 
22770 
  def write(self, oprot):
22771 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22772 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22773 
      return
22774 
    oprot.writeStructBegin('getStorePricing_result')
22775 
    if self.success is not None:
22776 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22777 
      self.success.write(oprot)
22778 
      oprot.writeFieldEnd()
22779 
    oprot.writeFieldStop()
22780 
    oprot.writeStructEnd()
22781 
 
22782 
  def validate(self):
22783 
    return
22784 
 
22785 
 
22786 
  def __repr__(self):
22787 
    L = ['%s=%r' % (key, value)
22788 
      for key, value in self.__dict__.iteritems()]
22789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22790 
 
22791 
  def __eq__(self, other):
22792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22793 
 
22794 
  def __ne__(self, other):
22795 
    return not (self == other)
7265 rajveer 22796 
 
7306 rajveer 22797 
class getStorePricings_args:
22798 
  """
22799 
  Attributes:
22800 
   - itemIds
22801 
  """
22802 
 
22803 
  thrift_spec = (
22804 
    None, # 0
22805 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
22806 
  )
22807 
 
22808 
  def __init__(self, itemIds=None,):
22809 
    self.itemIds = itemIds
22810 
 
22811 
  def read(self, iprot):
22812 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22813 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22814 
      return
22815 
    iprot.readStructBegin()
22816 
    while True:
22817 
      (fname, ftype, fid) = iprot.readFieldBegin()
22818 
      if ftype == TType.STOP:
22819 
        break
22820 
      if fid == 1:
22821 
        if ftype == TType.LIST:
22822 
          self.itemIds = []
18719 kshitij.so 22823 
          (_etype434, _size431) = iprot.readListBegin()
22824 
          for _i435 in xrange(_size431):
22825 
            _elem436 = iprot.readI64();
22826 
            self.itemIds.append(_elem436)
7306 rajveer 22827 
          iprot.readListEnd()
22828 
        else:
22829 
          iprot.skip(ftype)
22830 
      else:
22831 
        iprot.skip(ftype)
22832 
      iprot.readFieldEnd()
22833 
    iprot.readStructEnd()
22834 
 
22835 
  def write(self, oprot):
22836 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22837 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22838 
      return
22839 
    oprot.writeStructBegin('getStorePricings_args')
22840 
    if self.itemIds is not None:
22841 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
22842 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
18719 kshitij.so 22843 
      for iter437 in self.itemIds:
22844 
        oprot.writeI64(iter437)
7306 rajveer 22845 
      oprot.writeListEnd()
22846 
      oprot.writeFieldEnd()
22847 
    oprot.writeFieldStop()
22848 
    oprot.writeStructEnd()
22849 
 
22850 
  def validate(self):
22851 
    return
22852 
 
22853 
 
22854 
  def __repr__(self):
22855 
    L = ['%s=%r' % (key, value)
22856 
      for key, value in self.__dict__.iteritems()]
22857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22858 
 
22859 
  def __eq__(self, other):
22860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22861 
 
22862 
  def __ne__(self, other):
22863 
    return not (self == other)
22864 
 
22865 
class getStorePricings_result:
22866 
  """
22867 
  Attributes:
22868 
   - success
22869 
  """
22870 
 
22871 
  thrift_spec = (
22872 
    (0, TType.LIST, 'success', (TType.STRUCT,(StorePricing, StorePricing.thrift_spec)), None, ), # 0
22873 
  )
22874 
 
22875 
  def __init__(self, success=None,):
22876 
    self.success = success
22877 
 
22878 
  def read(self, iprot):
22879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22881 
      return
22882 
    iprot.readStructBegin()
22883 
    while True:
22884 
      (fname, ftype, fid) = iprot.readFieldBegin()
22885 
      if ftype == TType.STOP:
22886 
        break
22887 
      if fid == 0:
22888 
        if ftype == TType.LIST:
22889 
          self.success = []
18719 kshitij.so 22890 
          (_etype441, _size438) = iprot.readListBegin()
22891 
          for _i442 in xrange(_size438):
22892 
            _elem443 = StorePricing()
22893 
            _elem443.read(iprot)
22894 
            self.success.append(_elem443)
7306 rajveer 22895 
          iprot.readListEnd()
22896 
        else:
22897 
          iprot.skip(ftype)
22898 
      else:
22899 
        iprot.skip(ftype)
22900 
      iprot.readFieldEnd()
22901 
    iprot.readStructEnd()
22902 
 
22903 
  def write(self, oprot):
22904 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22905 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22906 
      return
22907 
    oprot.writeStructBegin('getStorePricings_result')
22908 
    if self.success is not None:
22909 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22910 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 22911 
      for iter444 in self.success:
22912 
        iter444.write(oprot)
7306 rajveer 22913 
      oprot.writeListEnd()
22914 
      oprot.writeFieldEnd()
22915 
    oprot.writeFieldStop()
22916 
    oprot.writeStructEnd()
22917 
 
22918 
  def validate(self):
22919 
    return
22920 
 
22921 
 
22922 
  def __repr__(self):
22923 
    L = ['%s=%r' % (key, value)
22924 
      for key, value in self.__dict__.iteritems()]
22925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22926 
 
22927 
  def __eq__(self, other):
22928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22929 
 
22930 
  def __ne__(self, other):
22931 
    return not (self == other)
22932 
 
7265 rajveer 22933 
class updateStorePricing_args:
22934 
  """
22935 
  Attributes:
22936 
   - sp
7382 rajveer 22937 
   - allColors
7265 rajveer 22938 
  """
22939 
 
22940 
  thrift_spec = (
22941 
    None, # 0
22942 
    (1, TType.STRUCT, 'sp', (StorePricing, StorePricing.thrift_spec), None, ), # 1
7382 rajveer 22943 
    (2, TType.BOOL, 'allColors', None, None, ), # 2
7265 rajveer 22944 
  )
22945 
 
7382 rajveer 22946 
  def __init__(self, sp=None, allColors=None,):
7265 rajveer 22947 
    self.sp = sp
7382 rajveer 22948 
    self.allColors = allColors
7265 rajveer 22949 
 
22950 
  def read(self, iprot):
22951 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22952 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22953 
      return
22954 
    iprot.readStructBegin()
22955 
    while True:
22956 
      (fname, ftype, fid) = iprot.readFieldBegin()
22957 
      if ftype == TType.STOP:
22958 
        break
22959 
      if fid == 1:
22960 
        if ftype == TType.STRUCT:
22961 
          self.sp = StorePricing()
22962 
          self.sp.read(iprot)
22963 
        else:
22964 
          iprot.skip(ftype)
7382 rajveer 22965 
      elif fid == 2:
22966 
        if ftype == TType.BOOL:
22967 
          self.allColors = iprot.readBool();
22968 
        else:
22969 
          iprot.skip(ftype)
7265 rajveer 22970 
      else:
22971 
        iprot.skip(ftype)
22972 
      iprot.readFieldEnd()
22973 
    iprot.readStructEnd()
22974 
 
22975 
  def write(self, oprot):
22976 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22977 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22978 
      return
22979 
    oprot.writeStructBegin('updateStorePricing_args')
22980 
    if self.sp is not None:
22981 
      oprot.writeFieldBegin('sp', TType.STRUCT, 1)
22982 
      self.sp.write(oprot)
22983 
      oprot.writeFieldEnd()
7382 rajveer 22984 
    if self.allColors is not None:
22985 
      oprot.writeFieldBegin('allColors', TType.BOOL, 2)
22986 
      oprot.writeBool(self.allColors)
22987 
      oprot.writeFieldEnd()
7265 rajveer 22988 
    oprot.writeFieldStop()
22989 
    oprot.writeStructEnd()
22990 
 
22991 
  def validate(self):
22992 
    return
22993 
 
22994 
 
22995 
  def __repr__(self):
22996 
    L = ['%s=%r' % (key, value)
22997 
      for key, value in self.__dict__.iteritems()]
22998 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22999 
 
23000 
  def __eq__(self, other):
23001 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23002 
 
23003 
  def __ne__(self, other):
23004 
    return not (self == other)
23005 
 
23006 
class updateStorePricing_result:
23007 
 
23008 
  thrift_spec = (
23009 
  )
23010 
 
23011 
  def read(self, iprot):
23012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23014 
      return
23015 
    iprot.readStructBegin()
23016 
    while True:
23017 
      (fname, ftype, fid) = iprot.readFieldBegin()
23018 
      if ftype == TType.STOP:
23019 
        break
23020 
      else:
23021 
        iprot.skip(ftype)
23022 
      iprot.readFieldEnd()
23023 
    iprot.readStructEnd()
23024 
 
23025 
  def write(self, oprot):
23026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23028 
      return
23029 
    oprot.writeStructBegin('updateStorePricing_result')
23030 
    oprot.writeFieldStop()
23031 
    oprot.writeStructEnd()
23032 
 
23033 
  def validate(self):
23034 
    return
23035 
 
23036 
 
23037 
  def __repr__(self):
23038 
    L = ['%s=%r' % (key, value)
23039 
      for key, value in self.__dict__.iteritems()]
23040 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23041 
 
23042 
  def __eq__(self, other):
23043 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23044 
 
23045 
  def __ne__(self, other):
23046 
    return not (self == other)
7281 kshitij.so 23047 
 
23048 
class getAllAmazonListedItems_args:
23049 
 
23050 
  thrift_spec = (
23051 
  )
23052 
 
23053 
  def read(self, iprot):
23054 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23055 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23056 
      return
23057 
    iprot.readStructBegin()
23058 
    while True:
23059 
      (fname, ftype, fid) = iprot.readFieldBegin()
23060 
      if ftype == TType.STOP:
23061 
        break
23062 
      else:
23063 
        iprot.skip(ftype)
23064 
      iprot.readFieldEnd()
23065 
    iprot.readStructEnd()
23066 
 
23067 
  def write(self, oprot):
23068 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23069 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23070 
      return
23071 
    oprot.writeStructBegin('getAllAmazonListedItems_args')
23072 
    oprot.writeFieldStop()
23073 
    oprot.writeStructEnd()
23074 
 
23075 
  def validate(self):
23076 
    return
23077 
 
23078 
 
23079 
  def __repr__(self):
23080 
    L = ['%s=%r' % (key, value)
23081 
      for key, value in self.__dict__.iteritems()]
23082 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23083 
 
23084 
  def __eq__(self, other):
23085 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23086 
 
23087 
  def __ne__(self, other):
23088 
    return not (self == other)
23089 
 
23090 
class getAllAmazonListedItems_result:
23091 
  """
23092 
  Attributes:
23093 
   - success
23094 
  """
23095 
 
23096 
  thrift_spec = (
23097 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
23098 
  )
23099 
 
23100 
  def __init__(self, success=None,):
23101 
    self.success = success
23102 
 
23103 
  def read(self, iprot):
23104 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23105 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23106 
      return
23107 
    iprot.readStructBegin()
23108 
    while True:
23109 
      (fname, ftype, fid) = iprot.readFieldBegin()
23110 
      if ftype == TType.STOP:
23111 
        break
23112 
      if fid == 0:
23113 
        if ftype == TType.LIST:
23114 
          self.success = []
18719 kshitij.so 23115 
          (_etype448, _size445) = iprot.readListBegin()
23116 
          for _i449 in xrange(_size445):
23117 
            _elem450 = Amazonlisted()
23118 
            _elem450.read(iprot)
23119 
            self.success.append(_elem450)
7281 kshitij.so 23120 
          iprot.readListEnd()
23121 
        else:
23122 
          iprot.skip(ftype)
23123 
      else:
23124 
        iprot.skip(ftype)
23125 
      iprot.readFieldEnd()
23126 
    iprot.readStructEnd()
23127 
 
23128 
  def write(self, oprot):
23129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23131 
      return
23132 
    oprot.writeStructBegin('getAllAmazonListedItems_result')
23133 
    if self.success is not None:
23134 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23135 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 23136 
      for iter451 in self.success:
23137 
        iter451.write(oprot)
7281 kshitij.so 23138 
      oprot.writeListEnd()
23139 
      oprot.writeFieldEnd()
23140 
    oprot.writeFieldStop()
23141 
    oprot.writeStructEnd()
23142 
 
23143 
  def validate(self):
23144 
    return
23145 
 
23146 
 
23147 
  def __repr__(self):
23148 
    L = ['%s=%r' % (key, value)
23149 
      for key, value in self.__dict__.iteritems()]
23150 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23151 
 
23152 
  def __eq__(self, other):
23153 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23154 
 
23155 
  def __ne__(self, other):
23156 
    return not (self == other)
23157 
 
8619 kshitij.so 23158 
class searchAmazonItems_args:
23159 
  """
23160 
  Attributes:
23161 
   - searchTerm
23162 
   - offset
23163 
   - limit
23164 
  """
23165 
 
23166 
  thrift_spec = (
23167 
    None, # 0
23168 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
23169 
    (2, TType.I64, 'offset', None, None, ), # 2
23170 
    (3, TType.I64, 'limit', None, None, ), # 3
23171 
  )
23172 
 
23173 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
23174 
    self.searchTerm = searchTerm
23175 
    self.offset = offset
23176 
    self.limit = limit
23177 
 
23178 
  def read(self, iprot):
23179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23181 
      return
23182 
    iprot.readStructBegin()
23183 
    while True:
23184 
      (fname, ftype, fid) = iprot.readFieldBegin()
23185 
      if ftype == TType.STOP:
23186 
        break
23187 
      if fid == 1:
23188 
        if ftype == TType.LIST:
23189 
          self.searchTerm = []
18719 kshitij.so 23190 
          (_etype455, _size452) = iprot.readListBegin()
23191 
          for _i456 in xrange(_size452):
23192 
            _elem457 = iprot.readString();
23193 
            self.searchTerm.append(_elem457)
8619 kshitij.so 23194 
          iprot.readListEnd()
23195 
        else:
23196 
          iprot.skip(ftype)
23197 
      elif fid == 2:
23198 
        if ftype == TType.I64:
23199 
          self.offset = iprot.readI64();
23200 
        else:
23201 
          iprot.skip(ftype)
23202 
      elif fid == 3:
23203 
        if ftype == TType.I64:
23204 
          self.limit = iprot.readI64();
23205 
        else:
23206 
          iprot.skip(ftype)
23207 
      else:
23208 
        iprot.skip(ftype)
23209 
      iprot.readFieldEnd()
23210 
    iprot.readStructEnd()
23211 
 
23212 
  def write(self, oprot):
23213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23215 
      return
23216 
    oprot.writeStructBegin('searchAmazonItems_args')
23217 
    if self.searchTerm is not None:
23218 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
23219 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
18719 kshitij.so 23220 
      for iter458 in self.searchTerm:
23221 
        oprot.writeString(iter458)
8619 kshitij.so 23222 
      oprot.writeListEnd()
23223 
      oprot.writeFieldEnd()
23224 
    if self.offset is not None:
23225 
      oprot.writeFieldBegin('offset', TType.I64, 2)
23226 
      oprot.writeI64(self.offset)
23227 
      oprot.writeFieldEnd()
23228 
    if self.limit is not None:
23229 
      oprot.writeFieldBegin('limit', TType.I64, 3)
23230 
      oprot.writeI64(self.limit)
23231 
      oprot.writeFieldEnd()
23232 
    oprot.writeFieldStop()
23233 
    oprot.writeStructEnd()
23234 
 
23235 
  def validate(self):
23236 
    return
23237 
 
23238 
 
23239 
  def __repr__(self):
23240 
    L = ['%s=%r' % (key, value)
23241 
      for key, value in self.__dict__.iteritems()]
23242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23243 
 
23244 
  def __eq__(self, other):
23245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23246 
 
23247 
  def __ne__(self, other):
23248 
    return not (self == other)
23249 
 
23250 
class searchAmazonItems_result:
23251 
  """
23252 
  Attributes:
23253 
   - success
23254 
  """
23255 
 
23256 
  thrift_spec = (
23257 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
23258 
  )
23259 
 
23260 
  def __init__(self, success=None,):
23261 
    self.success = success
23262 
 
23263 
  def read(self, iprot):
23264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23266 
      return
23267 
    iprot.readStructBegin()
23268 
    while True:
23269 
      (fname, ftype, fid) = iprot.readFieldBegin()
23270 
      if ftype == TType.STOP:
23271 
        break
23272 
      if fid == 0:
23273 
        if ftype == TType.LIST:
23274 
          self.success = []
18719 kshitij.so 23275 
          (_etype462, _size459) = iprot.readListBegin()
23276 
          for _i463 in xrange(_size459):
23277 
            _elem464 = Amazonlisted()
23278 
            _elem464.read(iprot)
23279 
            self.success.append(_elem464)
8619 kshitij.so 23280 
          iprot.readListEnd()
23281 
        else:
23282 
          iprot.skip(ftype)
23283 
      else:
23284 
        iprot.skip(ftype)
23285 
      iprot.readFieldEnd()
23286 
    iprot.readStructEnd()
23287 
 
23288 
  def write(self, oprot):
23289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23291 
      return
23292 
    oprot.writeStructBegin('searchAmazonItems_result')
23293 
    if self.success is not None:
23294 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23295 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 23296 
      for iter465 in self.success:
23297 
        iter465.write(oprot)
8619 kshitij.so 23298 
      oprot.writeListEnd()
23299 
      oprot.writeFieldEnd()
23300 
    oprot.writeFieldStop()
23301 
    oprot.writeStructEnd()
23302 
 
23303 
  def validate(self):
23304 
    return
23305 
 
23306 
 
23307 
  def __repr__(self):
23308 
    L = ['%s=%r' % (key, value)
23309 
      for key, value in self.__dict__.iteritems()]
23310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23311 
 
23312 
  def __eq__(self, other):
23313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23314 
 
23315 
  def __ne__(self, other):
23316 
    return not (self == other)
23317 
 
23318 
class getAmazonSearchResultCount_args:
23319 
  """
23320 
  Attributes:
23321 
   - searchTerm
23322 
  """
23323 
 
23324 
  thrift_spec = (
23325 
    None, # 0
23326 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
23327 
  )
23328 
 
23329 
  def __init__(self, searchTerm=None,):
23330 
    self.searchTerm = searchTerm
23331 
 
23332 
  def read(self, iprot):
23333 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23334 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23335 
      return
23336 
    iprot.readStructBegin()
23337 
    while True:
23338 
      (fname, ftype, fid) = iprot.readFieldBegin()
23339 
      if ftype == TType.STOP:
23340 
        break
23341 
      if fid == 1:
23342 
        if ftype == TType.LIST:
23343 
          self.searchTerm = []
18719 kshitij.so 23344 
          (_etype469, _size466) = iprot.readListBegin()
23345 
          for _i470 in xrange(_size466):
23346 
            _elem471 = iprot.readString();
23347 
            self.searchTerm.append(_elem471)
8619 kshitij.so 23348 
          iprot.readListEnd()
23349 
        else:
23350 
          iprot.skip(ftype)
23351 
      else:
23352 
        iprot.skip(ftype)
23353 
      iprot.readFieldEnd()
23354 
    iprot.readStructEnd()
23355 
 
23356 
  def write(self, oprot):
23357 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23358 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23359 
      return
23360 
    oprot.writeStructBegin('getAmazonSearchResultCount_args')
23361 
    if self.searchTerm is not None:
23362 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
23363 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
18719 kshitij.so 23364 
      for iter472 in self.searchTerm:
23365 
        oprot.writeString(iter472)
8619 kshitij.so 23366 
      oprot.writeListEnd()
23367 
      oprot.writeFieldEnd()
23368 
    oprot.writeFieldStop()
23369 
    oprot.writeStructEnd()
23370 
 
23371 
  def validate(self):
23372 
    return
23373 
 
23374 
 
23375 
  def __repr__(self):
23376 
    L = ['%s=%r' % (key, value)
23377 
      for key, value in self.__dict__.iteritems()]
23378 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23379 
 
23380 
  def __eq__(self, other):
23381 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23382 
 
23383 
  def __ne__(self, other):
23384 
    return not (self == other)
23385 
 
23386 
class getAmazonSearchResultCount_result:
23387 
  """
23388 
  Attributes:
23389 
   - success
23390 
  """
23391 
 
23392 
  thrift_spec = (
23393 
    (0, TType.I64, 'success', None, None, ), # 0
23394 
  )
23395 
 
23396 
  def __init__(self, success=None,):
23397 
    self.success = success
23398 
 
23399 
  def read(self, iprot):
23400 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23401 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23402 
      return
23403 
    iprot.readStructBegin()
23404 
    while True:
23405 
      (fname, ftype, fid) = iprot.readFieldBegin()
23406 
      if ftype == TType.STOP:
23407 
        break
23408 
      if fid == 0:
23409 
        if ftype == TType.I64:
23410 
          self.success = iprot.readI64();
23411 
        else:
23412 
          iprot.skip(ftype)
23413 
      else:
23414 
        iprot.skip(ftype)
23415 
      iprot.readFieldEnd()
23416 
    iprot.readStructEnd()
23417 
 
23418 
  def write(self, oprot):
23419 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23420 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23421 
      return
23422 
    oprot.writeStructBegin('getAmazonSearchResultCount_result')
23423 
    if self.success is not None:
23424 
      oprot.writeFieldBegin('success', TType.I64, 0)
23425 
      oprot.writeI64(self.success)
23426 
      oprot.writeFieldEnd()
23427 
    oprot.writeFieldStop()
23428 
    oprot.writeStructEnd()
23429 
 
23430 
  def validate(self):
23431 
    return
23432 
 
23433 
 
23434 
  def __repr__(self):
23435 
    L = ['%s=%r' % (key, value)
23436 
      for key, value in self.__dict__.iteritems()]
23437 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23438 
 
23439 
  def __eq__(self, other):
23440 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23441 
 
23442 
  def __ne__(self, other):
23443 
    return not (self == other)
23444 
 
23445 
class getCountForAmazonlistedItems_args:
23446 
 
23447 
  thrift_spec = (
23448 
  )
23449 
 
23450 
  def read(self, iprot):
23451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23453 
      return
23454 
    iprot.readStructBegin()
23455 
    while True:
23456 
      (fname, ftype, fid) = iprot.readFieldBegin()
23457 
      if ftype == TType.STOP:
23458 
        break
23459 
      else:
23460 
        iprot.skip(ftype)
23461 
      iprot.readFieldEnd()
23462 
    iprot.readStructEnd()
23463 
 
23464 
  def write(self, oprot):
23465 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23466 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23467 
      return
23468 
    oprot.writeStructBegin('getCountForAmazonlistedItems_args')
23469 
    oprot.writeFieldStop()
23470 
    oprot.writeStructEnd()
23471 
 
23472 
  def validate(self):
23473 
    return
23474 
 
23475 
 
23476 
  def __repr__(self):
23477 
    L = ['%s=%r' % (key, value)
23478 
      for key, value in self.__dict__.iteritems()]
23479 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23480 
 
23481 
  def __eq__(self, other):
23482 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23483 
 
23484 
  def __ne__(self, other):
23485 
    return not (self == other)
23486 
 
23487 
class getCountForAmazonlistedItems_result:
23488 
  """
23489 
  Attributes:
23490 
   - success
23491 
  """
23492 
 
23493 
  thrift_spec = (
23494 
    (0, TType.I64, 'success', None, None, ), # 0
23495 
  )
23496 
 
23497 
  def __init__(self, success=None,):
23498 
    self.success = success
23499 
 
23500 
  def read(self, iprot):
23501 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23502 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23503 
      return
23504 
    iprot.readStructBegin()
23505 
    while True:
23506 
      (fname, ftype, fid) = iprot.readFieldBegin()
23507 
      if ftype == TType.STOP:
23508 
        break
23509 
      if fid == 0:
23510 
        if ftype == TType.I64:
23511 
          self.success = iprot.readI64();
23512 
        else:
23513 
          iprot.skip(ftype)
23514 
      else:
23515 
        iprot.skip(ftype)
23516 
      iprot.readFieldEnd()
23517 
    iprot.readStructEnd()
23518 
 
23519 
  def write(self, oprot):
23520 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23521 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23522 
      return
23523 
    oprot.writeStructBegin('getCountForAmazonlistedItems_result')
23524 
    if self.success is not None:
23525 
      oprot.writeFieldBegin('success', TType.I64, 0)
23526 
      oprot.writeI64(self.success)
23527 
      oprot.writeFieldEnd()
23528 
    oprot.writeFieldStop()
23529 
    oprot.writeStructEnd()
23530 
 
23531 
  def validate(self):
23532 
    return
23533 
 
23534 
 
23535 
  def __repr__(self):
23536 
    L = ['%s=%r' % (key, value)
23537 
      for key, value in self.__dict__.iteritems()]
23538 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23539 
 
23540 
  def __eq__(self, other):
23541 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23542 
 
23543 
  def __ne__(self, other):
23544 
    return not (self == other)
23545 
 
7281 kshitij.so 23546 
class getAmazonItemDetails_args:
23547 
  """
23548 
  Attributes:
23549 
   - itemId
23550 
  """
23551 
 
23552 
  thrift_spec = (
23553 
    None, # 0
23554 
    (1, TType.I64, 'itemId', None, None, ), # 1
23555 
  )
23556 
 
23557 
  def __init__(self, itemId=None,):
23558 
    self.itemId = itemId
23559 
 
23560 
  def read(self, iprot):
23561 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23562 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23563 
      return
23564 
    iprot.readStructBegin()
23565 
    while True:
23566 
      (fname, ftype, fid) = iprot.readFieldBegin()
23567 
      if ftype == TType.STOP:
23568 
        break
23569 
      if fid == 1:
23570 
        if ftype == TType.I64:
23571 
          self.itemId = iprot.readI64();
23572 
        else:
23573 
          iprot.skip(ftype)
23574 
      else:
23575 
        iprot.skip(ftype)
23576 
      iprot.readFieldEnd()
23577 
    iprot.readStructEnd()
23578 
 
23579 
  def write(self, oprot):
23580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23582 
      return
23583 
    oprot.writeStructBegin('getAmazonItemDetails_args')
23584 
    if self.itemId is not None:
23585 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
23586 
      oprot.writeI64(self.itemId)
23587 
      oprot.writeFieldEnd()
23588 
    oprot.writeFieldStop()
23589 
    oprot.writeStructEnd()
23590 
 
23591 
  def validate(self):
23592 
    return
23593 
 
23594 
 
23595 
  def __repr__(self):
23596 
    L = ['%s=%r' % (key, value)
23597 
      for key, value in self.__dict__.iteritems()]
23598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23599 
 
23600 
  def __eq__(self, other):
23601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23602 
 
23603 
  def __ne__(self, other):
23604 
    return not (self == other)
23605 
 
23606 
class getAmazonItemDetails_result:
23607 
  """
23608 
  Attributes:
23609 
   - success
23610 
  """
23611 
 
23612 
  thrift_spec = (
23613 
    (0, TType.STRUCT, 'success', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 0
23614 
  )
23615 
 
23616 
  def __init__(self, success=None,):
23617 
    self.success = success
23618 
 
23619 
  def read(self, iprot):
23620 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23621 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23622 
      return
23623 
    iprot.readStructBegin()
23624 
    while True:
23625 
      (fname, ftype, fid) = iprot.readFieldBegin()
23626 
      if ftype == TType.STOP:
23627 
        break
23628 
      if fid == 0:
23629 
        if ftype == TType.STRUCT:
23630 
          self.success = Amazonlisted()
23631 
          self.success.read(iprot)
23632 
        else:
23633 
          iprot.skip(ftype)
23634 
      else:
23635 
        iprot.skip(ftype)
23636 
      iprot.readFieldEnd()
23637 
    iprot.readStructEnd()
23638 
 
23639 
  def write(self, oprot):
23640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23642 
      return
23643 
    oprot.writeStructBegin('getAmazonItemDetails_result')
23644 
    if self.success is not None:
23645 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23646 
      self.success.write(oprot)
23647 
      oprot.writeFieldEnd()
23648 
    oprot.writeFieldStop()
23649 
    oprot.writeStructEnd()
23650 
 
23651 
  def validate(self):
23652 
    return
23653 
 
23654 
 
23655 
  def __repr__(self):
23656 
    L = ['%s=%r' % (key, value)
23657 
      for key, value in self.__dict__.iteritems()]
23658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23659 
 
23660 
  def __eq__(self, other):
23661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23662 
 
23663 
  def __ne__(self, other):
23664 
    return not (self == other)
23665 
 
23666 
class updateAmazonItemDetails_args:
23667 
  """
23668 
  Attributes:
8168 kshitij.so 23669 
   - amazonlisted
7281 kshitij.so 23670 
  """
23671 
 
23672 
  thrift_spec = (
23673 
    None, # 0
8168 kshitij.so 23674 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
7281 kshitij.so 23675 
  )
23676 
 
8168 kshitij.so 23677 
  def __init__(self, amazonlisted=None,):
23678 
    self.amazonlisted = amazonlisted
7281 kshitij.so 23679 
 
23680 
  def read(self, iprot):
23681 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23682 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23683 
      return
23684 
    iprot.readStructBegin()
23685 
    while True:
23686 
      (fname, ftype, fid) = iprot.readFieldBegin()
23687 
      if ftype == TType.STOP:
23688 
        break
23689 
      if fid == 1:
8168 kshitij.so 23690 
        if ftype == TType.STRUCT:
23691 
          self.amazonlisted = Amazonlisted()
23692 
          self.amazonlisted.read(iprot)
7281 kshitij.so 23693 
        else:
23694 
          iprot.skip(ftype)
23695 
      else:
23696 
        iprot.skip(ftype)
23697 
      iprot.readFieldEnd()
23698 
    iprot.readStructEnd()
23699 
 
23700 
  def write(self, oprot):
23701 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23702 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23703 
      return
23704 
    oprot.writeStructBegin('updateAmazonItemDetails_args')
8168 kshitij.so 23705 
    if self.amazonlisted is not None:
23706 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
23707 
      self.amazonlisted.write(oprot)
7281 kshitij.so 23708 
      oprot.writeFieldEnd()
23709 
    oprot.writeFieldStop()
23710 
    oprot.writeStructEnd()
23711 
 
23712 
  def validate(self):
23713 
    return
23714 
 
23715 
 
23716 
  def __repr__(self):
23717 
    L = ['%s=%r' % (key, value)
23718 
      for key, value in self.__dict__.iteritems()]
23719 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23720 
 
23721 
  def __eq__(self, other):
23722 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23723 
 
23724 
  def __ne__(self, other):
23725 
    return not (self == other)
23726 
 
23727 
class updateAmazonItemDetails_result:
23728 
 
23729 
  thrift_spec = (
23730 
  )
23731 
 
23732 
  def read(self, iprot):
23733 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23734 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23735 
      return
23736 
    iprot.readStructBegin()
23737 
    while True:
23738 
      (fname, ftype, fid) = iprot.readFieldBegin()
23739 
      if ftype == TType.STOP:
23740 
        break
23741 
      else:
23742 
        iprot.skip(ftype)
23743 
      iprot.readFieldEnd()
23744 
    iprot.readStructEnd()
23745 
 
23746 
  def write(self, oprot):
23747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23749 
      return
23750 
    oprot.writeStructBegin('updateAmazonItemDetails_result')
23751 
    oprot.writeFieldStop()
23752 
    oprot.writeStructEnd()
23753 
 
23754 
  def validate(self):
23755 
    return
23756 
 
23757 
 
23758 
  def __repr__(self):
23759 
    L = ['%s=%r' % (key, value)
23760 
      for key, value in self.__dict__.iteritems()]
23761 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23762 
 
23763 
  def __eq__(self, other):
23764 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23765 
 
23766 
  def __ne__(self, other):
23767 
    return not (self == other)
23768 
 
23769 
class addAmazonItem_args:
23770 
  """
23771 
  Attributes:
23772 
   - amazonlisted
23773 
  """
23774 
 
23775 
  thrift_spec = (
23776 
    None, # 0
23777 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
23778 
  )
23779 
 
23780 
  def __init__(self, amazonlisted=None,):
23781 
    self.amazonlisted = amazonlisted
23782 
 
23783 
  def read(self, iprot):
23784 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23785 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23786 
      return
23787 
    iprot.readStructBegin()
23788 
    while True:
23789 
      (fname, ftype, fid) = iprot.readFieldBegin()
23790 
      if ftype == TType.STOP:
23791 
        break
23792 
      if fid == 1:
23793 
        if ftype == TType.STRUCT:
23794 
          self.amazonlisted = Amazonlisted()
23795 
          self.amazonlisted.read(iprot)
23796 
        else:
23797 
          iprot.skip(ftype)
23798 
      else:
23799 
        iprot.skip(ftype)
23800 
      iprot.readFieldEnd()
23801 
    iprot.readStructEnd()
23802 
 
23803 
  def write(self, oprot):
23804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23806 
      return
23807 
    oprot.writeStructBegin('addAmazonItem_args')
23808 
    if self.amazonlisted is not None:
23809 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
23810 
      self.amazonlisted.write(oprot)
23811 
      oprot.writeFieldEnd()
23812 
    oprot.writeFieldStop()
23813 
    oprot.writeStructEnd()
23814 
 
23815 
  def validate(self):
23816 
    return
23817 
 
23818 
 
23819 
  def __repr__(self):
23820 
    L = ['%s=%r' % (key, value)
23821 
      for key, value in self.__dict__.iteritems()]
23822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23823 
 
23824 
  def __eq__(self, other):
23825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23826 
 
23827 
  def __ne__(self, other):
23828 
    return not (self == other)
23829 
 
23830 
class addAmazonItem_result:
23831 
 
23832 
  thrift_spec = (
23833 
  )
23834 
 
23835 
  def read(self, iprot):
23836 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23837 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23838 
      return
23839 
    iprot.readStructBegin()
23840 
    while True:
23841 
      (fname, ftype, fid) = iprot.readFieldBegin()
23842 
      if ftype == TType.STOP:
23843 
        break
23844 
      else:
23845 
        iprot.skip(ftype)
23846 
      iprot.readFieldEnd()
23847 
    iprot.readStructEnd()
23848 
 
23849 
  def write(self, oprot):
23850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23852 
      return
23853 
    oprot.writeStructBegin('addAmazonItem_result')
23854 
    oprot.writeFieldStop()
23855 
    oprot.writeStructEnd()
23856 
 
23857 
  def validate(self):
23858 
    return
23859 
 
23860 
 
23861 
  def __repr__(self):
23862 
    L = ['%s=%r' % (key, value)
23863 
      for key, value in self.__dict__.iteritems()]
23864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23865 
 
23866 
  def __eq__(self, other):
23867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23868 
 
23869 
  def __ne__(self, other):
23870 
    return not (self == other)
7291 vikram.rag 23871 
 
23872 
class getAsinItems_args:
23873 
 
23874 
  thrift_spec = (
23875 
  )
23876 
 
23877 
  def read(self, iprot):
23878 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23879 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23880 
      return
23881 
    iprot.readStructBegin()
23882 
    while True:
23883 
      (fname, ftype, fid) = iprot.readFieldBegin()
23884 
      if ftype == TType.STOP:
23885 
        break
23886 
      else:
23887 
        iprot.skip(ftype)
23888 
      iprot.readFieldEnd()
23889 
    iprot.readStructEnd()
23890 
 
23891 
  def write(self, oprot):
23892 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23893 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23894 
      return
23895 
    oprot.writeStructBegin('getAsinItems_args')
23896 
    oprot.writeFieldStop()
23897 
    oprot.writeStructEnd()
23898 
 
23899 
  def validate(self):
23900 
    return
23901 
 
23902 
 
23903 
  def __repr__(self):
23904 
    L = ['%s=%r' % (key, value)
23905 
      for key, value in self.__dict__.iteritems()]
23906 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23907 
 
23908 
  def __eq__(self, other):
23909 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23910 
 
23911 
  def __ne__(self, other):
23912 
    return not (self == other)
23913 
 
23914 
class getAsinItems_result:
23915 
  """
23916 
  Attributes:
23917 
   - success
23918 
  """
23919 
 
23920 
  thrift_spec = (
23921 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
23922 
  )
23923 
 
23924 
  def __init__(self, success=None,):
23925 
    self.success = success
23926 
 
23927 
  def read(self, iprot):
23928 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23929 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23930 
      return
23931 
    iprot.readStructBegin()
23932 
    while True:
23933 
      (fname, ftype, fid) = iprot.readFieldBegin()
23934 
      if ftype == TType.STOP:
23935 
        break
23936 
      if fid == 0:
23937 
        if ftype == TType.LIST:
23938 
          self.success = []
18719 kshitij.so 23939 
          (_etype476, _size473) = iprot.readListBegin()
23940 
          for _i477 in xrange(_size473):
23941 
            _elem478 = Item()
23942 
            _elem478.read(iprot)
23943 
            self.success.append(_elem478)
7291 vikram.rag 23944 
          iprot.readListEnd()
23945 
        else:
23946 
          iprot.skip(ftype)
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('getAsinItems_result')
23957 
    if self.success is not None:
23958 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23959 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 23960 
      for iter479 in self.success:
23961 
        iter479.write(oprot)
7291 vikram.rag 23962 
      oprot.writeListEnd()
23963 
      oprot.writeFieldEnd()
23964 
    oprot.writeFieldStop()
23965 
    oprot.writeStructEnd()
23966 
 
23967 
  def validate(self):
23968 
    return
23969 
 
23970 
 
23971 
  def __repr__(self):
23972 
    L = ['%s=%r' % (key, value)
23973 
      for key, value in self.__dict__.iteritems()]
23974 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23975 
 
23976 
  def __eq__(self, other):
23977 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23978 
 
23979 
  def __ne__(self, other):
23980 
    return not (self == other)
23981 
 
23982 
class getAllFbaListedItems_args:
23983 
 
23984 
  thrift_spec = (
23985 
  )
23986 
 
23987 
  def read(self, iprot):
23988 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23989 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23990 
      return
23991 
    iprot.readStructBegin()
23992 
    while True:
23993 
      (fname, ftype, fid) = iprot.readFieldBegin()
23994 
      if ftype == TType.STOP:
23995 
        break
23996 
      else:
23997 
        iprot.skip(ftype)
23998 
      iprot.readFieldEnd()
23999 
    iprot.readStructEnd()
24000 
 
24001 
  def write(self, oprot):
24002 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24003 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24004 
      return
24005 
    oprot.writeStructBegin('getAllFbaListedItems_args')
24006 
    oprot.writeFieldStop()
24007 
    oprot.writeStructEnd()
24008 
 
24009 
  def validate(self):
24010 
    return
24011 
 
24012 
 
24013 
  def __repr__(self):
24014 
    L = ['%s=%r' % (key, value)
24015 
      for key, value in self.__dict__.iteritems()]
24016 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24017 
 
24018 
  def __eq__(self, other):
24019 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24020 
 
24021 
  def __ne__(self, other):
24022 
    return not (self == other)
24023 
 
24024 
class getAllFbaListedItems_result:
24025 
  """
24026 
  Attributes:
24027 
   - success
24028 
  """
24029 
 
24030 
  thrift_spec = (
24031 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
24032 
  )
24033 
 
24034 
  def __init__(self, success=None,):
24035 
    self.success = success
24036 
 
24037 
  def read(self, iprot):
24038 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24039 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24040 
      return
24041 
    iprot.readStructBegin()
24042 
    while True:
24043 
      (fname, ftype, fid) = iprot.readFieldBegin()
24044 
      if ftype == TType.STOP:
24045 
        break
24046 
      if fid == 0:
24047 
        if ftype == TType.LIST:
24048 
          self.success = []
18719 kshitij.so 24049 
          (_etype483, _size480) = iprot.readListBegin()
24050 
          for _i484 in xrange(_size480):
24051 
            _elem485 = Amazonlisted()
24052 
            _elem485.read(iprot)
24053 
            self.success.append(_elem485)
7291 vikram.rag 24054 
          iprot.readListEnd()
24055 
        else:
24056 
          iprot.skip(ftype)
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('getAllFbaListedItems_result')
24067 
    if self.success is not None:
24068 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24069 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 24070 
      for iter486 in self.success:
24071 
        iter486.write(oprot)
7291 vikram.rag 24072 
      oprot.writeListEnd()
24073 
      oprot.writeFieldEnd()
24074 
    oprot.writeFieldStop()
24075 
    oprot.writeStructEnd()
24076 
 
24077 
  def validate(self):
24078 
    return
24079 
 
24080 
 
24081 
  def __repr__(self):
24082 
    L = ['%s=%r' % (key, value)
24083 
      for key, value in self.__dict__.iteritems()]
24084 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24085 
 
24086 
  def __eq__(self, other):
24087 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24088 
 
24089 
  def __ne__(self, other):
24090 
    return not (self == other)
24091 
 
24092 
class getAllNonFbaListedItems_args:
24093 
 
24094 
  thrift_spec = (
24095 
  )
24096 
 
24097 
  def read(self, iprot):
24098 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24099 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24100 
      return
24101 
    iprot.readStructBegin()
24102 
    while True:
24103 
      (fname, ftype, fid) = iprot.readFieldBegin()
24104 
      if ftype == TType.STOP:
24105 
        break
24106 
      else:
24107 
        iprot.skip(ftype)
24108 
      iprot.readFieldEnd()
24109 
    iprot.readStructEnd()
24110 
 
24111 
  def write(self, oprot):
24112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24114 
      return
24115 
    oprot.writeStructBegin('getAllNonFbaListedItems_args')
24116 
    oprot.writeFieldStop()
24117 
    oprot.writeStructEnd()
24118 
 
24119 
  def validate(self):
24120 
    return
24121 
 
24122 
 
24123 
  def __repr__(self):
24124 
    L = ['%s=%r' % (key, value)
24125 
      for key, value in self.__dict__.iteritems()]
24126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24127 
 
24128 
  def __eq__(self, other):
24129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24130 
 
24131 
  def __ne__(self, other):
24132 
    return not (self == other)
24133 
 
24134 
class getAllNonFbaListedItems_result:
24135 
  """
24136 
  Attributes:
24137 
   - success
24138 
  """
24139 
 
24140 
  thrift_spec = (
24141 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
24142 
  )
24143 
 
24144 
  def __init__(self, success=None,):
24145 
    self.success = success
24146 
 
24147 
  def read(self, iprot):
24148 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24149 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24150 
      return
24151 
    iprot.readStructBegin()
24152 
    while True:
24153 
      (fname, ftype, fid) = iprot.readFieldBegin()
24154 
      if ftype == TType.STOP:
24155 
        break
24156 
      if fid == 0:
24157 
        if ftype == TType.LIST:
24158 
          self.success = []
18719 kshitij.so 24159 
          (_etype490, _size487) = iprot.readListBegin()
24160 
          for _i491 in xrange(_size487):
24161 
            _elem492 = Amazonlisted()
24162 
            _elem492.read(iprot)
24163 
            self.success.append(_elem492)
7291 vikram.rag 24164 
          iprot.readListEnd()
24165 
        else:
24166 
          iprot.skip(ftype)
24167 
      else:
24168 
        iprot.skip(ftype)
24169 
      iprot.readFieldEnd()
24170 
    iprot.readStructEnd()
24171 
 
24172 
  def write(self, oprot):
24173 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24174 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24175 
      return
24176 
    oprot.writeStructBegin('getAllNonFbaListedItems_result')
24177 
    if self.success is not None:
24178 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24179 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 24180 
      for iter493 in self.success:
24181 
        iter493.write(oprot)
7291 vikram.rag 24182 
      oprot.writeListEnd()
24183 
      oprot.writeFieldEnd()
24184 
    oprot.writeFieldStop()
24185 
    oprot.writeStructEnd()
24186 
 
24187 
  def validate(self):
24188 
    return
24189 
 
24190 
 
24191 
  def __repr__(self):
24192 
    L = ['%s=%r' % (key, value)
24193 
      for key, value in self.__dict__.iteritems()]
24194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24195 
 
24196 
  def __eq__(self, other):
24197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24198 
 
24199 
  def __ne__(self, other):
24200 
    return not (self == other)
7460 kshitij.so 24201 
 
24202 
class updateItemInventory_args:
24203 
  """
24204 
  Attributes:
24205 
   - itemId
24206 
   - holdInventory
24207 
   - defaultInventory
24208 
  """
24209 
 
24210 
  thrift_spec = (
24211 
    None, # 0
24212 
    (1, TType.I64, 'itemId', None, None, ), # 1
24213 
    (2, TType.I64, 'holdInventory', None, None, ), # 2
24214 
    (3, TType.I64, 'defaultInventory', None, None, ), # 3
24215 
  )
24216 
 
24217 
  def __init__(self, itemId=None, holdInventory=None, defaultInventory=None,):
24218 
    self.itemId = itemId
24219 
    self.holdInventory = holdInventory
24220 
    self.defaultInventory = defaultInventory
24221 
 
24222 
  def read(self, iprot):
24223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24225 
      return
24226 
    iprot.readStructBegin()
24227 
    while True:
24228 
      (fname, ftype, fid) = iprot.readFieldBegin()
24229 
      if ftype == TType.STOP:
24230 
        break
24231 
      if fid == 1:
24232 
        if ftype == TType.I64:
24233 
          self.itemId = iprot.readI64();
24234 
        else:
24235 
          iprot.skip(ftype)
24236 
      elif fid == 2:
24237 
        if ftype == TType.I64:
24238 
          self.holdInventory = iprot.readI64();
24239 
        else:
24240 
          iprot.skip(ftype)
24241 
      elif fid == 3:
24242 
        if ftype == TType.I64:
24243 
          self.defaultInventory = iprot.readI64();
24244 
        else:
24245 
          iprot.skip(ftype)
24246 
      else:
24247 
        iprot.skip(ftype)
24248 
      iprot.readFieldEnd()
24249 
    iprot.readStructEnd()
24250 
 
24251 
  def write(self, oprot):
24252 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24253 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24254 
      return
24255 
    oprot.writeStructBegin('updateItemInventory_args')
24256 
    if self.itemId is not None:
24257 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
24258 
      oprot.writeI64(self.itemId)
24259 
      oprot.writeFieldEnd()
24260 
    if self.holdInventory is not None:
24261 
      oprot.writeFieldBegin('holdInventory', TType.I64, 2)
24262 
      oprot.writeI64(self.holdInventory)
24263 
      oprot.writeFieldEnd()
24264 
    if self.defaultInventory is not None:
24265 
      oprot.writeFieldBegin('defaultInventory', TType.I64, 3)
24266 
      oprot.writeI64(self.defaultInventory)
24267 
      oprot.writeFieldEnd()
24268 
    oprot.writeFieldStop()
24269 
    oprot.writeStructEnd()
24270 
 
24271 
  def validate(self):
24272 
    return
24273 
 
24274 
 
24275 
  def __repr__(self):
24276 
    L = ['%s=%r' % (key, value)
24277 
      for key, value in self.__dict__.iteritems()]
24278 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24279 
 
24280 
  def __eq__(self, other):
24281 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24282 
 
24283 
  def __ne__(self, other):
24284 
    return not (self == other)
24285 
 
24286 
class updateItemInventory_result:
24287 
  """
24288 
  Attributes:
24289 
   - success
24290 
  """
24291 
 
24292 
  thrift_spec = (
24293 
    (0, TType.BOOL, 'success', None, None, ), # 0
24294 
  )
24295 
 
24296 
  def __init__(self, success=None,):
24297 
    self.success = success
24298 
 
24299 
  def read(self, iprot):
24300 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24301 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24302 
      return
24303 
    iprot.readStructBegin()
24304 
    while True:
24305 
      (fname, ftype, fid) = iprot.readFieldBegin()
24306 
      if ftype == TType.STOP:
24307 
        break
24308 
      if fid == 0:
24309 
        if ftype == TType.BOOL:
24310 
          self.success = iprot.readBool();
24311 
        else:
24312 
          iprot.skip(ftype)
24313 
      else:
24314 
        iprot.skip(ftype)
24315 
      iprot.readFieldEnd()
24316 
    iprot.readStructEnd()
24317 
 
24318 
  def write(self, oprot):
24319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24321 
      return
24322 
    oprot.writeStructBegin('updateItemInventory_result')
24323 
    if self.success is not None:
24324 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
24325 
      oprot.writeBool(self.success)
24326 
      oprot.writeFieldEnd()
24327 
    oprot.writeFieldStop()
24328 
    oprot.writeStructEnd()
24329 
 
24330 
  def validate(self):
24331 
    return
24332 
 
24333 
 
24334 
  def __repr__(self):
24335 
    L = ['%s=%r' % (key, value)
24336 
      for key, value in self.__dict__.iteritems()]
24337 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24338 
 
24339 
  def __eq__(self, other):
24340 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24341 
 
24342 
  def __ne__(self, other):
24343 
    return not (self == other)
7770 kshitij.so 24344 
 
24345 
class updateTimestampForAmazonFeeds_args:
24346 
  """
24347 
  Attributes:
24348 
   - type
24349 
   - sku
24350 
   - timestamp
24351 
  """
24352 
 
24353 
  thrift_spec = (
24354 
    None, # 0
24355 
    (1, TType.STRING, 'type', None, None, ), # 1
24356 
    (2, TType.LIST, 'sku', (TType.I64,None), None, ), # 2
24357 
    (3, TType.I64, 'timestamp', None, None, ), # 3
24358 
  )
24359 
 
24360 
  def __init__(self, type=None, sku=None, timestamp=None,):
24361 
    self.type = type
24362 
    self.sku = sku
24363 
    self.timestamp = timestamp
24364 
 
24365 
  def read(self, iprot):
24366 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24367 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24368 
      return
24369 
    iprot.readStructBegin()
24370 
    while True:
24371 
      (fname, ftype, fid) = iprot.readFieldBegin()
24372 
      if ftype == TType.STOP:
24373 
        break
24374 
      if fid == 1:
24375 
        if ftype == TType.STRING:
24376 
          self.type = iprot.readString();
24377 
        else:
24378 
          iprot.skip(ftype)
24379 
      elif fid == 2:
24380 
        if ftype == TType.LIST:
24381 
          self.sku = []
18719 kshitij.so 24382 
          (_etype497, _size494) = iprot.readListBegin()
24383 
          for _i498 in xrange(_size494):
24384 
            _elem499 = iprot.readI64();
24385 
            self.sku.append(_elem499)
7770 kshitij.so 24386 
          iprot.readListEnd()
24387 
        else:
24388 
          iprot.skip(ftype)
24389 
      elif fid == 3:
24390 
        if ftype == TType.I64:
24391 
          self.timestamp = iprot.readI64();
24392 
        else:
24393 
          iprot.skip(ftype)
24394 
      else:
24395 
        iprot.skip(ftype)
24396 
      iprot.readFieldEnd()
24397 
    iprot.readStructEnd()
24398 
 
24399 
  def write(self, oprot):
24400 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24401 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24402 
      return
24403 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_args')
24404 
    if self.type is not None:
24405 
      oprot.writeFieldBegin('type', TType.STRING, 1)
24406 
      oprot.writeString(self.type)
24407 
      oprot.writeFieldEnd()
24408 
    if self.sku is not None:
24409 
      oprot.writeFieldBegin('sku', TType.LIST, 2)
24410 
      oprot.writeListBegin(TType.I64, len(self.sku))
18719 kshitij.so 24411 
      for iter500 in self.sku:
24412 
        oprot.writeI64(iter500)
7770 kshitij.so 24413 
      oprot.writeListEnd()
24414 
      oprot.writeFieldEnd()
24415 
    if self.timestamp is not None:
24416 
      oprot.writeFieldBegin('timestamp', TType.I64, 3)
24417 
      oprot.writeI64(self.timestamp)
24418 
      oprot.writeFieldEnd()
24419 
    oprot.writeFieldStop()
24420 
    oprot.writeStructEnd()
24421 
 
24422 
  def validate(self):
24423 
    return
24424 
 
24425 
 
24426 
  def __repr__(self):
24427 
    L = ['%s=%r' % (key, value)
24428 
      for key, value in self.__dict__.iteritems()]
24429 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24430 
 
24431 
  def __eq__(self, other):
24432 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24433 
 
24434 
  def __ne__(self, other):
24435 
    return not (self == other)
24436 
 
24437 
class updateTimestampForAmazonFeeds_result:
24438 
  """
24439 
  Attributes:
24440 
   - success
24441 
  """
24442 
 
24443 
  thrift_spec = (
24444 
    (0, TType.BOOL, 'success', None, None, ), # 0
24445 
  )
24446 
 
24447 
  def __init__(self, success=None,):
24448 
    self.success = success
24449 
 
24450 
  def read(self, iprot):
24451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24453 
      return
24454 
    iprot.readStructBegin()
24455 
    while True:
24456 
      (fname, ftype, fid) = iprot.readFieldBegin()
24457 
      if ftype == TType.STOP:
24458 
        break
24459 
      if fid == 0:
24460 
        if ftype == TType.BOOL:
24461 
          self.success = iprot.readBool();
24462 
        else:
24463 
          iprot.skip(ftype)
24464 
      else:
24465 
        iprot.skip(ftype)
24466 
      iprot.readFieldEnd()
24467 
    iprot.readStructEnd()
24468 
 
24469 
  def write(self, oprot):
24470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24472 
      return
24473 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_result')
24474 
    if self.success is not None:
24475 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
24476 
      oprot.writeBool(self.success)
24477 
      oprot.writeFieldEnd()
24478 
    oprot.writeFieldStop()
24479 
    oprot.writeStructEnd()
24480 
 
24481 
  def validate(self):
24482 
    return
24483 
 
24484 
 
24485 
  def __repr__(self):
24486 
    L = ['%s=%r' % (key, value)
24487 
      for key, value in self.__dict__.iteritems()]
24488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24489 
 
24490 
  def __eq__(self, other):
24491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24492 
 
24493 
  def __ne__(self, other):
24494 
    return not (self == other)
7897 amar.kumar 24495 
 
24496 
class getAllParentCategories_args:
24497 
 
24498 
  thrift_spec = (
24499 
  )
24500 
 
24501 
  def read(self, iprot):
24502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24504 
      return
24505 
    iprot.readStructBegin()
24506 
    while True:
24507 
      (fname, ftype, fid) = iprot.readFieldBegin()
24508 
      if ftype == TType.STOP:
24509 
        break
24510 
      else:
24511 
        iprot.skip(ftype)
24512 
      iprot.readFieldEnd()
24513 
    iprot.readStructEnd()
24514 
 
24515 
  def write(self, oprot):
24516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24518 
      return
24519 
    oprot.writeStructBegin('getAllParentCategories_args')
24520 
    oprot.writeFieldStop()
24521 
    oprot.writeStructEnd()
24522 
 
24523 
  def validate(self):
24524 
    return
24525 
 
24526 
 
24527 
  def __repr__(self):
24528 
    L = ['%s=%r' % (key, value)
24529 
      for key, value in self.__dict__.iteritems()]
24530 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24531 
 
24532 
  def __eq__(self, other):
24533 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24534 
 
24535 
  def __ne__(self, other):
24536 
    return not (self == other)
24537 
 
24538 
class getAllParentCategories_result:
24539 
  """
24540 
  Attributes:
24541 
   - success
24542 
  """
24543 
 
24544 
  thrift_spec = (
24545 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
24546 
  )
24547 
 
24548 
  def __init__(self, success=None,):
24549 
    self.success = success
24550 
 
24551 
  def read(self, iprot):
24552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24554 
      return
24555 
    iprot.readStructBegin()
24556 
    while True:
24557 
      (fname, ftype, fid) = iprot.readFieldBegin()
24558 
      if ftype == TType.STOP:
24559 
        break
24560 
      if fid == 0:
24561 
        if ftype == TType.LIST:
24562 
          self.success = []
18719 kshitij.so 24563 
          (_etype504, _size501) = iprot.readListBegin()
24564 
          for _i505 in xrange(_size501):
24565 
            _elem506 = Category()
24566 
            _elem506.read(iprot)
24567 
            self.success.append(_elem506)
7897 amar.kumar 24568 
          iprot.readListEnd()
24569 
        else:
24570 
          iprot.skip(ftype)
24571 
      else:
24572 
        iprot.skip(ftype)
24573 
      iprot.readFieldEnd()
24574 
    iprot.readStructEnd()
24575 
 
24576 
  def write(self, oprot):
24577 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24578 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24579 
      return
24580 
    oprot.writeStructBegin('getAllParentCategories_result')
24581 
    if self.success is not None:
24582 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24583 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 24584 
      for iter507 in self.success:
24585 
        iter507.write(oprot)
7897 amar.kumar 24586 
      oprot.writeListEnd()
24587 
      oprot.writeFieldEnd()
24588 
    oprot.writeFieldStop()
24589 
    oprot.writeStructEnd()
24590 
 
24591 
  def validate(self):
24592 
    return
24593 
 
24594 
 
24595 
  def __repr__(self):
24596 
    L = ['%s=%r' % (key, value)
24597 
      for key, value in self.__dict__.iteritems()]
24598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24599 
 
24600 
  def __eq__(self, other):
24601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24602 
 
24603 
  def __ne__(self, other):
24604 
    return not (self == other)
7977 kshitij.so 24605 
 
24606 
class addPageViewEvent_args:
24607 
  """
24608 
  Attributes:
24609 
   - pageViewEvents
24610 
  """
24611 
 
24612 
  thrift_spec = (
24613 
    None, # 0
24614 
    (1, TType.STRUCT, 'pageViewEvents', (PageViewEvents, PageViewEvents.thrift_spec), None, ), # 1
24615 
  )
24616 
 
24617 
  def __init__(self, pageViewEvents=None,):
24618 
    self.pageViewEvents = pageViewEvents
24619 
 
24620 
  def read(self, iprot):
24621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24623 
      return
24624 
    iprot.readStructBegin()
24625 
    while True:
24626 
      (fname, ftype, fid) = iprot.readFieldBegin()
24627 
      if ftype == TType.STOP:
24628 
        break
24629 
      if fid == 1:
24630 
        if ftype == TType.STRUCT:
24631 
          self.pageViewEvents = PageViewEvents()
24632 
          self.pageViewEvents.read(iprot)
24633 
        else:
24634 
          iprot.skip(ftype)
24635 
      else:
24636 
        iprot.skip(ftype)
24637 
      iprot.readFieldEnd()
24638 
    iprot.readStructEnd()
24639 
 
24640 
  def write(self, oprot):
24641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24643 
      return
24644 
    oprot.writeStructBegin('addPageViewEvent_args')
24645 
    if self.pageViewEvents is not None:
24646 
      oprot.writeFieldBegin('pageViewEvents', TType.STRUCT, 1)
24647 
      self.pageViewEvents.write(oprot)
24648 
      oprot.writeFieldEnd()
24649 
    oprot.writeFieldStop()
24650 
    oprot.writeStructEnd()
24651 
 
24652 
  def validate(self):
24653 
    return
24654 
 
24655 
 
24656 
  def __repr__(self):
24657 
    L = ['%s=%r' % (key, value)
24658 
      for key, value in self.__dict__.iteritems()]
24659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24660 
 
24661 
  def __eq__(self, other):
24662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24663 
 
24664 
  def __ne__(self, other):
24665 
    return not (self == other)
24666 
 
24667 
class addPageViewEvent_result:
24668 
 
24669 
  thrift_spec = (
24670 
  )
24671 
 
24672 
  def read(self, iprot):
24673 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24674 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24675 
      return
24676 
    iprot.readStructBegin()
24677 
    while True:
24678 
      (fname, ftype, fid) = iprot.readFieldBegin()
24679 
      if ftype == TType.STOP:
24680 
        break
24681 
      else:
24682 
        iprot.skip(ftype)
24683 
      iprot.readFieldEnd()
24684 
    iprot.readStructEnd()
24685 
 
24686 
  def write(self, oprot):
24687 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24688 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24689 
      return
24690 
    oprot.writeStructBegin('addPageViewEvent_result')
24691 
    oprot.writeFieldStop()
24692 
    oprot.writeStructEnd()
24693 
 
24694 
  def validate(self):
24695 
    return
24696 
 
24697 
 
24698 
  def __repr__(self):
24699 
    L = ['%s=%r' % (key, value)
24700 
      for key, value in self.__dict__.iteritems()]
24701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24702 
 
24703 
  def __eq__(self, other):
24704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24705 
 
24706 
  def __ne__(self, other):
24707 
    return not (self == other)
24708 
 
24709 
class addCartEvent_args:
24710 
  """
24711 
  Attributes:
24712 
   - cartEvents
24713 
  """
24714 
 
24715 
  thrift_spec = (
24716 
    None, # 0
24717 
    (1, TType.STRUCT, 'cartEvents', (CartEvents, CartEvents.thrift_spec), None, ), # 1
24718 
  )
24719 
 
24720 
  def __init__(self, cartEvents=None,):
24721 
    self.cartEvents = cartEvents
24722 
 
24723 
  def read(self, iprot):
24724 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24725 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24726 
      return
24727 
    iprot.readStructBegin()
24728 
    while True:
24729 
      (fname, ftype, fid) = iprot.readFieldBegin()
24730 
      if ftype == TType.STOP:
24731 
        break
24732 
      if fid == 1:
24733 
        if ftype == TType.STRUCT:
24734 
          self.cartEvents = CartEvents()
24735 
          self.cartEvents.read(iprot)
24736 
        else:
24737 
          iprot.skip(ftype)
24738 
      else:
24739 
        iprot.skip(ftype)
24740 
      iprot.readFieldEnd()
24741 
    iprot.readStructEnd()
24742 
 
24743 
  def write(self, oprot):
24744 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24745 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24746 
      return
24747 
    oprot.writeStructBegin('addCartEvent_args')
24748 
    if self.cartEvents is not None:
24749 
      oprot.writeFieldBegin('cartEvents', TType.STRUCT, 1)
24750 
      self.cartEvents.write(oprot)
24751 
      oprot.writeFieldEnd()
24752 
    oprot.writeFieldStop()
24753 
    oprot.writeStructEnd()
24754 
 
24755 
  def validate(self):
24756 
    return
24757 
 
24758 
 
24759 
  def __repr__(self):
24760 
    L = ['%s=%r' % (key, value)
24761 
      for key, value in self.__dict__.iteritems()]
24762 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24763 
 
24764 
  def __eq__(self, other):
24765 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24766 
 
24767 
  def __ne__(self, other):
24768 
    return not (self == other)
24769 
 
24770 
class addCartEvent_result:
24771 
 
24772 
  thrift_spec = (
24773 
  )
24774 
 
24775 
  def read(self, iprot):
24776 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24777 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24778 
      return
24779 
    iprot.readStructBegin()
24780 
    while True:
24781 
      (fname, ftype, fid) = iprot.readFieldBegin()
24782 
      if ftype == TType.STOP:
24783 
        break
24784 
      else:
24785 
        iprot.skip(ftype)
24786 
      iprot.readFieldEnd()
24787 
    iprot.readStructEnd()
24788 
 
24789 
  def write(self, oprot):
24790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24792 
      return
24793 
    oprot.writeStructBegin('addCartEvent_result')
24794 
    oprot.writeFieldStop()
24795 
    oprot.writeStructEnd()
24796 
 
24797 
  def validate(self):
24798 
    return
24799 
 
24800 
 
24801 
  def __repr__(self):
24802 
    L = ['%s=%r' % (key, value)
24803 
      for key, value in self.__dict__.iteritems()]
24804 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24805 
 
24806 
  def __eq__(self, other):
24807 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24808 
 
24809 
  def __ne__(self, other):
24810 
    return not (self == other)
8139 kshitij.so 24811 
 
8182 amar.kumar 24812 
class addEbayItem_args:
24813 
  """
24814 
  Attributes:
24815 
   - ebayItem
24816 
  """
24817 
 
24818 
  thrift_spec = (
24819 
    None, # 0
24820 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
24821 
  )
24822 
 
24823 
  def __init__(self, ebayItem=None,):
24824 
    self.ebayItem = ebayItem
24825 
 
24826 
  def read(self, iprot):
24827 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24828 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24829 
      return
24830 
    iprot.readStructBegin()
24831 
    while True:
24832 
      (fname, ftype, fid) = iprot.readFieldBegin()
24833 
      if ftype == TType.STOP:
24834 
        break
24835 
      if fid == 1:
24836 
        if ftype == TType.STRUCT:
24837 
          self.ebayItem = EbayItem()
24838 
          self.ebayItem.read(iprot)
24839 
        else:
24840 
          iprot.skip(ftype)
24841 
      else:
24842 
        iprot.skip(ftype)
24843 
      iprot.readFieldEnd()
24844 
    iprot.readStructEnd()
24845 
 
24846 
  def write(self, oprot):
24847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24849 
      return
24850 
    oprot.writeStructBegin('addEbayItem_args')
24851 
    if self.ebayItem is not None:
24852 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
24853 
      self.ebayItem.write(oprot)
24854 
      oprot.writeFieldEnd()
24855 
    oprot.writeFieldStop()
24856 
    oprot.writeStructEnd()
24857 
 
24858 
  def validate(self):
24859 
    return
24860 
 
24861 
 
24862 
  def __repr__(self):
24863 
    L = ['%s=%r' % (key, value)
24864 
      for key, value in self.__dict__.iteritems()]
24865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24866 
 
24867 
  def __eq__(self, other):
24868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24869 
 
24870 
  def __ne__(self, other):
24871 
    return not (self == other)
24872 
 
24873 
class addEbayItem_result:
24874 
 
24875 
  thrift_spec = (
24876 
  )
24877 
 
24878 
  def read(self, iprot):
24879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24881 
      return
24882 
    iprot.readStructBegin()
24883 
    while True:
24884 
      (fname, ftype, fid) = iprot.readFieldBegin()
24885 
      if ftype == TType.STOP:
24886 
        break
24887 
      else:
24888 
        iprot.skip(ftype)
24889 
      iprot.readFieldEnd()
24890 
    iprot.readStructEnd()
24891 
 
24892 
  def write(self, oprot):
24893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24895 
      return
24896 
    oprot.writeStructBegin('addEbayItem_result')
24897 
    oprot.writeFieldStop()
24898 
    oprot.writeStructEnd()
24899 
 
24900 
  def validate(self):
24901 
    return
24902 
 
24903 
 
24904 
  def __repr__(self):
24905 
    L = ['%s=%r' % (key, value)
24906 
      for key, value in self.__dict__.iteritems()]
24907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24908 
 
24909 
  def __eq__(self, other):
24910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24911 
 
24912 
  def __ne__(self, other):
24913 
    return not (self == other)
24914 
 
24915 
class getEbayItem_args:
24916 
  """
24917 
  Attributes:
24918 
   - listingId
24919 
  """
24920 
 
24921 
  thrift_spec = (
24922 
    None, # 0
24923 
    (1, TType.STRING, 'listingId', None, None, ), # 1
24924 
  )
24925 
 
24926 
  def __init__(self, listingId=None,):
24927 
    self.listingId = listingId
24928 
 
24929 
  def read(self, iprot):
24930 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24931 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24932 
      return
24933 
    iprot.readStructBegin()
24934 
    while True:
24935 
      (fname, ftype, fid) = iprot.readFieldBegin()
24936 
      if ftype == TType.STOP:
24937 
        break
24938 
      if fid == 1:
24939 
        if ftype == TType.STRING:
24940 
          self.listingId = iprot.readString();
24941 
        else:
24942 
          iprot.skip(ftype)
24943 
      else:
24944 
        iprot.skip(ftype)
24945 
      iprot.readFieldEnd()
24946 
    iprot.readStructEnd()
24947 
 
24948 
  def write(self, oprot):
24949 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24950 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24951 
      return
24952 
    oprot.writeStructBegin('getEbayItem_args')
24953 
    if self.listingId is not None:
24954 
      oprot.writeFieldBegin('listingId', TType.STRING, 1)
24955 
      oprot.writeString(self.listingId)
24956 
      oprot.writeFieldEnd()
24957 
    oprot.writeFieldStop()
24958 
    oprot.writeStructEnd()
24959 
 
24960 
  def validate(self):
24961 
    return
24962 
 
24963 
 
24964 
  def __repr__(self):
24965 
    L = ['%s=%r' % (key, value)
24966 
      for key, value in self.__dict__.iteritems()]
24967 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24968 
 
24969 
  def __eq__(self, other):
24970 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24971 
 
24972 
  def __ne__(self, other):
24973 
    return not (self == other)
24974 
 
24975 
class getEbayItem_result:
24976 
  """
24977 
  Attributes:
24978 
   - success
24979 
  """
24980 
 
24981 
  thrift_spec = (
24982 
    (0, TType.STRUCT, 'success', (EbayItem, EbayItem.thrift_spec), None, ), # 0
24983 
  )
24984 
 
24985 
  def __init__(self, success=None,):
24986 
    self.success = success
24987 
 
24988 
  def read(self, iprot):
24989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24991 
      return
24992 
    iprot.readStructBegin()
24993 
    while True:
24994 
      (fname, ftype, fid) = iprot.readFieldBegin()
24995 
      if ftype == TType.STOP:
24996 
        break
24997 
      if fid == 0:
24998 
        if ftype == TType.STRUCT:
24999 
          self.success = EbayItem()
25000 
          self.success.read(iprot)
25001 
        else:
25002 
          iprot.skip(ftype)
25003 
      else:
25004 
        iprot.skip(ftype)
25005 
      iprot.readFieldEnd()
25006 
    iprot.readStructEnd()
25007 
 
25008 
  def write(self, oprot):
25009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25011 
      return
25012 
    oprot.writeStructBegin('getEbayItem_result')
25013 
    if self.success is not None:
25014 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
25015 
      self.success.write(oprot)
25016 
      oprot.writeFieldEnd()
25017 
    oprot.writeFieldStop()
25018 
    oprot.writeStructEnd()
25019 
 
25020 
  def validate(self):
25021 
    return
25022 
 
25023 
 
25024 
  def __repr__(self):
25025 
    L = ['%s=%r' % (key, value)
25026 
      for key, value in self.__dict__.iteritems()]
25027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25028 
 
25029 
  def __eq__(self, other):
25030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25031 
 
25032 
  def __ne__(self, other):
25033 
    return not (self == other)
25034 
 
25035 
class updateEbayItem_args:
25036 
  """
25037 
  Attributes:
25038 
   - ebayItem
25039 
  """
25040 
 
25041 
  thrift_spec = (
25042 
    None, # 0
25043 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
25044 
  )
25045 
 
25046 
  def __init__(self, ebayItem=None,):
25047 
    self.ebayItem = ebayItem
25048 
 
25049 
  def read(self, iprot):
25050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25052 
      return
25053 
    iprot.readStructBegin()
25054 
    while True:
25055 
      (fname, ftype, fid) = iprot.readFieldBegin()
25056 
      if ftype == TType.STOP:
25057 
        break
25058 
      if fid == 1:
25059 
        if ftype == TType.STRUCT:
25060 
          self.ebayItem = EbayItem()
25061 
          self.ebayItem.read(iprot)
25062 
        else:
25063 
          iprot.skip(ftype)
25064 
      else:
25065 
        iprot.skip(ftype)
25066 
      iprot.readFieldEnd()
25067 
    iprot.readStructEnd()
25068 
 
25069 
  def write(self, oprot):
25070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25072 
      return
25073 
    oprot.writeStructBegin('updateEbayItem_args')
25074 
    if self.ebayItem is not None:
25075 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
25076 
      self.ebayItem.write(oprot)
25077 
      oprot.writeFieldEnd()
25078 
    oprot.writeFieldStop()
25079 
    oprot.writeStructEnd()
25080 
 
25081 
  def validate(self):
25082 
    return
25083 
 
25084 
 
25085 
  def __repr__(self):
25086 
    L = ['%s=%r' % (key, value)
25087 
      for key, value in self.__dict__.iteritems()]
25088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25089 
 
25090 
  def __eq__(self, other):
25091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25092 
 
25093 
  def __ne__(self, other):
25094 
    return not (self == other)
25095 
 
25096 
class updateEbayItem_result:
25097 
 
25098 
  thrift_spec = (
25099 
  )
25100 
 
25101 
  def read(self, iprot):
25102 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25103 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25104 
      return
25105 
    iprot.readStructBegin()
25106 
    while True:
25107 
      (fname, ftype, fid) = iprot.readFieldBegin()
25108 
      if ftype == TType.STOP:
25109 
        break
25110 
      else:
25111 
        iprot.skip(ftype)
25112 
      iprot.readFieldEnd()
25113 
    iprot.readStructEnd()
25114 
 
25115 
  def write(self, oprot):
25116 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25117 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25118 
      return
25119 
    oprot.writeStructBegin('updateEbayItem_result')
25120 
    oprot.writeFieldStop()
25121 
    oprot.writeStructEnd()
25122 
 
25123 
  def validate(self):
25124 
    return
25125 
 
25126 
 
25127 
  def __repr__(self):
25128 
    L = ['%s=%r' % (key, value)
25129 
      for key, value in self.__dict__.iteritems()]
25130 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25131 
 
25132 
  def __eq__(self, other):
25133 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25134 
 
25135 
  def __ne__(self, other):
25136 
    return not (self == other)
25137 
 
8139 kshitij.so 25138 
class getAmazonListedItems_args:
25139 
  """
25140 
  Attributes:
25141 
   - offset
25142 
   - limit
25143 
  """
25144 
 
25145 
  thrift_spec = (
25146 
    None, # 0
25147 
    (1, TType.I64, 'offset', None, None, ), # 1
25148 
    (2, TType.I64, 'limit', None, None, ), # 2
25149 
  )
25150 
 
25151 
  def __init__(self, offset=None, limit=None,):
25152 
    self.offset = offset
25153 
    self.limit = limit
25154 
 
25155 
  def read(self, iprot):
25156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25158 
      return
25159 
    iprot.readStructBegin()
25160 
    while True:
25161 
      (fname, ftype, fid) = iprot.readFieldBegin()
25162 
      if ftype == TType.STOP:
25163 
        break
25164 
      if fid == 1:
25165 
        if ftype == TType.I64:
25166 
          self.offset = iprot.readI64();
25167 
        else:
25168 
          iprot.skip(ftype)
25169 
      elif fid == 2:
25170 
        if ftype == TType.I64:
25171 
          self.limit = iprot.readI64();
25172 
        else:
25173 
          iprot.skip(ftype)
25174 
      else:
25175 
        iprot.skip(ftype)
25176 
      iprot.readFieldEnd()
25177 
    iprot.readStructEnd()
25178 
 
25179 
  def write(self, oprot):
25180 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25181 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25182 
      return
25183 
    oprot.writeStructBegin('getAmazonListedItems_args')
25184 
    if self.offset is not None:
25185 
      oprot.writeFieldBegin('offset', TType.I64, 1)
25186 
      oprot.writeI64(self.offset)
25187 
      oprot.writeFieldEnd()
25188 
    if self.limit is not None:
25189 
      oprot.writeFieldBegin('limit', TType.I64, 2)
25190 
      oprot.writeI64(self.limit)
25191 
      oprot.writeFieldEnd()
25192 
    oprot.writeFieldStop()
25193 
    oprot.writeStructEnd()
25194 
 
25195 
  def validate(self):
25196 
    return
25197 
 
25198 
 
25199 
  def __repr__(self):
25200 
    L = ['%s=%r' % (key, value)
25201 
      for key, value in self.__dict__.iteritems()]
25202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25203 
 
25204 
  def __eq__(self, other):
25205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25206 
 
25207 
  def __ne__(self, other):
25208 
    return not (self == other)
25209 
 
25210 
class getAmazonListedItems_result:
25211 
  """
25212 
  Attributes:
25213 
   - success
25214 
  """
25215 
 
25216 
  thrift_spec = (
25217 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
25218 
  )
25219 
 
25220 
  def __init__(self, success=None,):
25221 
    self.success = success
25222 
 
25223 
  def read(self, iprot):
25224 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25225 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25226 
      return
25227 
    iprot.readStructBegin()
25228 
    while True:
25229 
      (fname, ftype, fid) = iprot.readFieldBegin()
25230 
      if ftype == TType.STOP:
25231 
        break
25232 
      if fid == 0:
25233 
        if ftype == TType.LIST:
25234 
          self.success = []
18719 kshitij.so 25235 
          (_etype511, _size508) = iprot.readListBegin()
25236 
          for _i512 in xrange(_size508):
25237 
            _elem513 = Amazonlisted()
25238 
            _elem513.read(iprot)
25239 
            self.success.append(_elem513)
8139 kshitij.so 25240 
          iprot.readListEnd()
25241 
        else:
25242 
          iprot.skip(ftype)
25243 
      else:
25244 
        iprot.skip(ftype)
25245 
      iprot.readFieldEnd()
25246 
    iprot.readStructEnd()
25247 
 
25248 
  def write(self, oprot):
25249 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25250 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25251 
      return
25252 
    oprot.writeStructBegin('getAmazonListedItems_result')
25253 
    if self.success is not None:
25254 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25255 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 25256 
      for iter514 in self.success:
25257 
        iter514.write(oprot)
8139 kshitij.so 25258 
      oprot.writeListEnd()
25259 
      oprot.writeFieldEnd()
25260 
    oprot.writeFieldStop()
25261 
    oprot.writeStructEnd()
25262 
 
25263 
  def validate(self):
25264 
    return
25265 
 
25266 
 
25267 
  def __repr__(self):
25268 
    L = ['%s=%r' % (key, value)
25269 
      for key, value in self.__dict__.iteritems()]
25270 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25271 
 
25272 
  def __eq__(self, other):
25273 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25274 
 
25275 
  def __ne__(self, other):
25276 
    return not (self == other)
8168 kshitij.so 25277 
 
25278 
class updateAmazonAttributesInBulk_args:
25279 
  """
25280 
  Attributes:
25281 
   - amazonlisted
25282 
  """
25283 
 
25284 
  thrift_spec = (
25285 
    None, # 0
25286 
    (1, TType.MAP, 'amazonlisted', (TType.I64,None,TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 1
25287 
  )
25288 
 
25289 
  def __init__(self, amazonlisted=None,):
25290 
    self.amazonlisted = amazonlisted
25291 
 
25292 
  def read(self, iprot):
25293 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25294 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25295 
      return
25296 
    iprot.readStructBegin()
25297 
    while True:
25298 
      (fname, ftype, fid) = iprot.readFieldBegin()
25299 
      if ftype == TType.STOP:
25300 
        break
25301 
      if fid == 1:
25302 
        if ftype == TType.MAP:
25303 
          self.amazonlisted = {}
18719 kshitij.so 25304 
          (_ktype516, _vtype517, _size515 ) = iprot.readMapBegin()
25305 
          for _i519 in xrange(_size515):
25306 
            _key520 = iprot.readI64();
25307 
            _val521 = Amazonlisted()
25308 
            _val521.read(iprot)
25309 
            self.amazonlisted[_key520] = _val521
8168 kshitij.so 25310 
          iprot.readMapEnd()
25311 
        else:
25312 
          iprot.skip(ftype)
25313 
      else:
25314 
        iprot.skip(ftype)
25315 
      iprot.readFieldEnd()
25316 
    iprot.readStructEnd()
25317 
 
25318 
  def write(self, oprot):
25319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25321 
      return
25322 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_args')
25323 
    if self.amazonlisted is not None:
25324 
      oprot.writeFieldBegin('amazonlisted', TType.MAP, 1)
25325 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.amazonlisted))
18719 kshitij.so 25326 
      for kiter522,viter523 in self.amazonlisted.items():
25327 
        oprot.writeI64(kiter522)
25328 
        viter523.write(oprot)
8168 kshitij.so 25329 
      oprot.writeMapEnd()
25330 
      oprot.writeFieldEnd()
25331 
    oprot.writeFieldStop()
25332 
    oprot.writeStructEnd()
25333 
 
25334 
  def validate(self):
25335 
    return
25336 
 
25337 
 
25338 
  def __repr__(self):
25339 
    L = ['%s=%r' % (key, value)
25340 
      for key, value in self.__dict__.iteritems()]
25341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25342 
 
25343 
  def __eq__(self, other):
25344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25345 
 
25346 
  def __ne__(self, other):
25347 
    return not (self == other)
25348 
 
25349 
class updateAmazonAttributesInBulk_result:
25350 
  """
25351 
  Attributes:
25352 
   - success
25353 
  """
25354 
 
25355 
  thrift_spec = (
25356 
    (0, TType.BOOL, 'success', None, None, ), # 0
25357 
  )
25358 
 
25359 
  def __init__(self, success=None,):
25360 
    self.success = success
25361 
 
25362 
  def read(self, iprot):
25363 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25364 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25365 
      return
25366 
    iprot.readStructBegin()
25367 
    while True:
25368 
      (fname, ftype, fid) = iprot.readFieldBegin()
25369 
      if ftype == TType.STOP:
25370 
        break
25371 
      if fid == 0:
25372 
        if ftype == TType.BOOL:
25373 
          self.success = iprot.readBool();
25374 
        else:
25375 
          iprot.skip(ftype)
25376 
      else:
25377 
        iprot.skip(ftype)
25378 
      iprot.readFieldEnd()
25379 
    iprot.readStructEnd()
25380 
 
25381 
  def write(self, oprot):
25382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25384 
      return
25385 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_result')
25386 
    if self.success is not None:
25387 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
25388 
      oprot.writeBool(self.success)
25389 
      oprot.writeFieldEnd()
25390 
    oprot.writeFieldStop()
25391 
    oprot.writeStructEnd()
25392 
 
25393 
  def validate(self):
25394 
    return
25395 
 
25396 
 
25397 
  def __repr__(self):
25398 
    L = ['%s=%r' % (key, value)
25399 
      for key, value in self.__dict__.iteritems()]
25400 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25401 
 
25402 
  def __eq__(self, other):
25403 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25404 
 
25405 
  def __ne__(self, other):
25406 
    return not (self == other)
8379 vikram.rag 25407 
 
25408 
class getAllItemstoListOnFba_args:
25409 
 
25410 
  thrift_spec = (
25411 
  )
25412 
 
25413 
  def read(self, iprot):
25414 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25415 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25416 
      return
25417 
    iprot.readStructBegin()
25418 
    while True:
25419 
      (fname, ftype, fid) = iprot.readFieldBegin()
25420 
      if ftype == TType.STOP:
25421 
        break
25422 
      else:
25423 
        iprot.skip(ftype)
25424 
      iprot.readFieldEnd()
25425 
    iprot.readStructEnd()
25426 
 
25427 
  def write(self, oprot):
25428 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25429 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25430 
      return
25431 
    oprot.writeStructBegin('getAllItemstoListOnFba_args')
25432 
    oprot.writeFieldStop()
25433 
    oprot.writeStructEnd()
25434 
 
25435 
  def validate(self):
25436 
    return
25437 
 
25438 
 
25439 
  def __repr__(self):
25440 
    L = ['%s=%r' % (key, value)
25441 
      for key, value in self.__dict__.iteritems()]
25442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25443 
 
25444 
  def __eq__(self, other):
25445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25446 
 
25447 
  def __ne__(self, other):
25448 
    return not (self == other)
25449 
 
25450 
class getAllItemstoListOnFba_result:
25451 
  """
25452 
  Attributes:
25453 
   - success
25454 
  """
25455 
 
25456 
  thrift_spec = (
25457 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
25458 
  )
25459 
 
25460 
  def __init__(self, success=None,):
25461 
    self.success = success
25462 
 
25463 
  def read(self, iprot):
25464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25466 
      return
25467 
    iprot.readStructBegin()
25468 
    while True:
25469 
      (fname, ftype, fid) = iprot.readFieldBegin()
25470 
      if ftype == TType.STOP:
25471 
        break
25472 
      if fid == 0:
25473 
        if ftype == TType.LIST:
25474 
          self.success = []
18719 kshitij.so 25475 
          (_etype527, _size524) = iprot.readListBegin()
25476 
          for _i528 in xrange(_size524):
25477 
            _elem529 = Amazonlisted()
25478 
            _elem529.read(iprot)
25479 
            self.success.append(_elem529)
8379 vikram.rag 25480 
          iprot.readListEnd()
25481 
        else:
25482 
          iprot.skip(ftype)
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('getAllItemstoListOnFba_result')
25493 
    if self.success is not None:
25494 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25495 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 25496 
      for iter530 in self.success:
25497 
        iter530.write(oprot)
8379 vikram.rag 25498 
      oprot.writeListEnd()
25499 
      oprot.writeFieldEnd()
25500 
    oprot.writeFieldStop()
25501 
    oprot.writeStructEnd()
25502 
 
25503 
  def validate(self):
25504 
    return
25505 
 
25506 
 
25507 
  def __repr__(self):
25508 
    L = ['%s=%r' % (key, value)
25509 
      for key, value in self.__dict__.iteritems()]
25510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25511 
 
25512 
  def __eq__(self, other):
25513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25514 
 
25515 
  def __ne__(self, other):
25516 
    return not (self == other)
25517 
 
25518 
class getAllItemstoListOnNonFba_args:
25519 
 
25520 
  thrift_spec = (
25521 
  )
25522 
 
25523 
  def read(self, iprot):
25524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25526 
      return
25527 
    iprot.readStructBegin()
25528 
    while True:
25529 
      (fname, ftype, fid) = iprot.readFieldBegin()
25530 
      if ftype == TType.STOP:
25531 
        break
25532 
      else:
25533 
        iprot.skip(ftype)
25534 
      iprot.readFieldEnd()
25535 
    iprot.readStructEnd()
25536 
 
25537 
  def write(self, oprot):
25538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25540 
      return
25541 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_args')
25542 
    oprot.writeFieldStop()
25543 
    oprot.writeStructEnd()
25544 
 
25545 
  def validate(self):
25546 
    return
25547 
 
25548 
 
25549 
  def __repr__(self):
25550 
    L = ['%s=%r' % (key, value)
25551 
      for key, value in self.__dict__.iteritems()]
25552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25553 
 
25554 
  def __eq__(self, other):
25555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25556 
 
25557 
  def __ne__(self, other):
25558 
    return not (self == other)
25559 
 
25560 
class getAllItemstoListOnNonFba_result:
25561 
  """
25562 
  Attributes:
25563 
   - success
25564 
  """
25565 
 
25566 
  thrift_spec = (
25567 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
25568 
  )
25569 
 
25570 
  def __init__(self, success=None,):
25571 
    self.success = success
25572 
 
25573 
  def read(self, iprot):
25574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25576 
      return
25577 
    iprot.readStructBegin()
25578 
    while True:
25579 
      (fname, ftype, fid) = iprot.readFieldBegin()
25580 
      if ftype == TType.STOP:
25581 
        break
25582 
      if fid == 0:
25583 
        if ftype == TType.LIST:
25584 
          self.success = []
18719 kshitij.so 25585 
          (_etype534, _size531) = iprot.readListBegin()
25586 
          for _i535 in xrange(_size531):
25587 
            _elem536 = Amazonlisted()
25588 
            _elem536.read(iprot)
25589 
            self.success.append(_elem536)
8379 vikram.rag 25590 
          iprot.readListEnd()
25591 
        else:
25592 
          iprot.skip(ftype)
25593 
      else:
25594 
        iprot.skip(ftype)
25595 
      iprot.readFieldEnd()
25596 
    iprot.readStructEnd()
25597 
 
25598 
  def write(self, oprot):
25599 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25600 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25601 
      return
25602 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_result')
25603 
    if self.success is not None:
25604 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25605 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 25606 
      for iter537 in self.success:
25607 
        iter537.write(oprot)
8379 vikram.rag 25608 
      oprot.writeListEnd()
25609 
      oprot.writeFieldEnd()
25610 
    oprot.writeFieldStop()
25611 
    oprot.writeStructEnd()
25612 
 
25613 
  def validate(self):
25614 
    return
25615 
 
25616 
 
25617 
  def __repr__(self):
25618 
    L = ['%s=%r' % (key, value)
25619 
      for key, value in self.__dict__.iteritems()]
25620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25621 
 
25622 
  def __eq__(self, other):
25623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25624 
 
25625 
  def __ne__(self, other):
25626 
    return not (self == other)
8616 vikram.rag 25627 
 
9242 kshitij.so 25628 
class updateAsin_args:
25629 
  """
25630 
  Attributes:
25631 
   - item
25632 
  """
8616 vikram.rag 25633 
 
25634 
  thrift_spec = (
9242 kshitij.so 25635 
    None, # 0
25636 
    (1, TType.MAP, 'item', (TType.I64,None,TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 1
8616 vikram.rag 25637 
  )
25638 
 
9242 kshitij.so 25639 
  def __init__(self, item=None,):
25640 
    self.item = item
25641 
 
8616 vikram.rag 25642 
  def read(self, iprot):
25643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25645 
      return
25646 
    iprot.readStructBegin()
25647 
    while True:
25648 
      (fname, ftype, fid) = iprot.readFieldBegin()
25649 
      if ftype == TType.STOP:
25650 
        break
9242 kshitij.so 25651 
      if fid == 1:
25652 
        if ftype == TType.MAP:
25653 
          self.item = {}
18719 kshitij.so 25654 
          (_ktype539, _vtype540, _size538 ) = iprot.readMapBegin()
25655 
          for _i542 in xrange(_size538):
25656 
            _key543 = iprot.readI64();
25657 
            _val544 = Item()
25658 
            _val544.read(iprot)
25659 
            self.item[_key543] = _val544
9242 kshitij.so 25660 
          iprot.readMapEnd()
25661 
        else:
25662 
          iprot.skip(ftype)
8616 vikram.rag 25663 
      else:
25664 
        iprot.skip(ftype)
25665 
      iprot.readFieldEnd()
25666 
    iprot.readStructEnd()
25667 
 
25668 
  def write(self, oprot):
25669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25671 
      return
9242 kshitij.so 25672 
    oprot.writeStructBegin('updateAsin_args')
25673 
    if self.item is not None:
25674 
      oprot.writeFieldBegin('item', TType.MAP, 1)
25675 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.item))
18719 kshitij.so 25676 
      for kiter545,viter546 in self.item.items():
25677 
        oprot.writeI64(kiter545)
25678 
        viter546.write(oprot)
9242 kshitij.so 25679 
      oprot.writeMapEnd()
25680 
      oprot.writeFieldEnd()
8616 vikram.rag 25681 
    oprot.writeFieldStop()
25682 
    oprot.writeStructEnd()
25683 
 
25684 
  def validate(self):
25685 
    return
25686 
 
25687 
 
25688 
  def __repr__(self):
25689 
    L = ['%s=%r' % (key, value)
25690 
      for key, value in self.__dict__.iteritems()]
25691 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25692 
 
25693 
  def __eq__(self, other):
25694 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25695 
 
25696 
  def __ne__(self, other):
25697 
    return not (self == other)
25698 
 
9242 kshitij.so 25699 
class updateAsin_result:
8616 vikram.rag 25700 
 
25701 
  thrift_spec = (
25702 
  )
25703 
 
25704 
  def read(self, iprot):
25705 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25706 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25707 
      return
25708 
    iprot.readStructBegin()
25709 
    while True:
25710 
      (fname, ftype, fid) = iprot.readFieldBegin()
25711 
      if ftype == TType.STOP:
25712 
        break
25713 
      else:
25714 
        iprot.skip(ftype)
25715 
      iprot.readFieldEnd()
25716 
    iprot.readStructEnd()
25717 
 
25718 
  def write(self, oprot):
25719 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25720 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25721 
      return
9242 kshitij.so 25722 
    oprot.writeStructBegin('updateAsin_result')
8616 vikram.rag 25723 
    oprot.writeFieldStop()
25724 
    oprot.writeStructEnd()
25725 
 
25726 
  def validate(self):
25727 
    return
25728 
 
25729 
 
25730 
  def __repr__(self):
25731 
    L = ['%s=%r' % (key, value)
25732 
      for key, value in self.__dict__.iteritems()]
25733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25734 
 
25735 
  def __eq__(self, other):
25736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25737 
 
25738 
  def __ne__(self, other):
25739 
    return not (self == other)
8619 kshitij.so 25740 
 
9242 kshitij.so 25741 
class addOrUpdateSnapdealItem_args:
8619 kshitij.so 25742 
  """
25743 
  Attributes:
9242 kshitij.so 25744 
   - snapdealitem
8619 kshitij.so 25745 
  """
25746 
 
9242 kshitij.so 25747 
  thrift_spec = None
25748 
  def __init__(self, snapdealitem=None,):
25749 
    self.snapdealitem = snapdealitem
8619 kshitij.so 25750 
 
25751 
  def read(self, iprot):
25752 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25753 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25754 
      return
25755 
    iprot.readStructBegin()
25756 
    while True:
25757 
      (fname, ftype, fid) = iprot.readFieldBegin()
25758 
      if ftype == TType.STOP:
25759 
        break
9242 kshitij.so 25760 
      if fid == -1:
25761 
        if ftype == TType.STRUCT:
25762 
          self.snapdealitem = SnapdealItem()
25763 
          self.snapdealitem.read(iprot)
8619 kshitij.so 25764 
        else:
25765 
          iprot.skip(ftype)
25766 
      else:
25767 
        iprot.skip(ftype)
25768 
      iprot.readFieldEnd()
25769 
    iprot.readStructEnd()
25770 
 
25771 
  def write(self, oprot):
25772 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25773 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25774 
      return
9242 kshitij.so 25775 
    oprot.writeStructBegin('addOrUpdateSnapdealItem_args')
25776 
    if self.snapdealitem is not None:
25777 
      oprot.writeFieldBegin('snapdealitem', TType.STRUCT, -1)
25778 
      self.snapdealitem.write(oprot)
8619 kshitij.so 25779 
      oprot.writeFieldEnd()
25780 
    oprot.writeFieldStop()
25781 
    oprot.writeStructEnd()
25782 
 
25783 
  def validate(self):
25784 
    return
25785 
 
25786 
 
25787 
  def __repr__(self):
25788 
    L = ['%s=%r' % (key, value)
25789 
      for key, value in self.__dict__.iteritems()]
25790 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25791 
 
25792 
  def __eq__(self, other):
25793 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25794 
 
25795 
  def __ne__(self, other):
25796 
    return not (self == other)
25797 
 
9242 kshitij.so 25798 
class addOrUpdateSnapdealItem_result:
25799 
  """
25800 
  Attributes:
25801 
   - success
25802 
  """
8619 kshitij.so 25803 
 
25804 
  thrift_spec = (
9242 kshitij.so 25805 
    (0, TType.BOOL, 'success', None, None, ), # 0
8619 kshitij.so 25806 
  )
25807 
 
9242 kshitij.so 25808 
  def __init__(self, success=None,):
25809 
    self.success = success
25810 
 
8619 kshitij.so 25811 
  def read(self, iprot):
25812 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25813 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25814 
      return
25815 
    iprot.readStructBegin()
25816 
    while True:
25817 
      (fname, ftype, fid) = iprot.readFieldBegin()
25818 
      if ftype == TType.STOP:
25819 
        break
9242 kshitij.so 25820 
      if fid == 0:
25821 
        if ftype == TType.BOOL:
25822 
          self.success = iprot.readBool();
25823 
        else:
25824 
          iprot.skip(ftype)
8619 kshitij.so 25825 
      else:
25826 
        iprot.skip(ftype)
25827 
      iprot.readFieldEnd()
25828 
    iprot.readStructEnd()
25829 
 
25830 
  def write(self, oprot):
25831 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25832 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25833 
      return
9242 kshitij.so 25834 
    oprot.writeStructBegin('addOrUpdateSnapdealItem_result')
25835 
    if self.success is not None:
25836 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
25837 
      oprot.writeBool(self.success)
25838 
      oprot.writeFieldEnd()
8619 kshitij.so 25839 
    oprot.writeFieldStop()
25840 
    oprot.writeStructEnd()
25841 
 
25842 
  def validate(self):
25843 
    return
25844 
 
25845 
 
25846 
  def __repr__(self):
25847 
    L = ['%s=%r' % (key, value)
25848 
      for key, value in self.__dict__.iteritems()]
25849 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25850 
 
25851 
  def __eq__(self, other):
25852 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25853 
 
25854 
  def __ne__(self, other):
25855 
    return not (self == other)
8739 vikram.rag 25856 
 
9242 kshitij.so 25857 
class getSnapdealItem_args:
8739 vikram.rag 25858 
  """
25859 
  Attributes:
9242 kshitij.so 25860 
   - item_id
8739 vikram.rag 25861 
  """
25862 
 
9242 kshitij.so 25863 
  thrift_spec = (
25864 
    None, # 0
25865 
    (1, TType.I64, 'item_id', None, None, ), # 1
25866 
  )
8739 vikram.rag 25867 
 
9242 kshitij.so 25868 
  def __init__(self, item_id=None,):
25869 
    self.item_id = item_id
25870 
 
8739 vikram.rag 25871 
  def read(self, iprot):
25872 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25873 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25874 
      return
25875 
    iprot.readStructBegin()
25876 
    while True:
25877 
      (fname, ftype, fid) = iprot.readFieldBegin()
25878 
      if ftype == TType.STOP:
25879 
        break
9242 kshitij.so 25880 
      if fid == 1:
25881 
        if ftype == TType.I64:
25882 
          self.item_id = iprot.readI64();
8739 vikram.rag 25883 
        else:
25884 
          iprot.skip(ftype)
25885 
      else:
25886 
        iprot.skip(ftype)
25887 
      iprot.readFieldEnd()
25888 
    iprot.readStructEnd()
25889 
 
25890 
  def write(self, oprot):
25891 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25892 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25893 
      return
9242 kshitij.so 25894 
    oprot.writeStructBegin('getSnapdealItem_args')
25895 
    if self.item_id is not None:
25896 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
25897 
      oprot.writeI64(self.item_id)
8739 vikram.rag 25898 
      oprot.writeFieldEnd()
25899 
    oprot.writeFieldStop()
25900 
    oprot.writeStructEnd()
25901 
 
25902 
  def validate(self):
25903 
    return
25904 
 
25905 
 
25906 
  def __repr__(self):
25907 
    L = ['%s=%r' % (key, value)
25908 
      for key, value in self.__dict__.iteritems()]
25909 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25910 
 
25911 
  def __eq__(self, other):
25912 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25913 
 
25914 
  def __ne__(self, other):
25915 
    return not (self == other)
25916 
 
9242 kshitij.so 25917 
class getSnapdealItem_result:
8739 vikram.rag 25918 
  """
25919 
  Attributes:
25920 
   - success
25921 
  """
25922 
 
25923 
  thrift_spec = (
9242 kshitij.so 25924 
    (0, TType.STRUCT, 'success', (SnapdealItem, SnapdealItem.thrift_spec), None, ), # 0
8739 vikram.rag 25925 
  )
25926 
 
25927 
  def __init__(self, success=None,):
25928 
    self.success = success
25929 
 
25930 
  def read(self, iprot):
25931 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25932 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25933 
      return
25934 
    iprot.readStructBegin()
25935 
    while True:
25936 
      (fname, ftype, fid) = iprot.readFieldBegin()
25937 
      if ftype == TType.STOP:
25938 
        break
25939 
      if fid == 0:
9242 kshitij.so 25940 
        if ftype == TType.STRUCT:
25941 
          self.success = SnapdealItem()
25942 
          self.success.read(iprot)
8739 vikram.rag 25943 
        else:
25944 
          iprot.skip(ftype)
25945 
      else:
25946 
        iprot.skip(ftype)
25947 
      iprot.readFieldEnd()
25948 
    iprot.readStructEnd()
25949 
 
25950 
  def write(self, oprot):
25951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25953 
      return
9242 kshitij.so 25954 
    oprot.writeStructBegin('getSnapdealItem_result')
8739 vikram.rag 25955 
    if self.success is not None:
9242 kshitij.so 25956 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
25957 
      self.success.write(oprot)
8739 vikram.rag 25958 
      oprot.writeFieldEnd()
25959 
    oprot.writeFieldStop()
25960 
    oprot.writeStructEnd()
25961 
 
25962 
  def validate(self):
25963 
    return
25964 
 
25965 
 
25966 
  def __repr__(self):
25967 
    L = ['%s=%r' % (key, value)
25968 
      for key, value in self.__dict__.iteritems()]
25969 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25970 
 
25971 
  def __eq__(self, other):
25972 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25973 
 
25974 
  def __ne__(self, other):
25975 
    return not (self == other)
25976 
 
9242 kshitij.so 25977 
class getSnapdealItemDetails_args:
8739 vikram.rag 25978 
  """
25979 
  Attributes:
25980 
   - item_id
25981 
  """
25982 
 
25983 
  thrift_spec = (
25984 
    None, # 0
25985 
    (1, TType.I64, 'item_id', None, None, ), # 1
25986 
  )
25987 
 
25988 
  def __init__(self, item_id=None,):
25989 
    self.item_id = item_id
25990 
 
25991 
  def read(self, iprot):
25992 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25993 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25994 
      return
25995 
    iprot.readStructBegin()
25996 
    while True:
25997 
      (fname, ftype, fid) = iprot.readFieldBegin()
25998 
      if ftype == TType.STOP:
25999 
        break
26000 
      if fid == 1:
26001 
        if ftype == TType.I64:
26002 
          self.item_id = iprot.readI64();
26003 
        else:
26004 
          iprot.skip(ftype)
26005 
      else:
26006 
        iprot.skip(ftype)
26007 
      iprot.readFieldEnd()
26008 
    iprot.readStructEnd()
26009 
 
26010 
  def write(self, oprot):
26011 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26012 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26013 
      return
9242 kshitij.so 26014 
    oprot.writeStructBegin('getSnapdealItemDetails_args')
8739 vikram.rag 26015 
    if self.item_id is not None:
26016 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
26017 
      oprot.writeI64(self.item_id)
26018 
      oprot.writeFieldEnd()
26019 
    oprot.writeFieldStop()
26020 
    oprot.writeStructEnd()
26021 
 
26022 
  def validate(self):
26023 
    return
26024 
 
26025 
 
26026 
  def __repr__(self):
26027 
    L = ['%s=%r' % (key, value)
26028 
      for key, value in self.__dict__.iteritems()]
26029 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26030 
 
26031 
  def __eq__(self, other):
26032 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26033 
 
26034 
  def __ne__(self, other):
26035 
    return not (self == other)
26036 
 
9242 kshitij.so 26037 
class getSnapdealItemDetails_result:
8739 vikram.rag 26038 
  """
26039 
  Attributes:
26040 
   - success
26041 
  """
26042 
 
26043 
  thrift_spec = (
9242 kshitij.so 26044 
    (0, TType.STRUCT, 'success', (SnapdealItemDetails, SnapdealItemDetails.thrift_spec), None, ), # 0
8739 vikram.rag 26045 
  )
26046 
 
26047 
  def __init__(self, success=None,):
26048 
    self.success = success
26049 
 
26050 
  def read(self, iprot):
26051 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26052 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26053 
      return
26054 
    iprot.readStructBegin()
26055 
    while True:
26056 
      (fname, ftype, fid) = iprot.readFieldBegin()
26057 
      if ftype == TType.STOP:
26058 
        break
26059 
      if fid == 0:
26060 
        if ftype == TType.STRUCT:
9242 kshitij.so 26061 
          self.success = SnapdealItemDetails()
8739 vikram.rag 26062 
          self.success.read(iprot)
26063 
        else:
26064 
          iprot.skip(ftype)
26065 
      else:
26066 
        iprot.skip(ftype)
26067 
      iprot.readFieldEnd()
26068 
    iprot.readStructEnd()
26069 
 
26070 
  def write(self, oprot):
26071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26073 
      return
9242 kshitij.so 26074 
    oprot.writeStructBegin('getSnapdealItemDetails_result')
8739 vikram.rag 26075 
    if self.success is not None:
26076 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26077 
      self.success.write(oprot)
26078 
      oprot.writeFieldEnd()
26079 
    oprot.writeFieldStop()
26080 
    oprot.writeStructEnd()
26081 
 
26082 
  def validate(self):
26083 
    return
26084 
 
26085 
 
26086 
  def __repr__(self):
26087 
    L = ['%s=%r' % (key, value)
26088 
      for key, value in self.__dict__.iteritems()]
26089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26090 
 
26091 
  def __eq__(self, other):
26092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26093 
 
26094 
  def __ne__(self, other):
26095 
    return not (self == other)
26096 
 
26097 
class getAllSnapdealItems_args:
26098 
 
26099 
  thrift_spec = (
26100 
  )
26101 
 
26102 
  def read(self, iprot):
26103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26105 
      return
26106 
    iprot.readStructBegin()
26107 
    while True:
26108 
      (fname, ftype, fid) = iprot.readFieldBegin()
26109 
      if ftype == TType.STOP:
26110 
        break
26111 
      else:
26112 
        iprot.skip(ftype)
26113 
      iprot.readFieldEnd()
26114 
    iprot.readStructEnd()
26115 
 
26116 
  def write(self, oprot):
26117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26119 
      return
26120 
    oprot.writeStructBegin('getAllSnapdealItems_args')
26121 
    oprot.writeFieldStop()
26122 
    oprot.writeStructEnd()
26123 
 
26124 
  def validate(self):
26125 
    return
26126 
 
26127 
 
26128 
  def __repr__(self):
26129 
    L = ['%s=%r' % (key, value)
26130 
      for key, value in self.__dict__.iteritems()]
26131 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26132 
 
26133 
  def __eq__(self, other):
26134 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26135 
 
26136 
  def __ne__(self, other):
26137 
    return not (self == other)
26138 
 
26139 
class getAllSnapdealItems_result:
26140 
  """
26141 
  Attributes:
26142 
   - success
26143 
  """
26144 
 
26145 
  thrift_spec = (
9242 kshitij.so 26146 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
8739 vikram.rag 26147 
  )
26148 
 
26149 
  def __init__(self, success=None,):
26150 
    self.success = success
26151 
 
26152 
  def read(self, iprot):
26153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26155 
      return
26156 
    iprot.readStructBegin()
26157 
    while True:
26158 
      (fname, ftype, fid) = iprot.readFieldBegin()
26159 
      if ftype == TType.STOP:
26160 
        break
26161 
      if fid == 0:
26162 
        if ftype == TType.LIST:
26163 
          self.success = []
18719 kshitij.so 26164 
          (_etype550, _size547) = iprot.readListBegin()
26165 
          for _i551 in xrange(_size547):
26166 
            _elem552 = SnapdealItemDetails()
26167 
            _elem552.read(iprot)
26168 
            self.success.append(_elem552)
9242 kshitij.so 26169 
          iprot.readListEnd()
26170 
        else:
26171 
          iprot.skip(ftype)
26172 
      else:
26173 
        iprot.skip(ftype)
26174 
      iprot.readFieldEnd()
26175 
    iprot.readStructEnd()
26176 
 
26177 
  def write(self, oprot):
26178 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26179 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26180 
      return
26181 
    oprot.writeStructBegin('getAllSnapdealItems_result')
26182 
    if self.success is not None:
26183 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26184 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 26185 
      for iter553 in self.success:
26186 
        iter553.write(oprot)
9242 kshitij.so 26187 
      oprot.writeListEnd()
26188 
      oprot.writeFieldEnd()
26189 
    oprot.writeFieldStop()
26190 
    oprot.writeStructEnd()
26191 
 
26192 
  def validate(self):
26193 
    return
26194 
 
26195 
 
26196 
  def __repr__(self):
26197 
    L = ['%s=%r' % (key, value)
26198 
      for key, value in self.__dict__.iteritems()]
26199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26200 
 
26201 
  def __eq__(self, other):
26202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26203 
 
26204 
  def __ne__(self, other):
26205 
    return not (self == other)
26206 
 
26207 
class getSnapdealItems_args:
26208 
  """
26209 
  Attributes:
26210 
   - offset
26211 
   - limit
26212 
  """
26213 
 
26214 
  thrift_spec = (
26215 
    None, # 0
26216 
    (1, TType.I64, 'offset', None, None, ), # 1
26217 
    (2, TType.I64, 'limit', None, None, ), # 2
26218 
  )
26219 
 
26220 
  def __init__(self, offset=None, limit=None,):
26221 
    self.offset = offset
26222 
    self.limit = limit
26223 
 
26224 
  def read(self, iprot):
26225 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26226 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26227 
      return
26228 
    iprot.readStructBegin()
26229 
    while True:
26230 
      (fname, ftype, fid) = iprot.readFieldBegin()
26231 
      if ftype == TType.STOP:
26232 
        break
26233 
      if fid == 1:
26234 
        if ftype == TType.I64:
26235 
          self.offset = iprot.readI64();
26236 
        else:
26237 
          iprot.skip(ftype)
26238 
      elif fid == 2:
26239 
        if ftype == TType.I64:
26240 
          self.limit = iprot.readI64();
26241 
        else:
26242 
          iprot.skip(ftype)
26243 
      else:
26244 
        iprot.skip(ftype)
26245 
      iprot.readFieldEnd()
26246 
    iprot.readStructEnd()
26247 
 
26248 
  def write(self, oprot):
26249 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26250 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26251 
      return
26252 
    oprot.writeStructBegin('getSnapdealItems_args')
26253 
    if self.offset is not None:
26254 
      oprot.writeFieldBegin('offset', TType.I64, 1)
26255 
      oprot.writeI64(self.offset)
26256 
      oprot.writeFieldEnd()
26257 
    if self.limit is not None:
26258 
      oprot.writeFieldBegin('limit', TType.I64, 2)
26259 
      oprot.writeI64(self.limit)
26260 
      oprot.writeFieldEnd()
26261 
    oprot.writeFieldStop()
26262 
    oprot.writeStructEnd()
26263 
 
26264 
  def validate(self):
26265 
    return
26266 
 
26267 
 
26268 
  def __repr__(self):
26269 
    L = ['%s=%r' % (key, value)
26270 
      for key, value in self.__dict__.iteritems()]
26271 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26272 
 
26273 
  def __eq__(self, other):
26274 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26275 
 
26276 
  def __ne__(self, other):
26277 
    return not (self == other)
26278 
 
26279 
class getSnapdealItems_result:
26280 
  """
26281 
  Attributes:
26282 
   - success
26283 
  """
26284 
 
26285 
  thrift_spec = (
26286 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
26287 
  )
26288 
 
26289 
  def __init__(self, success=None,):
26290 
    self.success = success
26291 
 
26292 
  def read(self, iprot):
26293 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26294 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26295 
      return
26296 
    iprot.readStructBegin()
26297 
    while True:
26298 
      (fname, ftype, fid) = iprot.readFieldBegin()
26299 
      if ftype == TType.STOP:
26300 
        break
26301 
      if fid == 0:
26302 
        if ftype == TType.LIST:
26303 
          self.success = []
18719 kshitij.so 26304 
          (_etype557, _size554) = iprot.readListBegin()
26305 
          for _i558 in xrange(_size554):
26306 
            _elem559 = SnapdealItemDetails()
26307 
            _elem559.read(iprot)
26308 
            self.success.append(_elem559)
8739 vikram.rag 26309 
          iprot.readListEnd()
26310 
        else:
26311 
          iprot.skip(ftype)
26312 
      else:
26313 
        iprot.skip(ftype)
26314 
      iprot.readFieldEnd()
26315 
    iprot.readStructEnd()
26316 
 
26317 
  def write(self, oprot):
26318 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26319 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26320 
      return
9242 kshitij.so 26321 
    oprot.writeStructBegin('getSnapdealItems_result')
8739 vikram.rag 26322 
    if self.success is not None:
26323 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26324 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 26325 
      for iter560 in self.success:
26326 
        iter560.write(oprot)
8739 vikram.rag 26327 
      oprot.writeListEnd()
26328 
      oprot.writeFieldEnd()
26329 
    oprot.writeFieldStop()
26330 
    oprot.writeStructEnd()
26331 
 
26332 
  def validate(self):
26333 
    return
26334 
 
26335 
 
26336 
  def __repr__(self):
26337 
    L = ['%s=%r' % (key, value)
26338 
      for key, value in self.__dict__.iteritems()]
26339 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26340 
 
26341 
  def __eq__(self, other):
26342 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26343 
 
26344 
  def __ne__(self, other):
26345 
    return not (self == other)
9242 kshitij.so 26346 
 
26347 
class searchSnapdealItems_args:
26348 
  """
26349 
  Attributes:
26350 
   - searchTerm
26351 
   - offset
26352 
   - limit
26353 
  """
26354 
 
26355 
  thrift_spec = (
26356 
    None, # 0
26357 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
26358 
    (2, TType.I64, 'offset', None, None, ), # 2
26359 
    (3, TType.I64, 'limit', None, None, ), # 3
26360 
  )
26361 
 
26362 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
26363 
    self.searchTerm = searchTerm
26364 
    self.offset = offset
26365 
    self.limit = limit
26366 
 
26367 
  def read(self, iprot):
26368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26370 
      return
26371 
    iprot.readStructBegin()
26372 
    while True:
26373 
      (fname, ftype, fid) = iprot.readFieldBegin()
26374 
      if ftype == TType.STOP:
26375 
        break
26376 
      if fid == 1:
26377 
        if ftype == TType.LIST:
26378 
          self.searchTerm = []
18719 kshitij.so 26379 
          (_etype564, _size561) = iprot.readListBegin()
26380 
          for _i565 in xrange(_size561):
26381 
            _elem566 = iprot.readString();
26382 
            self.searchTerm.append(_elem566)
9242 kshitij.so 26383 
          iprot.readListEnd()
26384 
        else:
26385 
          iprot.skip(ftype)
26386 
      elif fid == 2:
26387 
        if ftype == TType.I64:
26388 
          self.offset = iprot.readI64();
26389 
        else:
26390 
          iprot.skip(ftype)
26391 
      elif fid == 3:
26392 
        if ftype == TType.I64:
26393 
          self.limit = iprot.readI64();
26394 
        else:
26395 
          iprot.skip(ftype)
26396 
      else:
26397 
        iprot.skip(ftype)
26398 
      iprot.readFieldEnd()
26399 
    iprot.readStructEnd()
26400 
 
26401 
  def write(self, oprot):
26402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26404 
      return
26405 
    oprot.writeStructBegin('searchSnapdealItems_args')
26406 
    if self.searchTerm is not None:
26407 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
26408 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
18719 kshitij.so 26409 
      for iter567 in self.searchTerm:
26410 
        oprot.writeString(iter567)
9242 kshitij.so 26411 
      oprot.writeListEnd()
26412 
      oprot.writeFieldEnd()
26413 
    if self.offset is not None:
26414 
      oprot.writeFieldBegin('offset', TType.I64, 2)
26415 
      oprot.writeI64(self.offset)
26416 
      oprot.writeFieldEnd()
26417 
    if self.limit is not None:
26418 
      oprot.writeFieldBegin('limit', TType.I64, 3)
26419 
      oprot.writeI64(self.limit)
26420 
      oprot.writeFieldEnd()
26421 
    oprot.writeFieldStop()
26422 
    oprot.writeStructEnd()
26423 
 
26424 
  def validate(self):
26425 
    return
26426 
 
26427 
 
26428 
  def __repr__(self):
26429 
    L = ['%s=%r' % (key, value)
26430 
      for key, value in self.__dict__.iteritems()]
26431 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26432 
 
26433 
  def __eq__(self, other):
26434 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26435 
 
26436 
  def __ne__(self, other):
26437 
    return not (self == other)
26438 
 
26439 
class searchSnapdealItems_result:
26440 
  """
26441 
  Attributes:
26442 
   - success
26443 
  """
26444 
 
26445 
  thrift_spec = (
26446 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
26447 
  )
26448 
 
26449 
  def __init__(self, success=None,):
26450 
    self.success = success
26451 
 
26452 
  def read(self, iprot):
26453 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26454 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26455 
      return
26456 
    iprot.readStructBegin()
26457 
    while True:
26458 
      (fname, ftype, fid) = iprot.readFieldBegin()
26459 
      if ftype == TType.STOP:
26460 
        break
26461 
      if fid == 0:
26462 
        if ftype == TType.LIST:
26463 
          self.success = []
18719 kshitij.so 26464 
          (_etype571, _size568) = iprot.readListBegin()
26465 
          for _i572 in xrange(_size568):
26466 
            _elem573 = SnapdealItemDetails()
26467 
            _elem573.read(iprot)
26468 
            self.success.append(_elem573)
9242 kshitij.so 26469 
          iprot.readListEnd()
26470 
        else:
26471 
          iprot.skip(ftype)
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('searchSnapdealItems_result')
26482 
    if self.success is not None:
26483 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26484 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 26485 
      for iter574 in self.success:
26486 
        iter574.write(oprot)
9242 kshitij.so 26487 
      oprot.writeListEnd()
26488 
      oprot.writeFieldEnd()
26489 
    oprot.writeFieldStop()
26490 
    oprot.writeStructEnd()
26491 
 
26492 
  def validate(self):
26493 
    return
26494 
 
26495 
 
26496 
  def __repr__(self):
26497 
    L = ['%s=%r' % (key, value)
26498 
      for key, value in self.__dict__.iteritems()]
26499 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26500 
 
26501 
  def __eq__(self, other):
26502 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26503 
 
26504 
  def __ne__(self, other):
26505 
    return not (self == other)
26506 
 
26507 
class getCountForSnapdealItems_args:
26508 
 
26509 
  thrift_spec = (
26510 
  )
26511 
 
26512 
  def read(self, iprot):
26513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26515 
      return
26516 
    iprot.readStructBegin()
26517 
    while True:
26518 
      (fname, ftype, fid) = iprot.readFieldBegin()
26519 
      if ftype == TType.STOP:
26520 
        break
26521 
      else:
26522 
        iprot.skip(ftype)
26523 
      iprot.readFieldEnd()
26524 
    iprot.readStructEnd()
26525 
 
26526 
  def write(self, oprot):
26527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26529 
      return
26530 
    oprot.writeStructBegin('getCountForSnapdealItems_args')
26531 
    oprot.writeFieldStop()
26532 
    oprot.writeStructEnd()
26533 
 
26534 
  def validate(self):
26535 
    return
26536 
 
26537 
 
26538 
  def __repr__(self):
26539 
    L = ['%s=%r' % (key, value)
26540 
      for key, value in self.__dict__.iteritems()]
26541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26542 
 
26543 
  def __eq__(self, other):
26544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26545 
 
26546 
  def __ne__(self, other):
26547 
    return not (self == other)
26548 
 
26549 
class getCountForSnapdealItems_result:
26550 
  """
26551 
  Attributes:
26552 
   - success
26553 
  """
26554 
 
26555 
  thrift_spec = (
26556 
    (0, TType.I64, 'success', None, None, ), # 0
26557 
  )
26558 
 
26559 
  def __init__(self, success=None,):
26560 
    self.success = success
26561 
 
26562 
  def read(self, iprot):
26563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26565 
      return
26566 
    iprot.readStructBegin()
26567 
    while True:
26568 
      (fname, ftype, fid) = iprot.readFieldBegin()
26569 
      if ftype == TType.STOP:
26570 
        break
26571 
      if fid == 0:
26572 
        if ftype == TType.I64:
26573 
          self.success = iprot.readI64();
26574 
        else:
26575 
          iprot.skip(ftype)
26576 
      else:
26577 
        iprot.skip(ftype)
26578 
      iprot.readFieldEnd()
26579 
    iprot.readStructEnd()
26580 
 
26581 
  def write(self, oprot):
26582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26584 
      return
26585 
    oprot.writeStructBegin('getCountForSnapdealItems_result')
26586 
    if self.success is not None:
26587 
      oprot.writeFieldBegin('success', TType.I64, 0)
26588 
      oprot.writeI64(self.success)
26589 
      oprot.writeFieldEnd()
26590 
    oprot.writeFieldStop()
26591 
    oprot.writeStructEnd()
26592 
 
26593 
  def validate(self):
26594 
    return
26595 
 
26596 
 
26597 
  def __repr__(self):
26598 
    L = ['%s=%r' % (key, value)
26599 
      for key, value in self.__dict__.iteritems()]
26600 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26601 
 
26602 
  def __eq__(self, other):
26603 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26604 
 
26605 
  def __ne__(self, other):
26606 
    return not (self == other)
26607 
 
26608 
class getSnapdealSearchResultCount_args:
26609 
  """
26610 
  Attributes:
26611 
   - searchTerm
26612 
  """
26613 
 
26614 
  thrift_spec = (
26615 
    None, # 0
26616 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
26617 
  )
26618 
 
26619 
  def __init__(self, searchTerm=None,):
26620 
    self.searchTerm = searchTerm
26621 
 
26622 
  def read(self, iprot):
26623 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26624 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26625 
      return
26626 
    iprot.readStructBegin()
26627 
    while True:
26628 
      (fname, ftype, fid) = iprot.readFieldBegin()
26629 
      if ftype == TType.STOP:
26630 
        break
26631 
      if fid == 1:
26632 
        if ftype == TType.LIST:
26633 
          self.searchTerm = []
18719 kshitij.so 26634 
          (_etype578, _size575) = iprot.readListBegin()
26635 
          for _i579 in xrange(_size575):
26636 
            _elem580 = iprot.readString();
26637 
            self.searchTerm.append(_elem580)
9242 kshitij.so 26638 
          iprot.readListEnd()
26639 
        else:
26640 
          iprot.skip(ftype)
26641 
      else:
26642 
        iprot.skip(ftype)
26643 
      iprot.readFieldEnd()
26644 
    iprot.readStructEnd()
26645 
 
26646 
  def write(self, oprot):
26647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26649 
      return
26650 
    oprot.writeStructBegin('getSnapdealSearchResultCount_args')
26651 
    if self.searchTerm is not None:
26652 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
26653 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
18719 kshitij.so 26654 
      for iter581 in self.searchTerm:
26655 
        oprot.writeString(iter581)
9242 kshitij.so 26656 
      oprot.writeListEnd()
26657 
      oprot.writeFieldEnd()
26658 
    oprot.writeFieldStop()
26659 
    oprot.writeStructEnd()
26660 
 
26661 
  def validate(self):
26662 
    return
26663 
 
26664 
 
26665 
  def __repr__(self):
26666 
    L = ['%s=%r' % (key, value)
26667 
      for key, value in self.__dict__.iteritems()]
26668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26669 
 
26670 
  def __eq__(self, other):
26671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26672 
 
26673 
  def __ne__(self, other):
26674 
    return not (self == other)
26675 
 
26676 
class getSnapdealSearchResultCount_result:
26677 
  """
26678 
  Attributes:
26679 
   - success
26680 
  """
26681 
 
26682 
  thrift_spec = (
26683 
    (0, TType.I64, 'success', None, None, ), # 0
26684 
  )
26685 
 
26686 
  def __init__(self, success=None,):
26687 
    self.success = success
26688 
 
26689 
  def read(self, iprot):
26690 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26691 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26692 
      return
26693 
    iprot.readStructBegin()
26694 
    while True:
26695 
      (fname, ftype, fid) = iprot.readFieldBegin()
26696 
      if ftype == TType.STOP:
26697 
        break
26698 
      if fid == 0:
26699 
        if ftype == TType.I64:
26700 
          self.success = iprot.readI64();
26701 
        else:
26702 
          iprot.skip(ftype)
26703 
      else:
26704 
        iprot.skip(ftype)
26705 
      iprot.readFieldEnd()
26706 
    iprot.readStructEnd()
26707 
 
26708 
  def write(self, oprot):
26709 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26710 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26711 
      return
26712 
    oprot.writeStructBegin('getSnapdealSearchResultCount_result')
26713 
    if self.success is not None:
26714 
      oprot.writeFieldBegin('success', TType.I64, 0)
26715 
      oprot.writeI64(self.success)
26716 
      oprot.writeFieldEnd()
26717 
    oprot.writeFieldStop()
26718 
    oprot.writeStructEnd()
26719 
 
26720 
  def validate(self):
26721 
    return
26722 
 
26723 
 
26724 
  def __repr__(self):
26725 
    L = ['%s=%r' % (key, value)
26726 
      for key, value in self.__dict__.iteritems()]
26727 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26728 
 
26729 
  def __eq__(self, other):
26730 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26731 
 
26732 
  def __ne__(self, other):
26733 
    return not (self == other)
9299 kshitij.so 26734 
 
26735 
class getPrefferedInsurerForItem_args:
26736 
  """
26737 
  Attributes:
26738 
   - itemId
26739 
   - insurerType
26740 
  """
26741 
 
26742 
  thrift_spec = (
26743 
    None, # 0
26744 
    (1, TType.I64, 'itemId', None, None, ), # 1
26745 
    (2, TType.I32, 'insurerType', None, None, ), # 2
26746 
  )
26747 
 
26748 
  def __init__(self, itemId=None, insurerType=None,):
26749 
    self.itemId = itemId
26750 
    self.insurerType = insurerType
26751 
 
26752 
  def read(self, iprot):
26753 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26754 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26755 
      return
26756 
    iprot.readStructBegin()
26757 
    while True:
26758 
      (fname, ftype, fid) = iprot.readFieldBegin()
26759 
      if ftype == TType.STOP:
26760 
        break
26761 
      if fid == 1:
26762 
        if ftype == TType.I64:
26763 
          self.itemId = iprot.readI64();
26764 
        else:
26765 
          iprot.skip(ftype)
26766 
      elif fid == 2:
26767 
        if ftype == TType.I32:
26768 
          self.insurerType = iprot.readI32();
26769 
        else:
26770 
          iprot.skip(ftype)
26771 
      else:
26772 
        iprot.skip(ftype)
26773 
      iprot.readFieldEnd()
26774 
    iprot.readStructEnd()
26775 
 
26776 
  def write(self, oprot):
26777 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26778 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26779 
      return
26780 
    oprot.writeStructBegin('getPrefferedInsurerForItem_args')
26781 
    if self.itemId is not None:
26782 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
26783 
      oprot.writeI64(self.itemId)
26784 
      oprot.writeFieldEnd()
26785 
    if self.insurerType is not None:
26786 
      oprot.writeFieldBegin('insurerType', TType.I32, 2)
26787 
      oprot.writeI32(self.insurerType)
26788 
      oprot.writeFieldEnd()
26789 
    oprot.writeFieldStop()
26790 
    oprot.writeStructEnd()
26791 
 
26792 
  def validate(self):
26793 
    return
26794 
 
26795 
 
26796 
  def __repr__(self):
26797 
    L = ['%s=%r' % (key, value)
26798 
      for key, value in self.__dict__.iteritems()]
26799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26800 
 
26801 
  def __eq__(self, other):
26802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26803 
 
26804 
  def __ne__(self, other):
26805 
    return not (self == other)
26806 
 
26807 
class getPrefferedInsurerForItem_result:
26808 
  """
26809 
  Attributes:
26810 
   - success
26811 
  """
26812 
 
26813 
  thrift_spec = (
26814 
    (0, TType.I64, 'success', None, None, ), # 0
26815 
  )
26816 
 
26817 
  def __init__(self, success=None,):
26818 
    self.success = success
26819 
 
26820 
  def read(self, iprot):
26821 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26822 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26823 
      return
26824 
    iprot.readStructBegin()
26825 
    while True:
26826 
      (fname, ftype, fid) = iprot.readFieldBegin()
26827 
      if ftype == TType.STOP:
26828 
        break
26829 
      if fid == 0:
26830 
        if ftype == TType.I64:
26831 
          self.success = iprot.readI64();
26832 
        else:
26833 
          iprot.skip(ftype)
26834 
      else:
26835 
        iprot.skip(ftype)
26836 
      iprot.readFieldEnd()
26837 
    iprot.readStructEnd()
26838 
 
26839 
  def write(self, oprot):
26840 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26841 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26842 
      return
26843 
    oprot.writeStructBegin('getPrefferedInsurerForItem_result')
26844 
    if self.success is not None:
26845 
      oprot.writeFieldBegin('success', TType.I64, 0)
26846 
      oprot.writeI64(self.success)
26847 
      oprot.writeFieldEnd()
26848 
    oprot.writeFieldStop()
26849 
    oprot.writeStructEnd()
26850 
 
26851 
  def validate(self):
26852 
    return
26853 
 
26854 
 
26855 
  def __repr__(self):
26856 
    L = ['%s=%r' % (key, value)
26857 
      for key, value in self.__dict__.iteritems()]
26858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26859 
 
26860 
  def __eq__(self, other):
26861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26862 
 
26863 
  def __ne__(self, other):
26864 
    return not (self == other)
9456 vikram.rag 26865 
 
26866 
class getSnapdealItembySkuAtSnapdeal_args:
26867 
  """
26868 
  Attributes:
26869 
   - skuAtSnapdeal
26870 
  """
26871 
 
26872 
  thrift_spec = None
26873 
  def __init__(self, skuAtSnapdeal=None,):
26874 
    self.skuAtSnapdeal = skuAtSnapdeal
26875 
 
26876 
  def read(self, iprot):
26877 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26878 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26879 
      return
26880 
    iprot.readStructBegin()
26881 
    while True:
26882 
      (fname, ftype, fid) = iprot.readFieldBegin()
26883 
      if ftype == TType.STOP:
26884 
        break
26885 
      if fid == -1:
26886 
        if ftype == TType.STRING:
26887 
          self.skuAtSnapdeal = iprot.readString();
26888 
        else:
26889 
          iprot.skip(ftype)
26890 
      else:
26891 
        iprot.skip(ftype)
26892 
      iprot.readFieldEnd()
26893 
    iprot.readStructEnd()
26894 
 
26895 
  def write(self, oprot):
26896 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26897 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26898 
      return
26899 
    oprot.writeStructBegin('getSnapdealItembySkuAtSnapdeal_args')
26900 
    if self.skuAtSnapdeal is not None:
26901 
      oprot.writeFieldBegin('skuAtSnapdeal', TType.STRING, -1)
26902 
      oprot.writeString(self.skuAtSnapdeal)
26903 
      oprot.writeFieldEnd()
26904 
    oprot.writeFieldStop()
26905 
    oprot.writeStructEnd()
26906 
 
26907 
  def validate(self):
26908 
    return
26909 
 
26910 
 
26911 
  def __repr__(self):
26912 
    L = ['%s=%r' % (key, value)
26913 
      for key, value in self.__dict__.iteritems()]
26914 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26915 
 
26916 
  def __eq__(self, other):
26917 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26918 
 
26919 
  def __ne__(self, other):
26920 
    return not (self == other)
26921 
 
26922 
class getSnapdealItembySkuAtSnapdeal_result:
26923 
  """
26924 
  Attributes:
26925 
   - success
26926 
  """
26927 
 
26928 
  thrift_spec = (
26929 
    (0, TType.STRUCT, 'success', (SnapdealItem, SnapdealItem.thrift_spec), None, ), # 0
26930 
  )
26931 
 
26932 
  def __init__(self, success=None,):
26933 
    self.success = success
26934 
 
26935 
  def read(self, iprot):
26936 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26937 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26938 
      return
26939 
    iprot.readStructBegin()
26940 
    while True:
26941 
      (fname, ftype, fid) = iprot.readFieldBegin()
26942 
      if ftype == TType.STOP:
26943 
        break
26944 
      if fid == 0:
26945 
        if ftype == TType.STRUCT:
26946 
          self.success = SnapdealItem()
26947 
          self.success.read(iprot)
26948 
        else:
26949 
          iprot.skip(ftype)
26950 
      else:
26951 
        iprot.skip(ftype)
26952 
      iprot.readFieldEnd()
26953 
    iprot.readStructEnd()
26954 
 
26955 
  def write(self, oprot):
26956 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26957 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26958 
      return
26959 
    oprot.writeStructBegin('getSnapdealItembySkuAtSnapdeal_result')
26960 
    if self.success is not None:
26961 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26962 
      self.success.write(oprot)
26963 
      oprot.writeFieldEnd()
26964 
    oprot.writeFieldStop()
26965 
    oprot.writeStructEnd()
26966 
 
26967 
  def validate(self):
26968 
    return
26969 
 
26970 
 
26971 
  def __repr__(self):
26972 
    L = ['%s=%r' % (key, value)
26973 
      for key, value in self.__dict__.iteritems()]
26974 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26975 
 
26976 
  def __eq__(self, other):
26977 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26978 
 
26979 
  def __ne__(self, other):
26980 
    return not (self == other)
9621 manish.sha 26981 
 
26982 
class getProductFeedSubmit_args:
26983 
  """
26984 
  Attributes:
26985 
   - catalogItemId
26986 
  """
26987 
 
26988 
  thrift_spec = (
26989 
    None, # 0
26990 
    (1, TType.I64, 'catalogItemId', None, None, ), # 1
26991 
  )
26992 
 
26993 
  def __init__(self, catalogItemId=None,):
26994 
    self.catalogItemId = catalogItemId
26995 
 
26996 
  def read(self, iprot):
26997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26999 
      return
27000 
    iprot.readStructBegin()
27001 
    while True:
27002 
      (fname, ftype, fid) = iprot.readFieldBegin()
27003 
      if ftype == TType.STOP:
27004 
        break
27005 
      if fid == 1:
27006 
        if ftype == TType.I64:
27007 
          self.catalogItemId = iprot.readI64();
27008 
        else:
27009 
          iprot.skip(ftype)
27010 
      else:
27011 
        iprot.skip(ftype)
27012 
      iprot.readFieldEnd()
27013 
    iprot.readStructEnd()
27014 
 
27015 
  def write(self, oprot):
27016 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27017 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27018 
      return
27019 
    oprot.writeStructBegin('getProductFeedSubmit_args')
27020 
    if self.catalogItemId is not None:
27021 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 1)
27022 
      oprot.writeI64(self.catalogItemId)
27023 
      oprot.writeFieldEnd()
27024 
    oprot.writeFieldStop()
27025 
    oprot.writeStructEnd()
27026 
 
27027 
  def validate(self):
27028 
    return
27029 
 
27030 
 
27031 
  def __repr__(self):
27032 
    L = ['%s=%r' % (key, value)
27033 
      for key, value in self.__dict__.iteritems()]
27034 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27035 
 
27036 
  def __eq__(self, other):
27037 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27038 
 
27039 
  def __ne__(self, other):
27040 
    return not (self == other)
27041 
 
27042 
class getProductFeedSubmit_result:
27043 
  """
27044 
  Attributes:
27045 
   - success
27046 
   - cex
27047 
  """
27048 
 
27049 
  thrift_spec = (
27050 
    (0, TType.STRUCT, 'success', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 0
27051 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
27052 
  )
27053 
 
27054 
  def __init__(self, success=None, cex=None,):
27055 
    self.success = success
27056 
    self.cex = cex
27057 
 
27058 
  def read(self, iprot):
27059 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27060 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27061 
      return
27062 
    iprot.readStructBegin()
27063 
    while True:
27064 
      (fname, ftype, fid) = iprot.readFieldBegin()
27065 
      if ftype == TType.STOP:
27066 
        break
27067 
      if fid == 0:
27068 
        if ftype == TType.STRUCT:
27069 
          self.success = ProductFeedSubmit()
27070 
          self.success.read(iprot)
27071 
        else:
27072 
          iprot.skip(ftype)
27073 
      elif fid == 1:
27074 
        if ftype == TType.STRUCT:
27075 
          self.cex = CatalogServiceException()
27076 
          self.cex.read(iprot)
27077 
        else:
27078 
          iprot.skip(ftype)
27079 
      else:
27080 
        iprot.skip(ftype)
27081 
      iprot.readFieldEnd()
27082 
    iprot.readStructEnd()
27083 
 
27084 
  def write(self, oprot):
27085 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27086 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27087 
      return
27088 
    oprot.writeStructBegin('getProductFeedSubmit_result')
27089 
    if self.success is not None:
27090 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27091 
      self.success.write(oprot)
27092 
      oprot.writeFieldEnd()
27093 
    if self.cex is not None:
27094 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
27095 
      self.cex.write(oprot)
27096 
      oprot.writeFieldEnd()
27097 
    oprot.writeFieldStop()
27098 
    oprot.writeStructEnd()
27099 
 
27100 
  def validate(self):
27101 
    return
27102 
 
27103 
 
27104 
  def __repr__(self):
27105 
    L = ['%s=%r' % (key, value)
27106 
      for key, value in self.__dict__.iteritems()]
27107 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27108 
 
27109 
  def __eq__(self, other):
27110 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27111 
 
27112 
  def __ne__(self, other):
27113 
    return not (self == other)
27114 
 
27115 
class addProductFeedSubmit_args:
27116 
  """
27117 
  Attributes:
27118 
   - productFeedSubmit
27119 
  """
27120 
 
27121 
  thrift_spec = (
27122 
    None, # 0
27123 
    (1, TType.STRUCT, 'productFeedSubmit', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 1
27124 
  )
27125 
 
27126 
  def __init__(self, productFeedSubmit=None,):
27127 
    self.productFeedSubmit = productFeedSubmit
27128 
 
27129 
  def read(self, iprot):
27130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27132 
      return
27133 
    iprot.readStructBegin()
27134 
    while True:
27135 
      (fname, ftype, fid) = iprot.readFieldBegin()
27136 
      if ftype == TType.STOP:
27137 
        break
27138 
      if fid == 1:
27139 
        if ftype == TType.STRUCT:
27140 
          self.productFeedSubmit = ProductFeedSubmit()
27141 
          self.productFeedSubmit.read(iprot)
27142 
        else:
27143 
          iprot.skip(ftype)
27144 
      else:
27145 
        iprot.skip(ftype)
27146 
      iprot.readFieldEnd()
27147 
    iprot.readStructEnd()
27148 
 
27149 
  def write(self, oprot):
27150 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27151 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27152 
      return
27153 
    oprot.writeStructBegin('addProductFeedSubmit_args')
27154 
    if self.productFeedSubmit is not None:
27155 
      oprot.writeFieldBegin('productFeedSubmit', TType.STRUCT, 1)
27156 
      self.productFeedSubmit.write(oprot)
27157 
      oprot.writeFieldEnd()
27158 
    oprot.writeFieldStop()
27159 
    oprot.writeStructEnd()
27160 
 
27161 
  def validate(self):
27162 
    return
27163 
 
27164 
 
27165 
  def __repr__(self):
27166 
    L = ['%s=%r' % (key, value)
27167 
      for key, value in self.__dict__.iteritems()]
27168 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27169 
 
27170 
  def __eq__(self, other):
27171 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27172 
 
27173 
  def __ne__(self, other):
27174 
    return not (self == other)
27175 
 
27176 
class addProductFeedSubmit_result:
27177 
  """
27178 
  Attributes:
27179 
   - success
27180 
   - cex
27181 
  """
27182 
 
27183 
  thrift_spec = (
27184 
    (0, TType.BOOL, 'success', None, None, ), # 0
27185 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
27186 
  )
27187 
 
27188 
  def __init__(self, success=None, cex=None,):
27189 
    self.success = success
27190 
    self.cex = cex
27191 
 
27192 
  def read(self, iprot):
27193 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27194 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27195 
      return
27196 
    iprot.readStructBegin()
27197 
    while True:
27198 
      (fname, ftype, fid) = iprot.readFieldBegin()
27199 
      if ftype == TType.STOP:
27200 
        break
27201 
      if fid == 0:
27202 
        if ftype == TType.BOOL:
27203 
          self.success = iprot.readBool();
27204 
        else:
27205 
          iprot.skip(ftype)
27206 
      elif fid == 1:
27207 
        if ftype == TType.STRUCT:
27208 
          self.cex = CatalogServiceException()
27209 
          self.cex.read(iprot)
27210 
        else:
27211 
          iprot.skip(ftype)
27212 
      else:
27213 
        iprot.skip(ftype)
27214 
      iprot.readFieldEnd()
27215 
    iprot.readStructEnd()
27216 
 
27217 
  def write(self, oprot):
27218 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27219 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27220 
      return
27221 
    oprot.writeStructBegin('addProductFeedSubmit_result')
27222 
    if self.success is not None:
27223 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27224 
      oprot.writeBool(self.success)
27225 
      oprot.writeFieldEnd()
27226 
    if self.cex is not None:
27227 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
27228 
      self.cex.write(oprot)
27229 
      oprot.writeFieldEnd()
27230 
    oprot.writeFieldStop()
27231 
    oprot.writeStructEnd()
27232 
 
27233 
  def validate(self):
27234 
    return
27235 
 
27236 
 
27237 
  def __repr__(self):
27238 
    L = ['%s=%r' % (key, value)
27239 
      for key, value in self.__dict__.iteritems()]
27240 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27241 
 
27242 
  def __eq__(self, other):
27243 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27244 
 
27245 
  def __ne__(self, other):
27246 
    return not (self == other)
27247 
 
27248 
class updateProductFeedSubmit_args:
27249 
  """
27250 
  Attributes:
27251 
   - productFeedSubmit
27252 
  """
27253 
 
27254 
  thrift_spec = (
27255 
    None, # 0
27256 
    (1, TType.STRUCT, 'productFeedSubmit', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 1
27257 
  )
27258 
 
27259 
  def __init__(self, productFeedSubmit=None,):
27260 
    self.productFeedSubmit = productFeedSubmit
27261 
 
27262 
  def read(self, iprot):
27263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27265 
      return
27266 
    iprot.readStructBegin()
27267 
    while True:
27268 
      (fname, ftype, fid) = iprot.readFieldBegin()
27269 
      if ftype == TType.STOP:
27270 
        break
27271 
      if fid == 1:
27272 
        if ftype == TType.STRUCT:
27273 
          self.productFeedSubmit = ProductFeedSubmit()
27274 
          self.productFeedSubmit.read(iprot)
27275 
        else:
27276 
          iprot.skip(ftype)
27277 
      else:
27278 
        iprot.skip(ftype)
27279 
      iprot.readFieldEnd()
27280 
    iprot.readStructEnd()
27281 
 
27282 
  def write(self, oprot):
27283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27285 
      return
27286 
    oprot.writeStructBegin('updateProductFeedSubmit_args')
27287 
    if self.productFeedSubmit is not None:
27288 
      oprot.writeFieldBegin('productFeedSubmit', TType.STRUCT, 1)
27289 
      self.productFeedSubmit.write(oprot)
27290 
      oprot.writeFieldEnd()
27291 
    oprot.writeFieldStop()
27292 
    oprot.writeStructEnd()
27293 
 
27294 
  def validate(self):
27295 
    return
27296 
 
27297 
 
27298 
  def __repr__(self):
27299 
    L = ['%s=%r' % (key, value)
27300 
      for key, value in self.__dict__.iteritems()]
27301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27302 
 
27303 
  def __eq__(self, other):
27304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27305 
 
27306 
  def __ne__(self, other):
27307 
    return not (self == other)
27308 
 
27309 
class updateProductFeedSubmit_result:
27310 
  """
27311 
  Attributes:
27312 
   - success
27313 
   - cex
27314 
  """
27315 
 
27316 
  thrift_spec = (
27317 
    (0, TType.BOOL, 'success', None, None, ), # 0
27318 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
27319 
  )
27320 
 
27321 
  def __init__(self, success=None, cex=None,):
27322 
    self.success = success
27323 
    self.cex = cex
27324 
 
27325 
  def read(self, iprot):
27326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27328 
      return
27329 
    iprot.readStructBegin()
27330 
    while True:
27331 
      (fname, ftype, fid) = iprot.readFieldBegin()
27332 
      if ftype == TType.STOP:
27333 
        break
27334 
      if fid == 0:
27335 
        if ftype == TType.BOOL:
27336 
          self.success = iprot.readBool();
27337 
        else:
27338 
          iprot.skip(ftype)
27339 
      elif fid == 1:
27340 
        if ftype == TType.STRUCT:
27341 
          self.cex = CatalogServiceException()
27342 
          self.cex.read(iprot)
27343 
        else:
27344 
          iprot.skip(ftype)
27345 
      else:
27346 
        iprot.skip(ftype)
27347 
      iprot.readFieldEnd()
27348 
    iprot.readStructEnd()
27349 
 
27350 
  def write(self, oprot):
27351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27353 
      return
27354 
    oprot.writeStructBegin('updateProductFeedSubmit_result')
27355 
    if self.success is not None:
27356 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27357 
      oprot.writeBool(self.success)
27358 
      oprot.writeFieldEnd()
27359 
    if self.cex is not None:
27360 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
27361 
      self.cex.write(oprot)
27362 
      oprot.writeFieldEnd()
27363 
    oprot.writeFieldStop()
27364 
    oprot.writeStructEnd()
27365 
 
27366 
  def validate(self):
27367 
    return
27368 
 
27369 
 
27370 
  def __repr__(self):
27371 
    L = ['%s=%r' % (key, value)
27372 
      for key, value in self.__dict__.iteritems()]
27373 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27374 
 
27375 
  def __eq__(self, other):
27376 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27377 
 
27378 
  def __ne__(self, other):
27379 
    return not (self == other)
27380 
 
27381 
class deleteProductFeedSubmit_args:
27382 
  """
27383 
  Attributes:
27384 
   - catalogItemId
27385 
  """
27386 
 
27387 
  thrift_spec = (
27388 
    None, # 0
27389 
    (1, TType.I64, 'catalogItemId', None, None, ), # 1
27390 
  )
27391 
 
27392 
  def __init__(self, catalogItemId=None,):
27393 
    self.catalogItemId = catalogItemId
27394 
 
27395 
  def read(self, iprot):
27396 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27397 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27398 
      return
27399 
    iprot.readStructBegin()
27400 
    while True:
27401 
      (fname, ftype, fid) = iprot.readFieldBegin()
27402 
      if ftype == TType.STOP:
27403 
        break
27404 
      if fid == 1:
27405 
        if ftype == TType.I64:
27406 
          self.catalogItemId = iprot.readI64();
27407 
        else:
27408 
          iprot.skip(ftype)
27409 
      else:
27410 
        iprot.skip(ftype)
27411 
      iprot.readFieldEnd()
27412 
    iprot.readStructEnd()
27413 
 
27414 
  def write(self, oprot):
27415 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27416 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27417 
      return
27418 
    oprot.writeStructBegin('deleteProductFeedSubmit_args')
27419 
    if self.catalogItemId is not None:
27420 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 1)
27421 
      oprot.writeI64(self.catalogItemId)
27422 
      oprot.writeFieldEnd()
27423 
    oprot.writeFieldStop()
27424 
    oprot.writeStructEnd()
27425 
 
27426 
  def validate(self):
27427 
    return
27428 
 
27429 
 
27430 
  def __repr__(self):
27431 
    L = ['%s=%r' % (key, value)
27432 
      for key, value in self.__dict__.iteritems()]
27433 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27434 
 
27435 
  def __eq__(self, other):
27436 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27437 
 
27438 
  def __ne__(self, other):
27439 
    return not (self == other)
27440 
 
27441 
class deleteProductFeedSubmit_result:
27442 
  """
27443 
  Attributes:
27444 
   - success
27445 
   - cex
27446 
  """
27447 
 
27448 
  thrift_spec = (
27449 
    (0, TType.BOOL, 'success', None, None, ), # 0
27450 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
27451 
  )
27452 
 
27453 
  def __init__(self, success=None, cex=None,):
27454 
    self.success = success
27455 
    self.cex = cex
27456 
 
27457 
  def read(self, iprot):
27458 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27459 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27460 
      return
27461 
    iprot.readStructBegin()
27462 
    while True:
27463 
      (fname, ftype, fid) = iprot.readFieldBegin()
27464 
      if ftype == TType.STOP:
27465 
        break
27466 
      if fid == 0:
27467 
        if ftype == TType.BOOL:
27468 
          self.success = iprot.readBool();
27469 
        else:
27470 
          iprot.skip(ftype)
27471 
      elif fid == 1:
27472 
        if ftype == TType.STRUCT:
27473 
          self.cex = CatalogServiceException()
27474 
          self.cex.read(iprot)
27475 
        else:
27476 
          iprot.skip(ftype)
27477 
      else:
27478 
        iprot.skip(ftype)
27479 
      iprot.readFieldEnd()
27480 
    iprot.readStructEnd()
27481 
 
27482 
  def write(self, oprot):
27483 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27484 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27485 
      return
27486 
    oprot.writeStructBegin('deleteProductFeedSubmit_result')
27487 
    if self.success is not None:
27488 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27489 
      oprot.writeBool(self.success)
27490 
      oprot.writeFieldEnd()
27491 
    if self.cex is not None:
27492 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
27493 
      self.cex.write(oprot)
27494 
      oprot.writeFieldEnd()
27495 
    oprot.writeFieldStop()
27496 
    oprot.writeStructEnd()
27497 
 
27498 
  def validate(self):
27499 
    return
27500 
 
27501 
 
27502 
  def __repr__(self):
27503 
    L = ['%s=%r' % (key, value)
27504 
      for key, value in self.__dict__.iteritems()]
27505 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27506 
 
27507 
  def __eq__(self, other):
27508 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27509 
 
27510 
  def __ne__(self, other):
27511 
    return not (self == other)
27512 
 
27513 
class getAllProductFeedSubmit_args:
27514 
 
27515 
  thrift_spec = (
27516 
  )
27517 
 
27518 
  def read(self, iprot):
27519 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27520 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27521 
      return
27522 
    iprot.readStructBegin()
27523 
    while True:
27524 
      (fname, ftype, fid) = iprot.readFieldBegin()
27525 
      if ftype == TType.STOP:
27526 
        break
27527 
      else:
27528 
        iprot.skip(ftype)
27529 
      iprot.readFieldEnd()
27530 
    iprot.readStructEnd()
27531 
 
27532 
  def write(self, oprot):
27533 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27534 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27535 
      return
27536 
    oprot.writeStructBegin('getAllProductFeedSubmit_args')
27537 
    oprot.writeFieldStop()
27538 
    oprot.writeStructEnd()
27539 
 
27540 
  def validate(self):
27541 
    return
27542 
 
27543 
 
27544 
  def __repr__(self):
27545 
    L = ['%s=%r' % (key, value)
27546 
      for key, value in self.__dict__.iteritems()]
27547 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27548 
 
27549 
  def __eq__(self, other):
27550 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27551 
 
27552 
  def __ne__(self, other):
27553 
    return not (self == other)
27554 
 
27555 
class getAllProductFeedSubmit_result:
27556 
  """
27557 
  Attributes:
27558 
   - success
27559 
   - cex
27560 
  """
27561 
 
27562 
  thrift_spec = (
27563 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductFeedSubmit, ProductFeedSubmit.thrift_spec)), None, ), # 0
27564 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
27565 
  )
27566 
 
27567 
  def __init__(self, success=None, cex=None,):
27568 
    self.success = success
27569 
    self.cex = cex
27570 
 
27571 
  def read(self, iprot):
27572 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27573 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27574 
      return
27575 
    iprot.readStructBegin()
27576 
    while True:
27577 
      (fname, ftype, fid) = iprot.readFieldBegin()
27578 
      if ftype == TType.STOP:
27579 
        break
27580 
      if fid == 0:
27581 
        if ftype == TType.LIST:
27582 
          self.success = []
18719 kshitij.so 27583 
          (_etype585, _size582) = iprot.readListBegin()
27584 
          for _i586 in xrange(_size582):
27585 
            _elem587 = ProductFeedSubmit()
27586 
            _elem587.read(iprot)
27587 
            self.success.append(_elem587)
9621 manish.sha 27588 
          iprot.readListEnd()
27589 
        else:
27590 
          iprot.skip(ftype)
27591 
      elif fid == 1:
27592 
        if ftype == TType.STRUCT:
27593 
          self.cex = CatalogServiceException()
27594 
          self.cex.read(iprot)
27595 
        else:
27596 
          iprot.skip(ftype)
27597 
      else:
27598 
        iprot.skip(ftype)
27599 
      iprot.readFieldEnd()
27600 
    iprot.readStructEnd()
27601 
 
27602 
  def write(self, oprot):
27603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27605 
      return
27606 
    oprot.writeStructBegin('getAllProductFeedSubmit_result')
27607 
    if self.success is not None:
27608 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27609 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 27610 
      for iter588 in self.success:
27611 
        iter588.write(oprot)
9621 manish.sha 27612 
      oprot.writeListEnd()
27613 
      oprot.writeFieldEnd()
27614 
    if self.cex is not None:
27615 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
27616 
      self.cex.write(oprot)
27617 
      oprot.writeFieldEnd()
27618 
    oprot.writeFieldStop()
27619 
    oprot.writeStructEnd()
27620 
 
27621 
  def validate(self):
27622 
    return
27623 
 
27624 
 
27625 
  def __repr__(self):
27626 
    L = ['%s=%r' % (key, value)
27627 
      for key, value in self.__dict__.iteritems()]
27628 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27629 
 
27630 
  def __eq__(self, other):
27631 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27632 
 
27633 
  def __ne__(self, other):
27634 
    return not (self == other)
9724 kshitij.so 27635 
 
27636 
class getMarketplacedetailsForItem_args:
27637 
  """
27638 
  Attributes:
27639 
   - itemId
27640 
   - sourceId
27641 
  """
27642 
 
27643 
  thrift_spec = (
27644 
    None, # 0
27645 
    (1, TType.I64, 'itemId', None, None, ), # 1
27646 
    (2, TType.I64, 'sourceId', None, None, ), # 2
27647 
  )
27648 
 
27649 
  def __init__(self, itemId=None, sourceId=None,):
27650 
    self.itemId = itemId
27651 
    self.sourceId = sourceId
27652 
 
27653 
  def read(self, iprot):
27654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27656 
      return
27657 
    iprot.readStructBegin()
27658 
    while True:
27659 
      (fname, ftype, fid) = iprot.readFieldBegin()
27660 
      if ftype == TType.STOP:
27661 
        break
27662 
      if fid == 1:
27663 
        if ftype == TType.I64:
27664 
          self.itemId = iprot.readI64();
27665 
        else:
27666 
          iprot.skip(ftype)
27667 
      elif fid == 2:
27668 
        if ftype == TType.I64:
27669 
          self.sourceId = iprot.readI64();
27670 
        else:
27671 
          iprot.skip(ftype)
27672 
      else:
27673 
        iprot.skip(ftype)
27674 
      iprot.readFieldEnd()
27675 
    iprot.readStructEnd()
27676 
 
27677 
  def write(self, oprot):
27678 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27679 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27680 
      return
27681 
    oprot.writeStructBegin('getMarketplacedetailsForItem_args')
27682 
    if self.itemId is not None:
27683 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
27684 
      oprot.writeI64(self.itemId)
27685 
      oprot.writeFieldEnd()
27686 
    if self.sourceId is not None:
27687 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
27688 
      oprot.writeI64(self.sourceId)
27689 
      oprot.writeFieldEnd()
27690 
    oprot.writeFieldStop()
27691 
    oprot.writeStructEnd()
27692 
 
27693 
  def validate(self):
27694 
    return
27695 
 
27696 
 
27697 
  def __repr__(self):
27698 
    L = ['%s=%r' % (key, value)
27699 
      for key, value in self.__dict__.iteritems()]
27700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27701 
 
27702 
  def __eq__(self, other):
27703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27704 
 
27705 
  def __ne__(self, other):
27706 
    return not (self == other)
27707 
 
27708 
class getMarketplacedetailsForItem_result:
27709 
  """
27710 
  Attributes:
27711 
   - success
27712 
  """
27713 
 
27714 
  thrift_spec = (
27715 
    (0, TType.STRUCT, 'success', (MarketplaceItems, MarketplaceItems.thrift_spec), None, ), # 0
27716 
  )
27717 
 
27718 
  def __init__(self, success=None,):
27719 
    self.success = success
27720 
 
27721 
  def read(self, iprot):
27722 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27723 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27724 
      return
27725 
    iprot.readStructBegin()
27726 
    while True:
27727 
      (fname, ftype, fid) = iprot.readFieldBegin()
27728 
      if ftype == TType.STOP:
27729 
        break
27730 
      if fid == 0:
27731 
        if ftype == TType.STRUCT:
27732 
          self.success = MarketplaceItems()
27733 
          self.success.read(iprot)
27734 
        else:
27735 
          iprot.skip(ftype)
27736 
      else:
27737 
        iprot.skip(ftype)
27738 
      iprot.readFieldEnd()
27739 
    iprot.readStructEnd()
27740 
 
27741 
  def write(self, oprot):
27742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27744 
      return
27745 
    oprot.writeStructBegin('getMarketplacedetailsForItem_result')
27746 
    if self.success is not None:
27747 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27748 
      self.success.write(oprot)
27749 
      oprot.writeFieldEnd()
27750 
    oprot.writeFieldStop()
27751 
    oprot.writeStructEnd()
27752 
 
27753 
  def validate(self):
27754 
    return
27755 
 
27756 
 
27757 
  def __repr__(self):
27758 
    L = ['%s=%r' % (key, value)
27759 
      for key, value in self.__dict__.iteritems()]
27760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27761 
 
27762 
  def __eq__(self, other):
27763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27764 
 
27765 
  def __ne__(self, other):
27766 
    return not (self == other)
27767 
 
27768 
class updateMarketplaceAttributesForItem_args:
27769 
  """
27770 
  Attributes:
27771 
   - marketPlaceItem
27772 
  """
27773 
 
27774 
  thrift_spec = (
27775 
    None, # 0
27776 
    (1, TType.STRUCT, 'marketPlaceItem', (MarketplaceItems, MarketplaceItems.thrift_spec), None, ), # 1
27777 
  )
27778 
 
27779 
  def __init__(self, marketPlaceItem=None,):
27780 
    self.marketPlaceItem = marketPlaceItem
27781 
 
27782 
  def read(self, iprot):
27783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27785 
      return
27786 
    iprot.readStructBegin()
27787 
    while True:
27788 
      (fname, ftype, fid) = iprot.readFieldBegin()
27789 
      if ftype == TType.STOP:
27790 
        break
27791 
      if fid == 1:
27792 
        if ftype == TType.STRUCT:
27793 
          self.marketPlaceItem = MarketplaceItems()
27794 
          self.marketPlaceItem.read(iprot)
27795 
        else:
27796 
          iprot.skip(ftype)
27797 
      else:
27798 
        iprot.skip(ftype)
27799 
      iprot.readFieldEnd()
27800 
    iprot.readStructEnd()
27801 
 
27802 
  def write(self, oprot):
27803 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27804 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27805 
      return
27806 
    oprot.writeStructBegin('updateMarketplaceAttributesForItem_args')
27807 
    if self.marketPlaceItem is not None:
27808 
      oprot.writeFieldBegin('marketPlaceItem', TType.STRUCT, 1)
27809 
      self.marketPlaceItem.write(oprot)
27810 
      oprot.writeFieldEnd()
27811 
    oprot.writeFieldStop()
27812 
    oprot.writeStructEnd()
27813 
 
27814 
  def validate(self):
27815 
    return
27816 
 
27817 
 
27818 
  def __repr__(self):
27819 
    L = ['%s=%r' % (key, value)
27820 
      for key, value in self.__dict__.iteritems()]
27821 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27822 
 
27823 
  def __eq__(self, other):
27824 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27825 
 
27826 
  def __ne__(self, other):
27827 
    return not (self == other)
27828 
 
27829 
class updateMarketplaceAttributesForItem_result:
27830 
  """
27831 
  Attributes:
27832 
   - success
27833 
  """
27834 
 
27835 
  thrift_spec = (
27836 
    (0, TType.BOOL, 'success', None, None, ), # 0
27837 
  )
27838 
 
27839 
  def __init__(self, success=None,):
27840 
    self.success = success
27841 
 
27842 
  def read(self, iprot):
27843 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27844 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27845 
      return
27846 
    iprot.readStructBegin()
27847 
    while True:
27848 
      (fname, ftype, fid) = iprot.readFieldBegin()
27849 
      if ftype == TType.STOP:
27850 
        break
27851 
      if fid == 0:
27852 
        if ftype == TType.BOOL:
27853 
          self.success = iprot.readBool();
27854 
        else:
27855 
          iprot.skip(ftype)
27856 
      else:
27857 
        iprot.skip(ftype)
27858 
      iprot.readFieldEnd()
27859 
    iprot.readStructEnd()
27860 
 
27861 
  def write(self, oprot):
27862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27864 
      return
27865 
    oprot.writeStructBegin('updateMarketplaceAttributesForItem_result')
27866 
    if self.success is not None:
27867 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27868 
      oprot.writeBool(self.success)
27869 
      oprot.writeFieldEnd()
27870 
    oprot.writeFieldStop()
27871 
    oprot.writeStructEnd()
27872 
 
27873 
  def validate(self):
27874 
    return
27875 
 
27876 
 
27877 
  def __repr__(self):
27878 
    L = ['%s=%r' % (key, value)
27879 
      for key, value in self.__dict__.iteritems()]
27880 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27881 
 
27882 
  def __eq__(self, other):
27883 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27884 
 
27885 
  def __ne__(self, other):
27886 
    return not (self == other)
9776 vikram.rag 27887 
 
9779 kshitij.so 27888 
class getCostingForMarketplace_args:
27889 
  """
27890 
  Attributes:
27891 
   - source
27892 
   - item_id
27893 
  """
27894 
 
27895 
  thrift_spec = (
27896 
    None, # 0
27897 
    (1, TType.I64, 'source', None, None, ), # 1
27898 
    (2, TType.I64, 'item_id', None, None, ), # 2
27899 
  )
27900 
 
27901 
  def __init__(self, source=None, item_id=None,):
27902 
    self.source = source
27903 
    self.item_id = item_id
27904 
 
27905 
  def read(self, iprot):
27906 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27907 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27908 
      return
27909 
    iprot.readStructBegin()
27910 
    while True:
27911 
      (fname, ftype, fid) = iprot.readFieldBegin()
27912 
      if ftype == TType.STOP:
27913 
        break
27914 
      if fid == 1:
27915 
        if ftype == TType.I64:
27916 
          self.source = iprot.readI64();
27917 
        else:
27918 
          iprot.skip(ftype)
27919 
      elif fid == 2:
27920 
        if ftype == TType.I64:
27921 
          self.item_id = iprot.readI64();
27922 
        else:
27923 
          iprot.skip(ftype)
27924 
      else:
27925 
        iprot.skip(ftype)
27926 
      iprot.readFieldEnd()
27927 
    iprot.readStructEnd()
27928 
 
27929 
  def write(self, oprot):
27930 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27931 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27932 
      return
27933 
    oprot.writeStructBegin('getCostingForMarketplace_args')
27934 
    if self.source is not None:
27935 
      oprot.writeFieldBegin('source', TType.I64, 1)
27936 
      oprot.writeI64(self.source)
27937 
      oprot.writeFieldEnd()
27938 
    if self.item_id is not None:
27939 
      oprot.writeFieldBegin('item_id', TType.I64, 2)
27940 
      oprot.writeI64(self.item_id)
27941 
      oprot.writeFieldEnd()
27942 
    oprot.writeFieldStop()
27943 
    oprot.writeStructEnd()
27944 
 
27945 
  def validate(self):
27946 
    return
27947 
 
27948 
 
27949 
  def __repr__(self):
27950 
    L = ['%s=%r' % (key, value)
27951 
      for key, value in self.__dict__.iteritems()]
27952 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27953 
 
27954 
  def __eq__(self, other):
27955 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27956 
 
27957 
  def __ne__(self, other):
27958 
    return not (self == other)
27959 
 
27960 
class getCostingForMarketplace_result:
27961 
  """
27962 
  Attributes:
27963 
   - success
27964 
  """
27965 
 
27966 
  thrift_spec = (
27967 
    (0, TType.STRUCT, 'success', (MarketplacePercentage, MarketplacePercentage.thrift_spec), None, ), # 0
27968 
  )
27969 
 
27970 
  def __init__(self, success=None,):
27971 
    self.success = success
27972 
 
27973 
  def read(self, iprot):
27974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27976 
      return
27977 
    iprot.readStructBegin()
27978 
    while True:
27979 
      (fname, ftype, fid) = iprot.readFieldBegin()
27980 
      if ftype == TType.STOP:
27981 
        break
27982 
      if fid == 0:
27983 
        if ftype == TType.STRUCT:
27984 
          self.success = MarketplacePercentage()
27985 
          self.success.read(iprot)
27986 
        else:
27987 
          iprot.skip(ftype)
27988 
      else:
27989 
        iprot.skip(ftype)
27990 
      iprot.readFieldEnd()
27991 
    iprot.readStructEnd()
27992 
 
27993 
  def write(self, oprot):
27994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27996 
      return
27997 
    oprot.writeStructBegin('getCostingForMarketplace_result')
27998 
    if self.success is not None:
27999 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28000 
      self.success.write(oprot)
28001 
      oprot.writeFieldEnd()
28002 
    oprot.writeFieldStop()
28003 
    oprot.writeStructEnd()
28004 
 
28005 
  def validate(self):
28006 
    return
28007 
 
28008 
 
28009 
  def __repr__(self):
28010 
    L = ['%s=%r' % (key, value)
28011 
      for key, value in self.__dict__.iteritems()]
28012 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28013 
 
28014 
  def __eq__(self, other):
28015 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28016 
 
28017 
  def __ne__(self, other):
28018 
    return not (self == other)
28019 
 
9776 vikram.rag 28020 
class getMarketPlaceItemsForPriceUpdate_args:
28021 
  """
28022 
  Attributes:
28023 
   - source
28024 
  """
28025 
 
28026 
  thrift_spec = (
28027 
    None, # 0
28028 
    (1, TType.I64, 'source', None, None, ), # 1
28029 
  )
28030 
 
28031 
  def __init__(self, source=None,):
28032 
    self.source = source
28033 
 
28034 
  def read(self, iprot):
28035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28037 
      return
28038 
    iprot.readStructBegin()
28039 
    while True:
28040 
      (fname, ftype, fid) = iprot.readFieldBegin()
28041 
      if ftype == TType.STOP:
28042 
        break
28043 
      if fid == 1:
28044 
        if ftype == TType.I64:
28045 
          self.source = iprot.readI64();
28046 
        else:
28047 
          iprot.skip(ftype)
28048 
      else:
28049 
        iprot.skip(ftype)
28050 
      iprot.readFieldEnd()
28051 
    iprot.readStructEnd()
28052 
 
28053 
  def write(self, oprot):
28054 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28055 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28056 
      return
28057 
    oprot.writeStructBegin('getMarketPlaceItemsForPriceUpdate_args')
28058 
    if self.source is not None:
28059 
      oprot.writeFieldBegin('source', TType.I64, 1)
28060 
      oprot.writeI64(self.source)
28061 
      oprot.writeFieldEnd()
28062 
    oprot.writeFieldStop()
28063 
    oprot.writeStructEnd()
28064 
 
28065 
  def validate(self):
28066 
    return
28067 
 
28068 
 
28069 
  def __repr__(self):
28070 
    L = ['%s=%r' % (key, value)
28071 
      for key, value in self.__dict__.iteritems()]
28072 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28073 
 
28074 
  def __eq__(self, other):
28075 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28076 
 
28077 
  def __ne__(self, other):
28078 
    return not (self == other)
28079 
 
28080 
class getMarketPlaceItemsForPriceUpdate_result:
28081 
  """
28082 
  Attributes:
28083 
   - success
28084 
  """
28085 
 
28086 
  thrift_spec = (
28087 
    (0, TType.LIST, 'success', (TType.STRUCT,(MarketPlaceItemPrice, MarketPlaceItemPrice.thrift_spec)), None, ), # 0
28088 
  )
28089 
 
28090 
  def __init__(self, success=None,):
28091 
    self.success = success
28092 
 
28093 
  def read(self, iprot):
28094 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28095 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28096 
      return
28097 
    iprot.readStructBegin()
28098 
    while True:
28099 
      (fname, ftype, fid) = iprot.readFieldBegin()
28100 
      if ftype == TType.STOP:
28101 
        break
28102 
      if fid == 0:
28103 
        if ftype == TType.LIST:
28104 
          self.success = []
18719 kshitij.so 28105 
          (_etype592, _size589) = iprot.readListBegin()
28106 
          for _i593 in xrange(_size589):
28107 
            _elem594 = MarketPlaceItemPrice()
28108 
            _elem594.read(iprot)
28109 
            self.success.append(_elem594)
9776 vikram.rag 28110 
          iprot.readListEnd()
28111 
        else:
28112 
          iprot.skip(ftype)
28113 
      else:
28114 
        iprot.skip(ftype)
28115 
      iprot.readFieldEnd()
28116 
    iprot.readStructEnd()
28117 
 
28118 
  def write(self, oprot):
28119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28121 
      return
28122 
    oprot.writeStructBegin('getMarketPlaceItemsForPriceUpdate_result')
28123 
    if self.success is not None:
28124 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28125 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 28126 
      for iter595 in self.success:
28127 
        iter595.write(oprot)
9776 vikram.rag 28128 
      oprot.writeListEnd()
28129 
      oprot.writeFieldEnd()
28130 
    oprot.writeFieldStop()
28131 
    oprot.writeStructEnd()
28132 
 
28133 
  def validate(self):
28134 
    return
28135 
 
28136 
 
28137 
  def __repr__(self):
28138 
    L = ['%s=%r' % (key, value)
28139 
      for key, value in self.__dict__.iteritems()]
28140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28141 
 
28142 
  def __eq__(self, other):
28143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28144 
 
28145 
  def __ne__(self, other):
28146 
    return not (self == other)
28147 
 
28148 
class updateMarketPlacePriceUpdateStatus_args:
28149 
  """
28150 
  Attributes:
28151 
   - skulist
28152 
   - timestamp
9816 kshitij.so 28153 
   - source
9776 vikram.rag 28154 
  """
28155 
 
28156 
  thrift_spec = (
28157 
    None, # 0
28158 
    (1, TType.LIST, 'skulist', (TType.I64,None), None, ), # 1
28159 
    (2, TType.I64, 'timestamp', None, None, ), # 2
9816 kshitij.so 28160 
    (3, TType.I64, 'source', None, None, ), # 3
9776 vikram.rag 28161 
  )
28162 
 
9816 kshitij.so 28163 
  def __init__(self, skulist=None, timestamp=None, source=None,):
9776 vikram.rag 28164 
    self.skulist = skulist
28165 
    self.timestamp = timestamp
9816 kshitij.so 28166 
    self.source = source
9776 vikram.rag 28167 
 
28168 
  def read(self, iprot):
28169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28171 
      return
28172 
    iprot.readStructBegin()
28173 
    while True:
28174 
      (fname, ftype, fid) = iprot.readFieldBegin()
28175 
      if ftype == TType.STOP:
28176 
        break
28177 
      if fid == 1:
28178 
        if ftype == TType.LIST:
28179 
          self.skulist = []
18719 kshitij.so 28180 
          (_etype599, _size596) = iprot.readListBegin()
28181 
          for _i600 in xrange(_size596):
28182 
            _elem601 = iprot.readI64();
28183 
            self.skulist.append(_elem601)
9776 vikram.rag 28184 
          iprot.readListEnd()
28185 
        else:
28186 
          iprot.skip(ftype)
28187 
      elif fid == 2:
28188 
        if ftype == TType.I64:
28189 
          self.timestamp = iprot.readI64();
28190 
        else:
28191 
          iprot.skip(ftype)
9816 kshitij.so 28192 
      elif fid == 3:
28193 
        if ftype == TType.I64:
28194 
          self.source = iprot.readI64();
28195 
        else:
28196 
          iprot.skip(ftype)
9776 vikram.rag 28197 
      else:
28198 
        iprot.skip(ftype)
28199 
      iprot.readFieldEnd()
28200 
    iprot.readStructEnd()
28201 
 
28202 
  def write(self, oprot):
28203 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28204 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28205 
      return
28206 
    oprot.writeStructBegin('updateMarketPlacePriceUpdateStatus_args')
28207 
    if self.skulist is not None:
28208 
      oprot.writeFieldBegin('skulist', TType.LIST, 1)
28209 
      oprot.writeListBegin(TType.I64, len(self.skulist))
18719 kshitij.so 28210 
      for iter602 in self.skulist:
28211 
        oprot.writeI64(iter602)
9776 vikram.rag 28212 
      oprot.writeListEnd()
28213 
      oprot.writeFieldEnd()
28214 
    if self.timestamp is not None:
28215 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
28216 
      oprot.writeI64(self.timestamp)
28217 
      oprot.writeFieldEnd()
9816 kshitij.so 28218 
    if self.source is not None:
28219 
      oprot.writeFieldBegin('source', TType.I64, 3)
28220 
      oprot.writeI64(self.source)
28221 
      oprot.writeFieldEnd()
9776 vikram.rag 28222 
    oprot.writeFieldStop()
28223 
    oprot.writeStructEnd()
28224 
 
28225 
  def validate(self):
28226 
    return
28227 
 
28228 
 
28229 
  def __repr__(self):
28230 
    L = ['%s=%r' % (key, value)
28231 
      for key, value in self.__dict__.iteritems()]
28232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28233 
 
28234 
  def __eq__(self, other):
28235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28236 
 
28237 
  def __ne__(self, other):
28238 
    return not (self == other)
28239 
 
28240 
class updateMarketPlacePriceUpdateStatus_result:
28241 
 
28242 
  thrift_spec = (
28243 
  )
28244 
 
28245 
  def read(self, iprot):
28246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28248 
      return
28249 
    iprot.readStructBegin()
28250 
    while True:
28251 
      (fname, ftype, fid) = iprot.readFieldBegin()
28252 
      if ftype == TType.STOP:
28253 
        break
28254 
      else:
28255 
        iprot.skip(ftype)
28256 
      iprot.readFieldEnd()
28257 
    iprot.readStructEnd()
28258 
 
28259 
  def write(self, oprot):
28260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28262 
      return
28263 
    oprot.writeStructBegin('updateMarketPlacePriceUpdateStatus_result')
28264 
    oprot.writeFieldStop()
28265 
    oprot.writeStructEnd()
28266 
 
28267 
  def validate(self):
28268 
    return
28269 
 
28270 
 
28271 
  def __repr__(self):
28272 
    L = ['%s=%r' % (key, value)
28273 
      for key, value in self.__dict__.iteritems()]
28274 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28275 
 
28276 
  def __eq__(self, other):
28277 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28278 
 
28279 
  def __ne__(self, other):
28280 
    return not (self == other)
9861 rajveer 28281 
 
28282 
class updateItemHoldInventory_args:
28283 
  """
28284 
  Attributes:
28285 
   - itemHoldMap
28286 
  """
28287 
 
28288 
  thrift_spec = (
28289 
    None, # 0
28290 
    (1, TType.MAP, 'itemHoldMap', (TType.I64,None,TType.I64,None), None, ), # 1
28291 
  )
28292 
 
28293 
  def __init__(self, itemHoldMap=None,):
28294 
    self.itemHoldMap = itemHoldMap
28295 
 
28296 
  def read(self, iprot):
28297 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28298 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28299 
      return
28300 
    iprot.readStructBegin()
28301 
    while True:
28302 
      (fname, ftype, fid) = iprot.readFieldBegin()
28303 
      if ftype == TType.STOP:
28304 
        break
28305 
      if fid == 1:
28306 
        if ftype == TType.MAP:
28307 
          self.itemHoldMap = {}
18719 kshitij.so 28308 
          (_ktype604, _vtype605, _size603 ) = iprot.readMapBegin()
28309 
          for _i607 in xrange(_size603):
28310 
            _key608 = iprot.readI64();
28311 
            _val609 = iprot.readI64();
28312 
            self.itemHoldMap[_key608] = _val609
9861 rajveer 28313 
          iprot.readMapEnd()
28314 
        else:
28315 
          iprot.skip(ftype)
28316 
      else:
28317 
        iprot.skip(ftype)
28318 
      iprot.readFieldEnd()
28319 
    iprot.readStructEnd()
28320 
 
28321 
  def write(self, oprot):
28322 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28323 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28324 
      return
28325 
    oprot.writeStructBegin('updateItemHoldInventory_args')
28326 
    if self.itemHoldMap is not None:
28327 
      oprot.writeFieldBegin('itemHoldMap', TType.MAP, 1)
28328 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.itemHoldMap))
18719 kshitij.so 28329 
      for kiter610,viter611 in self.itemHoldMap.items():
28330 
        oprot.writeI64(kiter610)
28331 
        oprot.writeI64(viter611)
9861 rajveer 28332 
      oprot.writeMapEnd()
28333 
      oprot.writeFieldEnd()
28334 
    oprot.writeFieldStop()
28335 
    oprot.writeStructEnd()
28336 
 
28337 
  def validate(self):
28338 
    return
28339 
 
28340 
 
28341 
  def __repr__(self):
28342 
    L = ['%s=%r' % (key, value)
28343 
      for key, value in self.__dict__.iteritems()]
28344 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28345 
 
28346 
  def __eq__(self, other):
28347 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28348 
 
28349 
  def __ne__(self, other):
28350 
    return not (self == other)
28351 
 
28352 
class updateItemHoldInventory_result:
28353 
 
28354 
  thrift_spec = (
28355 
  )
28356 
 
28357 
  def read(self, iprot):
28358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28360 
      return
28361 
    iprot.readStructBegin()
28362 
    while True:
28363 
      (fname, ftype, fid) = iprot.readFieldBegin()
28364 
      if ftype == TType.STOP:
28365 
        break
28366 
      else:
28367 
        iprot.skip(ftype)
28368 
      iprot.readFieldEnd()
28369 
    iprot.readStructEnd()
28370 
 
28371 
  def write(self, oprot):
28372 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28373 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28374 
      return
28375 
    oprot.writeStructBegin('updateItemHoldInventory_result')
28376 
    oprot.writeFieldStop()
28377 
    oprot.writeStructEnd()
28378 
 
28379 
  def validate(self):
28380 
    return
28381 
 
28382 
 
28383 
  def __repr__(self):
28384 
    L = ['%s=%r' % (key, value)
28385 
      for key, value in self.__dict__.iteritems()]
28386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28387 
 
28388 
  def __eq__(self, other):
28389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28390 
 
28391 
  def __ne__(self, other):
28392 
    return not (self == other)
9895 vikram.rag 28393 
 
28394 
class updateNlcAtMarketplaces_args:
28395 
  """
28396 
  Attributes:
28397 
   - item_id
28398 
   - vendor_id
28399 
   - nlc
28400 
  """
28401 
 
28402 
  thrift_spec = None
28403 
  def __init__(self, item_id=None, vendor_id=None, nlc=None,):
28404 
    self.item_id = item_id
28405 
    self.vendor_id = vendor_id
28406 
    self.nlc = nlc
28407 
 
28408 
  def read(self, iprot):
28409 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28410 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28411 
      return
28412 
    iprot.readStructBegin()
28413 
    while True:
28414 
      (fname, ftype, fid) = iprot.readFieldBegin()
28415 
      if ftype == TType.STOP:
28416 
        break
28417 
      if fid == 1:
28418 
        if ftype == TType.I64:
28419 
          self.item_id = iprot.readI64();
28420 
        else:
28421 
          iprot.skip(ftype)
28422 
      elif fid == 2:
28423 
        if ftype == TType.I64:
28424 
          self.vendor_id = iprot.readI64();
28425 
        else:
28426 
          iprot.skip(ftype)
28427 
      elif fid == -1:
28428 
        if ftype == TType.DOUBLE:
28429 
          self.nlc = iprot.readDouble();
28430 
        else:
28431 
          iprot.skip(ftype)
28432 
      else:
28433 
        iprot.skip(ftype)
28434 
      iprot.readFieldEnd()
28435 
    iprot.readStructEnd()
28436 
 
28437 
  def write(self, oprot):
28438 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28439 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28440 
      return
28441 
    oprot.writeStructBegin('updateNlcAtMarketplaces_args')
28442 
    if self.nlc is not None:
28443 
      oprot.writeFieldBegin('nlc', TType.DOUBLE, -1)
28444 
      oprot.writeDouble(self.nlc)
28445 
      oprot.writeFieldEnd()
28446 
    if self.item_id is not None:
28447 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
28448 
      oprot.writeI64(self.item_id)
28449 
      oprot.writeFieldEnd()
28450 
    if self.vendor_id is not None:
28451 
      oprot.writeFieldBegin('vendor_id', TType.I64, 2)
28452 
      oprot.writeI64(self.vendor_id)
28453 
      oprot.writeFieldEnd()
28454 
    oprot.writeFieldStop()
28455 
    oprot.writeStructEnd()
28456 
 
28457 
  def validate(self):
28458 
    return
28459 
 
28460 
 
28461 
  def __repr__(self):
28462 
    L = ['%s=%r' % (key, value)
28463 
      for key, value in self.__dict__.iteritems()]
28464 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28465 
 
28466 
  def __eq__(self, other):
28467 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28468 
 
28469 
  def __ne__(self, other):
28470 
    return not (self == other)
28471 
 
28472 
class updateNlcAtMarketplaces_result:
28473 
 
28474 
  thrift_spec = (
28475 
  )
28476 
 
28477 
  def read(self, iprot):
28478 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28479 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28480 
      return
28481 
    iprot.readStructBegin()
28482 
    while True:
28483 
      (fname, ftype, fid) = iprot.readFieldBegin()
28484 
      if ftype == TType.STOP:
28485 
        break
28486 
      else:
28487 
        iprot.skip(ftype)
28488 
      iprot.readFieldEnd()
28489 
    iprot.readStructEnd()
28490 
 
28491 
  def write(self, oprot):
28492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28494 
      return
28495 
    oprot.writeStructBegin('updateNlcAtMarketplaces_result')
28496 
    oprot.writeFieldStop()
28497 
    oprot.writeStructEnd()
28498 
 
28499 
  def validate(self):
28500 
    return
28501 
 
28502 
 
28503 
  def __repr__(self):
28504 
    L = ['%s=%r' % (key, value)
28505 
      for key, value in self.__dict__.iteritems()]
28506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28507 
 
28508 
  def __eq__(self, other):
28509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28510 
 
28511 
  def __ne__(self, other):
28512 
    return not (self == other)
9945 vikram.rag 28513 
 
28514 
class getAllFlipkartItems_args:
28515 
 
28516 
  thrift_spec = (
28517 
  )
28518 
 
28519 
  def read(self, iprot):
28520 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28521 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28522 
      return
28523 
    iprot.readStructBegin()
28524 
    while True:
28525 
      (fname, ftype, fid) = iprot.readFieldBegin()
28526 
      if ftype == TType.STOP:
28527 
        break
28528 
      else:
28529 
        iprot.skip(ftype)
28530 
      iprot.readFieldEnd()
28531 
    iprot.readStructEnd()
28532 
 
28533 
  def write(self, oprot):
28534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28536 
      return
28537 
    oprot.writeStructBegin('getAllFlipkartItems_args')
28538 
    oprot.writeFieldStop()
28539 
    oprot.writeStructEnd()
28540 
 
28541 
  def validate(self):
28542 
    return
28543 
 
28544 
 
28545 
  def __repr__(self):
28546 
    L = ['%s=%r' % (key, value)
28547 
      for key, value in self.__dict__.iteritems()]
28548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28549 
 
28550 
  def __eq__(self, other):
28551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28552 
 
28553 
  def __ne__(self, other):
28554 
    return not (self == other)
28555 
 
28556 
class getAllFlipkartItems_result:
28557 
  """
28558 
  Attributes:
28559 
   - success
28560 
  """
28561 
 
28562 
  thrift_spec = (
28563 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartItem, FlipkartItem.thrift_spec)), None, ), # 0
28564 
  )
28565 
 
28566 
  def __init__(self, success=None,):
28567 
    self.success = success
28568 
 
28569 
  def read(self, iprot):
28570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28572 
      return
28573 
    iprot.readStructBegin()
28574 
    while True:
28575 
      (fname, ftype, fid) = iprot.readFieldBegin()
28576 
      if ftype == TType.STOP:
28577 
        break
28578 
      if fid == 0:
28579 
        if ftype == TType.LIST:
28580 
          self.success = []
18719 kshitij.so 28581 
          (_etype615, _size612) = iprot.readListBegin()
28582 
          for _i616 in xrange(_size612):
28583 
            _elem617 = FlipkartItem()
28584 
            _elem617.read(iprot)
28585 
            self.success.append(_elem617)
9945 vikram.rag 28586 
          iprot.readListEnd()
28587 
        else:
28588 
          iprot.skip(ftype)
28589 
      else:
28590 
        iprot.skip(ftype)
28591 
      iprot.readFieldEnd()
28592 
    iprot.readStructEnd()
28593 
 
28594 
  def write(self, oprot):
28595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28597 
      return
28598 
    oprot.writeStructBegin('getAllFlipkartItems_result')
28599 
    if self.success is not None:
28600 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28601 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 28602 
      for iter618 in self.success:
28603 
        iter618.write(oprot)
9945 vikram.rag 28604 
      oprot.writeListEnd()
28605 
      oprot.writeFieldEnd()
28606 
    oprot.writeFieldStop()
28607 
    oprot.writeStructEnd()
28608 
 
28609 
  def validate(self):
28610 
    return
28611 
 
28612 
 
28613 
  def __repr__(self):
28614 
    L = ['%s=%r' % (key, value)
28615 
      for key, value in self.__dict__.iteritems()]
28616 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28617 
 
28618 
  def __eq__(self, other):
28619 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28620 
 
28621 
  def __ne__(self, other):
28622 
    return not (self == other)
10097 kshitij.so 28623 
 
28624 
class addOrUpdateFlipkartItem_args:
28625 
  """
28626 
  Attributes:
28627 
   - flipkartitem
28628 
  """
28629 
 
28630 
  thrift_spec = None
28631 
  def __init__(self, flipkartitem=None,):
28632 
    self.flipkartitem = flipkartitem
28633 
 
28634 
  def read(self, iprot):
28635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28637 
      return
28638 
    iprot.readStructBegin()
28639 
    while True:
28640 
      (fname, ftype, fid) = iprot.readFieldBegin()
28641 
      if ftype == TType.STOP:
28642 
        break
28643 
      if fid == -1:
28644 
        if ftype == TType.STRUCT:
28645 
          self.flipkartitem = FlipkartItem()
28646 
          self.flipkartitem.read(iprot)
28647 
        else:
28648 
          iprot.skip(ftype)
28649 
      else:
28650 
        iprot.skip(ftype)
28651 
      iprot.readFieldEnd()
28652 
    iprot.readStructEnd()
28653 
 
28654 
  def write(self, oprot):
28655 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28656 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28657 
      return
28658 
    oprot.writeStructBegin('addOrUpdateFlipkartItem_args')
28659 
    if self.flipkartitem is not None:
28660 
      oprot.writeFieldBegin('flipkartitem', TType.STRUCT, -1)
28661 
      self.flipkartitem.write(oprot)
28662 
      oprot.writeFieldEnd()
28663 
    oprot.writeFieldStop()
28664 
    oprot.writeStructEnd()
28665 
 
28666 
  def validate(self):
28667 
    return
28668 
 
28669 
 
28670 
  def __repr__(self):
28671 
    L = ['%s=%r' % (key, value)
28672 
      for key, value in self.__dict__.iteritems()]
28673 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28674 
 
28675 
  def __eq__(self, other):
28676 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28677 
 
28678 
  def __ne__(self, other):
28679 
    return not (self == other)
28680 
 
28681 
class addOrUpdateFlipkartItem_result:
28682 
  """
28683 
  Attributes:
28684 
   - success
28685 
  """
28686 
 
28687 
  thrift_spec = (
28688 
    (0, TType.BOOL, 'success', None, None, ), # 0
28689 
  )
28690 
 
28691 
  def __init__(self, success=None,):
28692 
    self.success = success
28693 
 
28694 
  def read(self, iprot):
28695 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28696 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28697 
      return
28698 
    iprot.readStructBegin()
28699 
    while True:
28700 
      (fname, ftype, fid) = iprot.readFieldBegin()
28701 
      if ftype == TType.STOP:
28702 
        break
28703 
      if fid == 0:
28704 
        if ftype == TType.BOOL:
28705 
          self.success = iprot.readBool();
28706 
        else:
28707 
          iprot.skip(ftype)
28708 
      else:
28709 
        iprot.skip(ftype)
28710 
      iprot.readFieldEnd()
28711 
    iprot.readStructEnd()
28712 
 
28713 
  def write(self, oprot):
28714 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28715 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28716 
      return
28717 
    oprot.writeStructBegin('addOrUpdateFlipkartItem_result')
28718 
    if self.success is not None:
28719 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
28720 
      oprot.writeBool(self.success)
28721 
      oprot.writeFieldEnd()
28722 
    oprot.writeFieldStop()
28723 
    oprot.writeStructEnd()
28724 
 
28725 
  def validate(self):
28726 
    return
28727 
 
28728 
 
28729 
  def __repr__(self):
28730 
    L = ['%s=%r' % (key, value)
28731 
      for key, value in self.__dict__.iteritems()]
28732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28733 
 
28734 
  def __eq__(self, other):
28735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28736 
 
28737 
  def __ne__(self, other):
28738 
    return not (self == other)
28739 
 
28740 
class getFlipkartItem_args:
28741 
  """
28742 
  Attributes:
28743 
   - item_id
28744 
  """
28745 
 
28746 
  thrift_spec = (
28747 
    None, # 0
28748 
    (1, TType.I64, 'item_id', None, None, ), # 1
28749 
  )
28750 
 
28751 
  def __init__(self, item_id=None,):
28752 
    self.item_id = item_id
28753 
 
28754 
  def read(self, iprot):
28755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28757 
      return
28758 
    iprot.readStructBegin()
28759 
    while True:
28760 
      (fname, ftype, fid) = iprot.readFieldBegin()
28761 
      if ftype == TType.STOP:
28762 
        break
28763 
      if fid == 1:
28764 
        if ftype == TType.I64:
28765 
          self.item_id = iprot.readI64();
28766 
        else:
28767 
          iprot.skip(ftype)
28768 
      else:
28769 
        iprot.skip(ftype)
28770 
      iprot.readFieldEnd()
28771 
    iprot.readStructEnd()
28772 
 
28773 
  def write(self, oprot):
28774 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28775 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28776 
      return
28777 
    oprot.writeStructBegin('getFlipkartItem_args')
28778 
    if self.item_id is not None:
28779 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
28780 
      oprot.writeI64(self.item_id)
28781 
      oprot.writeFieldEnd()
28782 
    oprot.writeFieldStop()
28783 
    oprot.writeStructEnd()
28784 
 
28785 
  def validate(self):
28786 
    return
28787 
 
28788 
 
28789 
  def __repr__(self):
28790 
    L = ['%s=%r' % (key, value)
28791 
      for key, value in self.__dict__.iteritems()]
28792 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28793 
 
28794 
  def __eq__(self, other):
28795 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28796 
 
28797 
  def __ne__(self, other):
28798 
    return not (self == other)
28799 
 
28800 
class getFlipkartItem_result:
28801 
  """
28802 
  Attributes:
28803 
   - success
28804 
  """
28805 
 
28806 
  thrift_spec = (
28807 
    (0, TType.STRUCT, 'success', (FlipkartItem, FlipkartItem.thrift_spec), None, ), # 0
28808 
  )
28809 
 
28810 
  def __init__(self, success=None,):
28811 
    self.success = success
28812 
 
28813 
  def read(self, iprot):
28814 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28815 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28816 
      return
28817 
    iprot.readStructBegin()
28818 
    while True:
28819 
      (fname, ftype, fid) = iprot.readFieldBegin()
28820 
      if ftype == TType.STOP:
28821 
        break
28822 
      if fid == 0:
28823 
        if ftype == TType.STRUCT:
28824 
          self.success = FlipkartItem()
28825 
          self.success.read(iprot)
28826 
        else:
28827 
          iprot.skip(ftype)
28828 
      else:
28829 
        iprot.skip(ftype)
28830 
      iprot.readFieldEnd()
28831 
    iprot.readStructEnd()
28832 
 
28833 
  def write(self, oprot):
28834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28836 
      return
28837 
    oprot.writeStructBegin('getFlipkartItem_result')
28838 
    if self.success is not None:
28839 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28840 
      self.success.write(oprot)
28841 
      oprot.writeFieldEnd()
28842 
    oprot.writeFieldStop()
28843 
    oprot.writeStructEnd()
28844 
 
28845 
  def validate(self):
28846 
    return
28847 
 
28848 
 
28849 
  def __repr__(self):
28850 
    L = ['%s=%r' % (key, value)
28851 
      for key, value in self.__dict__.iteritems()]
28852 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28853 
 
28854 
  def __eq__(self, other):
28855 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28856 
 
28857 
  def __ne__(self, other):
28858 
    return not (self == other)
28859 
 
28860 
class getFlipkartItemDetails_args:
28861 
  """
28862 
  Attributes:
28863 
   - item_id
28864 
  """
28865 
 
28866 
  thrift_spec = (
28867 
    None, # 0
28868 
    (1, TType.I64, 'item_id', None, None, ), # 1
28869 
  )
28870 
 
28871 
  def __init__(self, item_id=None,):
28872 
    self.item_id = item_id
28873 
 
28874 
  def read(self, iprot):
28875 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28876 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28877 
      return
28878 
    iprot.readStructBegin()
28879 
    while True:
28880 
      (fname, ftype, fid) = iprot.readFieldBegin()
28881 
      if ftype == TType.STOP:
28882 
        break
28883 
      if fid == 1:
28884 
        if ftype == TType.I64:
28885 
          self.item_id = iprot.readI64();
28886 
        else:
28887 
          iprot.skip(ftype)
28888 
      else:
28889 
        iprot.skip(ftype)
28890 
      iprot.readFieldEnd()
28891 
    iprot.readStructEnd()
28892 
 
28893 
  def write(self, oprot):
28894 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28895 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28896 
      return
28897 
    oprot.writeStructBegin('getFlipkartItemDetails_args')
28898 
    if self.item_id is not None:
28899 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
28900 
      oprot.writeI64(self.item_id)
28901 
      oprot.writeFieldEnd()
28902 
    oprot.writeFieldStop()
28903 
    oprot.writeStructEnd()
28904 
 
28905 
  def validate(self):
28906 
    return
28907 
 
28908 
 
28909 
  def __repr__(self):
28910 
    L = ['%s=%r' % (key, value)
28911 
      for key, value in self.__dict__.iteritems()]
28912 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28913 
 
28914 
  def __eq__(self, other):
28915 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28916 
 
28917 
  def __ne__(self, other):
28918 
    return not (self == other)
28919 
 
28920 
class getFlipkartItemDetails_result:
28921 
  """
28922 
  Attributes:
28923 
   - success
28924 
  """
28925 
 
28926 
  thrift_spec = (
28927 
    (0, TType.STRUCT, 'success', (FlipkartItemDetails, FlipkartItemDetails.thrift_spec), None, ), # 0
28928 
  )
28929 
 
28930 
  def __init__(self, success=None,):
28931 
    self.success = success
28932 
 
28933 
  def read(self, iprot):
28934 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28935 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28936 
      return
28937 
    iprot.readStructBegin()
28938 
    while True:
28939 
      (fname, ftype, fid) = iprot.readFieldBegin()
28940 
      if ftype == TType.STOP:
28941 
        break
28942 
      if fid == 0:
28943 
        if ftype == TType.STRUCT:
28944 
          self.success = FlipkartItemDetails()
28945 
          self.success.read(iprot)
28946 
        else:
28947 
          iprot.skip(ftype)
28948 
      else:
28949 
        iprot.skip(ftype)
28950 
      iprot.readFieldEnd()
28951 
    iprot.readStructEnd()
28952 
 
28953 
  def write(self, oprot):
28954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28956 
      return
28957 
    oprot.writeStructBegin('getFlipkartItemDetails_result')
28958 
    if self.success is not None:
28959 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28960 
      self.success.write(oprot)
28961 
      oprot.writeFieldEnd()
28962 
    oprot.writeFieldStop()
28963 
    oprot.writeStructEnd()
28964 
 
28965 
  def validate(self):
28966 
    return
28967 
 
28968 
 
28969 
  def __repr__(self):
28970 
    L = ['%s=%r' % (key, value)
28971 
      for key, value in self.__dict__.iteritems()]
28972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28973 
 
28974 
  def __eq__(self, other):
28975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28976 
 
28977 
  def __ne__(self, other):
28978 
    return not (self == other)
28979 
 
28980 
class getFlipkartItems_args:
28981 
  """
28982 
  Attributes:
28983 
   - offset
28984 
   - limit
28985 
  """
28986 
 
28987 
  thrift_spec = (
28988 
    None, # 0
28989 
    (1, TType.I64, 'offset', None, None, ), # 1
28990 
    (2, TType.I64, 'limit', None, None, ), # 2
28991 
  )
28992 
 
28993 
  def __init__(self, offset=None, limit=None,):
28994 
    self.offset = offset
28995 
    self.limit = limit
28996 
 
28997 
  def read(self, iprot):
28998 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28999 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29000 
      return
29001 
    iprot.readStructBegin()
29002 
    while True:
29003 
      (fname, ftype, fid) = iprot.readFieldBegin()
29004 
      if ftype == TType.STOP:
29005 
        break
29006 
      if fid == 1:
29007 
        if ftype == TType.I64:
29008 
          self.offset = iprot.readI64();
29009 
        else:
29010 
          iprot.skip(ftype)
29011 
      elif fid == 2:
29012 
        if ftype == TType.I64:
29013 
          self.limit = iprot.readI64();
29014 
        else:
29015 
          iprot.skip(ftype)
29016 
      else:
29017 
        iprot.skip(ftype)
29018 
      iprot.readFieldEnd()
29019 
    iprot.readStructEnd()
29020 
 
29021 
  def write(self, oprot):
29022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29024 
      return
29025 
    oprot.writeStructBegin('getFlipkartItems_args')
29026 
    if self.offset is not None:
29027 
      oprot.writeFieldBegin('offset', TType.I64, 1)
29028 
      oprot.writeI64(self.offset)
29029 
      oprot.writeFieldEnd()
29030 
    if self.limit is not None:
29031 
      oprot.writeFieldBegin('limit', TType.I64, 2)
29032 
      oprot.writeI64(self.limit)
29033 
      oprot.writeFieldEnd()
29034 
    oprot.writeFieldStop()
29035 
    oprot.writeStructEnd()
29036 
 
29037 
  def validate(self):
29038 
    return
29039 
 
29040 
 
29041 
  def __repr__(self):
29042 
    L = ['%s=%r' % (key, value)
29043 
      for key, value in self.__dict__.iteritems()]
29044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29045 
 
29046 
  def __eq__(self, other):
29047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29048 
 
29049 
  def __ne__(self, other):
29050 
    return not (self == other)
29051 
 
29052 
class getFlipkartItems_result:
29053 
  """
29054 
  Attributes:
29055 
   - success
29056 
  """
29057 
 
29058 
  thrift_spec = (
29059 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartItemDetails, FlipkartItemDetails.thrift_spec)), None, ), # 0
29060 
  )
29061 
 
29062 
  def __init__(self, success=None,):
29063 
    self.success = success
29064 
 
29065 
  def read(self, iprot):
29066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29068 
      return
29069 
    iprot.readStructBegin()
29070 
    while True:
29071 
      (fname, ftype, fid) = iprot.readFieldBegin()
29072 
      if ftype == TType.STOP:
29073 
        break
29074 
      if fid == 0:
29075 
        if ftype == TType.LIST:
29076 
          self.success = []
18719 kshitij.so 29077 
          (_etype622, _size619) = iprot.readListBegin()
29078 
          for _i623 in xrange(_size619):
29079 
            _elem624 = FlipkartItemDetails()
29080 
            _elem624.read(iprot)
29081 
            self.success.append(_elem624)
10097 kshitij.so 29082 
          iprot.readListEnd()
29083 
        else:
29084 
          iprot.skip(ftype)
29085 
      else:
29086 
        iprot.skip(ftype)
29087 
      iprot.readFieldEnd()
29088 
    iprot.readStructEnd()
29089 
 
29090 
  def write(self, oprot):
29091 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29092 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29093 
      return
29094 
    oprot.writeStructBegin('getFlipkartItems_result')
29095 
    if self.success is not None:
29096 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29097 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 29098 
      for iter625 in self.success:
29099 
        iter625.write(oprot)
10097 kshitij.so 29100 
      oprot.writeListEnd()
29101 
      oprot.writeFieldEnd()
29102 
    oprot.writeFieldStop()
29103 
    oprot.writeStructEnd()
29104 
 
29105 
  def validate(self):
29106 
    return
29107 
 
29108 
 
29109 
  def __repr__(self):
29110 
    L = ['%s=%r' % (key, value)
29111 
      for key, value in self.__dict__.iteritems()]
29112 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29113 
 
29114 
  def __eq__(self, other):
29115 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29116 
 
29117 
  def __ne__(self, other):
29118 
    return not (self == other)
29119 
 
29120 
class searchFlipkartItems_args:
29121 
  """
29122 
  Attributes:
29123 
   - searchTerm
29124 
   - offset
29125 
   - limit
29126 
  """
29127 
 
29128 
  thrift_spec = (
29129 
    None, # 0
29130 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
29131 
    (2, TType.I64, 'offset', None, None, ), # 2
29132 
    (3, TType.I64, 'limit', None, None, ), # 3
29133 
  )
29134 
 
29135 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
29136 
    self.searchTerm = searchTerm
29137 
    self.offset = offset
29138 
    self.limit = limit
29139 
 
29140 
  def read(self, iprot):
29141 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29142 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29143 
      return
29144 
    iprot.readStructBegin()
29145 
    while True:
29146 
      (fname, ftype, fid) = iprot.readFieldBegin()
29147 
      if ftype == TType.STOP:
29148 
        break
29149 
      if fid == 1:
29150 
        if ftype == TType.LIST:
29151 
          self.searchTerm = []
18719 kshitij.so 29152 
          (_etype629, _size626) = iprot.readListBegin()
29153 
          for _i630 in xrange(_size626):
29154 
            _elem631 = iprot.readString();
29155 
            self.searchTerm.append(_elem631)
10097 kshitij.so 29156 
          iprot.readListEnd()
29157 
        else:
29158 
          iprot.skip(ftype)
29159 
      elif fid == 2:
29160 
        if ftype == TType.I64:
29161 
          self.offset = iprot.readI64();
29162 
        else:
29163 
          iprot.skip(ftype)
29164 
      elif fid == 3:
29165 
        if ftype == TType.I64:
29166 
          self.limit = iprot.readI64();
29167 
        else:
29168 
          iprot.skip(ftype)
29169 
      else:
29170 
        iprot.skip(ftype)
29171 
      iprot.readFieldEnd()
29172 
    iprot.readStructEnd()
29173 
 
29174 
  def write(self, oprot):
29175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29177 
      return
29178 
    oprot.writeStructBegin('searchFlipkartItems_args')
29179 
    if self.searchTerm is not None:
29180 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
29181 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
18719 kshitij.so 29182 
      for iter632 in self.searchTerm:
29183 
        oprot.writeString(iter632)
10097 kshitij.so 29184 
      oprot.writeListEnd()
29185 
      oprot.writeFieldEnd()
29186 
    if self.offset is not None:
29187 
      oprot.writeFieldBegin('offset', TType.I64, 2)
29188 
      oprot.writeI64(self.offset)
29189 
      oprot.writeFieldEnd()
29190 
    if self.limit is not None:
29191 
      oprot.writeFieldBegin('limit', TType.I64, 3)
29192 
      oprot.writeI64(self.limit)
29193 
      oprot.writeFieldEnd()
29194 
    oprot.writeFieldStop()
29195 
    oprot.writeStructEnd()
29196 
 
29197 
  def validate(self):
29198 
    return
29199 
 
29200 
 
29201 
  def __repr__(self):
29202 
    L = ['%s=%r' % (key, value)
29203 
      for key, value in self.__dict__.iteritems()]
29204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29205 
 
29206 
  def __eq__(self, other):
29207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29208 
 
29209 
  def __ne__(self, other):
29210 
    return not (self == other)
29211 
 
29212 
class searchFlipkartItems_result:
29213 
  """
29214 
  Attributes:
29215 
   - success
29216 
  """
29217 
 
29218 
  thrift_spec = (
29219 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartItemDetails, FlipkartItemDetails.thrift_spec)), None, ), # 0
29220 
  )
29221 
 
29222 
  def __init__(self, success=None,):
29223 
    self.success = success
29224 
 
29225 
  def read(self, iprot):
29226 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29227 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29228 
      return
29229 
    iprot.readStructBegin()
29230 
    while True:
29231 
      (fname, ftype, fid) = iprot.readFieldBegin()
29232 
      if ftype == TType.STOP:
29233 
        break
29234 
      if fid == 0:
29235 
        if ftype == TType.LIST:
29236 
          self.success = []
18719 kshitij.so 29237 
          (_etype636, _size633) = iprot.readListBegin()
29238 
          for _i637 in xrange(_size633):
29239 
            _elem638 = FlipkartItemDetails()
29240 
            _elem638.read(iprot)
29241 
            self.success.append(_elem638)
10097 kshitij.so 29242 
          iprot.readListEnd()
29243 
        else:
29244 
          iprot.skip(ftype)
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('searchFlipkartItems_result')
29255 
    if self.success is not None:
29256 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29257 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 29258 
      for iter639 in self.success:
29259 
        iter639.write(oprot)
10097 kshitij.so 29260 
      oprot.writeListEnd()
29261 
      oprot.writeFieldEnd()
29262 
    oprot.writeFieldStop()
29263 
    oprot.writeStructEnd()
29264 
 
29265 
  def validate(self):
29266 
    return
29267 
 
29268 
 
29269 
  def __repr__(self):
29270 
    L = ['%s=%r' % (key, value)
29271 
      for key, value in self.__dict__.iteritems()]
29272 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29273 
 
29274 
  def __eq__(self, other):
29275 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29276 
 
29277 
  def __ne__(self, other):
29278 
    return not (self == other)
29279 
 
29280 
class getCountForFlipkartItems_args:
29281 
 
29282 
  thrift_spec = (
29283 
  )
29284 
 
29285 
  def read(self, iprot):
29286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29288 
      return
29289 
    iprot.readStructBegin()
29290 
    while True:
29291 
      (fname, ftype, fid) = iprot.readFieldBegin()
29292 
      if ftype == TType.STOP:
29293 
        break
29294 
      else:
29295 
        iprot.skip(ftype)
29296 
      iprot.readFieldEnd()
29297 
    iprot.readStructEnd()
29298 
 
29299 
  def write(self, oprot):
29300 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29301 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29302 
      return
29303 
    oprot.writeStructBegin('getCountForFlipkartItems_args')
29304 
    oprot.writeFieldStop()
29305 
    oprot.writeStructEnd()
29306 
 
29307 
  def validate(self):
29308 
    return
29309 
 
29310 
 
29311 
  def __repr__(self):
29312 
    L = ['%s=%r' % (key, value)
29313 
      for key, value in self.__dict__.iteritems()]
29314 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29315 
 
29316 
  def __eq__(self, other):
29317 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29318 
 
29319 
  def __ne__(self, other):
29320 
    return not (self == other)
29321 
 
29322 
class getCountForFlipkartItems_result:
29323 
  """
29324 
  Attributes:
29325 
   - success
29326 
  """
29327 
 
29328 
  thrift_spec = (
29329 
    (0, TType.I64, 'success', None, None, ), # 0
29330 
  )
29331 
 
29332 
  def __init__(self, success=None,):
29333 
    self.success = success
29334 
 
29335 
  def read(self, iprot):
29336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29338 
      return
29339 
    iprot.readStructBegin()
29340 
    while True:
29341 
      (fname, ftype, fid) = iprot.readFieldBegin()
29342 
      if ftype == TType.STOP:
29343 
        break
29344 
      if fid == 0:
29345 
        if ftype == TType.I64:
29346 
          self.success = iprot.readI64();
29347 
        else:
29348 
          iprot.skip(ftype)
29349 
      else:
29350 
        iprot.skip(ftype)
29351 
      iprot.readFieldEnd()
29352 
    iprot.readStructEnd()
29353 
 
29354 
  def write(self, oprot):
29355 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29356 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29357 
      return
29358 
    oprot.writeStructBegin('getCountForFlipkartItems_result')
29359 
    if self.success is not None:
29360 
      oprot.writeFieldBegin('success', TType.I64, 0)
29361 
      oprot.writeI64(self.success)
29362 
      oprot.writeFieldEnd()
29363 
    oprot.writeFieldStop()
29364 
    oprot.writeStructEnd()
29365 
 
29366 
  def validate(self):
29367 
    return
29368 
 
29369 
 
29370 
  def __repr__(self):
29371 
    L = ['%s=%r' % (key, value)
29372 
      for key, value in self.__dict__.iteritems()]
29373 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29374 
 
29375 
  def __eq__(self, other):
29376 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29377 
 
29378 
  def __ne__(self, other):
29379 
    return not (self == other)
29380 
 
29381 
class getFlipkartSearchResultCount_args:
29382 
  """
29383 
  Attributes:
29384 
   - searchTerm
29385 
  """
29386 
 
29387 
  thrift_spec = (
29388 
    None, # 0
29389 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
29390 
  )
29391 
 
29392 
  def __init__(self, searchTerm=None,):
29393 
    self.searchTerm = searchTerm
29394 
 
29395 
  def read(self, iprot):
29396 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29397 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29398 
      return
29399 
    iprot.readStructBegin()
29400 
    while True:
29401 
      (fname, ftype, fid) = iprot.readFieldBegin()
29402 
      if ftype == TType.STOP:
29403 
        break
29404 
      if fid == 1:
29405 
        if ftype == TType.LIST:
29406 
          self.searchTerm = []
18719 kshitij.so 29407 
          (_etype643, _size640) = iprot.readListBegin()
29408 
          for _i644 in xrange(_size640):
29409 
            _elem645 = iprot.readString();
29410 
            self.searchTerm.append(_elem645)
10097 kshitij.so 29411 
          iprot.readListEnd()
29412 
        else:
29413 
          iprot.skip(ftype)
29414 
      else:
29415 
        iprot.skip(ftype)
29416 
      iprot.readFieldEnd()
29417 
    iprot.readStructEnd()
29418 
 
29419 
  def write(self, oprot):
29420 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29421 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29422 
      return
29423 
    oprot.writeStructBegin('getFlipkartSearchResultCount_args')
29424 
    if self.searchTerm is not None:
29425 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
29426 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
18719 kshitij.so 29427 
      for iter646 in self.searchTerm:
29428 
        oprot.writeString(iter646)
10097 kshitij.so 29429 
      oprot.writeListEnd()
29430 
      oprot.writeFieldEnd()
29431 
    oprot.writeFieldStop()
29432 
    oprot.writeStructEnd()
29433 
 
29434 
  def validate(self):
29435 
    return
29436 
 
29437 
 
29438 
  def __repr__(self):
29439 
    L = ['%s=%r' % (key, value)
29440 
      for key, value in self.__dict__.iteritems()]
29441 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29442 
 
29443 
  def __eq__(self, other):
29444 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29445 
 
29446 
  def __ne__(self, other):
29447 
    return not (self == other)
29448 
 
29449 
class getFlipkartSearchResultCount_result:
29450 
  """
29451 
  Attributes:
29452 
   - success
29453 
  """
29454 
 
29455 
  thrift_spec = (
29456 
    (0, TType.I64, 'success', None, None, ), # 0
29457 
  )
29458 
 
29459 
  def __init__(self, success=None,):
29460 
    self.success = success
29461 
 
29462 
  def read(self, iprot):
29463 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29464 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29465 
      return
29466 
    iprot.readStructBegin()
29467 
    while True:
29468 
      (fname, ftype, fid) = iprot.readFieldBegin()
29469 
      if ftype == TType.STOP:
29470 
        break
29471 
      if fid == 0:
29472 
        if ftype == TType.I64:
29473 
          self.success = iprot.readI64();
29474 
        else:
29475 
          iprot.skip(ftype)
29476 
      else:
29477 
        iprot.skip(ftype)
29478 
      iprot.readFieldEnd()
29479 
    iprot.readStructEnd()
29480 
 
29481 
  def write(self, oprot):
29482 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29483 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29484 
      return
29485 
    oprot.writeStructBegin('getFlipkartSearchResultCount_result')
29486 
    if self.success is not None:
29487 
      oprot.writeFieldBegin('success', TType.I64, 0)
29488 
      oprot.writeI64(self.success)
29489 
      oprot.writeFieldEnd()
29490 
    oprot.writeFieldStop()
29491 
    oprot.writeStructEnd()
29492 
 
29493 
  def validate(self):
29494 
    return
29495 
 
29496 
 
29497 
  def __repr__(self):
29498 
    L = ['%s=%r' % (key, value)
29499 
      for key, value in self.__dict__.iteritems()]
29500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29501 
 
29502 
  def __eq__(self, other):
29503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29504 
 
29505 
  def __ne__(self, other):
29506 
    return not (self == other)
29507 
 
29508 
class getAllFkItems_args:
29509 
 
29510 
  thrift_spec = (
29511 
  )
29512 
 
29513 
  def read(self, iprot):
29514 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29515 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29516 
      return
29517 
    iprot.readStructBegin()
29518 
    while True:
29519 
      (fname, ftype, fid) = iprot.readFieldBegin()
29520 
      if ftype == TType.STOP:
29521 
        break
29522 
      else:
29523 
        iprot.skip(ftype)
29524 
      iprot.readFieldEnd()
29525 
    iprot.readStructEnd()
29526 
 
29527 
  def write(self, oprot):
29528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29530 
      return
29531 
    oprot.writeStructBegin('getAllFkItems_args')
29532 
    oprot.writeFieldStop()
29533 
    oprot.writeStructEnd()
29534 
 
29535 
  def validate(self):
29536 
    return
29537 
 
29538 
 
29539 
  def __repr__(self):
29540 
    L = ['%s=%r' % (key, value)
29541 
      for key, value in self.__dict__.iteritems()]
29542 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29543 
 
29544 
  def __eq__(self, other):
29545 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29546 
 
29547 
  def __ne__(self, other):
29548 
    return not (self == other)
29549 
 
29550 
class getAllFkItems_result:
29551 
  """
29552 
  Attributes:
29553 
   - success
29554 
  """
29555 
 
29556 
  thrift_spec = (
29557 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartItemDetails, FlipkartItemDetails.thrift_spec)), None, ), # 0
29558 
  )
29559 
 
29560 
  def __init__(self, success=None,):
29561 
    self.success = success
29562 
 
29563 
  def read(self, iprot):
29564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29566 
      return
29567 
    iprot.readStructBegin()
29568 
    while True:
29569 
      (fname, ftype, fid) = iprot.readFieldBegin()
29570 
      if ftype == TType.STOP:
29571 
        break
29572 
      if fid == 0:
29573 
        if ftype == TType.LIST:
29574 
          self.success = []
18719 kshitij.so 29575 
          (_etype650, _size647) = iprot.readListBegin()
29576 
          for _i651 in xrange(_size647):
29577 
            _elem652 = FlipkartItemDetails()
29578 
            _elem652.read(iprot)
29579 
            self.success.append(_elem652)
10097 kshitij.so 29580 
          iprot.readListEnd()
29581 
        else:
29582 
          iprot.skip(ftype)
29583 
      else:
29584 
        iprot.skip(ftype)
29585 
      iprot.readFieldEnd()
29586 
    iprot.readStructEnd()
29587 
 
29588 
  def write(self, oprot):
29589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29591 
      return
29592 
    oprot.writeStructBegin('getAllFkItems_result')
29593 
    if self.success is not None:
29594 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29595 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 29596 
      for iter653 in self.success:
29597 
        iter653.write(oprot)
10097 kshitij.so 29598 
      oprot.writeListEnd()
29599 
      oprot.writeFieldEnd()
29600 
    oprot.writeFieldStop()
29601 
    oprot.writeStructEnd()
29602 
 
29603 
  def validate(self):
29604 
    return
29605 
 
29606 
 
29607 
  def __repr__(self):
29608 
    L = ['%s=%r' % (key, value)
29609 
      for key, value in self.__dict__.iteritems()]
29610 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29611 
 
29612 
  def __eq__(self, other):
29613 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29614 
 
29615 
  def __ne__(self, other):
29616 
    return not (self == other)
10140 vikram.rag 29617 
 
29618 
class getFlipkartItemBySkyAtFlipkart_args:
29619 
  """
29620 
  Attributes:
29621 
   - sku
29622 
  """
29623 
 
11531 vikram.rag 29624 
  thrift_spec = None
10140 vikram.rag 29625 
  def __init__(self, sku=None,):
29626 
    self.sku = sku
29627 
 
29628 
  def read(self, iprot):
29629 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29630 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29631 
      return
29632 
    iprot.readStructBegin()
29633 
    while True:
29634 
      (fname, ftype, fid) = iprot.readFieldBegin()
29635 
      if ftype == TType.STOP:
29636 
        break
11531 vikram.rag 29637 
      if fid == -1:
10140 vikram.rag 29638 
        if ftype == TType.STRING:
29639 
          self.sku = iprot.readString();
29640 
        else:
29641 
          iprot.skip(ftype)
29642 
      else:
29643 
        iprot.skip(ftype)
29644 
      iprot.readFieldEnd()
29645 
    iprot.readStructEnd()
29646 
 
29647 
  def write(self, oprot):
29648 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29649 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29650 
      return
29651 
    oprot.writeStructBegin('getFlipkartItemBySkyAtFlipkart_args')
29652 
    if self.sku is not None:
11531 vikram.rag 29653 
      oprot.writeFieldBegin('sku', TType.STRING, -1)
10140 vikram.rag 29654 
      oprot.writeString(self.sku)
29655 
      oprot.writeFieldEnd()
29656 
    oprot.writeFieldStop()
29657 
    oprot.writeStructEnd()
29658 
 
29659 
  def validate(self):
29660 
    return
29661 
 
29662 
 
29663 
  def __repr__(self):
29664 
    L = ['%s=%r' % (key, value)
29665 
      for key, value in self.__dict__.iteritems()]
29666 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29667 
 
29668 
  def __eq__(self, other):
29669 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29670 
 
29671 
  def __ne__(self, other):
29672 
    return not (self == other)
29673 
 
29674 
class getFlipkartItemBySkyAtFlipkart_result:
29675 
  """
29676 
  Attributes:
29677 
   - success
29678 
  """
29679 
 
29680 
  thrift_spec = (
29681 
    (0, TType.STRUCT, 'success', (FlipkartItem, FlipkartItem.thrift_spec), None, ), # 0
29682 
  )
29683 
 
29684 
  def __init__(self, success=None,):
29685 
    self.success = success
29686 
 
29687 
  def read(self, iprot):
29688 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29689 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29690 
      return
29691 
    iprot.readStructBegin()
29692 
    while True:
29693 
      (fname, ftype, fid) = iprot.readFieldBegin()
29694 
      if ftype == TType.STOP:
29695 
        break
29696 
      if fid == 0:
29697 
        if ftype == TType.STRUCT:
29698 
          self.success = FlipkartItem()
29699 
          self.success.read(iprot)
29700 
        else:
29701 
          iprot.skip(ftype)
29702 
      else:
29703 
        iprot.skip(ftype)
29704 
      iprot.readFieldEnd()
29705 
    iprot.readStructEnd()
29706 
 
29707 
  def write(self, oprot):
29708 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29709 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29710 
      return
29711 
    oprot.writeStructBegin('getFlipkartItemBySkyAtFlipkart_result')
29712 
    if self.success is not None:
29713 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
29714 
      self.success.write(oprot)
29715 
      oprot.writeFieldEnd()
29716 
    oprot.writeFieldStop()
29717 
    oprot.writeStructEnd()
29718 
 
29719 
  def validate(self):
29720 
    return
29721 
 
29722 
 
29723 
  def __repr__(self):
29724 
    L = ['%s=%r' % (key, value)
29725 
      for key, value in self.__dict__.iteritems()]
29726 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29727 
 
29728 
  def __eq__(self, other):
29729 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29730 
 
29731 
  def __ne__(self, other):
29732 
    return not (self == other)
10909 vikram.rag 29733 
 
11015 kshitij.so 29734 
class getMarketplaceHistory_args:
29735 
  """
29736 
  Attributes:
29737 
   - source
29738 
   - offset
29739 
   - itemId
29740 
  """
10909 vikram.rag 29741 
 
29742 
  thrift_spec = (
11015 kshitij.so 29743 
    None, # 0
29744 
    (1, TType.I64, 'source', None, None, ), # 1
29745 
    (2, TType.I64, 'offset', None, None, ), # 2
29746 
    (3, TType.I64, 'itemId', None, None, ), # 3
10909 vikram.rag 29747 
  )
29748 
 
11015 kshitij.so 29749 
  def __init__(self, source=None, offset=None, itemId=None,):
29750 
    self.source = source
29751 
    self.offset = offset
29752 
    self.itemId = itemId
29753 
 
10909 vikram.rag 29754 
  def read(self, iprot):
29755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29757 
      return
29758 
    iprot.readStructBegin()
29759 
    while True:
29760 
      (fname, ftype, fid) = iprot.readFieldBegin()
29761 
      if ftype == TType.STOP:
29762 
        break
11015 kshitij.so 29763 
      if fid == 1:
29764 
        if ftype == TType.I64:
29765 
          self.source = iprot.readI64();
29766 
        else:
29767 
          iprot.skip(ftype)
29768 
      elif fid == 2:
29769 
        if ftype == TType.I64:
29770 
          self.offset = iprot.readI64();
29771 
        else:
29772 
          iprot.skip(ftype)
29773 
      elif fid == 3:
29774 
        if ftype == TType.I64:
29775 
          self.itemId = iprot.readI64();
29776 
        else:
29777 
          iprot.skip(ftype)
10909 vikram.rag 29778 
      else:
29779 
        iprot.skip(ftype)
29780 
      iprot.readFieldEnd()
29781 
    iprot.readStructEnd()
29782 
 
29783 
  def write(self, oprot):
29784 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29785 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29786 
      return
11015 kshitij.so 29787 
    oprot.writeStructBegin('getMarketplaceHistory_args')
29788 
    if self.source is not None:
29789 
      oprot.writeFieldBegin('source', TType.I64, 1)
29790 
      oprot.writeI64(self.source)
29791 
      oprot.writeFieldEnd()
29792 
    if self.offset is not None:
29793 
      oprot.writeFieldBegin('offset', TType.I64, 2)
29794 
      oprot.writeI64(self.offset)
29795 
      oprot.writeFieldEnd()
29796 
    if self.itemId is not None:
29797 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
29798 
      oprot.writeI64(self.itemId)
29799 
      oprot.writeFieldEnd()
10909 vikram.rag 29800 
    oprot.writeFieldStop()
29801 
    oprot.writeStructEnd()
29802 
 
29803 
  def validate(self):
29804 
    return
29805 
 
29806 
 
29807 
  def __repr__(self):
29808 
    L = ['%s=%r' % (key, value)
29809 
      for key, value in self.__dict__.iteritems()]
29810 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29811 
 
29812 
  def __eq__(self, other):
29813 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29814 
 
29815 
  def __ne__(self, other):
29816 
    return not (self == other)
29817 
 
11015 kshitij.so 29818 
class getMarketplaceHistory_result:
10909 vikram.rag 29819 
  """
29820 
  Attributes:
29821 
   - success
29822 
  """
29823 
 
29824 
  thrift_spec = (
11015 kshitij.so 29825 
    (0, TType.LIST, 'success', (TType.STRUCT,(MarketplaceHistory, MarketplaceHistory.thrift_spec)), None, ), # 0
10909 vikram.rag 29826 
  )
29827 
 
29828 
  def __init__(self, success=None,):
29829 
    self.success = success
29830 
 
29831 
  def read(self, iprot):
29832 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29833 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29834 
      return
29835 
    iprot.readStructBegin()
29836 
    while True:
29837 
      (fname, ftype, fid) = iprot.readFieldBegin()
29838 
      if ftype == TType.STOP:
29839 
        break
29840 
      if fid == 0:
29841 
        if ftype == TType.LIST:
29842 
          self.success = []
18719 kshitij.so 29843 
          (_etype657, _size654) = iprot.readListBegin()
29844 
          for _i658 in xrange(_size654):
29845 
            _elem659 = MarketplaceHistory()
29846 
            _elem659.read(iprot)
29847 
            self.success.append(_elem659)
10909 vikram.rag 29848 
          iprot.readListEnd()
29849 
        else:
29850 
          iprot.skip(ftype)
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('getMarketplaceHistory_result')
10909 vikram.rag 29861 
    if self.success is not None:
29862 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29863 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 29864 
      for iter660 in self.success:
29865 
        iter660.write(oprot)
10909 vikram.rag 29866 
      oprot.writeListEnd()
29867 
      oprot.writeFieldEnd()
29868 
    oprot.writeFieldStop()
29869 
    oprot.writeStructEnd()
29870 
 
29871 
  def validate(self):
29872 
    return
29873 
 
29874 
 
29875 
  def __repr__(self):
29876 
    L = ['%s=%r' % (key, value)
29877 
      for key, value in self.__dict__.iteritems()]
29878 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29879 
 
29880 
  def __eq__(self, other):
29881 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29882 
 
29883 
  def __ne__(self, other):
29884 
    return not (self == other)
10924 vikram.rag 29885 
 
11015 kshitij.so 29886 
class getAllFbbListedItems_args:
10924 vikram.rag 29887 
 
29888 
  thrift_spec = (
29889 
  )
29890 
 
29891 
  def read(self, iprot):
29892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29894 
      return
29895 
    iprot.readStructBegin()
29896 
    while True:
29897 
      (fname, ftype, fid) = iprot.readFieldBegin()
29898 
      if ftype == TType.STOP:
29899 
        break
29900 
      else:
29901 
        iprot.skip(ftype)
29902 
      iprot.readFieldEnd()
29903 
    iprot.readStructEnd()
29904 
 
29905 
  def write(self, oprot):
29906 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29907 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29908 
      return
11015 kshitij.so 29909 
    oprot.writeStructBegin('getAllFbbListedItems_args')
10924 vikram.rag 29910 
    oprot.writeFieldStop()
29911 
    oprot.writeStructEnd()
29912 
 
29913 
  def validate(self):
29914 
    return
29915 
 
29916 
 
29917 
  def __repr__(self):
29918 
    L = ['%s=%r' % (key, value)
29919 
      for key, value in self.__dict__.iteritems()]
29920 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29921 
 
29922 
  def __eq__(self, other):
29923 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29924 
 
29925 
  def __ne__(self, other):
29926 
    return not (self == other)
29927 
 
11015 kshitij.so 29928 
class getAllFbbListedItems_result:
10924 vikram.rag 29929 
  """
29930 
  Attributes:
29931 
   - success
29932 
  """
29933 
 
29934 
  thrift_spec = (
29935 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
29936 
  )
29937 
 
29938 
  def __init__(self, success=None,):
29939 
    self.success = success
29940 
 
29941 
  def read(self, iprot):
29942 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29943 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29944 
      return
29945 
    iprot.readStructBegin()
29946 
    while True:
29947 
      (fname, ftype, fid) = iprot.readFieldBegin()
29948 
      if ftype == TType.STOP:
29949 
        break
29950 
      if fid == 0:
29951 
        if ftype == TType.LIST:
29952 
          self.success = []
18719 kshitij.so 29953 
          (_etype664, _size661) = iprot.readListBegin()
29954 
          for _i665 in xrange(_size661):
29955 
            _elem666 = Amazonlisted()
29956 
            _elem666.read(iprot)
29957 
            self.success.append(_elem666)
10924 vikram.rag 29958 
          iprot.readListEnd()
29959 
        else:
29960 
          iprot.skip(ftype)
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
11015 kshitij.so 29970 
    oprot.writeStructBegin('getAllFbbListedItems_result')
10924 vikram.rag 29971 
    if self.success is not None:
29972 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29973 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 29974 
      for iter667 in self.success:
29975 
        iter667.write(oprot)
10924 vikram.rag 29976 
      oprot.writeListEnd()
29977 
      oprot.writeFieldEnd()
29978 
    oprot.writeFieldStop()
29979 
    oprot.writeStructEnd()
29980 
 
29981 
  def validate(self):
29982 
    return
29983 
 
29984 
 
29985 
  def __repr__(self):
29986 
    L = ['%s=%r' % (key, value)
29987 
      for key, value in self.__dict__.iteritems()]
29988 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29989 
 
29990 
  def __eq__(self, other):
29991 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29992 
 
29993 
  def __ne__(self, other):
29994 
    return not (self == other)
11015 kshitij.so 29995 
 
29996 
class getAllFbbPricingItems_args:
29997 
 
29998 
  thrift_spec = (
29999 
  )
30000 
 
30001 
  def read(self, iprot):
30002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30004 
      return
30005 
    iprot.readStructBegin()
30006 
    while True:
30007 
      (fname, ftype, fid) = iprot.readFieldBegin()
30008 
      if ftype == TType.STOP:
30009 
        break
30010 
      else:
30011 
        iprot.skip(ftype)
30012 
      iprot.readFieldEnd()
30013 
    iprot.readStructEnd()
30014 
 
30015 
  def write(self, oprot):
30016 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30017 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30018 
      return
30019 
    oprot.writeStructBegin('getAllFbbPricingItems_args')
30020 
    oprot.writeFieldStop()
30021 
    oprot.writeStructEnd()
30022 
 
30023 
  def validate(self):
30024 
    return
30025 
 
30026 
 
30027 
  def __repr__(self):
30028 
    L = ['%s=%r' % (key, value)
30029 
      for key, value in self.__dict__.iteritems()]
30030 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30031 
 
30032 
  def __eq__(self, other):
30033 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30034 
 
30035 
  def __ne__(self, other):
30036 
    return not (self == other)
30037 
 
30038 
class getAllFbbPricingItems_result:
30039 
  """
30040 
  Attributes:
30041 
   - success
30042 
  """
30043 
 
30044 
  thrift_spec = (
30045 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
30046 
  )
30047 
 
30048 
  def __init__(self, success=None,):
30049 
    self.success = success
30050 
 
30051 
  def read(self, iprot):
30052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30054 
      return
30055 
    iprot.readStructBegin()
30056 
    while True:
30057 
      (fname, ftype, fid) = iprot.readFieldBegin()
30058 
      if ftype == TType.STOP:
30059 
        break
30060 
      if fid == 0:
30061 
        if ftype == TType.LIST:
30062 
          self.success = []
18719 kshitij.so 30063 
          (_etype671, _size668) = iprot.readListBegin()
30064 
          for _i672 in xrange(_size668):
30065 
            _elem673 = Amazonlisted()
30066 
            _elem673.read(iprot)
30067 
            self.success.append(_elem673)
11015 kshitij.so 30068 
          iprot.readListEnd()
30069 
        else:
30070 
          iprot.skip(ftype)
30071 
      else:
30072 
        iprot.skip(ftype)
30073 
      iprot.readFieldEnd()
30074 
    iprot.readStructEnd()
30075 
 
30076 
  def write(self, oprot):
30077 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30078 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30079 
      return
30080 
    oprot.writeStructBegin('getAllFbbPricingItems_result')
30081 
    if self.success is not None:
30082 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30083 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 30084 
      for iter674 in self.success:
30085 
        iter674.write(oprot)
11015 kshitij.so 30086 
      oprot.writeListEnd()
30087 
      oprot.writeFieldEnd()
30088 
    oprot.writeFieldStop()
30089 
    oprot.writeStructEnd()
30090 
 
30091 
  def validate(self):
30092 
    return
30093 
 
30094 
 
30095 
  def __repr__(self):
30096 
    L = ['%s=%r' % (key, value)
30097 
      for key, value in self.__dict__.iteritems()]
30098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30099 
 
30100 
  def __eq__(self, other):
30101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30102 
 
30103 
  def __ne__(self, other):
30104 
    return not (self == other)
30105 
 
30106 
class getCountForMarketplaceHistory_args:
30107 
  """
30108 
  Attributes:
30109 
   - source
30110 
   - itemId
30111 
  """
30112 
 
30113 
  thrift_spec = (
30114 
    None, # 0
30115 
    (1, TType.I64, 'source', None, None, ), # 1
30116 
    (2, TType.I64, 'itemId', None, None, ), # 2
30117 
  )
30118 
 
30119 
  def __init__(self, source=None, itemId=None,):
30120 
    self.source = source
30121 
    self.itemId = itemId
30122 
 
30123 
  def read(self, iprot):
30124 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30125 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30126 
      return
30127 
    iprot.readStructBegin()
30128 
    while True:
30129 
      (fname, ftype, fid) = iprot.readFieldBegin()
30130 
      if ftype == TType.STOP:
30131 
        break
30132 
      if fid == 1:
30133 
        if ftype == TType.I64:
30134 
          self.source = iprot.readI64();
30135 
        else:
30136 
          iprot.skip(ftype)
30137 
      elif fid == 2:
30138 
        if ftype == TType.I64:
30139 
          self.itemId = iprot.readI64();
30140 
        else:
30141 
          iprot.skip(ftype)
30142 
      else:
30143 
        iprot.skip(ftype)
30144 
      iprot.readFieldEnd()
30145 
    iprot.readStructEnd()
30146 
 
30147 
  def write(self, oprot):
30148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30150 
      return
30151 
    oprot.writeStructBegin('getCountForMarketplaceHistory_args')
30152 
    if self.source is not None:
30153 
      oprot.writeFieldBegin('source', TType.I64, 1)
30154 
      oprot.writeI64(self.source)
30155 
      oprot.writeFieldEnd()
30156 
    if self.itemId is not None:
30157 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
30158 
      oprot.writeI64(self.itemId)
30159 
      oprot.writeFieldEnd()
30160 
    oprot.writeFieldStop()
30161 
    oprot.writeStructEnd()
30162 
 
30163 
  def validate(self):
30164 
    return
30165 
 
30166 
 
30167 
  def __repr__(self):
30168 
    L = ['%s=%r' % (key, value)
30169 
      for key, value in self.__dict__.iteritems()]
30170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30171 
 
30172 
  def __eq__(self, other):
30173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30174 
 
30175 
  def __ne__(self, other):
30176 
    return not (self == other)
30177 
 
30178 
class getCountForMarketplaceHistory_result:
30179 
  """
30180 
  Attributes:
30181 
   - success
30182 
  """
30183 
 
30184 
  thrift_spec = (
30185 
    (0, TType.I64, 'success', None, None, ), # 0
30186 
  )
30187 
 
30188 
  def __init__(self, success=None,):
30189 
    self.success = success
30190 
 
30191 
  def read(self, iprot):
30192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30194 
      return
30195 
    iprot.readStructBegin()
30196 
    while True:
30197 
      (fname, ftype, fid) = iprot.readFieldBegin()
30198 
      if ftype == TType.STOP:
30199 
        break
30200 
      if fid == 0:
30201 
        if ftype == TType.I64:
30202 
          self.success = iprot.readI64();
30203 
        else:
30204 
          iprot.skip(ftype)
30205 
      else:
30206 
        iprot.skip(ftype)
30207 
      iprot.readFieldEnd()
30208 
    iprot.readStructEnd()
30209 
 
30210 
  def write(self, oprot):
30211 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30212 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30213 
      return
30214 
    oprot.writeStructBegin('getCountForMarketplaceHistory_result')
30215 
    if self.success is not None:
30216 
      oprot.writeFieldBegin('success', TType.I64, 0)
30217 
      oprot.writeI64(self.success)
30218 
      oprot.writeFieldEnd()
30219 
    oprot.writeFieldStop()
30220 
    oprot.writeStructEnd()
30221 
 
30222 
  def validate(self):
30223 
    return
30224 
 
30225 
 
30226 
  def __repr__(self):
30227 
    L = ['%s=%r' % (key, value)
30228 
      for key, value in self.__dict__.iteritems()]
30229 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30230 
 
30231 
  def __eq__(self, other):
30232 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30233 
 
30234 
  def __ne__(self, other):
30235 
    return not (self == other)
30236 
 
30237 
class getMarketplaceHistoryByDate_args:
30238 
  """
30239 
  Attributes:
30240 
   - source
30241 
   - startDate
30242 
   - endDate
30243 
   - offset
30244 
   - limit
30245 
   - itemId
30246 
  """
30247 
 
30248 
  thrift_spec = (
30249 
    None, # 0
30250 
    (1, TType.I64, 'source', None, None, ), # 1
30251 
    (2, TType.I64, 'startDate', None, None, ), # 2
30252 
    (3, TType.I64, 'endDate', None, None, ), # 3
30253 
    (4, TType.I64, 'offset', None, None, ), # 4
30254 
    (5, TType.I64, 'limit', None, None, ), # 5
30255 
    (6, TType.I64, 'itemId', None, None, ), # 6
30256 
  )
30257 
 
30258 
  def __init__(self, source=None, startDate=None, endDate=None, offset=None, limit=None, itemId=None,):
30259 
    self.source = source
30260 
    self.startDate = startDate
30261 
    self.endDate = endDate
30262 
    self.offset = offset
30263 
    self.limit = limit
30264 
    self.itemId = itemId
30265 
 
30266 
  def read(self, iprot):
30267 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30268 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30269 
      return
30270 
    iprot.readStructBegin()
30271 
    while True:
30272 
      (fname, ftype, fid) = iprot.readFieldBegin()
30273 
      if ftype == TType.STOP:
30274 
        break
30275 
      if fid == 1:
30276 
        if ftype == TType.I64:
30277 
          self.source = iprot.readI64();
30278 
        else:
30279 
          iprot.skip(ftype)
30280 
      elif fid == 2:
30281 
        if ftype == TType.I64:
30282 
          self.startDate = iprot.readI64();
30283 
        else:
30284 
          iprot.skip(ftype)
30285 
      elif fid == 3:
30286 
        if ftype == TType.I64:
30287 
          self.endDate = iprot.readI64();
30288 
        else:
30289 
          iprot.skip(ftype)
30290 
      elif fid == 4:
30291 
        if ftype == TType.I64:
30292 
          self.offset = iprot.readI64();
30293 
        else:
30294 
          iprot.skip(ftype)
30295 
      elif fid == 5:
30296 
        if ftype == TType.I64:
30297 
          self.limit = iprot.readI64();
30298 
        else:
30299 
          iprot.skip(ftype)
30300 
      elif fid == 6:
30301 
        if ftype == TType.I64:
30302 
          self.itemId = iprot.readI64();
30303 
        else:
30304 
          iprot.skip(ftype)
30305 
      else:
30306 
        iprot.skip(ftype)
30307 
      iprot.readFieldEnd()
30308 
    iprot.readStructEnd()
30309 
 
30310 
  def write(self, oprot):
30311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30313 
      return
30314 
    oprot.writeStructBegin('getMarketplaceHistoryByDate_args')
30315 
    if self.source is not None:
30316 
      oprot.writeFieldBegin('source', TType.I64, 1)
30317 
      oprot.writeI64(self.source)
30318 
      oprot.writeFieldEnd()
30319 
    if self.startDate is not None:
30320 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
30321 
      oprot.writeI64(self.startDate)
30322 
      oprot.writeFieldEnd()
30323 
    if self.endDate is not None:
30324 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
30325 
      oprot.writeI64(self.endDate)
30326 
      oprot.writeFieldEnd()
30327 
    if self.offset is not None:
30328 
      oprot.writeFieldBegin('offset', TType.I64, 4)
30329 
      oprot.writeI64(self.offset)
30330 
      oprot.writeFieldEnd()
30331 
    if self.limit is not None:
30332 
      oprot.writeFieldBegin('limit', TType.I64, 5)
30333 
      oprot.writeI64(self.limit)
30334 
      oprot.writeFieldEnd()
30335 
    if self.itemId is not None:
30336 
      oprot.writeFieldBegin('itemId', TType.I64, 6)
30337 
      oprot.writeI64(self.itemId)
30338 
      oprot.writeFieldEnd()
30339 
    oprot.writeFieldStop()
30340 
    oprot.writeStructEnd()
30341 
 
30342 
  def validate(self):
30343 
    return
30344 
 
30345 
 
30346 
  def __repr__(self):
30347 
    L = ['%s=%r' % (key, value)
30348 
      for key, value in self.__dict__.iteritems()]
30349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30350 
 
30351 
  def __eq__(self, other):
30352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30353 
 
30354 
  def __ne__(self, other):
30355 
    return not (self == other)
30356 
 
30357 
class getMarketplaceHistoryByDate_result:
30358 
  """
30359 
  Attributes:
30360 
   - success
30361 
  """
30362 
 
30363 
  thrift_spec = (
30364 
    (0, TType.LIST, 'success', (TType.STRUCT,(MarketplaceHistory, MarketplaceHistory.thrift_spec)), None, ), # 0
30365 
  )
30366 
 
30367 
  def __init__(self, success=None,):
30368 
    self.success = success
30369 
 
30370 
  def read(self, iprot):
30371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30373 
      return
30374 
    iprot.readStructBegin()
30375 
    while True:
30376 
      (fname, ftype, fid) = iprot.readFieldBegin()
30377 
      if ftype == TType.STOP:
30378 
        break
30379 
      if fid == 0:
30380 
        if ftype == TType.LIST:
30381 
          self.success = []
18719 kshitij.so 30382 
          (_etype678, _size675) = iprot.readListBegin()
30383 
          for _i679 in xrange(_size675):
30384 
            _elem680 = MarketplaceHistory()
30385 
            _elem680.read(iprot)
30386 
            self.success.append(_elem680)
11015 kshitij.so 30387 
          iprot.readListEnd()
30388 
        else:
30389 
          iprot.skip(ftype)
30390 
      else:
30391 
        iprot.skip(ftype)
30392 
      iprot.readFieldEnd()
30393 
    iprot.readStructEnd()
30394 
 
30395 
  def write(self, oprot):
30396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30398 
      return
30399 
    oprot.writeStructBegin('getMarketplaceHistoryByDate_result')
30400 
    if self.success is not None:
30401 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30402 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 30403 
      for iter681 in self.success:
30404 
        iter681.write(oprot)
11015 kshitij.so 30405 
      oprot.writeListEnd()
30406 
      oprot.writeFieldEnd()
30407 
    oprot.writeFieldStop()
30408 
    oprot.writeStructEnd()
30409 
 
30410 
  def validate(self):
30411 
    return
30412 
 
30413 
 
30414 
  def __repr__(self):
30415 
    L = ['%s=%r' % (key, value)
30416 
      for key, value in self.__dict__.iteritems()]
30417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30418 
 
30419 
  def __eq__(self, other):
30420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30421 
 
30422 
  def __ne__(self, other):
30423 
    return not (self == other)
11531 vikram.rag 30424 
 
30425 
class getPrivateDealDetails_args:
30426 
  """
30427 
  Attributes:
30428 
   - item_id
30429 
  """
30430 
 
30431 
  thrift_spec = (
30432 
    None, # 0
30433 
    (1, TType.I64, 'item_id', None, None, ), # 1
30434 
  )
30435 
 
30436 
  def __init__(self, item_id=None,):
30437 
    self.item_id = item_id
30438 
 
30439 
  def read(self, iprot):
30440 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30441 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30442 
      return
30443 
    iprot.readStructBegin()
30444 
    while True:
30445 
      (fname, ftype, fid) = iprot.readFieldBegin()
30446 
      if ftype == TType.STOP:
30447 
        break
30448 
      if fid == 1:
30449 
        if ftype == TType.I64:
30450 
          self.item_id = iprot.readI64();
30451 
        else:
30452 
          iprot.skip(ftype)
30453 
      else:
30454 
        iprot.skip(ftype)
30455 
      iprot.readFieldEnd()
30456 
    iprot.readStructEnd()
30457 
 
30458 
  def write(self, oprot):
30459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30461 
      return
30462 
    oprot.writeStructBegin('getPrivateDealDetails_args')
30463 
    if self.item_id is not None:
30464 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
30465 
      oprot.writeI64(self.item_id)
30466 
      oprot.writeFieldEnd()
30467 
    oprot.writeFieldStop()
30468 
    oprot.writeStructEnd()
30469 
 
30470 
  def validate(self):
30471 
    return
30472 
 
30473 
 
30474 
  def __repr__(self):
30475 
    L = ['%s=%r' % (key, value)
30476 
      for key, value in self.__dict__.iteritems()]
30477 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30478 
 
30479 
  def __eq__(self, other):
30480 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30481 
 
30482 
  def __ne__(self, other):
30483 
    return not (self == other)
30484 
 
30485 
class getPrivateDealDetails_result:
30486 
  """
30487 
  Attributes:
30488 
   - success
30489 
  """
30490 
 
30491 
  thrift_spec = (
30492 
    (0, TType.STRUCT, 'success', (PrivateDeal, PrivateDeal.thrift_spec), None, ), # 0
30493 
  )
30494 
 
30495 
  def __init__(self, success=None,):
30496 
    self.success = success
30497 
 
30498 
  def read(self, iprot):
30499 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30500 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30501 
      return
30502 
    iprot.readStructBegin()
30503 
    while True:
30504 
      (fname, ftype, fid) = iprot.readFieldBegin()
30505 
      if ftype == TType.STOP:
30506 
        break
30507 
      if fid == 0:
30508 
        if ftype == TType.STRUCT:
30509 
          self.success = PrivateDeal()
30510 
          self.success.read(iprot)
30511 
        else:
30512 
          iprot.skip(ftype)
30513 
      else:
30514 
        iprot.skip(ftype)
30515 
      iprot.readFieldEnd()
30516 
    iprot.readStructEnd()
30517 
 
30518 
  def write(self, oprot):
30519 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30520 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30521 
      return
30522 
    oprot.writeStructBegin('getPrivateDealDetails_result')
30523 
    if self.success is not None:
30524 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
30525 
      self.success.write(oprot)
30526 
      oprot.writeFieldEnd()
30527 
    oprot.writeFieldStop()
30528 
    oprot.writeStructEnd()
30529 
 
30530 
  def validate(self):
30531 
    return
30532 
 
30533 
 
30534 
  def __repr__(self):
30535 
    L = ['%s=%r' % (key, value)
30536 
      for key, value in self.__dict__.iteritems()]
30537 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30538 
 
30539 
  def __eq__(self, other):
30540 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30541 
 
30542 
  def __ne__(self, other):
30543 
    return not (self == other)
30544 
 
30545 
class getPrivateDealItems_args:
30546 
  """
30547 
  Attributes:
30548 
   - offset
30549 
   - limit
30550 
  """
30551 
 
30552 
  thrift_spec = (
30553 
    None, # 0
30554 
    (1, TType.I64, 'offset', None, None, ), # 1
30555 
    (2, TType.I64, 'limit', None, None, ), # 2
30556 
  )
30557 
 
30558 
  def __init__(self, offset=None, limit=None,):
30559 
    self.offset = offset
30560 
    self.limit = limit
30561 
 
30562 
  def read(self, iprot):
30563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30565 
      return
30566 
    iprot.readStructBegin()
30567 
    while True:
30568 
      (fname, ftype, fid) = iprot.readFieldBegin()
30569 
      if ftype == TType.STOP:
30570 
        break
30571 
      if fid == 1:
30572 
        if ftype == TType.I64:
30573 
          self.offset = iprot.readI64();
30574 
        else:
30575 
          iprot.skip(ftype)
30576 
      elif fid == 2:
30577 
        if ftype == TType.I64:
30578 
          self.limit = iprot.readI64();
30579 
        else:
30580 
          iprot.skip(ftype)
30581 
      else:
30582 
        iprot.skip(ftype)
30583 
      iprot.readFieldEnd()
30584 
    iprot.readStructEnd()
30585 
 
30586 
  def write(self, oprot):
30587 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30588 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30589 
      return
30590 
    oprot.writeStructBegin('getPrivateDealItems_args')
30591 
    if self.offset is not None:
30592 
      oprot.writeFieldBegin('offset', TType.I64, 1)
30593 
      oprot.writeI64(self.offset)
30594 
      oprot.writeFieldEnd()
30595 
    if self.limit is not None:
30596 
      oprot.writeFieldBegin('limit', TType.I64, 2)
30597 
      oprot.writeI64(self.limit)
30598 
      oprot.writeFieldEnd()
30599 
    oprot.writeFieldStop()
30600 
    oprot.writeStructEnd()
30601 
 
30602 
  def validate(self):
30603 
    return
30604 
 
30605 
 
30606 
  def __repr__(self):
30607 
    L = ['%s=%r' % (key, value)
30608 
      for key, value in self.__dict__.iteritems()]
30609 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30610 
 
30611 
  def __eq__(self, other):
30612 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30613 
 
30614 
  def __ne__(self, other):
30615 
    return not (self == other)
30616 
 
30617 
class getPrivateDealItems_result:
30618 
  """
30619 
  Attributes:
30620 
   - success
30621 
  """
30622 
 
30623 
  thrift_spec = (
30624 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
30625 
  )
30626 
 
30627 
  def __init__(self, success=None,):
30628 
    self.success = success
30629 
 
30630 
  def read(self, iprot):
30631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30633 
      return
30634 
    iprot.readStructBegin()
30635 
    while True:
30636 
      (fname, ftype, fid) = iprot.readFieldBegin()
30637 
      if ftype == TType.STOP:
30638 
        break
30639 
      if fid == 0:
30640 
        if ftype == TType.LIST:
30641 
          self.success = []
18719 kshitij.so 30642 
          (_etype685, _size682) = iprot.readListBegin()
30643 
          for _i686 in xrange(_size682):
30644 
            _elem687 = Item()
30645 
            _elem687.read(iprot)
30646 
            self.success.append(_elem687)
11531 vikram.rag 30647 
          iprot.readListEnd()
30648 
        else:
30649 
          iprot.skip(ftype)
30650 
      else:
30651 
        iprot.skip(ftype)
30652 
      iprot.readFieldEnd()
30653 
    iprot.readStructEnd()
30654 
 
30655 
  def write(self, oprot):
30656 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30657 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30658 
      return
30659 
    oprot.writeStructBegin('getPrivateDealItems_result')
30660 
    if self.success is not None:
30661 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30662 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 30663 
      for iter688 in self.success:
30664 
        iter688.write(oprot)
11531 vikram.rag 30665 
      oprot.writeListEnd()
30666 
      oprot.writeFieldEnd()
30667 
    oprot.writeFieldStop()
30668 
    oprot.writeStructEnd()
30669 
 
30670 
  def validate(self):
30671 
    return
30672 
 
30673 
 
30674 
  def __repr__(self):
30675 
    L = ['%s=%r' % (key, value)
30676 
      for key, value in self.__dict__.iteritems()]
30677 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30678 
 
30679 
  def __eq__(self, other):
30680 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30681 
 
30682 
  def __ne__(self, other):
30683 
    return not (self == other)
30684 
 
11592 amit.gupta 30685 
class getAllActivePrivateDeals_args:
11653 amit.gupta 30686 
  """
30687 
  Attributes:
30688 
   - itemIds
30689 
   - daysDelta
30690 
  """
11592 amit.gupta 30691 
 
30692 
  thrift_spec = (
11653 amit.gupta 30693 
    None, # 0
30694 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
30695 
    (2, TType.I64, 'daysDelta', None, None, ), # 2
11592 amit.gupta 30696 
  )
30697 
 
11653 amit.gupta 30698 
  def __init__(self, itemIds=None, daysDelta=None,):
30699 
    self.itemIds = itemIds
30700 
    self.daysDelta = daysDelta
30701 
 
11592 amit.gupta 30702 
  def read(self, iprot):
30703 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30704 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30705 
      return
30706 
    iprot.readStructBegin()
30707 
    while True:
30708 
      (fname, ftype, fid) = iprot.readFieldBegin()
30709 
      if ftype == TType.STOP:
30710 
        break
11653 amit.gupta 30711 
      if fid == 1:
30712 
        if ftype == TType.LIST:
30713 
          self.itemIds = []
18719 kshitij.so 30714 
          (_etype692, _size689) = iprot.readListBegin()
30715 
          for _i693 in xrange(_size689):
30716 
            _elem694 = iprot.readI64();
30717 
            self.itemIds.append(_elem694)
11653 amit.gupta 30718 
          iprot.readListEnd()
30719 
        else:
30720 
          iprot.skip(ftype)
30721 
      elif fid == 2:
30722 
        if ftype == TType.I64:
30723 
          self.daysDelta = iprot.readI64();
30724 
        else:
30725 
          iprot.skip(ftype)
11592 amit.gupta 30726 
      else:
30727 
        iprot.skip(ftype)
30728 
      iprot.readFieldEnd()
30729 
    iprot.readStructEnd()
30730 
 
30731 
  def write(self, oprot):
30732 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30733 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30734 
      return
30735 
    oprot.writeStructBegin('getAllActivePrivateDeals_args')
11653 amit.gupta 30736 
    if self.itemIds is not None:
30737 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
30738 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
18719 kshitij.so 30739 
      for iter695 in self.itemIds:
30740 
        oprot.writeI64(iter695)
11653 amit.gupta 30741 
      oprot.writeListEnd()
30742 
      oprot.writeFieldEnd()
30743 
    if self.daysDelta is not None:
30744 
      oprot.writeFieldBegin('daysDelta', TType.I64, 2)
30745 
      oprot.writeI64(self.daysDelta)
30746 
      oprot.writeFieldEnd()
11592 amit.gupta 30747 
    oprot.writeFieldStop()
30748 
    oprot.writeStructEnd()
30749 
 
30750 
  def validate(self):
30751 
    return
30752 
 
30753 
 
30754 
  def __repr__(self):
30755 
    L = ['%s=%r' % (key, value)
30756 
      for key, value in self.__dict__.iteritems()]
30757 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30758 
 
30759 
  def __eq__(self, other):
30760 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30761 
 
30762 
  def __ne__(self, other):
30763 
    return not (self == other)
30764 
 
30765 
class getAllActivePrivateDeals_result:
30766 
  """
30767 
  Attributes:
30768 
   - success
30769 
  """
30770 
 
30771 
  thrift_spec = (
30772 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRUCT,(PrivateDeal, PrivateDeal.thrift_spec)), None, ), # 0
30773 
  )
30774 
 
30775 
  def __init__(self, success=None,):
30776 
    self.success = success
30777 
 
30778 
  def read(self, iprot):
30779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30781 
      return
30782 
    iprot.readStructBegin()
30783 
    while True:
30784 
      (fname, ftype, fid) = iprot.readFieldBegin()
30785 
      if ftype == TType.STOP:
30786 
        break
30787 
      if fid == 0:
30788 
        if ftype == TType.MAP:
30789 
          self.success = {}
18719 kshitij.so 30790 
          (_ktype697, _vtype698, _size696 ) = iprot.readMapBegin()
30791 
          for _i700 in xrange(_size696):
30792 
            _key701 = iprot.readI64();
30793 
            _val702 = PrivateDeal()
30794 
            _val702.read(iprot)
30795 
            self.success[_key701] = _val702
11592 amit.gupta 30796 
          iprot.readMapEnd()
30797 
        else:
30798 
          iprot.skip(ftype)
30799 
      else:
30800 
        iprot.skip(ftype)
30801 
      iprot.readFieldEnd()
30802 
    iprot.readStructEnd()
30803 
 
30804 
  def write(self, oprot):
30805 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30806 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30807 
      return
30808 
    oprot.writeStructBegin('getAllActivePrivateDeals_result')
30809 
    if self.success is not None:
30810 
      oprot.writeFieldBegin('success', TType.MAP, 0)
30811 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.success))
18719 kshitij.so 30812 
      for kiter703,viter704 in self.success.items():
30813 
        oprot.writeI64(kiter703)
30814 
        viter704.write(oprot)
11592 amit.gupta 30815 
      oprot.writeMapEnd()
30816 
      oprot.writeFieldEnd()
30817 
    oprot.writeFieldStop()
30818 
    oprot.writeStructEnd()
30819 
 
30820 
  def validate(self):
30821 
    return
30822 
 
30823 
 
30824 
  def __repr__(self):
30825 
    L = ['%s=%r' % (key, value)
30826 
      for key, value in self.__dict__.iteritems()]
30827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30828 
 
30829 
  def __eq__(self, other):
30830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30831 
 
30832 
  def __ne__(self, other):
30833 
    return not (self == other)
30834 
 
11531 vikram.rag 30835 
class addOrUpdatePrivateDeal_args:
30836 
  """
30837 
  Attributes:
30838 
   - privateDeal
30839 
  """
30840 
 
30841 
  thrift_spec = (
30842 
    None, # 0
30843 
    (1, TType.STRUCT, 'privateDeal', (PrivateDeal, PrivateDeal.thrift_spec), None, ), # 1
30844 
  )
30845 
 
30846 
  def __init__(self, privateDeal=None,):
30847 
    self.privateDeal = privateDeal
30848 
 
30849 
  def read(self, iprot):
30850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30852 
      return
30853 
    iprot.readStructBegin()
30854 
    while True:
30855 
      (fname, ftype, fid) = iprot.readFieldBegin()
30856 
      if ftype == TType.STOP:
30857 
        break
30858 
      if fid == 1:
30859 
        if ftype == TType.STRUCT:
30860 
          self.privateDeal = PrivateDeal()
30861 
          self.privateDeal.read(iprot)
30862 
        else:
30863 
          iprot.skip(ftype)
30864 
      else:
30865 
        iprot.skip(ftype)
30866 
      iprot.readFieldEnd()
30867 
    iprot.readStructEnd()
30868 
 
30869 
  def write(self, oprot):
30870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30872 
      return
30873 
    oprot.writeStructBegin('addOrUpdatePrivateDeal_args')
30874 
    if self.privateDeal is not None:
30875 
      oprot.writeFieldBegin('privateDeal', TType.STRUCT, 1)
30876 
      self.privateDeal.write(oprot)
30877 
      oprot.writeFieldEnd()
30878 
    oprot.writeFieldStop()
30879 
    oprot.writeStructEnd()
30880 
 
30881 
  def validate(self):
30882 
    return
30883 
 
30884 
 
30885 
  def __repr__(self):
30886 
    L = ['%s=%r' % (key, value)
30887 
      for key, value in self.__dict__.iteritems()]
30888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30889 
 
30890 
  def __eq__(self, other):
30891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30892 
 
30893 
  def __ne__(self, other):
30894 
    return not (self == other)
30895 
 
30896 
class addOrUpdatePrivateDeal_result:
30897 
  """
30898 
  Attributes:
30899 
   - success
30900 
  """
30901 
 
30902 
  thrift_spec = (
30903 
    (0, TType.BOOL, 'success', None, None, ), # 0
30904 
  )
30905 
 
30906 
  def __init__(self, success=None,):
30907 
    self.success = success
30908 
 
30909 
  def read(self, iprot):
30910 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30911 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30912 
      return
30913 
    iprot.readStructBegin()
30914 
    while True:
30915 
      (fname, ftype, fid) = iprot.readFieldBegin()
30916 
      if ftype == TType.STOP:
30917 
        break
30918 
      if fid == 0:
30919 
        if ftype == TType.BOOL:
30920 
          self.success = iprot.readBool();
30921 
        else:
30922 
          iprot.skip(ftype)
30923 
      else:
30924 
        iprot.skip(ftype)
30925 
      iprot.readFieldEnd()
30926 
    iprot.readStructEnd()
30927 
 
30928 
  def write(self, oprot):
30929 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30930 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30931 
      return
30932 
    oprot.writeStructBegin('addOrUpdatePrivateDeal_result')
30933 
    if self.success is not None:
30934 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
30935 
      oprot.writeBool(self.success)
30936 
      oprot.writeFieldEnd()
30937 
    oprot.writeFieldStop()
30938 
    oprot.writeStructEnd()
30939 
 
30940 
  def validate(self):
30941 
    return
30942 
 
30943 
 
30944 
  def __repr__(self):
30945 
    L = ['%s=%r' % (key, value)
30946 
      for key, value in self.__dict__.iteritems()]
30947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30948 
 
30949 
  def __eq__(self, other):
30950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30951 
 
30952 
  def __ne__(self, other):
30953 
    return not (self == other)
11635 vikram.rag 30954 
 
30955 
class getPrivateDealsCatalogIds_args:
30956 
  """
30957 
  Attributes:
30958 
   - beginIndex
30959 
   - totalItems
30960 
  """
30961 
 
30962 
  thrift_spec = (
30963 
    None, # 0
30964 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
30965 
    (2, TType.I64, 'totalItems', None, None, ), # 2
30966 
  )
30967 
 
30968 
  def __init__(self, beginIndex=None, totalItems=None,):
30969 
    self.beginIndex = beginIndex
30970 
    self.totalItems = totalItems
30971 
 
30972 
  def read(self, iprot):
30973 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30974 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30975 
      return
30976 
    iprot.readStructBegin()
30977 
    while True:
30978 
      (fname, ftype, fid) = iprot.readFieldBegin()
30979 
      if ftype == TType.STOP:
30980 
        break
30981 
      if fid == 1:
30982 
        if ftype == TType.I64:
30983 
          self.beginIndex = iprot.readI64();
30984 
        else:
30985 
          iprot.skip(ftype)
30986 
      elif fid == 2:
30987 
        if ftype == TType.I64:
30988 
          self.totalItems = iprot.readI64();
30989 
        else:
30990 
          iprot.skip(ftype)
30991 
      else:
30992 
        iprot.skip(ftype)
30993 
      iprot.readFieldEnd()
30994 
    iprot.readStructEnd()
30995 
 
30996 
  def write(self, oprot):
30997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30999 
      return
31000 
    oprot.writeStructBegin('getPrivateDealsCatalogIds_args')
31001 
    if self.beginIndex is not None:
31002 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
31003 
      oprot.writeI64(self.beginIndex)
31004 
      oprot.writeFieldEnd()
31005 
    if self.totalItems is not None:
31006 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
31007 
      oprot.writeI64(self.totalItems)
31008 
      oprot.writeFieldEnd()
31009 
    oprot.writeFieldStop()
31010 
    oprot.writeStructEnd()
31011 
 
31012 
  def validate(self):
31013 
    return
31014 
 
31015 
 
31016 
  def __repr__(self):
31017 
    L = ['%s=%r' % (key, value)
31018 
      for key, value in self.__dict__.iteritems()]
31019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31020 
 
31021 
  def __eq__(self, other):
31022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31023 
 
31024 
  def __ne__(self, other):
31025 
    return not (self == other)
31026 
 
31027 
class getPrivateDealsCatalogIds_result:
31028 
  """
31029 
  Attributes:
31030 
   - success
31031 
   - cex
31032 
  """
31033 
 
31034 
  thrift_spec = (
31035 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
31036 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
31037 
  )
31038 
 
31039 
  def __init__(self, success=None, cex=None,):
31040 
    self.success = success
31041 
    self.cex = cex
31042 
 
31043 
  def read(self, iprot):
31044 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31045 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31046 
      return
31047 
    iprot.readStructBegin()
31048 
    while True:
31049 
      (fname, ftype, fid) = iprot.readFieldBegin()
31050 
      if ftype == TType.STOP:
31051 
        break
31052 
      if fid == 0:
31053 
        if ftype == TType.LIST:
31054 
          self.success = []
18719 kshitij.so 31055 
          (_etype708, _size705) = iprot.readListBegin()
31056 
          for _i709 in xrange(_size705):
31057 
            _elem710 = iprot.readI64();
31058 
            self.success.append(_elem710)
11635 vikram.rag 31059 
          iprot.readListEnd()
31060 
        else:
31061 
          iprot.skip(ftype)
31062 
      elif fid == 1:
31063 
        if ftype == TType.STRUCT:
31064 
          self.cex = CatalogServiceException()
31065 
          self.cex.read(iprot)
31066 
        else:
31067 
          iprot.skip(ftype)
31068 
      else:
31069 
        iprot.skip(ftype)
31070 
      iprot.readFieldEnd()
31071 
    iprot.readStructEnd()
31072 
 
31073 
  def write(self, oprot):
31074 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31075 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31076 
      return
31077 
    oprot.writeStructBegin('getPrivateDealsCatalogIds_result')
31078 
    if self.success is not None:
31079 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31080 
      oprot.writeListBegin(TType.I64, len(self.success))
18719 kshitij.so 31081 
      for iter711 in self.success:
31082 
        oprot.writeI64(iter711)
11635 vikram.rag 31083 
      oprot.writeListEnd()
31084 
      oprot.writeFieldEnd()
31085 
    if self.cex is not None:
31086 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
31087 
      self.cex.write(oprot)
31088 
      oprot.writeFieldEnd()
31089 
    oprot.writeFieldStop()
31090 
    oprot.writeStructEnd()
31091 
 
31092 
  def validate(self):
31093 
    return
31094 
 
31095 
 
31096 
  def __repr__(self):
31097 
    L = ['%s=%r' % (key, value)
31098 
      for key, value in self.__dict__.iteritems()]
31099 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31100 
 
31101 
  def __eq__(self, other):
31102 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31103 
 
31104 
  def __ne__(self, other):
31105 
    return not (self == other)
11645 amit.gupta 31106 
 
31107 
class getPrivateDealsCount_args:
31108 
 
31109 
  thrift_spec = (
31110 
  )
31111 
 
31112 
  def read(self, iprot):
31113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31115 
      return
31116 
    iprot.readStructBegin()
31117 
    while True:
31118 
      (fname, ftype, fid) = iprot.readFieldBegin()
31119 
      if ftype == TType.STOP:
31120 
        break
31121 
      else:
31122 
        iprot.skip(ftype)
31123 
      iprot.readFieldEnd()
31124 
    iprot.readStructEnd()
31125 
 
31126 
  def write(self, oprot):
31127 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31128 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31129 
      return
31130 
    oprot.writeStructBegin('getPrivateDealsCount_args')
31131 
    oprot.writeFieldStop()
31132 
    oprot.writeStructEnd()
31133 
 
31134 
  def validate(self):
31135 
    return
31136 
 
31137 
 
31138 
  def __repr__(self):
31139 
    L = ['%s=%r' % (key, value)
31140 
      for key, value in self.__dict__.iteritems()]
31141 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31142 
 
31143 
  def __eq__(self, other):
31144 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31145 
 
31146 
  def __ne__(self, other):
31147 
    return not (self == other)
31148 
 
31149 
class getPrivateDealsCount_result:
31150 
  """
31151 
  Attributes:
31152 
   - success
31153 
  """
31154 
 
31155 
  thrift_spec = (
31156 
    (0, TType.I32, 'success', None, None, ), # 0
31157 
  )
31158 
 
31159 
  def __init__(self, success=None,):
31160 
    self.success = success
31161 
 
31162 
  def read(self, iprot):
31163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31165 
      return
31166 
    iprot.readStructBegin()
31167 
    while True:
31168 
      (fname, ftype, fid) = iprot.readFieldBegin()
31169 
      if ftype == TType.STOP:
31170 
        break
31171 
      if fid == 0:
31172 
        if ftype == TType.I32:
31173 
          self.success = iprot.readI32();
31174 
        else:
31175 
          iprot.skip(ftype)
31176 
      else:
31177 
        iprot.skip(ftype)
31178 
      iprot.readFieldEnd()
31179 
    iprot.readStructEnd()
31180 
 
31181 
  def write(self, oprot):
31182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31184 
      return
31185 
    oprot.writeStructBegin('getPrivateDealsCount_result')
31186 
    if self.success is not None:
31187 
      oprot.writeFieldBegin('success', TType.I32, 0)
31188 
      oprot.writeI32(self.success)
31189 
      oprot.writeFieldEnd()
31190 
    oprot.writeFieldStop()
31191 
    oprot.writeStructEnd()
31192 
 
31193 
  def validate(self):
31194 
    return
31195 
 
31196 
 
31197 
  def __repr__(self):
31198 
    L = ['%s=%r' % (key, value)
31199 
      for key, value in self.__dict__.iteritems()]
31200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31201 
 
31202 
  def __eq__(self, other):
31203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31204 
 
31205 
  def __ne__(self, other):
31206 
    return not (self == other)
11905 kshitij.so 31207 
 
31208 
class getAmazonOutSyncItems_args:
31209 
  """
31210 
  Attributes:
31211 
   - item_id
31212 
  """
31213 
 
31214 
  thrift_spec = (
31215 
    None, # 0
31216 
    (1, TType.I64, 'item_id', None, None, ), # 1
31217 
  )
31218 
 
31219 
  def __init__(self, item_id=None,):
31220 
    self.item_id = item_id
31221 
 
31222 
  def read(self, iprot):
31223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31225 
      return
31226 
    iprot.readStructBegin()
31227 
    while True:
31228 
      (fname, ftype, fid) = iprot.readFieldBegin()
31229 
      if ftype == TType.STOP:
31230 
        break
31231 
      if fid == 1:
31232 
        if ftype == TType.I64:
31233 
          self.item_id = iprot.readI64();
31234 
        else:
31235 
          iprot.skip(ftype)
31236 
      else:
31237 
        iprot.skip(ftype)
31238 
      iprot.readFieldEnd()
31239 
    iprot.readStructEnd()
31240 
 
31241 
  def write(self, oprot):
31242 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31243 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31244 
      return
31245 
    oprot.writeStructBegin('getAmazonOutSyncItems_args')
31246 
    if self.item_id is not None:
31247 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
31248 
      oprot.writeI64(self.item_id)
31249 
      oprot.writeFieldEnd()
31250 
    oprot.writeFieldStop()
31251 
    oprot.writeStructEnd()
31252 
 
31253 
  def validate(self):
31254 
    return
31255 
 
31256 
 
31257 
  def __repr__(self):
31258 
    L = ['%s=%r' % (key, value)
31259 
      for key, value in self.__dict__.iteritems()]
31260 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31261 
 
31262 
  def __eq__(self, other):
31263 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31264 
 
31265 
  def __ne__(self, other):
31266 
    return not (self == other)
31267 
 
31268 
class getAmazonOutSyncItems_result:
31269 
  """
31270 
  Attributes:
31271 
   - success
31272 
  """
31273 
 
31274 
  thrift_spec = (
31275 
    (0, TType.STRUCT, 'success', (AmazonOutOfSync, AmazonOutOfSync.thrift_spec), None, ), # 0
31276 
  )
31277 
 
31278 
  def __init__(self, success=None,):
31279 
    self.success = success
31280 
 
31281 
  def read(self, iprot):
31282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31284 
      return
31285 
    iprot.readStructBegin()
31286 
    while True:
31287 
      (fname, ftype, fid) = iprot.readFieldBegin()
31288 
      if ftype == TType.STOP:
31289 
        break
31290 
      if fid == 0:
31291 
        if ftype == TType.STRUCT:
31292 
          self.success = AmazonOutOfSync()
31293 
          self.success.read(iprot)
31294 
        else:
31295 
          iprot.skip(ftype)
31296 
      else:
31297 
        iprot.skip(ftype)
31298 
      iprot.readFieldEnd()
31299 
    iprot.readStructEnd()
31300 
 
31301 
  def write(self, oprot):
31302 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31303 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31304 
      return
31305 
    oprot.writeStructBegin('getAmazonOutSyncItems_result')
31306 
    if self.success is not None:
31307 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
31308 
      self.success.write(oprot)
31309 
      oprot.writeFieldEnd()
31310 
    oprot.writeFieldStop()
31311 
    oprot.writeStructEnd()
31312 
 
31313 
  def validate(self):
31314 
    return
31315 
 
31316 
 
31317 
  def __repr__(self):
31318 
    L = ['%s=%r' % (key, value)
31319 
      for key, value in self.__dict__.iteritems()]
31320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31321 
 
31322 
  def __eq__(self, other):
31323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31324 
 
31325 
  def __ne__(self, other):
31326 
    return not (self == other)
31327 
 
31328 
class getAllPrivateDealsComparison_args:
31329 
 
31330 
  thrift_spec = (
31331 
  )
31332 
 
31333 
  def read(self, iprot):
31334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31336 
      return
31337 
    iprot.readStructBegin()
31338 
    while True:
31339 
      (fname, ftype, fid) = iprot.readFieldBegin()
31340 
      if ftype == TType.STOP:
31341 
        break
31342 
      else:
31343 
        iprot.skip(ftype)
31344 
      iprot.readFieldEnd()
31345 
    iprot.readStructEnd()
31346 
 
31347 
  def write(self, oprot):
31348 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31349 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31350 
      return
31351 
    oprot.writeStructBegin('getAllPrivateDealsComparison_args')
31352 
    oprot.writeFieldStop()
31353 
    oprot.writeStructEnd()
31354 
 
31355 
  def validate(self):
31356 
    return
31357 
 
31358 
 
31359 
  def __repr__(self):
31360 
    L = ['%s=%r' % (key, value)
31361 
      for key, value in self.__dict__.iteritems()]
31362 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31363 
 
31364 
  def __eq__(self, other):
31365 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31366 
 
31367 
  def __ne__(self, other):
31368 
    return not (self == other)
31369 
 
31370 
class getAllPrivateDealsComparison_result:
31371 
  """
31372 
  Attributes:
31373 
   - success
31374 
  """
31375 
 
31376 
  thrift_spec = (
31377 
    (0, TType.LIST, 'success', (TType.STRUCT,(PdPriceComp, PdPriceComp.thrift_spec)), None, ), # 0
31378 
  )
31379 
 
31380 
  def __init__(self, success=None,):
31381 
    self.success = success
31382 
 
31383 
  def read(self, iprot):
31384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31386 
      return
31387 
    iprot.readStructBegin()
31388 
    while True:
31389 
      (fname, ftype, fid) = iprot.readFieldBegin()
31390 
      if ftype == TType.STOP:
31391 
        break
31392 
      if fid == 0:
31393 
        if ftype == TType.LIST:
31394 
          self.success = []
18719 kshitij.so 31395 
          (_etype715, _size712) = iprot.readListBegin()
31396 
          for _i716 in xrange(_size712):
31397 
            _elem717 = PdPriceComp()
31398 
            _elem717.read(iprot)
31399 
            self.success.append(_elem717)
11905 kshitij.so 31400 
          iprot.readListEnd()
31401 
        else:
31402 
          iprot.skip(ftype)
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('getAllPrivateDealsComparison_result')
31413 
    if self.success is not None:
31414 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31415 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 31416 
      for iter718 in self.success:
31417 
        iter718.write(oprot)
11905 kshitij.so 31418 
      oprot.writeListEnd()
31419 
      oprot.writeFieldEnd()
31420 
    oprot.writeFieldStop()
31421 
    oprot.writeStructEnd()
31422 
 
31423 
  def validate(self):
31424 
    return
31425 
 
31426 
 
31427 
  def __repr__(self):
31428 
    L = ['%s=%r' % (key, value)
31429 
      for key, value in self.__dict__.iteritems()]
31430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31431 
 
31432 
  def __eq__(self, other):
31433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31434 
 
31435 
  def __ne__(self, other):
31436 
    return not (self == other)
12133 kshitij.so 31437 
 
31438 
class getAllSnapdealMarketplaceItem_args:
31439 
 
31440 
  thrift_spec = (
31441 
  )
31442 
 
31443 
  def read(self, iprot):
31444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31446 
      return
31447 
    iprot.readStructBegin()
31448 
    while True:
31449 
      (fname, ftype, fid) = iprot.readFieldBegin()
31450 
      if ftype == TType.STOP:
31451 
        break
31452 
      else:
31453 
        iprot.skip(ftype)
31454 
      iprot.readFieldEnd()
31455 
    iprot.readStructEnd()
31456 
 
31457 
  def write(self, oprot):
31458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31460 
      return
31461 
    oprot.writeStructBegin('getAllSnapdealMarketplaceItem_args')
31462 
    oprot.writeFieldStop()
31463 
    oprot.writeStructEnd()
31464 
 
31465 
  def validate(self):
31466 
    return
31467 
 
31468 
 
31469 
  def __repr__(self):
31470 
    L = ['%s=%r' % (key, value)
31471 
      for key, value in self.__dict__.iteritems()]
31472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31473 
 
31474 
  def __eq__(self, other):
31475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31476 
 
31477 
  def __ne__(self, other):
31478 
    return not (self == other)
31479 
 
31480 
class getAllSnapdealMarketplaceItem_result:
31481 
  """
31482 
  Attributes:
31483 
   - success
31484 
  """
31485 
 
31486 
  thrift_spec = (
31487 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItem, SnapdealItem.thrift_spec)), None, ), # 0
31488 
  )
31489 
 
31490 
  def __init__(self, success=None,):
31491 
    self.success = success
31492 
 
31493 
  def read(self, iprot):
31494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31496 
      return
31497 
    iprot.readStructBegin()
31498 
    while True:
31499 
      (fname, ftype, fid) = iprot.readFieldBegin()
31500 
      if ftype == TType.STOP:
31501 
        break
31502 
      if fid == 0:
31503 
        if ftype == TType.LIST:
31504 
          self.success = []
18719 kshitij.so 31505 
          (_etype722, _size719) = iprot.readListBegin()
31506 
          for _i723 in xrange(_size719):
31507 
            _elem724 = SnapdealItem()
31508 
            _elem724.read(iprot)
31509 
            self.success.append(_elem724)
12133 kshitij.so 31510 
          iprot.readListEnd()
31511 
        else:
31512 
          iprot.skip(ftype)
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('getAllSnapdealMarketplaceItem_result')
31523 
    if self.success is not None:
31524 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31525 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 31526 
      for iter725 in self.success:
31527 
        iter725.write(oprot)
12133 kshitij.so 31528 
      oprot.writeListEnd()
31529 
      oprot.writeFieldEnd()
31530 
    oprot.writeFieldStop()
31531 
    oprot.writeStructEnd()
31532 
 
31533 
  def validate(self):
31534 
    return
31535 
 
31536 
 
31537 
  def __repr__(self):
31538 
    L = ['%s=%r' % (key, value)
31539 
      for key, value in self.__dict__.iteritems()]
31540 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31541 
 
31542 
  def __eq__(self, other):
31543 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31544 
 
31545 
  def __ne__(self, other):
31546 
    return not (self == other)
31547 
 
31548 
class getAllFlipkartMarketplaceItem_args:
31549 
 
31550 
  thrift_spec = (
31551 
  )
31552 
 
31553 
  def read(self, iprot):
31554 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31555 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31556 
      return
31557 
    iprot.readStructBegin()
31558 
    while True:
31559 
      (fname, ftype, fid) = iprot.readFieldBegin()
31560 
      if ftype == TType.STOP:
31561 
        break
31562 
      else:
31563 
        iprot.skip(ftype)
31564 
      iprot.readFieldEnd()
31565 
    iprot.readStructEnd()
31566 
 
31567 
  def write(self, oprot):
31568 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31569 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31570 
      return
31571 
    oprot.writeStructBegin('getAllFlipkartMarketplaceItem_args')
31572 
    oprot.writeFieldStop()
31573 
    oprot.writeStructEnd()
31574 
 
31575 
  def validate(self):
31576 
    return
31577 
 
31578 
 
31579 
  def __repr__(self):
31580 
    L = ['%s=%r' % (key, value)
31581 
      for key, value in self.__dict__.iteritems()]
31582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31583 
 
31584 
  def __eq__(self, other):
31585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31586 
 
31587 
  def __ne__(self, other):
31588 
    return not (self == other)
31589 
 
31590 
class getAllFlipkartMarketplaceItem_result:
31591 
  """
31592 
  Attributes:
31593 
   - success
31594 
  """
31595 
 
31596 
  thrift_spec = (
31597 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartItem, FlipkartItem.thrift_spec)), None, ), # 0
31598 
  )
31599 
 
31600 
  def __init__(self, success=None,):
31601 
    self.success = success
31602 
 
31603 
  def read(self, iprot):
31604 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31605 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31606 
      return
31607 
    iprot.readStructBegin()
31608 
    while True:
31609 
      (fname, ftype, fid) = iprot.readFieldBegin()
31610 
      if ftype == TType.STOP:
31611 
        break
31612 
      if fid == 0:
31613 
        if ftype == TType.LIST:
31614 
          self.success = []
18719 kshitij.so 31615 
          (_etype729, _size726) = iprot.readListBegin()
31616 
          for _i730 in xrange(_size726):
31617 
            _elem731 = FlipkartItem()
31618 
            _elem731.read(iprot)
31619 
            self.success.append(_elem731)
12133 kshitij.so 31620 
          iprot.readListEnd()
31621 
        else:
31622 
          iprot.skip(ftype)
31623 
      else:
31624 
        iprot.skip(ftype)
31625 
      iprot.readFieldEnd()
31626 
    iprot.readStructEnd()
31627 
 
31628 
  def write(self, oprot):
31629 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31630 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31631 
      return
31632 
    oprot.writeStructBegin('getAllFlipkartMarketplaceItem_result')
31633 
    if self.success is not None:
31634 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31635 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 31636 
      for iter732 in self.success:
31637 
        iter732.write(oprot)
12133 kshitij.so 31638 
      oprot.writeListEnd()
31639 
      oprot.writeFieldEnd()
31640 
    oprot.writeFieldStop()
31641 
    oprot.writeStructEnd()
31642 
 
31643 
  def validate(self):
31644 
    return
31645 
 
31646 
 
31647 
  def __repr__(self):
31648 
    L = ['%s=%r' % (key, value)
31649 
      for key, value in self.__dict__.iteritems()]
31650 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31651 
 
31652 
  def __eq__(self, other):
31653 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31654 
 
31655 
  def __ne__(self, other):
31656 
    return not (self == other)
12243 kshitij.so 31657 
 
31658 
class addCompetitorScraping_args:
31659 
  """
31660 
  Attributes:
31661 
   - competitorPricingMap
31662 
  """
31663 
 
31664 
  thrift_spec = (
31665 
    None, # 0
31666 
    (1, TType.MAP, 'competitorPricingMap', (TType.I64,None,TType.STRUCT,(CompetitorPricing, CompetitorPricing.thrift_spec)), None, ), # 1
31667 
  )
31668 
 
31669 
  def __init__(self, competitorPricingMap=None,):
31670 
    self.competitorPricingMap = competitorPricingMap
31671 
 
31672 
  def read(self, iprot):
31673 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31674 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31675 
      return
31676 
    iprot.readStructBegin()
31677 
    while True:
31678 
      (fname, ftype, fid) = iprot.readFieldBegin()
31679 
      if ftype == TType.STOP:
31680 
        break
31681 
      if fid == 1:
31682 
        if ftype == TType.MAP:
31683 
          self.competitorPricingMap = {}
18719 kshitij.so 31684 
          (_ktype734, _vtype735, _size733 ) = iprot.readMapBegin()
31685 
          for _i737 in xrange(_size733):
31686 
            _key738 = iprot.readI64();
31687 
            _val739 = CompetitorPricing()
31688 
            _val739.read(iprot)
31689 
            self.competitorPricingMap[_key738] = _val739
12243 kshitij.so 31690 
          iprot.readMapEnd()
31691 
        else:
31692 
          iprot.skip(ftype)
31693 
      else:
31694 
        iprot.skip(ftype)
31695 
      iprot.readFieldEnd()
31696 
    iprot.readStructEnd()
31697 
 
31698 
  def write(self, oprot):
31699 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31700 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31701 
      return
31702 
    oprot.writeStructBegin('addCompetitorScraping_args')
31703 
    if self.competitorPricingMap is not None:
31704 
      oprot.writeFieldBegin('competitorPricingMap', TType.MAP, 1)
31705 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.competitorPricingMap))
18719 kshitij.so 31706 
      for kiter740,viter741 in self.competitorPricingMap.items():
31707 
        oprot.writeI64(kiter740)
31708 
        viter741.write(oprot)
12243 kshitij.so 31709 
      oprot.writeMapEnd()
31710 
      oprot.writeFieldEnd()
31711 
    oprot.writeFieldStop()
31712 
    oprot.writeStructEnd()
31713 
 
31714 
  def validate(self):
31715 
    return
31716 
 
31717 
 
31718 
  def __repr__(self):
31719 
    L = ['%s=%r' % (key, value)
31720 
      for key, value in self.__dict__.iteritems()]
31721 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31722 
 
31723 
  def __eq__(self, other):
31724 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31725 
 
31726 
  def __ne__(self, other):
31727 
    return not (self == other)
31728 
 
31729 
class addCompetitorScraping_result:
31730 
 
31731 
  thrift_spec = (
31732 
  )
31733 
 
31734 
  def read(self, iprot):
31735 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31736 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31737 
      return
31738 
    iprot.readStructBegin()
31739 
    while True:
31740 
      (fname, ftype, fid) = iprot.readFieldBegin()
31741 
      if ftype == TType.STOP:
31742 
        break
31743 
      else:
31744 
        iprot.skip(ftype)
31745 
      iprot.readFieldEnd()
31746 
    iprot.readStructEnd()
31747 
 
31748 
  def write(self, oprot):
31749 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31750 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31751 
      return
31752 
    oprot.writeStructBegin('addCompetitorScraping_result')
31753 
    oprot.writeFieldStop()
31754 
    oprot.writeStructEnd()
31755 
 
31756 
  def validate(self):
31757 
    return
31758 
 
31759 
 
31760 
  def __repr__(self):
31761 
    L = ['%s=%r' % (key, value)
31762 
      for key, value in self.__dict__.iteritems()]
31763 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31764 
 
31765 
  def __eq__(self, other):
31766 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31767 
 
31768 
  def __ne__(self, other):
31769 
    return not (self == other)
31770 
 
31771 
class getPreviousCompetitorScraping_args:
31772 
  """
31773 
  Attributes:
31774 
   - delta
31775 
  """
31776 
 
31777 
  thrift_spec = (
31778 
    None, # 0
31779 
    (1, TType.I64, 'delta', None, None, ), # 1
31780 
  )
31781 
 
31782 
  def __init__(self, delta=None,):
31783 
    self.delta = delta
31784 
 
31785 
  def read(self, iprot):
31786 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31787 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31788 
      return
31789 
    iprot.readStructBegin()
31790 
    while True:
31791 
      (fname, ftype, fid) = iprot.readFieldBegin()
31792 
      if ftype == TType.STOP:
31793 
        break
31794 
      if fid == 1:
31795 
        if ftype == TType.I64:
31796 
          self.delta = iprot.readI64();
31797 
        else:
31798 
          iprot.skip(ftype)
31799 
      else:
31800 
        iprot.skip(ftype)
31801 
      iprot.readFieldEnd()
31802 
    iprot.readStructEnd()
31803 
 
31804 
  def write(self, oprot):
31805 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31806 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31807 
      return
31808 
    oprot.writeStructBegin('getPreviousCompetitorScraping_args')
31809 
    if self.delta is not None:
31810 
      oprot.writeFieldBegin('delta', TType.I64, 1)
31811 
      oprot.writeI64(self.delta)
31812 
      oprot.writeFieldEnd()
31813 
    oprot.writeFieldStop()
31814 
    oprot.writeStructEnd()
31815 
 
31816 
  def validate(self):
31817 
    return
31818 
 
31819 
 
31820 
  def __repr__(self):
31821 
    L = ['%s=%r' % (key, value)
31822 
      for key, value in self.__dict__.iteritems()]
31823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31824 
 
31825 
  def __eq__(self, other):
31826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31827 
 
31828 
  def __ne__(self, other):
31829 
    return not (self == other)
31830 
 
31831 
class getPreviousCompetitorScraping_result:
31832 
  """
31833 
  Attributes:
31834 
   - success
31835 
  """
31836 
 
31837 
  thrift_spec = (
31838 
    (0, TType.LIST, 'success', (TType.STRUCT,(CompetitorPricing, CompetitorPricing.thrift_spec)), None, ), # 0
31839 
  )
31840 
 
31841 
  def __init__(self, success=None,):
31842 
    self.success = success
31843 
 
31844 
  def read(self, iprot):
31845 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31846 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31847 
      return
31848 
    iprot.readStructBegin()
31849 
    while True:
31850 
      (fname, ftype, fid) = iprot.readFieldBegin()
31851 
      if ftype == TType.STOP:
31852 
        break
31853 
      if fid == 0:
31854 
        if ftype == TType.LIST:
31855 
          self.success = []
18719 kshitij.so 31856 
          (_etype745, _size742) = iprot.readListBegin()
31857 
          for _i746 in xrange(_size742):
31858 
            _elem747 = CompetitorPricing()
31859 
            _elem747.read(iprot)
31860 
            self.success.append(_elem747)
12243 kshitij.so 31861 
          iprot.readListEnd()
31862 
        else:
31863 
          iprot.skip(ftype)
31864 
      else:
31865 
        iprot.skip(ftype)
31866 
      iprot.readFieldEnd()
31867 
    iprot.readStructEnd()
31868 
 
31869 
  def write(self, oprot):
31870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31872 
      return
31873 
    oprot.writeStructBegin('getPreviousCompetitorScraping_result')
31874 
    if self.success is not None:
31875 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31876 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 31877 
      for iter748 in self.success:
31878 
        iter748.write(oprot)
12243 kshitij.so 31879 
      oprot.writeListEnd()
31880 
      oprot.writeFieldEnd()
31881 
    oprot.writeFieldStop()
31882 
    oprot.writeStructEnd()
31883 
 
31884 
  def validate(self):
31885 
    return
31886 
 
31887 
 
31888 
  def __repr__(self):
31889 
    L = ['%s=%r' % (key, value)
31890 
      for key, value in self.__dict__.iteritems()]
31891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31892 
 
31893 
  def __eq__(self, other):
31894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31895 
 
31896 
  def __ne__(self, other):
31897 
    return not (self == other)
12256 kshitij.so 31898 
 
31899 
class getUploadResultById_args:
31900 
  """
31901 
  Attributes:
31902 
   - uploadId
31903 
  """
31904 
 
31905 
  thrift_spec = (
31906 
    None, # 0
31907 
    (1, TType.I64, 'uploadId', None, None, ), # 1
31908 
  )
31909 
 
31910 
  def __init__(self, uploadId=None,):
31911 
    self.uploadId = uploadId
31912 
 
31913 
  def read(self, iprot):
31914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31916 
      return
31917 
    iprot.readStructBegin()
31918 
    while True:
31919 
      (fname, ftype, fid) = iprot.readFieldBegin()
31920 
      if ftype == TType.STOP:
31921 
        break
31922 
      if fid == 1:
31923 
        if ftype == TType.I64:
31924 
          self.uploadId = iprot.readI64();
31925 
        else:
31926 
          iprot.skip(ftype)
31927 
      else:
31928 
        iprot.skip(ftype)
31929 
      iprot.readFieldEnd()
31930 
    iprot.readStructEnd()
31931 
 
31932 
  def write(self, oprot):
31933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31935 
      return
31936 
    oprot.writeStructBegin('getUploadResultById_args')
31937 
    if self.uploadId is not None:
31938 
      oprot.writeFieldBegin('uploadId', TType.I64, 1)
31939 
      oprot.writeI64(self.uploadId)
31940 
      oprot.writeFieldEnd()
31941 
    oprot.writeFieldStop()
31942 
    oprot.writeStructEnd()
31943 
 
31944 
  def validate(self):
31945 
    return
31946 
 
31947 
 
31948 
  def __repr__(self):
31949 
    L = ['%s=%r' % (key, value)
31950 
      for key, value in self.__dict__.iteritems()]
31951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31952 
 
31953 
  def __eq__(self, other):
31954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31955 
 
31956 
  def __ne__(self, other):
31957 
    return not (self == other)
31958 
 
31959 
class getUploadResultById_result:
31960 
  """
31961 
  Attributes:
31962 
   - success
31963 
  """
31964 
 
31965 
  thrift_spec = (
31966 
    (0, TType.LIST, 'success', (TType.STRUCT,(CompetitorPricing, CompetitorPricing.thrift_spec)), None, ), # 0
31967 
  )
31968 
 
31969 
  def __init__(self, success=None,):
31970 
    self.success = success
31971 
 
31972 
  def read(self, iprot):
31973 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31974 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31975 
      return
31976 
    iprot.readStructBegin()
31977 
    while True:
31978 
      (fname, ftype, fid) = iprot.readFieldBegin()
31979 
      if ftype == TType.STOP:
31980 
        break
31981 
      if fid == 0:
31982 
        if ftype == TType.LIST:
31983 
          self.success = []
18719 kshitij.so 31984 
          (_etype752, _size749) = iprot.readListBegin()
31985 
          for _i753 in xrange(_size749):
31986 
            _elem754 = CompetitorPricing()
31987 
            _elem754.read(iprot)
31988 
            self.success.append(_elem754)
12256 kshitij.so 31989 
          iprot.readListEnd()
31990 
        else:
31991 
          iprot.skip(ftype)
31992 
      else:
31993 
        iprot.skip(ftype)
31994 
      iprot.readFieldEnd()
31995 
    iprot.readStructEnd()
31996 
 
31997 
  def write(self, oprot):
31998 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31999 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32000 
      return
32001 
    oprot.writeStructBegin('getUploadResultById_result')
32002 
    if self.success is not None:
32003 
      oprot.writeFieldBegin('success', TType.LIST, 0)
32004 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 32005 
      for iter755 in self.success:
32006 
        iter755.write(oprot)
12256 kshitij.so 32007 
      oprot.writeListEnd()
32008 
      oprot.writeFieldEnd()
32009 
    oprot.writeFieldStop()
32010 
    oprot.writeStructEnd()
32011 
 
32012 
  def validate(self):
32013 
    return
32014 
 
32015 
 
32016 
  def __repr__(self):
32017 
    L = ['%s=%r' % (key, value)
32018 
      for key, value in self.__dict__.iteritems()]
32019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32020 
 
32021 
  def __eq__(self, other):
32022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32023 
 
32024 
  def __ne__(self, other):
32025 
    return not (self == other)
12363 kshitij.so 32026 
 
32027 
class addAmazonPromotion_args:
32028 
  """
32029 
  Attributes:
32030 
   - amazonPromotions
32031 
  """
32032 
 
32033 
  thrift_spec = (
32034 
    None, # 0
32035 
    (1, TType.MAP, 'amazonPromotions', (TType.STRING,None,TType.STRUCT,(AmazonPromotion, AmazonPromotion.thrift_spec)), None, ), # 1
32036 
  )
32037 
 
32038 
  def __init__(self, amazonPromotions=None,):
32039 
    self.amazonPromotions = amazonPromotions
32040 
 
32041 
  def read(self, iprot):
32042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32044 
      return
32045 
    iprot.readStructBegin()
32046 
    while True:
32047 
      (fname, ftype, fid) = iprot.readFieldBegin()
32048 
      if ftype == TType.STOP:
32049 
        break
32050 
      if fid == 1:
32051 
        if ftype == TType.MAP:
32052 
          self.amazonPromotions = {}
18719 kshitij.so 32053 
          (_ktype757, _vtype758, _size756 ) = iprot.readMapBegin()
32054 
          for _i760 in xrange(_size756):
32055 
            _key761 = iprot.readString();
32056 
            _val762 = AmazonPromotion()
32057 
            _val762.read(iprot)
32058 
            self.amazonPromotions[_key761] = _val762
12363 kshitij.so 32059 
          iprot.readMapEnd()
32060 
        else:
32061 
          iprot.skip(ftype)
32062 
      else:
32063 
        iprot.skip(ftype)
32064 
      iprot.readFieldEnd()
32065 
    iprot.readStructEnd()
32066 
 
32067 
  def write(self, oprot):
32068 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32069 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32070 
      return
32071 
    oprot.writeStructBegin('addAmazonPromotion_args')
32072 
    if self.amazonPromotions is not None:
32073 
      oprot.writeFieldBegin('amazonPromotions', TType.MAP, 1)
32074 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.amazonPromotions))
18719 kshitij.so 32075 
      for kiter763,viter764 in self.amazonPromotions.items():
32076 
        oprot.writeString(kiter763)
32077 
        viter764.write(oprot)
12363 kshitij.so 32078 
      oprot.writeMapEnd()
32079 
      oprot.writeFieldEnd()
32080 
    oprot.writeFieldStop()
32081 
    oprot.writeStructEnd()
32082 
 
32083 
  def validate(self):
32084 
    return
32085 
 
32086 
 
32087 
  def __repr__(self):
32088 
    L = ['%s=%r' % (key, value)
32089 
      for key, value in self.__dict__.iteritems()]
32090 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32091 
 
32092 
  def __eq__(self, other):
32093 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32094 
 
32095 
  def __ne__(self, other):
32096 
    return not (self == other)
32097 
 
32098 
class addAmazonPromotion_result:
32099 
  """
32100 
  Attributes:
32101 
   - success
12947 kshitij.so 32102 
   - cex
12363 kshitij.so 32103 
  """
32104 
 
32105 
  thrift_spec = (
12947 kshitij.so 32106 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
32107 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12363 kshitij.so 32108 
  )
32109 
 
12947 kshitij.so 32110 
  def __init__(self, success=None, cex=None,):
12363 kshitij.so 32111 
    self.success = success
12947 kshitij.so 32112 
    self.cex = cex
12363 kshitij.so 32113 
 
32114 
  def read(self, iprot):
32115 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32116 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32117 
      return
32118 
    iprot.readStructBegin()
32119 
    while True:
32120 
      (fname, ftype, fid) = iprot.readFieldBegin()
32121 
      if ftype == TType.STOP:
32122 
        break
32123 
      if fid == 0:
12947 kshitij.so 32124 
        if ftype == TType.LIST:
32125 
          self.success = []
18719 kshitij.so 32126 
          (_etype768, _size765) = iprot.readListBegin()
32127 
          for _i769 in xrange(_size765):
32128 
            _elem770 = iprot.readString();
32129 
            self.success.append(_elem770)
12947 kshitij.so 32130 
          iprot.readListEnd()
12363 kshitij.so 32131 
        else:
32132 
          iprot.skip(ftype)
12947 kshitij.so 32133 
      elif fid == 1:
32134 
        if ftype == TType.STRUCT:
32135 
          self.cex = CatalogServiceException()
32136 
          self.cex.read(iprot)
32137 
        else:
32138 
          iprot.skip(ftype)
12363 kshitij.so 32139 
      else:
32140 
        iprot.skip(ftype)
32141 
      iprot.readFieldEnd()
32142 
    iprot.readStructEnd()
32143 
 
32144 
  def write(self, oprot):
32145 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32146 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32147 
      return
32148 
    oprot.writeStructBegin('addAmazonPromotion_result')
32149 
    if self.success is not None:
12947 kshitij.so 32150 
      oprot.writeFieldBegin('success', TType.LIST, 0)
32151 
      oprot.writeListBegin(TType.STRING, len(self.success))
18719 kshitij.so 32152 
      for iter771 in self.success:
32153 
        oprot.writeString(iter771)
12947 kshitij.so 32154 
      oprot.writeListEnd()
12363 kshitij.so 32155 
      oprot.writeFieldEnd()
12947 kshitij.so 32156 
    if self.cex is not None:
32157 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
32158 
      self.cex.write(oprot)
32159 
      oprot.writeFieldEnd()
12363 kshitij.so 32160 
    oprot.writeFieldStop()
32161 
    oprot.writeStructEnd()
32162 
 
32163 
  def validate(self):
32164 
    return
32165 
 
32166 
 
32167 
  def __repr__(self):
32168 
    L = ['%s=%r' % (key, value)
32169 
      for key, value in self.__dict__.iteritems()]
32170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32171 
 
32172 
  def __eq__(self, other):
32173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32174 
 
32175 
  def __ne__(self, other):
32176 
    return not (self == other)
32177 
 
32178 
class getAmazonPromotion_args:
32179 
  """
32180 
  Attributes:
32181 
   - startDate
32182 
   - endDate
32183 
  """
32184 
 
32185 
  thrift_spec = (
32186 
    None, # 0
32187 
    (1, TType.I64, 'startDate', None, None, ), # 1
32188 
    (2, TType.I64, 'endDate', None, None, ), # 2
32189 
  )
32190 
 
32191 
  def __init__(self, startDate=None, endDate=None,):
32192 
    self.startDate = startDate
32193 
    self.endDate = endDate
32194 
 
32195 
  def read(self, iprot):
32196 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32197 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32198 
      return
32199 
    iprot.readStructBegin()
32200 
    while True:
32201 
      (fname, ftype, fid) = iprot.readFieldBegin()
32202 
      if ftype == TType.STOP:
32203 
        break
32204 
      if fid == 1:
32205 
        if ftype == TType.I64:
32206 
          self.startDate = iprot.readI64();
32207 
        else:
32208 
          iprot.skip(ftype)
32209 
      elif fid == 2:
32210 
        if ftype == TType.I64:
32211 
          self.endDate = iprot.readI64();
32212 
        else:
32213 
          iprot.skip(ftype)
32214 
      else:
32215 
        iprot.skip(ftype)
32216 
      iprot.readFieldEnd()
32217 
    iprot.readStructEnd()
32218 
 
32219 
  def write(self, oprot):
32220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32222 
      return
32223 
    oprot.writeStructBegin('getAmazonPromotion_args')
32224 
    if self.startDate is not None:
32225 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
32226 
      oprot.writeI64(self.startDate)
32227 
      oprot.writeFieldEnd()
32228 
    if self.endDate is not None:
32229 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
32230 
      oprot.writeI64(self.endDate)
32231 
      oprot.writeFieldEnd()
32232 
    oprot.writeFieldStop()
32233 
    oprot.writeStructEnd()
32234 
 
32235 
  def validate(self):
32236 
    return
32237 
 
32238 
 
32239 
  def __repr__(self):
32240 
    L = ['%s=%r' % (key, value)
32241 
      for key, value in self.__dict__.iteritems()]
32242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32243 
 
32244 
  def __eq__(self, other):
32245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32246 
 
32247 
  def __ne__(self, other):
32248 
    return not (self == other)
32249 
 
32250 
class getAmazonPromotion_result:
32251 
  """
32252 
  Attributes:
32253 
   - success
32254 
  """
32255 
 
32256 
  thrift_spec = (
32257 
    (0, TType.LIST, 'success', (TType.STRUCT,(AmazonPromotion, AmazonPromotion.thrift_spec)), None, ), # 0
32258 
  )
32259 
 
32260 
  def __init__(self, success=None,):
32261 
    self.success = success
32262 
 
32263 
  def read(self, iprot):
32264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32266 
      return
32267 
    iprot.readStructBegin()
32268 
    while True:
32269 
      (fname, ftype, fid) = iprot.readFieldBegin()
32270 
      if ftype == TType.STOP:
32271 
        break
32272 
      if fid == 0:
32273 
        if ftype == TType.LIST:
32274 
          self.success = []
18719 kshitij.so 32275 
          (_etype775, _size772) = iprot.readListBegin()
32276 
          for _i776 in xrange(_size772):
32277 
            _elem777 = AmazonPromotion()
32278 
            _elem777.read(iprot)
32279 
            self.success.append(_elem777)
12363 kshitij.so 32280 
          iprot.readListEnd()
32281 
        else:
32282 
          iprot.skip(ftype)
32283 
      else:
32284 
        iprot.skip(ftype)
32285 
      iprot.readFieldEnd()
32286 
    iprot.readStructEnd()
32287 
 
32288 
  def write(self, oprot):
32289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32291 
      return
32292 
    oprot.writeStructBegin('getAmazonPromotion_result')
32293 
    if self.success is not None:
32294 
      oprot.writeFieldBegin('success', TType.LIST, 0)
32295 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 32296 
      for iter778 in self.success:
32297 
        iter778.write(oprot)
12363 kshitij.so 32298 
      oprot.writeListEnd()
32299 
      oprot.writeFieldEnd()
32300 
    oprot.writeFieldStop()
32301 
    oprot.writeStructEnd()
32302 
 
32303 
  def validate(self):
32304 
    return
32305 
 
32306 
 
32307 
  def __repr__(self):
32308 
    L = ['%s=%r' % (key, value)
32309 
      for key, value in self.__dict__.iteritems()]
32310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32311 
 
32312 
  def __eq__(self, other):
32313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32314 
 
32315 
  def __ne__(self, other):
32316 
    return not (self == other)
32317 
 
32318 
class updateAmazonPromotion_args:
32319 
  """
32320 
  Attributes:
32321 
   - amazonPromotions
32322 
  """
32323 
 
32324 
  thrift_spec = (
32325 
    None, # 0
32326 
    (1, TType.LIST, 'amazonPromotions', (TType.STRUCT,(AmazonPromotion, AmazonPromotion.thrift_spec)), None, ), # 1
32327 
  )
32328 
 
32329 
  def __init__(self, amazonPromotions=None,):
32330 
    self.amazonPromotions = amazonPromotions
32331 
 
32332 
  def read(self, iprot):
32333 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32334 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32335 
      return
32336 
    iprot.readStructBegin()
32337 
    while True:
32338 
      (fname, ftype, fid) = iprot.readFieldBegin()
32339 
      if ftype == TType.STOP:
32340 
        break
32341 
      if fid == 1:
32342 
        if ftype == TType.LIST:
32343 
          self.amazonPromotions = []
18719 kshitij.so 32344 
          (_etype782, _size779) = iprot.readListBegin()
32345 
          for _i783 in xrange(_size779):
32346 
            _elem784 = AmazonPromotion()
32347 
            _elem784.read(iprot)
32348 
            self.amazonPromotions.append(_elem784)
12363 kshitij.so 32349 
          iprot.readListEnd()
32350 
        else:
32351 
          iprot.skip(ftype)
32352 
      else:
32353 
        iprot.skip(ftype)
32354 
      iprot.readFieldEnd()
32355 
    iprot.readStructEnd()
32356 
 
32357 
  def write(self, oprot):
32358 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32359 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32360 
      return
32361 
    oprot.writeStructBegin('updateAmazonPromotion_args')
32362 
    if self.amazonPromotions is not None:
32363 
      oprot.writeFieldBegin('amazonPromotions', TType.LIST, 1)
32364 
      oprot.writeListBegin(TType.STRUCT, len(self.amazonPromotions))
18719 kshitij.so 32365 
      for iter785 in self.amazonPromotions:
32366 
        iter785.write(oprot)
12363 kshitij.so 32367 
      oprot.writeListEnd()
32368 
      oprot.writeFieldEnd()
32369 
    oprot.writeFieldStop()
32370 
    oprot.writeStructEnd()
32371 
 
32372 
  def validate(self):
32373 
    return
32374 
 
32375 
 
32376 
  def __repr__(self):
32377 
    L = ['%s=%r' % (key, value)
32378 
      for key, value in self.__dict__.iteritems()]
32379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32380 
 
32381 
  def __eq__(self, other):
32382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32383 
 
32384 
  def __ne__(self, other):
32385 
    return not (self == other)
32386 
 
32387 
class updateAmazonPromotion_result:
32388 
  """
32389 
  Attributes:
32390 
   - success
32391 
  """
32392 
 
32393 
  thrift_spec = (
32394 
    (0, TType.BOOL, 'success', None, None, ), # 0
32395 
  )
32396 
 
32397 
  def __init__(self, success=None,):
32398 
    self.success = success
32399 
 
32400 
  def read(self, iprot):
32401 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32402 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32403 
      return
32404 
    iprot.readStructBegin()
32405 
    while True:
32406 
      (fname, ftype, fid) = iprot.readFieldBegin()
32407 
      if ftype == TType.STOP:
32408 
        break
32409 
      if fid == 0:
32410 
        if ftype == TType.BOOL:
32411 
          self.success = iprot.readBool();
32412 
        else:
32413 
          iprot.skip(ftype)
32414 
      else:
32415 
        iprot.skip(ftype)
32416 
      iprot.readFieldEnd()
32417 
    iprot.readStructEnd()
32418 
 
32419 
  def write(self, oprot):
32420 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32421 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32422 
      return
32423 
    oprot.writeStructBegin('updateAmazonPromotion_result')
32424 
    if self.success is not None:
32425 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
32426 
      oprot.writeBool(self.success)
32427 
      oprot.writeFieldEnd()
32428 
    oprot.writeFieldStop()
32429 
    oprot.writeStructEnd()
32430 
 
32431 
  def validate(self):
32432 
    return
32433 
 
32434 
 
32435 
  def __repr__(self):
32436 
    L = ['%s=%r' % (key, value)
32437 
      for key, value in self.__dict__.iteritems()]
32438 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32439 
 
32440 
  def __eq__(self, other):
32441 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32442 
 
32443 
  def __ne__(self, other):
32444 
    return not (self == other)
12567 amit.gupta 32445 
 
32446 
class markPartiallyActive_args:
32447 
  """
32448 
  Attributes:
32449 
   - itemId
32450 
   - categoryId
32451 
  """
32452 
 
32453 
  thrift_spec = (
32454 
    None, # 0
32455 
    (1, TType.I64, 'itemId', None, None, ), # 1
32456 
    (2, TType.I64, 'categoryId', None, None, ), # 2
32457 
  )
32458 
 
32459 
  def __init__(self, itemId=None, categoryId=None,):
32460 
    self.itemId = itemId
32461 
    self.categoryId = categoryId
32462 
 
32463 
  def read(self, iprot):
32464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32466 
      return
32467 
    iprot.readStructBegin()
32468 
    while True:
32469 
      (fname, ftype, fid) = iprot.readFieldBegin()
32470 
      if ftype == TType.STOP:
32471 
        break
32472 
      if fid == 1:
32473 
        if ftype == TType.I64:
32474 
          self.itemId = iprot.readI64();
32475 
        else:
32476 
          iprot.skip(ftype)
32477 
      elif fid == 2:
32478 
        if ftype == TType.I64:
32479 
          self.categoryId = iprot.readI64();
32480 
        else:
32481 
          iprot.skip(ftype)
32482 
      else:
32483 
        iprot.skip(ftype)
32484 
      iprot.readFieldEnd()
32485 
    iprot.readStructEnd()
32486 
 
32487 
  def write(self, oprot):
32488 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32489 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32490 
      return
32491 
    oprot.writeStructBegin('markPartiallyActive_args')
32492 
    if self.itemId is not None:
32493 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
32494 
      oprot.writeI64(self.itemId)
32495 
      oprot.writeFieldEnd()
32496 
    if self.categoryId is not None:
32497 
      oprot.writeFieldBegin('categoryId', TType.I64, 2)
32498 
      oprot.writeI64(self.categoryId)
32499 
      oprot.writeFieldEnd()
32500 
    oprot.writeFieldStop()
32501 
    oprot.writeStructEnd()
32502 
 
32503 
  def validate(self):
32504 
    return
32505 
 
32506 
 
32507 
  def __repr__(self):
32508 
    L = ['%s=%r' % (key, value)
32509 
      for key, value in self.__dict__.iteritems()]
32510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32511 
 
32512 
  def __eq__(self, other):
32513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32514 
 
32515 
  def __ne__(self, other):
32516 
    return not (self == other)
32517 
 
32518 
class markPartiallyActive_result:
32519 
  """
32520 
  Attributes:
32521 
   - success
32522 
  """
32523 
 
32524 
  thrift_spec = (
32525 
    (0, TType.BOOL, 'success', None, None, ), # 0
32526 
  )
32527 
 
32528 
  def __init__(self, success=None,):
32529 
    self.success = success
32530 
 
32531 
  def read(self, iprot):
32532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32534 
      return
32535 
    iprot.readStructBegin()
32536 
    while True:
32537 
      (fname, ftype, fid) = iprot.readFieldBegin()
32538 
      if ftype == TType.STOP:
32539 
        break
32540 
      if fid == 0:
32541 
        if ftype == TType.BOOL:
32542 
          self.success = iprot.readBool();
32543 
        else:
32544 
          iprot.skip(ftype)
32545 
      else:
32546 
        iprot.skip(ftype)
32547 
      iprot.readFieldEnd()
32548 
    iprot.readStructEnd()
32549 
 
32550 
  def write(self, oprot):
32551 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32552 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32553 
      return
32554 
    oprot.writeStructBegin('markPartiallyActive_result')
32555 
    if self.success is not None:
32556 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
32557 
      oprot.writeBool(self.success)
32558 
      oprot.writeFieldEnd()
32559 
    oprot.writeFieldStop()
32560 
    oprot.writeStructEnd()
32561 
 
32562 
  def validate(self):
32563 
    return
32564 
 
32565 
 
32566 
  def __repr__(self):
32567 
    L = ['%s=%r' % (key, value)
32568 
      for key, value in self.__dict__.iteritems()]
32569 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32570 
 
32571 
  def __eq__(self, other):
32572 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32573 
 
32574 
  def __ne__(self, other):
32575 
    return not (self == other)
32576 
 
32577 
class updateItemStateVat_args:
32578 
  """
32579 
  Attributes:
32580 
   - itemId
32581 
   - statevat
32582 
  """
32583 
 
32584 
  thrift_spec = (
32585 
    None, # 0
32586 
    (1, TType.I64, 'itemId', None, None, ), # 1
32587 
    (2, TType.MAP, 'statevat', (TType.I64,None,TType.DOUBLE,None), None, ), # 2
32588 
  )
32589 
 
32590 
  def __init__(self, itemId=None, statevat=None,):
32591 
    self.itemId = itemId
32592 
    self.statevat = statevat
32593 
 
32594 
  def read(self, iprot):
32595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32597 
      return
32598 
    iprot.readStructBegin()
32599 
    while True:
32600 
      (fname, ftype, fid) = iprot.readFieldBegin()
32601 
      if ftype == TType.STOP:
32602 
        break
32603 
      if fid == 1:
32604 
        if ftype == TType.I64:
32605 
          self.itemId = iprot.readI64();
32606 
        else:
32607 
          iprot.skip(ftype)
32608 
      elif fid == 2:
32609 
        if ftype == TType.MAP:
32610 
          self.statevat = {}
18719 kshitij.so 32611 
          (_ktype787, _vtype788, _size786 ) = iprot.readMapBegin()
32612 
          for _i790 in xrange(_size786):
32613 
            _key791 = iprot.readI64();
32614 
            _val792 = iprot.readDouble();
32615 
            self.statevat[_key791] = _val792
12567 amit.gupta 32616 
          iprot.readMapEnd()
32617 
        else:
32618 
          iprot.skip(ftype)
32619 
      else:
32620 
        iprot.skip(ftype)
32621 
      iprot.readFieldEnd()
32622 
    iprot.readStructEnd()
32623 
 
32624 
  def write(self, oprot):
32625 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32626 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32627 
      return
32628 
    oprot.writeStructBegin('updateItemStateVat_args')
32629 
    if self.itemId is not None:
32630 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
32631 
      oprot.writeI64(self.itemId)
32632 
      oprot.writeFieldEnd()
32633 
    if self.statevat is not None:
32634 
      oprot.writeFieldBegin('statevat', TType.MAP, 2)
32635 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.statevat))
18719 kshitij.so 32636 
      for kiter793,viter794 in self.statevat.items():
32637 
        oprot.writeI64(kiter793)
32638 
        oprot.writeDouble(viter794)
12567 amit.gupta 32639 
      oprot.writeMapEnd()
32640 
      oprot.writeFieldEnd()
32641 
    oprot.writeFieldStop()
32642 
    oprot.writeStructEnd()
32643 
 
32644 
  def validate(self):
32645 
    return
32646 
 
32647 
 
32648 
  def __repr__(self):
32649 
    L = ['%s=%r' % (key, value)
32650 
      for key, value in self.__dict__.iteritems()]
32651 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32652 
 
32653 
  def __eq__(self, other):
32654 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32655 
 
32656 
  def __ne__(self, other):
32657 
    return not (self == other)
32658 
 
32659 
class updateItemStateVat_result:
32660 
  """
32661 
  Attributes:
32662 
   - success
32663 
  """
32664 
 
32665 
  thrift_spec = (
32666 
    (0, TType.BOOL, 'success', None, None, ), # 0
32667 
  )
32668 
 
32669 
  def __init__(self, success=None,):
32670 
    self.success = success
32671 
 
32672 
  def read(self, iprot):
32673 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32674 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32675 
      return
32676 
    iprot.readStructBegin()
32677 
    while True:
32678 
      (fname, ftype, fid) = iprot.readFieldBegin()
32679 
      if ftype == TType.STOP:
32680 
        break
32681 
      if fid == 0:
32682 
        if ftype == TType.BOOL:
32683 
          self.success = iprot.readBool();
32684 
        else:
32685 
          iprot.skip(ftype)
32686 
      else:
32687 
        iprot.skip(ftype)
32688 
      iprot.readFieldEnd()
32689 
    iprot.readStructEnd()
32690 
 
32691 
  def write(self, oprot):
32692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32694 
      return
32695 
    oprot.writeStructBegin('updateItemStateVat_result')
32696 
    if self.success is not None:
32697 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
32698 
      oprot.writeBool(self.success)
32699 
      oprot.writeFieldEnd()
32700 
    oprot.writeFieldStop()
32701 
    oprot.writeStructEnd()
32702 
 
32703 
  def validate(self):
32704 
    return
32705 
 
32706 
 
32707 
  def __repr__(self):
32708 
    L = ['%s=%r' % (key, value)
32709 
      for key, value in self.__dict__.iteritems()]
32710 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32711 
 
32712 
  def __eq__(self, other):
32713 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32714 
 
32715 
  def __ne__(self, other):
32716 
    return not (self == other)
12620 amit.gupta 32717 
 
32718 
class getExAffiliateItemInfo_args:
32719 
 
32720 
  thrift_spec = (
32721 
  )
32722 
 
32723 
  def read(self, iprot):
32724 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32725 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32726 
      return
32727 
    iprot.readStructBegin()
32728 
    while True:
32729 
      (fname, ftype, fid) = iprot.readFieldBegin()
32730 
      if ftype == TType.STOP:
32731 
        break
32732 
      else:
32733 
        iprot.skip(ftype)
32734 
      iprot.readFieldEnd()
32735 
    iprot.readStructEnd()
32736 
 
32737 
  def write(self, oprot):
32738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32740 
      return
32741 
    oprot.writeStructBegin('getExAffiliateItemInfo_args')
32742 
    oprot.writeFieldStop()
32743 
    oprot.writeStructEnd()
32744 
 
32745 
  def validate(self):
32746 
    return
32747 
 
32748 
 
32749 
  def __repr__(self):
32750 
    L = ['%s=%r' % (key, value)
32751 
      for key, value in self.__dict__.iteritems()]
32752 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32753 
 
32754 
  def __eq__(self, other):
32755 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32756 
 
32757 
  def __ne__(self, other):
32758 
    return not (self == other)
32759 
 
32760 
class getExAffiliateItemInfo_result:
32761 
  """
32762 
  Attributes:
32763 
   - success
32764 
  """
32765 
 
32766 
  thrift_spec = (
32767 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRUCT,(ExclusiveAffiliateItemInfo, ExclusiveAffiliateItemInfo.thrift_spec)), None, ), # 0
32768 
  )
32769 
 
32770 
  def __init__(self, success=None,):
32771 
    self.success = success
32772 
 
32773 
  def read(self, iprot):
32774 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32775 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32776 
      return
32777 
    iprot.readStructBegin()
32778 
    while True:
32779 
      (fname, ftype, fid) = iprot.readFieldBegin()
32780 
      if ftype == TType.STOP:
32781 
        break
32782 
      if fid == 0:
32783 
        if ftype == TType.MAP:
32784 
          self.success = {}
18719 kshitij.so 32785 
          (_ktype796, _vtype797, _size795 ) = iprot.readMapBegin()
32786 
          for _i799 in xrange(_size795):
32787 
            _key800 = iprot.readI64();
32788 
            _val801 = ExclusiveAffiliateItemInfo()
32789 
            _val801.read(iprot)
32790 
            self.success[_key800] = _val801
12620 amit.gupta 32791 
          iprot.readMapEnd()
32792 
        else:
32793 
          iprot.skip(ftype)
32794 
      else:
32795 
        iprot.skip(ftype)
32796 
      iprot.readFieldEnd()
32797 
    iprot.readStructEnd()
32798 
 
32799 
  def write(self, oprot):
32800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32802 
      return
32803 
    oprot.writeStructBegin('getExAffiliateItemInfo_result')
32804 
    if self.success is not None:
32805 
      oprot.writeFieldBegin('success', TType.MAP, 0)
32806 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.success))
18719 kshitij.so 32807 
      for kiter802,viter803 in self.success.items():
32808 
        oprot.writeI64(kiter802)
32809 
        viter803.write(oprot)
12620 amit.gupta 32810 
      oprot.writeMapEnd()
32811 
      oprot.writeFieldEnd()
32812 
    oprot.writeFieldStop()
32813 
    oprot.writeStructEnd()
32814 
 
32815 
  def validate(self):
32816 
    return
32817 
 
32818 
 
32819 
  def __repr__(self):
32820 
    L = ['%s=%r' % (key, value)
32821 
      for key, value in self.__dict__.iteritems()]
32822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32823 
 
32824 
  def __eq__(self, other):
32825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32826 
 
32827 
  def __ne__(self, other):
32828 
    return not (self == other)
12888 kshitij.so 32829 
 
32830 
class getAllItemstoListOnFbg_args:
32831 
 
32832 
  thrift_spec = (
32833 
  )
32834 
 
32835 
  def read(self, iprot):
32836 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32837 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32838 
      return
32839 
    iprot.readStructBegin()
32840 
    while True:
32841 
      (fname, ftype, fid) = iprot.readFieldBegin()
32842 
      if ftype == TType.STOP:
32843 
        break
32844 
      else:
32845 
        iprot.skip(ftype)
32846 
      iprot.readFieldEnd()
32847 
    iprot.readStructEnd()
32848 
 
32849 
  def write(self, oprot):
32850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32852 
      return
32853 
    oprot.writeStructBegin('getAllItemstoListOnFbg_args')
32854 
    oprot.writeFieldStop()
32855 
    oprot.writeStructEnd()
32856 
 
32857 
  def validate(self):
32858 
    return
32859 
 
32860 
 
32861 
  def __repr__(self):
32862 
    L = ['%s=%r' % (key, value)
32863 
      for key, value in self.__dict__.iteritems()]
32864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32865 
 
32866 
  def __eq__(self, other):
32867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32868 
 
32869 
  def __ne__(self, other):
32870 
    return not (self == other)
32871 
 
32872 
class getAllItemstoListOnFbg_result:
32873 
  """
32874 
  Attributes:
32875 
   - success
32876 
  """
32877 
 
32878 
  thrift_spec = (
32879 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
32880 
  )
32881 
 
32882 
  def __init__(self, success=None,):
32883 
    self.success = success
32884 
 
32885 
  def read(self, iprot):
32886 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32887 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32888 
      return
32889 
    iprot.readStructBegin()
32890 
    while True:
32891 
      (fname, ftype, fid) = iprot.readFieldBegin()
32892 
      if ftype == TType.STOP:
32893 
        break
32894 
      if fid == 0:
32895 
        if ftype == TType.LIST:
32896 
          self.success = []
18719 kshitij.so 32897 
          (_etype807, _size804) = iprot.readListBegin()
32898 
          for _i808 in xrange(_size804):
32899 
            _elem809 = Amazonlisted()
32900 
            _elem809.read(iprot)
32901 
            self.success.append(_elem809)
12888 kshitij.so 32902 
          iprot.readListEnd()
32903 
        else:
32904 
          iprot.skip(ftype)
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('getAllItemstoListOnFbg_result')
32915 
    if self.success is not None:
32916 
      oprot.writeFieldBegin('success', TType.LIST, 0)
32917 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 32918 
      for iter810 in self.success:
32919 
        iter810.write(oprot)
12888 kshitij.so 32920 
      oprot.writeListEnd()
32921 
      oprot.writeFieldEnd()
32922 
    oprot.writeFieldStop()
32923 
    oprot.writeStructEnd()
32924 
 
32925 
  def validate(self):
32926 
    return
32927 
 
32928 
 
32929 
  def __repr__(self):
32930 
    L = ['%s=%r' % (key, value)
32931 
      for key, value in self.__dict__.iteritems()]
32932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32933 
 
32934 
  def __eq__(self, other):
32935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32936 
 
32937 
  def __ne__(self, other):
32938 
    return not (self == other)
12892 kshitij.so 32939 
 
32940 
class getAllFbgListedItems_args:
32941 
 
32942 
  thrift_spec = (
32943 
  )
32944 
 
32945 
  def read(self, iprot):
32946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32948 
      return
32949 
    iprot.readStructBegin()
32950 
    while True:
32951 
      (fname, ftype, fid) = iprot.readFieldBegin()
32952 
      if ftype == TType.STOP:
32953 
        break
32954 
      else:
32955 
        iprot.skip(ftype)
32956 
      iprot.readFieldEnd()
32957 
    iprot.readStructEnd()
32958 
 
32959 
  def write(self, oprot):
32960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32962 
      return
32963 
    oprot.writeStructBegin('getAllFbgListedItems_args')
32964 
    oprot.writeFieldStop()
32965 
    oprot.writeStructEnd()
32966 
 
32967 
  def validate(self):
32968 
    return
32969 
 
32970 
 
32971 
  def __repr__(self):
32972 
    L = ['%s=%r' % (key, value)
32973 
      for key, value in self.__dict__.iteritems()]
32974 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32975 
 
32976 
  def __eq__(self, other):
32977 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32978 
 
32979 
  def __ne__(self, other):
32980 
    return not (self == other)
32981 
 
32982 
class getAllFbgListedItems_result:
32983 
  """
32984 
  Attributes:
32985 
   - success
32986 
  """
32987 
 
32988 
  thrift_spec = (
32989 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
32990 
  )
32991 
 
32992 
  def __init__(self, success=None,):
32993 
    self.success = success
32994 
 
32995 
  def read(self, iprot):
32996 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32997 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32998 
      return
32999 
    iprot.readStructBegin()
33000 
    while True:
33001 
      (fname, ftype, fid) = iprot.readFieldBegin()
33002 
      if ftype == TType.STOP:
33003 
        break
33004 
      if fid == 0:
33005 
        if ftype == TType.LIST:
33006 
          self.success = []
18719 kshitij.so 33007 
          (_etype814, _size811) = iprot.readListBegin()
33008 
          for _i815 in xrange(_size811):
33009 
            _elem816 = Amazonlisted()
33010 
            _elem816.read(iprot)
33011 
            self.success.append(_elem816)
12892 kshitij.so 33012 
          iprot.readListEnd()
33013 
        else:
33014 
          iprot.skip(ftype)
33015 
      else:
33016 
        iprot.skip(ftype)
33017 
      iprot.readFieldEnd()
33018 
    iprot.readStructEnd()
33019 
 
33020 
  def write(self, oprot):
33021 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33022 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33023 
      return
33024 
    oprot.writeStructBegin('getAllFbgListedItems_result')
33025 
    if self.success is not None:
33026 
      oprot.writeFieldBegin('success', TType.LIST, 0)
33027 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 33028 
      for iter817 in self.success:
33029 
        iter817.write(oprot)
12892 kshitij.so 33030 
      oprot.writeListEnd()
33031 
      oprot.writeFieldEnd()
33032 
    oprot.writeFieldStop()
33033 
    oprot.writeStructEnd()
33034 
 
33035 
  def validate(self):
33036 
    return
33037 
 
33038 
 
33039 
  def __repr__(self):
33040 
    L = ['%s=%r' % (key, value)
33041 
      for key, value in self.__dict__.iteritems()]
33042 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33043 
 
33044 
  def __eq__(self, other):
33045 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33046 
 
33047 
  def __ne__(self, other):
33048 
    return not (self == other)
13136 amit.gupta 33049 
 
33050 
class checkServices_args:
33051 
  """
33052 
  Attributes:
33053 
   - lines
33054 
  """
33055 
 
33056 
  thrift_spec = (
33057 
    None, # 0
33058 
    (1, TType.MAP, 'lines', (TType.I64,None,TType.MAP,(TType.STRING,None,TType.I64,None)), None, ), # 1
33059 
  )
33060 
 
33061 
  def __init__(self, lines=None,):
33062 
    self.lines = lines
33063 
 
33064 
  def read(self, iprot):
33065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33067 
      return
33068 
    iprot.readStructBegin()
33069 
    while True:
33070 
      (fname, ftype, fid) = iprot.readFieldBegin()
33071 
      if ftype == TType.STOP:
33072 
        break
33073 
      if fid == 1:
33074 
        if ftype == TType.MAP:
33075 
          self.lines = {}
18719 kshitij.so 33076 
          (_ktype819, _vtype820, _size818 ) = iprot.readMapBegin()
33077 
          for _i822 in xrange(_size818):
33078 
            _key823 = iprot.readI64();
33079 
            _val824 = {}
33080 
            (_ktype826, _vtype827, _size825 ) = iprot.readMapBegin()
33081 
            for _i829 in xrange(_size825):
33082 
              _key830 = iprot.readString();
33083 
              _val831 = iprot.readI64();
33084 
              _val824[_key830] = _val831
13136 amit.gupta 33085 
            iprot.readMapEnd()
18719 kshitij.so 33086 
            self.lines[_key823] = _val824
13136 amit.gupta 33087 
          iprot.readMapEnd()
33088 
        else:
33089 
          iprot.skip(ftype)
33090 
      else:
33091 
        iprot.skip(ftype)
33092 
      iprot.readFieldEnd()
33093 
    iprot.readStructEnd()
33094 
 
33095 
  def write(self, oprot):
33096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33098 
      return
33099 
    oprot.writeStructBegin('checkServices_args')
33100 
    if self.lines is not None:
33101 
      oprot.writeFieldBegin('lines', TType.MAP, 1)
33102 
      oprot.writeMapBegin(TType.I64, TType.MAP, len(self.lines))
18719 kshitij.so 33103 
      for kiter832,viter833 in self.lines.items():
33104 
        oprot.writeI64(kiter832)
33105 
        oprot.writeMapBegin(TType.STRING, TType.I64, len(viter833))
33106 
        for kiter834,viter835 in viter833.items():
33107 
          oprot.writeString(kiter834)
33108 
          oprot.writeI64(viter835)
13136 amit.gupta 33109 
        oprot.writeMapEnd()
33110 
      oprot.writeMapEnd()
33111 
      oprot.writeFieldEnd()
33112 
    oprot.writeFieldStop()
33113 
    oprot.writeStructEnd()
33114 
 
33115 
  def validate(self):
33116 
    return
33117 
 
33118 
 
33119 
  def __repr__(self):
33120 
    L = ['%s=%r' % (key, value)
33121 
      for key, value in self.__dict__.iteritems()]
33122 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33123 
 
33124 
  def __eq__(self, other):
33125 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33126 
 
33127 
  def __ne__(self, other):
33128 
    return not (self == other)
33129 
 
33130 
class checkServices_result:
33131 
  """
33132 
  Attributes:
33133 
   - success
33134 
   - cex
33135 
  """
33136 
 
33137 
  thrift_spec = (
33138 
    (0, TType.MAP, 'success', (TType.I64,None,TType.MAP,(TType.STRING,None,TType.I64,None)), None, ), # 0
33139 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
33140 
  )
33141 
 
33142 
  def __init__(self, success=None, cex=None,):
33143 
    self.success = success
33144 
    self.cex = cex
33145 
 
33146 
  def read(self, iprot):
33147 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33148 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33149 
      return
33150 
    iprot.readStructBegin()
33151 
    while True:
33152 
      (fname, ftype, fid) = iprot.readFieldBegin()
33153 
      if ftype == TType.STOP:
33154 
        break
33155 
      if fid == 0:
33156 
        if ftype == TType.MAP:
33157 
          self.success = {}
18719 kshitij.so 33158 
          (_ktype837, _vtype838, _size836 ) = iprot.readMapBegin()
33159 
          for _i840 in xrange(_size836):
33160 
            _key841 = iprot.readI64();
33161 
            _val842 = {}
33162 
            (_ktype844, _vtype845, _size843 ) = iprot.readMapBegin()
33163 
            for _i847 in xrange(_size843):
33164 
              _key848 = iprot.readString();
33165 
              _val849 = iprot.readI64();
33166 
              _val842[_key848] = _val849
13136 amit.gupta 33167 
            iprot.readMapEnd()
18719 kshitij.so 33168 
            self.success[_key841] = _val842
13136 amit.gupta 33169 
          iprot.readMapEnd()
33170 
        else:
33171 
          iprot.skip(ftype)
33172 
      elif fid == 1:
33173 
        if ftype == TType.STRUCT:
33174 
          self.cex = CatalogServiceException()
33175 
          self.cex.read(iprot)
33176 
        else:
33177 
          iprot.skip(ftype)
33178 
      else:
33179 
        iprot.skip(ftype)
33180 
      iprot.readFieldEnd()
33181 
    iprot.readStructEnd()
33182 
 
33183 
  def write(self, oprot):
33184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33186 
      return
33187 
    oprot.writeStructBegin('checkServices_result')
33188 
    if self.success is not None:
33189 
      oprot.writeFieldBegin('success', TType.MAP, 0)
33190 
      oprot.writeMapBegin(TType.I64, TType.MAP, len(self.success))
18719 kshitij.so 33191 
      for kiter850,viter851 in self.success.items():
33192 
        oprot.writeI64(kiter850)
33193 
        oprot.writeMapBegin(TType.STRING, TType.I64, len(viter851))
33194 
        for kiter852,viter853 in viter851.items():
33195 
          oprot.writeString(kiter852)
33196 
          oprot.writeI64(viter853)
13136 amit.gupta 33197 
        oprot.writeMapEnd()
33198 
      oprot.writeMapEnd()
33199 
      oprot.writeFieldEnd()
33200 
    if self.cex is not None:
33201 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
33202 
      self.cex.write(oprot)
33203 
      oprot.writeFieldEnd()
33204 
    oprot.writeFieldStop()
33205 
    oprot.writeStructEnd()
33206 
 
33207 
  def validate(self):
33208 
    return
33209 
 
33210 
 
33211 
  def __repr__(self):
33212 
    L = ['%s=%r' % (key, value)
33213 
      for key, value in self.__dict__.iteritems()]
33214 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33215 
 
33216 
  def __eq__(self, other):
33217 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33218 
 
33219 
  def __ne__(self, other):
33220 
    return not (self == other)
13709 manish.sha 33221 
 
33222 
class addHsItem_args:
33223 
  """
33224 
  Attributes:
33225 
   - hsItems
33226 
  """
33227 
 
33228 
  thrift_spec = (
33229 
    None, # 0
33230 
    (1, TType.LIST, 'hsItems', (TType.STRUCT,(HsItem, HsItem.thrift_spec)), None, ), # 1
33231 
  )
33232 
 
33233 
  def __init__(self, hsItems=None,):
33234 
    self.hsItems = hsItems
33235 
 
33236 
  def read(self, iprot):
33237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33239 
      return
33240 
    iprot.readStructBegin()
33241 
    while True:
33242 
      (fname, ftype, fid) = iprot.readFieldBegin()
33243 
      if ftype == TType.STOP:
33244 
        break
33245 
      if fid == 1:
33246 
        if ftype == TType.LIST:
33247 
          self.hsItems = []
18719 kshitij.so 33248 
          (_etype857, _size854) = iprot.readListBegin()
33249 
          for _i858 in xrange(_size854):
33250 
            _elem859 = HsItem()
33251 
            _elem859.read(iprot)
33252 
            self.hsItems.append(_elem859)
13709 manish.sha 33253 
          iprot.readListEnd()
33254 
        else:
33255 
          iprot.skip(ftype)
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_args')
33266 
    if self.hsItems is not None:
33267 
      oprot.writeFieldBegin('hsItems', TType.LIST, 1)
33268 
      oprot.writeListBegin(TType.STRUCT, len(self.hsItems))
18719 kshitij.so 33269 
      for iter860 in self.hsItems:
33270 
        iter860.write(oprot)
13709 manish.sha 33271 
      oprot.writeListEnd()
33272 
      oprot.writeFieldEnd()
33273 
    oprot.writeFieldStop()
33274 
    oprot.writeStructEnd()
33275 
 
33276 
  def validate(self):
33277 
    return
33278 
 
33279 
 
33280 
  def __repr__(self):
33281 
    L = ['%s=%r' % (key, value)
33282 
      for key, value in self.__dict__.iteritems()]
33283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33284 
 
33285 
  def __eq__(self, other):
33286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33287 
 
33288 
  def __ne__(self, other):
33289 
    return not (self == other)
33290 
 
33291 
class addHsItem_result:
33292 
 
33293 
  thrift_spec = (
33294 
  )
33295 
 
33296 
  def read(self, iprot):
33297 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33298 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33299 
      return
33300 
    iprot.readStructBegin()
33301 
    while True:
33302 
      (fname, ftype, fid) = iprot.readFieldBegin()
33303 
      if ftype == TType.STOP:
33304 
        break
33305 
      else:
33306 
        iprot.skip(ftype)
33307 
      iprot.readFieldEnd()
33308 
    iprot.readStructEnd()
33309 
 
33310 
  def write(self, oprot):
33311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33313 
      return
33314 
    oprot.writeStructBegin('addHsItem_result')
33315 
    oprot.writeFieldStop()
33316 
    oprot.writeStructEnd()
33317 
 
33318 
  def validate(self):
33319 
    return
33320 
 
33321 
 
33322 
  def __repr__(self):
33323 
    L = ['%s=%r' % (key, value)
33324 
      for key, value in self.__dict__.iteritems()]
33325 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33326 
 
33327 
  def __eq__(self, other):
33328 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33329 
 
33330 
  def __ne__(self, other):
33331 
    return not (self == other)
33332 
 
33333 
class getHsItem_args:
33334 
  """
33335 
  Attributes:
33336 
   - hsItemId
33337 
  """
33338 
 
33339 
  thrift_spec = (
33340 
    None, # 0
33341 
    (1, TType.STRING, 'hsItemId', None, None, ), # 1
33342 
  )
33343 
 
33344 
  def __init__(self, hsItemId=None,):
33345 
    self.hsItemId = hsItemId
33346 
 
33347 
  def read(self, iprot):
33348 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33349 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33350 
      return
33351 
    iprot.readStructBegin()
33352 
    while True:
33353 
      (fname, ftype, fid) = iprot.readFieldBegin()
33354 
      if ftype == TType.STOP:
33355 
        break
33356 
      if fid == 1:
33357 
        if ftype == TType.STRING:
33358 
          self.hsItemId = iprot.readString();
33359 
        else:
33360 
          iprot.skip(ftype)
33361 
      else:
33362 
        iprot.skip(ftype)
33363 
      iprot.readFieldEnd()
33364 
    iprot.readStructEnd()
33365 
 
33366 
  def write(self, oprot):
33367 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33368 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33369 
      return
33370 
    oprot.writeStructBegin('getHsItem_args')
33371 
    if self.hsItemId is not None:
33372 
      oprot.writeFieldBegin('hsItemId', TType.STRING, 1)
33373 
      oprot.writeString(self.hsItemId)
33374 
      oprot.writeFieldEnd()
33375 
    oprot.writeFieldStop()
33376 
    oprot.writeStructEnd()
33377 
 
33378 
  def validate(self):
33379 
    return
33380 
 
33381 
 
33382 
  def __repr__(self):
33383 
    L = ['%s=%r' % (key, value)
33384 
      for key, value in self.__dict__.iteritems()]
33385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33386 
 
33387 
  def __eq__(self, other):
33388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33389 
 
33390 
  def __ne__(self, other):
33391 
    return not (self == other)
33392 
 
33393 
class getHsItem_result:
33394 
  """
33395 
  Attributes:
33396 
   - success
33397 
  """
33398 
 
33399 
  thrift_spec = (
33400 
    (0, TType.STRUCT, 'success', (HsItem, HsItem.thrift_spec), None, ), # 0
33401 
  )
33402 
 
33403 
  def __init__(self, success=None,):
33404 
    self.success = success
33405 
 
33406 
  def read(self, iprot):
33407 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33408 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33409 
      return
33410 
    iprot.readStructBegin()
33411 
    while True:
33412 
      (fname, ftype, fid) = iprot.readFieldBegin()
33413 
      if ftype == TType.STOP:
33414 
        break
33415 
      if fid == 0:
33416 
        if ftype == TType.STRUCT:
33417 
          self.success = HsItem()
33418 
          self.success.read(iprot)
33419 
        else:
33420 
          iprot.skip(ftype)
33421 
      else:
33422 
        iprot.skip(ftype)
33423 
      iprot.readFieldEnd()
33424 
    iprot.readStructEnd()
33425 
 
33426 
  def write(self, oprot):
33427 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33428 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33429 
      return
33430 
    oprot.writeStructBegin('getHsItem_result')
33431 
    if self.success is not None:
33432 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
33433 
      self.success.write(oprot)
33434 
      oprot.writeFieldEnd()
33435 
    oprot.writeFieldStop()
33436 
    oprot.writeStructEnd()
33437 
 
33438 
  def validate(self):
33439 
    return
33440 
 
33441 
 
33442 
  def __repr__(self):
33443 
    L = ['%s=%r' % (key, value)
33444 
      for key, value in self.__dict__.iteritems()]
33445 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33446 
 
33447 
  def __eq__(self, other):
33448 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33449 
 
33450 
  def __ne__(self, other):
33451 
    return not (self == other)
33452 
 
33453 
class updateHsItem_args:
33454 
  """
33455 
  Attributes:
33456 
   - hsItem
33457 
  """
33458 
 
33459 
  thrift_spec = (
33460 
    None, # 0
33461 
    (1, TType.STRUCT, 'hsItem', (HsItem, HsItem.thrift_spec), None, ), # 1
33462 
  )
33463 
 
33464 
  def __init__(self, hsItem=None,):
33465 
    self.hsItem = hsItem
33466 
 
33467 
  def read(self, iprot):
33468 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33469 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33470 
      return
33471 
    iprot.readStructBegin()
33472 
    while True:
33473 
      (fname, ftype, fid) = iprot.readFieldBegin()
33474 
      if ftype == TType.STOP:
33475 
        break
33476 
      if fid == 1:
33477 
        if ftype == TType.STRUCT:
33478 
          self.hsItem = HsItem()
33479 
          self.hsItem.read(iprot)
33480 
        else:
33481 
          iprot.skip(ftype)
33482 
      else:
33483 
        iprot.skip(ftype)
33484 
      iprot.readFieldEnd()
33485 
    iprot.readStructEnd()
33486 
 
33487 
  def write(self, oprot):
33488 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33489 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33490 
      return
33491 
    oprot.writeStructBegin('updateHsItem_args')
33492 
    if self.hsItem is not None:
33493 
      oprot.writeFieldBegin('hsItem', TType.STRUCT, 1)
33494 
      self.hsItem.write(oprot)
33495 
      oprot.writeFieldEnd()
33496 
    oprot.writeFieldStop()
33497 
    oprot.writeStructEnd()
33498 
 
33499 
  def validate(self):
33500 
    return
33501 
 
33502 
 
33503 
  def __repr__(self):
33504 
    L = ['%s=%r' % (key, value)
33505 
      for key, value in self.__dict__.iteritems()]
33506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33507 
 
33508 
  def __eq__(self, other):
33509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33510 
 
33511 
  def __ne__(self, other):
33512 
    return not (self == other)
33513 
 
33514 
class updateHsItem_result:
33515 
 
33516 
  thrift_spec = (
33517 
  )
33518 
 
33519 
  def read(self, iprot):
33520 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33521 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33522 
      return
33523 
    iprot.readStructBegin()
33524 
    while True:
33525 
      (fname, ftype, fid) = iprot.readFieldBegin()
33526 
      if ftype == TType.STOP:
33527 
        break
33528 
      else:
33529 
        iprot.skip(ftype)
33530 
      iprot.readFieldEnd()
33531 
    iprot.readStructEnd()
33532 
 
33533 
  def write(self, oprot):
33534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33536 
      return
33537 
    oprot.writeStructBegin('updateHsItem_result')
33538 
    oprot.writeFieldStop()
33539 
    oprot.writeStructEnd()
33540 
 
33541 
  def validate(self):
33542 
    return
33543 
 
33544 
 
33545 
  def __repr__(self):
33546 
    L = ['%s=%r' % (key, value)
33547 
      for key, value in self.__dict__.iteritems()]
33548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33549 
 
33550 
  def __eq__(self, other):
33551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33552 
 
33553 
  def __ne__(self, other):
33554 
    return not (self == other)
14182 kshitij.so 33555 
 
33556 
class getPricingForDtr_args:
33557 
  """
33558 
  Attributes:
33559 
   - catalogItemId
33560 
  """
33561 
 
33562 
  thrift_spec = (
33563 
    None, # 0
33564 
    (1, TType.I64, 'catalogItemId', None, None, ), # 1
33565 
  )
33566 
 
33567 
  def __init__(self, catalogItemId=None,):
33568 
    self.catalogItemId = catalogItemId
33569 
 
33570 
  def read(self, iprot):
33571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33573 
      return
33574 
    iprot.readStructBegin()
33575 
    while True:
33576 
      (fname, ftype, fid) = iprot.readFieldBegin()
33577 
      if ftype == TType.STOP:
33578 
        break
33579 
      if fid == 1:
33580 
        if ftype == TType.I64:
33581 
          self.catalogItemId = iprot.readI64();
33582 
        else:
33583 
          iprot.skip(ftype)
33584 
      else:
33585 
        iprot.skip(ftype)
33586 
      iprot.readFieldEnd()
33587 
    iprot.readStructEnd()
33588 
 
33589 
  def write(self, oprot):
33590 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33591 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33592 
      return
33593 
    oprot.writeStructBegin('getPricingForDtr_args')
33594 
    if self.catalogItemId is not None:
33595 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 1)
33596 
      oprot.writeI64(self.catalogItemId)
33597 
      oprot.writeFieldEnd()
33598 
    oprot.writeFieldStop()
33599 
    oprot.writeStructEnd()
33600 
 
33601 
  def validate(self):
33602 
    return
33603 
 
33604 
 
33605 
  def __repr__(self):
33606 
    L = ['%s=%r' % (key, value)
33607 
      for key, value in self.__dict__.iteritems()]
33608 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33609 
 
33610 
  def __eq__(self, other):
33611 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33612 
 
33613 
  def __ne__(self, other):
33614 
    return not (self == other)
33615 
 
33616 
class getPricingForDtr_result:
33617 
  """
33618 
  Attributes:
33619 
   - success
33620 
  """
33621 
 
33622 
  thrift_spec = (
18719 kshitij.so 33623 
    (0, TType.STRUCT, 'success', (DtrPricing, DtrPricing.thrift_spec), None, ), # 0
14182 kshitij.so 33624 
  )
33625 
 
33626 
  def __init__(self, success=None,):
33627 
    self.success = success
33628 
 
33629 
  def read(self, iprot):
33630 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33631 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33632 
      return
33633 
    iprot.readStructBegin()
33634 
    while True:
33635 
      (fname, ftype, fid) = iprot.readFieldBegin()
33636 
      if ftype == TType.STOP:
33637 
        break
33638 
      if fid == 0:
33639 
        if ftype == TType.STRUCT:
18719 kshitij.so 33640 
          self.success = DtrPricing()
14182 kshitij.so 33641 
          self.success.read(iprot)
33642 
        else:
33643 
          iprot.skip(ftype)
33644 
      else:
33645 
        iprot.skip(ftype)
33646 
      iprot.readFieldEnd()
33647 
    iprot.readStructEnd()
33648 
 
33649 
  def write(self, oprot):
33650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33652 
      return
33653 
    oprot.writeStructBegin('getPricingForDtr_result')
33654 
    if self.success is not None:
33655 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
33656 
      self.success.write(oprot)
33657 
      oprot.writeFieldEnd()
33658 
    oprot.writeFieldStop()
33659 
    oprot.writeStructEnd()
33660 
 
33661 
  def validate(self):
33662 
    return
33663 
 
33664 
 
33665 
  def __repr__(self):
33666 
    L = ['%s=%r' % (key, value)
33667 
      for key, value in self.__dict__.iteritems()]
33668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33669 
 
33670 
  def __eq__(self, other):
33671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33672 
 
33673 
  def __ne__(self, other):
33674 
    return not (self == other)
15702 kshitij.so 33675 
 
33676 
class getAllItemstoListOnFbd_args:
33677 
 
33678 
  thrift_spec = (
33679 
  )
33680 
 
33681 
  def read(self, iprot):
33682 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33683 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33684 
      return
33685 
    iprot.readStructBegin()
33686 
    while True:
33687 
      (fname, ftype, fid) = iprot.readFieldBegin()
33688 
      if ftype == TType.STOP:
33689 
        break
33690 
      else:
33691 
        iprot.skip(ftype)
33692 
      iprot.readFieldEnd()
33693 
    iprot.readStructEnd()
33694 
 
33695 
  def write(self, oprot):
33696 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33697 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33698 
      return
33699 
    oprot.writeStructBegin('getAllItemstoListOnFbd_args')
33700 
    oprot.writeFieldStop()
33701 
    oprot.writeStructEnd()
33702 
 
33703 
  def validate(self):
33704 
    return
33705 
 
33706 
 
33707 
  def __repr__(self):
33708 
    L = ['%s=%r' % (key, value)
33709 
      for key, value in self.__dict__.iteritems()]
33710 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33711 
 
33712 
  def __eq__(self, other):
33713 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33714 
 
33715 
  def __ne__(self, other):
33716 
    return not (self == other)
33717 
 
33718 
class getAllItemstoListOnFbd_result:
33719 
  """
33720 
  Attributes:
33721 
   - success
33722 
  """
33723 
 
33724 
  thrift_spec = (
33725 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
33726 
  )
33727 
 
33728 
  def __init__(self, success=None,):
33729 
    self.success = success
33730 
 
33731 
  def read(self, iprot):
33732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33734 
      return
33735 
    iprot.readStructBegin()
33736 
    while True:
33737 
      (fname, ftype, fid) = iprot.readFieldBegin()
33738 
      if ftype == TType.STOP:
33739 
        break
33740 
      if fid == 0:
33741 
        if ftype == TType.LIST:
33742 
          self.success = []
18719 kshitij.so 33743 
          (_etype864, _size861) = iprot.readListBegin()
33744 
          for _i865 in xrange(_size861):
33745 
            _elem866 = Amazonlisted()
33746 
            _elem866.read(iprot)
33747 
            self.success.append(_elem866)
15702 kshitij.so 33748 
          iprot.readListEnd()
33749 
        else:
33750 
          iprot.skip(ftype)
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('getAllItemstoListOnFbd_result')
33761 
    if self.success is not None:
33762 
      oprot.writeFieldBegin('success', TType.LIST, 0)
33763 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 33764 
      for iter867 in self.success:
33765 
        iter867.write(oprot)
15702 kshitij.so 33766 
      oprot.writeListEnd()
33767 
      oprot.writeFieldEnd()
33768 
    oprot.writeFieldStop()
33769 
    oprot.writeStructEnd()
33770 
 
33771 
  def validate(self):
33772 
    return
33773 
 
33774 
 
33775 
  def __repr__(self):
33776 
    L = ['%s=%r' % (key, value)
33777 
      for key, value in self.__dict__.iteritems()]
33778 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33779 
 
33780 
  def __eq__(self, other):
33781 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33782 
 
33783 
  def __ne__(self, other):
33784 
    return not (self == other)
15706 kshitij.so 33785 
 
33786 
class getAllFbdListedItems_args:
33787 
 
33788 
  thrift_spec = (
33789 
  )
33790 
 
33791 
  def read(self, iprot):
33792 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33793 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33794 
      return
33795 
    iprot.readStructBegin()
33796 
    while True:
33797 
      (fname, ftype, fid) = iprot.readFieldBegin()
33798 
      if ftype == TType.STOP:
33799 
        break
33800 
      else:
33801 
        iprot.skip(ftype)
33802 
      iprot.readFieldEnd()
33803 
    iprot.readStructEnd()
33804 
 
33805 
  def write(self, oprot):
33806 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33807 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33808 
      return
33809 
    oprot.writeStructBegin('getAllFbdListedItems_args')
33810 
    oprot.writeFieldStop()
33811 
    oprot.writeStructEnd()
33812 
 
33813 
  def validate(self):
33814 
    return
33815 
 
33816 
 
33817 
  def __repr__(self):
33818 
    L = ['%s=%r' % (key, value)
33819 
      for key, value in self.__dict__.iteritems()]
33820 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33821 
 
33822 
  def __eq__(self, other):
33823 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33824 
 
33825 
  def __ne__(self, other):
33826 
    return not (self == other)
33827 
 
33828 
class getAllFbdListedItems_result:
33829 
  """
33830 
  Attributes:
33831 
   - success
33832 
  """
33833 
 
33834 
  thrift_spec = (
33835 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
33836 
  )
33837 
 
33838 
  def __init__(self, success=None,):
33839 
    self.success = success
33840 
 
33841 
  def read(self, iprot):
33842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33844 
      return
33845 
    iprot.readStructBegin()
33846 
    while True:
33847 
      (fname, ftype, fid) = iprot.readFieldBegin()
33848 
      if ftype == TType.STOP:
33849 
        break
33850 
      if fid == 0:
33851 
        if ftype == TType.LIST:
33852 
          self.success = []
18719 kshitij.so 33853 
          (_etype871, _size868) = iprot.readListBegin()
33854 
          for _i872 in xrange(_size868):
33855 
            _elem873 = Amazonlisted()
33856 
            _elem873.read(iprot)
33857 
            self.success.append(_elem873)
15706 kshitij.so 33858 
          iprot.readListEnd()
33859 
        else:
33860 
          iprot.skip(ftype)
33861 
      else:
33862 
        iprot.skip(ftype)
33863 
      iprot.readFieldEnd()
33864 
    iprot.readStructEnd()
33865 
 
33866 
  def write(self, oprot):
33867 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33868 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33869 
      return
33870 
    oprot.writeStructBegin('getAllFbdListedItems_result')
33871 
    if self.success is not None:
33872 
      oprot.writeFieldBegin('success', TType.LIST, 0)
33873 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 33874 
      for iter874 in self.success:
33875 
        iter874.write(oprot)
15706 kshitij.so 33876 
      oprot.writeListEnd()
33877 
      oprot.writeFieldEnd()
33878 
    oprot.writeFieldStop()
33879 
    oprot.writeStructEnd()
33880 
 
33881 
  def validate(self):
33882 
    return
33883 
 
33884 
 
33885 
  def __repr__(self):
33886 
    L = ['%s=%r' % (key, value)
33887 
      for key, value in self.__dict__.iteritems()]
33888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33889 
 
33890 
  def __eq__(self, other):
33891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33892 
 
33893 
  def __ne__(self, other):
33894 
    return not (self == other)
18150 kshitij.so 33895 
 
33896 
class getBulkPricingForItems_args:
33897 
  """
33898 
  Attributes:
33899 
   - itemIds
33900 
  """
33901 
 
33902 
  thrift_spec = (
33903 
    None, # 0
33904 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
33905 
  )
33906 
 
33907 
  def __init__(self, itemIds=None,):
33908 
    self.itemIds = itemIds
33909 
 
33910 
  def read(self, iprot):
33911 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33912 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33913 
      return
33914 
    iprot.readStructBegin()
33915 
    while True:
33916 
      (fname, ftype, fid) = iprot.readFieldBegin()
33917 
      if ftype == TType.STOP:
33918 
        break
33919 
      if fid == 1:
33920 
        if ftype == TType.LIST:
33921 
          self.itemIds = []
18719 kshitij.so 33922 
          (_etype878, _size875) = iprot.readListBegin()
33923 
          for _i879 in xrange(_size875):
33924 
            _elem880 = iprot.readI64();
33925 
            self.itemIds.append(_elem880)
18150 kshitij.so 33926 
          iprot.readListEnd()
33927 
        else:
33928 
          iprot.skip(ftype)
33929 
      else:
33930 
        iprot.skip(ftype)
33931 
      iprot.readFieldEnd()
33932 
    iprot.readStructEnd()
33933 
 
33934 
  def write(self, oprot):
33935 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33936 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33937 
      return
33938 
    oprot.writeStructBegin('getBulkPricingForItems_args')
33939 
    if self.itemIds is not None:
33940 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
33941 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
18719 kshitij.so 33942 
      for iter881 in self.itemIds:
33943 
        oprot.writeI64(iter881)
18150 kshitij.so 33944 
      oprot.writeListEnd()
33945 
      oprot.writeFieldEnd()
33946 
    oprot.writeFieldStop()
33947 
    oprot.writeStructEnd()
33948 
 
33949 
  def validate(self):
33950 
    return
33951 
 
33952 
 
33953 
  def __repr__(self):
33954 
    L = ['%s=%r' % (key, value)
33955 
      for key, value in self.__dict__.iteritems()]
33956 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33957 
 
33958 
  def __eq__(self, other):
33959 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33960 
 
33961 
  def __ne__(self, other):
33962 
    return not (self == other)
33963 
 
33964 
class getBulkPricingForItems_result:
33965 
  """
33966 
  Attributes:
33967 
   - success
33968 
  """
33969 
 
33970 
  thrift_spec = (
33971 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRUCT,(BulkItemPricing, BulkItemPricing.thrift_spec))), None, ), # 0
33972 
  )
33973 
 
33974 
  def __init__(self, success=None,):
33975 
    self.success = success
33976 
 
33977 
  def read(self, iprot):
33978 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33979 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33980 
      return
33981 
    iprot.readStructBegin()
33982 
    while True:
33983 
      (fname, ftype, fid) = iprot.readFieldBegin()
33984 
      if ftype == TType.STOP:
33985 
        break
33986 
      if fid == 0:
33987 
        if ftype == TType.MAP:
33988 
          self.success = {}
18719 kshitij.so 33989 
          (_ktype883, _vtype884, _size882 ) = iprot.readMapBegin()
33990 
          for _i886 in xrange(_size882):
33991 
            _key887 = iprot.readI64();
33992 
            _val888 = []
33993 
            (_etype892, _size889) = iprot.readListBegin()
33994 
            for _i893 in xrange(_size889):
33995 
              _elem894 = BulkItemPricing()
33996 
              _elem894.read(iprot)
33997 
              _val888.append(_elem894)
18150 kshitij.so 33998 
            iprot.readListEnd()
18719 kshitij.so 33999 
            self.success[_key887] = _val888
18150 kshitij.so 34000 
          iprot.readMapEnd()
34001 
        else:
34002 
          iprot.skip(ftype)
34003 
      else:
34004 
        iprot.skip(ftype)
34005 
      iprot.readFieldEnd()
34006 
    iprot.readStructEnd()
34007 
 
34008 
  def write(self, oprot):
34009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34011 
      return
34012 
    oprot.writeStructBegin('getBulkPricingForItems_result')
34013 
    if self.success is not None:
34014 
      oprot.writeFieldBegin('success', TType.MAP, 0)
34015 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
18719 kshitij.so 34016 
      for kiter895,viter896 in self.success.items():
34017 
        oprot.writeI64(kiter895)
34018 
        oprot.writeListBegin(TType.STRUCT, len(viter896))
34019 
        for iter897 in viter896:
34020 
          iter897.write(oprot)
18150 kshitij.so 34021 
        oprot.writeListEnd()
34022 
      oprot.writeMapEnd()
34023 
      oprot.writeFieldEnd()
34024 
    oprot.writeFieldStop()
34025 
    oprot.writeStructEnd()
34026 
 
34027 
  def validate(self):
34028 
    return
34029 
 
34030 
 
34031 
  def __repr__(self):
34032 
    L = ['%s=%r' % (key, value)
34033 
      for key, value in self.__dict__.iteritems()]
34034 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34035 
 
34036 
  def __eq__(self, other):
34037 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34038 
 
34039 
  def __ne__(self, other):
34040 
    return not (self == other)
34041 
 
34042 
class addBulkPricingForItem_args:
34043 
  """
34044 
  Attributes:
34045 
   - bulkItemPricing
34046 
  """
34047 
 
34048 
  thrift_spec = (
34049 
    None, # 0
34050 
    (1, TType.STRUCT, 'bulkItemPricing', (BulkItemPricing, BulkItemPricing.thrift_spec), None, ), # 1
34051 
  )
34052 
 
34053 
  def __init__(self, bulkItemPricing=None,):
34054 
    self.bulkItemPricing = bulkItemPricing
34055 
 
34056 
  def read(self, iprot):
34057 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34058 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34059 
      return
34060 
    iprot.readStructBegin()
34061 
    while True:
34062 
      (fname, ftype, fid) = iprot.readFieldBegin()
34063 
      if ftype == TType.STOP:
34064 
        break
34065 
      if fid == 1:
34066 
        if ftype == TType.STRUCT:
34067 
          self.bulkItemPricing = BulkItemPricing()
34068 
          self.bulkItemPricing.read(iprot)
34069 
        else:
34070 
          iprot.skip(ftype)
34071 
      else:
34072 
        iprot.skip(ftype)
34073 
      iprot.readFieldEnd()
34074 
    iprot.readStructEnd()
34075 
 
34076 
  def write(self, oprot):
34077 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34078 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34079 
      return
34080 
    oprot.writeStructBegin('addBulkPricingForItem_args')
34081 
    if self.bulkItemPricing is not None:
34082 
      oprot.writeFieldBegin('bulkItemPricing', TType.STRUCT, 1)
34083 
      self.bulkItemPricing.write(oprot)
34084 
      oprot.writeFieldEnd()
34085 
    oprot.writeFieldStop()
34086 
    oprot.writeStructEnd()
34087 
 
34088 
  def validate(self):
34089 
    return
34090 
 
34091 
 
34092 
  def __repr__(self):
34093 
    L = ['%s=%r' % (key, value)
34094 
      for key, value in self.__dict__.iteritems()]
34095 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34096 
 
34097 
  def __eq__(self, other):
34098 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34099 
 
34100 
  def __ne__(self, other):
34101 
    return not (self == other)
34102 
 
34103 
class addBulkPricingForItem_result:
34104 
  """
34105 
  Attributes:
34106 
   - success
34107 
  """
34108 
 
34109 
  thrift_spec = (
34110 
    (0, TType.STRUCT, 'success', (BulkItemPricing, BulkItemPricing.thrift_spec), None, ), # 0
34111 
  )
34112 
 
34113 
  def __init__(self, success=None,):
34114 
    self.success = success
34115 
 
34116 
  def read(self, iprot):
34117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34119 
      return
34120 
    iprot.readStructBegin()
34121 
    while True:
34122 
      (fname, ftype, fid) = iprot.readFieldBegin()
34123 
      if ftype == TType.STOP:
34124 
        break
34125 
      if fid == 0:
34126 
        if ftype == TType.STRUCT:
34127 
          self.success = BulkItemPricing()
34128 
          self.success.read(iprot)
34129 
        else:
34130 
          iprot.skip(ftype)
34131 
      else:
34132 
        iprot.skip(ftype)
34133 
      iprot.readFieldEnd()
34134 
    iprot.readStructEnd()
34135 
 
34136 
  def write(self, oprot):
34137 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34138 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34139 
      return
34140 
    oprot.writeStructBegin('addBulkPricingForItem_result')
34141 
    if self.success is not None:
34142 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
34143 
      self.success.write(oprot)
34144 
      oprot.writeFieldEnd()
34145 
    oprot.writeFieldStop()
34146 
    oprot.writeStructEnd()
34147 
 
34148 
  def validate(self):
34149 
    return
34150 
 
34151 
 
34152 
  def __repr__(self):
34153 
    L = ['%s=%r' % (key, value)
34154 
      for key, value in self.__dict__.iteritems()]
34155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34156 
 
34157 
  def __eq__(self, other):
34158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34159 
 
34160 
  def __ne__(self, other):
34161 
    return not (self == other)
34162 
 
34163 
class deleteBulkPricingForItemById_args:
34164 
  """
34165 
  Attributes:
34166 
   - id
34167 
  """
34168 
 
34169 
  thrift_spec = (
34170 
    None, # 0
34171 
    (1, TType.I64, 'id', None, None, ), # 1
34172 
  )
34173 
 
34174 
  def __init__(self, id=None,):
34175 
    self.id = id
34176 
 
34177 
  def read(self, iprot):
34178 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34179 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34180 
      return
34181 
    iprot.readStructBegin()
34182 
    while True:
34183 
      (fname, ftype, fid) = iprot.readFieldBegin()
34184 
      if ftype == TType.STOP:
34185 
        break
34186 
      if fid == 1:
34187 
        if ftype == TType.I64:
34188 
          self.id = iprot.readI64();
34189 
        else:
34190 
          iprot.skip(ftype)
34191 
      else:
34192 
        iprot.skip(ftype)
34193 
      iprot.readFieldEnd()
34194 
    iprot.readStructEnd()
34195 
 
34196 
  def write(self, oprot):
34197 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34198 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34199 
      return
34200 
    oprot.writeStructBegin('deleteBulkPricingForItemById_args')
34201 
    if self.id is not None:
34202 
      oprot.writeFieldBegin('id', TType.I64, 1)
34203 
      oprot.writeI64(self.id)
34204 
      oprot.writeFieldEnd()
34205 
    oprot.writeFieldStop()
34206 
    oprot.writeStructEnd()
34207 
 
34208 
  def validate(self):
34209 
    return
34210 
 
34211 
 
34212 
  def __repr__(self):
34213 
    L = ['%s=%r' % (key, value)
34214 
      for key, value in self.__dict__.iteritems()]
34215 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34216 
 
34217 
  def __eq__(self, other):
34218 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34219 
 
34220 
  def __ne__(self, other):
34221 
    return not (self == other)
34222 
 
34223 
class deleteBulkPricingForItemById_result:
34224 
  """
34225 
  Attributes:
34226 
   - success
34227 
  """
34228 
 
34229 
  thrift_spec = (
34230 
    (0, TType.BOOL, 'success', None, None, ), # 0
34231 
  )
34232 
 
34233 
  def __init__(self, success=None,):
34234 
    self.success = success
34235 
 
34236 
  def read(self, iprot):
34237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34239 
      return
34240 
    iprot.readStructBegin()
34241 
    while True:
34242 
      (fname, ftype, fid) = iprot.readFieldBegin()
34243 
      if ftype == TType.STOP:
34244 
        break
34245 
      if fid == 0:
34246 
        if ftype == TType.BOOL:
34247 
          self.success = iprot.readBool();
34248 
        else:
34249 
          iprot.skip(ftype)
34250 
      else:
34251 
        iprot.skip(ftype)
34252 
      iprot.readFieldEnd()
34253 
    iprot.readStructEnd()
34254 
 
34255 
  def write(self, oprot):
34256 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34257 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34258 
      return
34259 
    oprot.writeStructBegin('deleteBulkPricingForItemById_result')
34260 
    if self.success is not None:
34261 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
34262 
      oprot.writeBool(self.success)
34263 
      oprot.writeFieldEnd()
34264 
    oprot.writeFieldStop()
34265 
    oprot.writeStructEnd()
34266 
 
34267 
  def validate(self):
34268 
    return
34269 
 
34270 
 
34271 
  def __repr__(self):
34272 
    L = ['%s=%r' % (key, value)
34273 
      for key, value in self.__dict__.iteritems()]
34274 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34275 
 
34276 
  def __eq__(self, other):
34277 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34278 
 
34279 
  def __ne__(self, other):
34280 
    return not (self == other)
34281 
 
34282 
class deleteBulkPricingForItem_args:
34283 
  """
34284 
  Attributes:
34285 
   - item_id
34286 
  """
34287 
 
34288 
  thrift_spec = (
34289 
    None, # 0
34290 
    (1, TType.I64, 'item_id', None, None, ), # 1
34291 
  )
34292 
 
34293 
  def __init__(self, item_id=None,):
34294 
    self.item_id = item_id
34295 
 
34296 
  def read(self, iprot):
34297 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34298 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34299 
      return
34300 
    iprot.readStructBegin()
34301 
    while True:
34302 
      (fname, ftype, fid) = iprot.readFieldBegin()
34303 
      if ftype == TType.STOP:
34304 
        break
34305 
      if fid == 1:
34306 
        if ftype == TType.I64:
34307 
          self.item_id = iprot.readI64();
34308 
        else:
34309 
          iprot.skip(ftype)
34310 
      else:
34311 
        iprot.skip(ftype)
34312 
      iprot.readFieldEnd()
34313 
    iprot.readStructEnd()
34314 
 
34315 
  def write(self, oprot):
34316 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34317 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34318 
      return
34319 
    oprot.writeStructBegin('deleteBulkPricingForItem_args')
34320 
    if self.item_id is not None:
34321 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
34322 
      oprot.writeI64(self.item_id)
34323 
      oprot.writeFieldEnd()
34324 
    oprot.writeFieldStop()
34325 
    oprot.writeStructEnd()
34326 
 
34327 
  def validate(self):
34328 
    return
34329 
 
34330 
 
34331 
  def __repr__(self):
34332 
    L = ['%s=%r' % (key, value)
34333 
      for key, value in self.__dict__.iteritems()]
34334 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34335 
 
34336 
  def __eq__(self, other):
34337 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34338 
 
34339 
  def __ne__(self, other):
34340 
    return not (self == other)
34341 
 
34342 
class deleteBulkPricingForItem_result:
34343 
  """
34344 
  Attributes:
34345 
   - success
34346 
  """
34347 
 
34348 
  thrift_spec = (
34349 
    (0, TType.BOOL, 'success', None, None, ), # 0
34350 
  )
34351 
 
34352 
  def __init__(self, success=None,):
34353 
    self.success = success
34354 
 
34355 
  def read(self, iprot):
34356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34358 
      return
34359 
    iprot.readStructBegin()
34360 
    while True:
34361 
      (fname, ftype, fid) = iprot.readFieldBegin()
34362 
      if ftype == TType.STOP:
34363 
        break
34364 
      if fid == 0:
34365 
        if ftype == TType.BOOL:
34366 
          self.success = iprot.readBool();
34367 
        else:
34368 
          iprot.skip(ftype)
34369 
      else:
34370 
        iprot.skip(ftype)
34371 
      iprot.readFieldEnd()
34372 
    iprot.readStructEnd()
34373 
 
34374 
  def write(self, oprot):
34375 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34376 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34377 
      return
34378 
    oprot.writeStructBegin('deleteBulkPricingForItem_result')
34379 
    if self.success is not None:
34380 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
34381 
      oprot.writeBool(self.success)
34382 
      oprot.writeFieldEnd()
34383 
    oprot.writeFieldStop()
34384 
    oprot.writeStructEnd()
34385 
 
34386 
  def validate(self):
34387 
    return
34388 
 
34389 
 
34390 
  def __repr__(self):
34391 
    L = ['%s=%r' % (key, value)
34392 
      for key, value in self.__dict__.iteritems()]
34393 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34394 
 
34395 
  def __eq__(self, other):
34396 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34397 
 
34398 
  def __ne__(self, other):
34399 
    return not (self == other)
34400 
 
34401 
class getBulkPricingByItemId_args:
34402 
  """
34403 
  Attributes:
34404 
   - item_id
34405 
  """
34406 
 
34407 
  thrift_spec = (
34408 
    None, # 0
34409 
    (1, TType.I64, 'item_id', None, None, ), # 1
34410 
  )
34411 
 
34412 
  def __init__(self, item_id=None,):
34413 
    self.item_id = item_id
34414 
 
34415 
  def read(self, iprot):
34416 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34417 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34418 
      return
34419 
    iprot.readStructBegin()
34420 
    while True:
34421 
      (fname, ftype, fid) = iprot.readFieldBegin()
34422 
      if ftype == TType.STOP:
34423 
        break
34424 
      if fid == 1:
34425 
        if ftype == TType.I64:
34426 
          self.item_id = iprot.readI64();
34427 
        else:
34428 
          iprot.skip(ftype)
34429 
      else:
34430 
        iprot.skip(ftype)
34431 
      iprot.readFieldEnd()
34432 
    iprot.readStructEnd()
34433 
 
34434 
  def write(self, oprot):
34435 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34436 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34437 
      return
34438 
    oprot.writeStructBegin('getBulkPricingByItemId_args')
34439 
    if self.item_id is not None:
34440 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
34441 
      oprot.writeI64(self.item_id)
34442 
      oprot.writeFieldEnd()
34443 
    oprot.writeFieldStop()
34444 
    oprot.writeStructEnd()
34445 
 
34446 
  def validate(self):
34447 
    return
34448 
 
34449 
 
34450 
  def __repr__(self):
34451 
    L = ['%s=%r' % (key, value)
34452 
      for key, value in self.__dict__.iteritems()]
34453 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34454 
 
34455 
  def __eq__(self, other):
34456 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34457 
 
34458 
  def __ne__(self, other):
34459 
    return not (self == other)
34460 
 
34461 
class getBulkPricingByItemId_result:
34462 
  """
34463 
  Attributes:
34464 
   - success
34465 
  """
34466 
 
34467 
  thrift_spec = (
34468 
    (0, TType.LIST, 'success', (TType.STRUCT,(BulkItemPricing, BulkItemPricing.thrift_spec)), None, ), # 0
34469 
  )
34470 
 
34471 
  def __init__(self, success=None,):
34472 
    self.success = success
34473 
 
34474 
  def read(self, iprot):
34475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34477 
      return
34478 
    iprot.readStructBegin()
34479 
    while True:
34480 
      (fname, ftype, fid) = iprot.readFieldBegin()
34481 
      if ftype == TType.STOP:
34482 
        break
34483 
      if fid == 0:
34484 
        if ftype == TType.LIST:
34485 
          self.success = []
18719 kshitij.so 34486 
          (_etype901, _size898) = iprot.readListBegin()
34487 
          for _i902 in xrange(_size898):
34488 
            _elem903 = BulkItemPricing()
34489 
            _elem903.read(iprot)
34490 
            self.success.append(_elem903)
18150 kshitij.so 34491 
          iprot.readListEnd()
34492 
        else:
34493 
          iprot.skip(ftype)
34494 
      else:
34495 
        iprot.skip(ftype)
34496 
      iprot.readFieldEnd()
34497 
    iprot.readStructEnd()
34498 
 
34499 
  def write(self, oprot):
34500 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34501 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34502 
      return
34503 
    oprot.writeStructBegin('getBulkPricingByItemId_result')
34504 
    if self.success is not None:
34505 
      oprot.writeFieldBegin('success', TType.LIST, 0)
34506 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18719 kshitij.so 34507 
      for iter904 in self.success:
34508 
        iter904.write(oprot)
18150 kshitij.so 34509 
      oprot.writeListEnd()
34510 
      oprot.writeFieldEnd()
34511 
    oprot.writeFieldStop()
34512 
    oprot.writeStructEnd()
34513 
 
34514 
  def validate(self):
34515 
    return
34516 
 
34517 
 
34518 
  def __repr__(self):
34519 
    L = ['%s=%r' % (key, value)
34520 
      for key, value in self.__dict__.iteritems()]
34521 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34522 
 
34523 
  def __eq__(self, other):
34524 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34525 
 
34526 
  def __ne__(self, other):
34527 
    return not (self == other)
18602 kshitij.so 34528 
 
34529 
class updateBulkPricesOnProduction_args:
34530 
  """
34531 
  Attributes:
34532 
   - item_id
34533 
   - bulkItemPricingList
34534 
  """
34535 
 
34536 
  thrift_spec = (
34537 
    None, # 0
34538 
    (1, TType.I64, 'item_id', None, None, ), # 1
34539 
    (2, TType.LIST, 'bulkItemPricingList', (TType.STRUCT,(BulkItemPricing, BulkItemPricing.thrift_spec)), None, ), # 2
34540 
  )
34541 
 
34542 
  def __init__(self, item_id=None, bulkItemPricingList=None,):
34543 
    self.item_id = item_id
34544 
    self.bulkItemPricingList = bulkItemPricingList
34545 
 
34546 
  def read(self, iprot):
34547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34549 
      return
34550 
    iprot.readStructBegin()
34551 
    while True:
34552 
      (fname, ftype, fid) = iprot.readFieldBegin()
34553 
      if ftype == TType.STOP:
34554 
        break
34555 
      if fid == 1:
34556 
        if ftype == TType.I64:
34557 
          self.item_id = iprot.readI64();
34558 
        else:
34559 
          iprot.skip(ftype)
34560 
      elif fid == 2:
34561 
        if ftype == TType.LIST:
34562 
          self.bulkItemPricingList = []
18719 kshitij.so 34563 
          (_etype908, _size905) = iprot.readListBegin()
34564 
          for _i909 in xrange(_size905):
34565 
            _elem910 = BulkItemPricing()
34566 
            _elem910.read(iprot)
34567 
            self.bulkItemPricingList.append(_elem910)
18602 kshitij.so 34568 
          iprot.readListEnd()
34569 
        else:
34570 
          iprot.skip(ftype)
34571 
      else:
34572 
        iprot.skip(ftype)
34573 
      iprot.readFieldEnd()
34574 
    iprot.readStructEnd()
34575 
 
34576 
  def write(self, oprot):
34577 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34578 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34579 
      return
34580 
    oprot.writeStructBegin('updateBulkPricesOnProduction_args')
34581 
    if self.item_id is not None:
34582 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
34583 
      oprot.writeI64(self.item_id)
34584 
      oprot.writeFieldEnd()
34585 
    if self.bulkItemPricingList is not None:
34586 
      oprot.writeFieldBegin('bulkItemPricingList', TType.LIST, 2)
34587 
      oprot.writeListBegin(TType.STRUCT, len(self.bulkItemPricingList))
18719 kshitij.so 34588 
      for iter911 in self.bulkItemPricingList:
34589 
        iter911.write(oprot)
18602 kshitij.so 34590 
      oprot.writeListEnd()
34591 
      oprot.writeFieldEnd()
34592 
    oprot.writeFieldStop()
34593 
    oprot.writeStructEnd()
34594 
 
34595 
  def validate(self):
34596 
    return
34597 
 
34598 
 
34599 
  def __repr__(self):
34600 
    L = ['%s=%r' % (key, value)
34601 
      for key, value in self.__dict__.iteritems()]
34602 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34603 
 
34604 
  def __eq__(self, other):
34605 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34606 
 
34607 
  def __ne__(self, other):
34608 
    return not (self == other)
34609 
 
34610 
class updateBulkPricesOnProduction_result:
34611 
  """
34612 
  Attributes:
34613 
   - success
34614 
  """
34615 
 
34616 
  thrift_spec = (
34617 
    (0, TType.BOOL, 'success', None, None, ), # 0
34618 
  )
34619 
 
34620 
  def __init__(self, success=None,):
34621 
    self.success = success
34622 
 
34623 
  def read(self, iprot):
34624 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34625 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34626 
      return
34627 
    iprot.readStructBegin()
34628 
    while True:
34629 
      (fname, ftype, fid) = iprot.readFieldBegin()
34630 
      if ftype == TType.STOP:
34631 
        break
34632 
      if fid == 0:
34633 
        if ftype == TType.BOOL:
34634 
          self.success = iprot.readBool();
34635 
        else:
34636 
          iprot.skip(ftype)
34637 
      else:
34638 
        iprot.skip(ftype)
34639 
      iprot.readFieldEnd()
34640 
    iprot.readStructEnd()
34641 
 
34642 
  def write(self, oprot):
34643 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34644 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34645 
      return
34646 
    oprot.writeStructBegin('updateBulkPricesOnProduction_result')
34647 
    if self.success is not None:
34648 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
34649 
      oprot.writeBool(self.success)
34650 
      oprot.writeFieldEnd()
34651 
    oprot.writeFieldStop()
34652 
    oprot.writeStructEnd()
34653 
 
34654 
  def validate(self):
34655 
    return
34656 
 
34657 
 
34658 
  def __repr__(self):
34659 
    L = ['%s=%r' % (key, value)
34660 
      for key, value in self.__dict__.iteritems()]
34661 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34662 
 
34663 
  def __eq__(self, other):
34664 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34665 
 
34666 
  def __ne__(self, other):
34667 
    return not (self == other)
18764 kshitij.so 34668 
 
34669 
class getCartByValue_args:
34670 
  """
34671 
  Attributes:
34672 
   - cartIds
34673 
  """
34674 
 
34675 
  thrift_spec = (
34676 
    None, # 0
34677 
    (1, TType.LIST, 'cartIds', (TType.I64,None), None, ), # 1
34678 
  )
34679 
 
34680 
  def __init__(self, cartIds=None,):
34681 
    self.cartIds = cartIds
34682 
 
34683 
  def read(self, iprot):
34684 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34685 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34686 
      return
34687 
    iprot.readStructBegin()
34688 
    while True:
34689 
      (fname, ftype, fid) = iprot.readFieldBegin()
34690 
      if ftype == TType.STOP:
34691 
        break
34692 
      if fid == 1:
34693 
        if ftype == TType.LIST:
34694 
          self.cartIds = []
34695 
          (_etype915, _size912) = iprot.readListBegin()
34696 
          for _i916 in xrange(_size912):
34697 
            _elem917 = iprot.readI64();
34698 
            self.cartIds.append(_elem917)
34699 
          iprot.readListEnd()
34700 
        else:
34701 
          iprot.skip(ftype)
34702 
      else:
34703 
        iprot.skip(ftype)
34704 
      iprot.readFieldEnd()
34705 
    iprot.readStructEnd()
34706 
 
34707 
  def write(self, oprot):
34708 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34709 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34710 
      return
34711 
    oprot.writeStructBegin('getCartByValue_args')
34712 
    if self.cartIds is not None:
34713 
      oprot.writeFieldBegin('cartIds', TType.LIST, 1)
34714 
      oprot.writeListBegin(TType.I64, len(self.cartIds))
34715 
      for iter918 in self.cartIds:
34716 
        oprot.writeI64(iter918)
34717 
      oprot.writeListEnd()
34718 
      oprot.writeFieldEnd()
34719 
    oprot.writeFieldStop()
34720 
    oprot.writeStructEnd()
34721 
 
34722 
  def validate(self):
34723 
    return
34724 
 
34725 
 
34726 
  def __repr__(self):
34727 
    L = ['%s=%r' % (key, value)
34728 
      for key, value in self.__dict__.iteritems()]
34729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34730 
 
34731 
  def __eq__(self, other):
34732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34733 
 
34734 
  def __ne__(self, other):
34735 
    return not (self == other)
34736 
 
34737 
class getCartByValue_result:
34738 
  """
34739 
  Attributes:
34740 
   - success
34741 
  """
34742 
 
34743 
  thrift_spec = (
34744 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
34745 
  )
34746 
 
34747 
  def __init__(self, success=None,):
34748 
    self.success = success
34749 
 
34750 
  def read(self, iprot):
34751 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34752 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34753 
      return
34754 
    iprot.readStructBegin()
34755 
    while True:
34756 
      (fname, ftype, fid) = iprot.readFieldBegin()
34757 
      if ftype == TType.STOP:
34758 
        break
34759 
      if fid == 0:
34760 
        if ftype == TType.LIST:
34761 
          self.success = []
34762 
          (_etype922, _size919) = iprot.readListBegin()
34763 
          for _i923 in xrange(_size919):
34764 
            _elem924 = iprot.readI64();
34765 
            self.success.append(_elem924)
34766 
          iprot.readListEnd()
34767 
        else:
34768 
          iprot.skip(ftype)
34769 
      else:
34770 
        iprot.skip(ftype)
34771 
      iprot.readFieldEnd()
34772 
    iprot.readStructEnd()
34773 
 
34774 
  def write(self, oprot):
34775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34777 
      return
34778 
    oprot.writeStructBegin('getCartByValue_result')
34779 
    if self.success is not None:
34780 
      oprot.writeFieldBegin('success', TType.LIST, 0)
34781 
      oprot.writeListBegin(TType.I64, len(self.success))
34782 
      for iter925 in self.success:
34783 
        oprot.writeI64(iter925)
34784 
      oprot.writeListEnd()
34785 
      oprot.writeFieldEnd()
34786 
    oprot.writeFieldStop()
34787 
    oprot.writeStructEnd()
34788 
 
34789 
  def validate(self):
34790 
    return
34791 
 
34792 
 
34793 
  def __repr__(self):
34794 
    L = ['%s=%r' % (key, value)
34795 
      for key, value in self.__dict__.iteritems()]
34796 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34797 
 
34798 
  def __eq__(self, other):
34799 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34800 
 
34801 
  def __ne__(self, other):
34802 
    return not (self == other)