Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
5944 mandeep.dh 1 
#
2 
# Autogenerated by Thrift Compiler (0.7.0)
3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
8 
import shop2020.thriftpy.generic.GenericService
9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
12 
from thrift.protocol import TBinaryProtocol, TProtocol
13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
20 
  def addItem(self, item):
21 
    """
22 
    Availability and inventory attributes
23 
 
24 
    Parameters:
25 
     - item
26 
    """
27 
    pass
28 
 
29 
  def updateItem(self, item):
30 
    """
31 
    Parameters:
32 
     - item
33 
    """
34 
    pass
35 
 
36 
  def isActive(self, itemId):
37 
    """
38 
    Checks if the item given to the corresponding itemId is active. If it's active,
39 
    whether it's risky and if it's risky, its inventory position.
40 
 
41 
    Parameters:
42 
     - itemId
43 
    """
44 
    pass
45 
 
7438 amit.gupta 46 
  def getItemsStatus(self, itemIds):
47 
    """
48 
    Parameters:
49 
     - itemIds
50 
    """
51 
    pass
52 
 
5944 mandeep.dh 53 
  def getItemStatusDescription(self, itemId):
54 
    """
55 
    Parameters:
56 
     - itemId
57 
    """
58 
    pass
59 
 
60 
  def startItemOn(self, item_id, timestamp):
61 
    """
62 
    Parameters:
63 
     - item_id
64 
     - timestamp
65 
    """
66 
    pass
67 
 
68 
  def retireItemOn(self, item_id, timestamp):
69 
    """
70 
    Parameters:
71 
     - item_id
72 
     - timestamp
73 
    """
74 
    pass
75 
 
76 
  def changeItemStatus(self, item_id, timestamp, newstatus):
77 
    """
78 
    Parameters:
79 
     - item_id
80 
     - timestamp
81 
     - newstatus
82 
    """
83 
    pass
84 
 
85 
  def getItem(self, item_id):
86 
    """
87 
    Parameters:
88 
     - item_id
89 
    """
90 
    pass
91 
 
92 
  def getItemsByCatalogId(self, catalog_item_id):
93 
    """
94 
    Parameters:
95 
     - catalog_item_id
96 
    """
97 
    pass
98 
 
99 
  def getValidItemsByCatalogId(self, catalog_item_id):
100 
    """
101 
    Parameters:
102 
     - catalog_item_id
103 
    """
104 
    pass
105 
 
106 
  def getAllItems(self, isActive):
107 
    """
108 
    Parameters:
109 
     - isActive
110 
    """
111 
    pass
112 
 
113 
  def getAllItemsByStatus(self, itemStatus):
114 
    """
115 
    Parameters:
116 
     - itemStatus
117 
    """
118 
    pass
119 
 
120 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
121 
    """
122 
    Parameters:
123 
     - entityId
124 
     - category
125 
     - brand
126 
     - modelName
127 
     - modelNumber
128 
    """
129 
    pass
130 
 
131 
  def getAllItemsInRange(self, offset, limit):
132 
    """
133 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
134 
 
135 
    Parameters:
136 
     - offset
137 
     - limit
138 
    """
139 
    pass
140 
 
141 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
142 
    """
143 
    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.
144 
 
145 
    Parameters:
146 
     - itemStatus
147 
     - offset
148 
     - limit
149 
    """
150 
    pass
151 
 
152 
  def getItemCountByStatus(self, useStatus, itemStatus):
153 
    """
154 
    Gets a count of all items by status
155 
 
156 
    Parameters:
157 
     - useStatus
158 
     - itemStatus
159 
    """
160 
    pass
161 
 
162 
  def getBestSellers(self, ):
163 
    pass
164 
 
165 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
166 
    """
167 
    Parameters:
168 
     - beginIndex
169 
     - totalItems
170 
     - brand
171 
     - category
172 
    """
173 
    pass
174 
 
175 
  def getBestSellersCount(self, ):
176 
    pass
177 
 
178 
  def getBestDeals(self, ):
179 
    pass
180 
 
181 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
182 
    """
183 
    Parameters:
184 
     - beginIndex
185 
     - totalItems
186 
     - brand
187 
     - category
188 
    """
189 
    pass
190 
 
191 
  def getBestDealsCount(self, ):
192 
    pass
193 
 
194 
  def getComingSoon(self, ):
195 
    pass
196 
 
197 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
198 
    """
199 
    Parameters:
200 
     - beginIndex
201 
     - totalItems
202 
     - brand
203 
     - category
204 
    """
205 
    pass
206 
 
207 
  def getComingSoonCount(self, ):
208 
    pass
209 
 
210 
  def getLatestArrivals(self, ):
211 
    """
212 
    Returns a list of items sorted in the descending order by start date.
213 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
214 
    """
215 
    pass
216 
 
217 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
218 
    """
219 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
220 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
221 
 
222 
    Parameters:
223 
     - beginIndex
224 
     - totalItems
225 
     - brand
226 
     - categories
227 
    """
228 
    pass
229 
 
230 
  def getLatestArrivalsCount(self, ):
231 
    """
232 
    Get the total number of latest arrivals we are willing to show.
233 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
234 
    """
235 
    pass
236 
 
237 
  def generateNewEntityID(self, ):
238 
    pass
239 
 
240 
  def addCategory(self, category):
241 
    """
242 
    All category related functions
243 
 
244 
    Parameters:
245 
     - category
246 
    """
247 
    pass
248 
 
249 
  def getCategory(self, id):
250 
    """
251 
    Parameters:
252 
     - id
253 
    """
254 
    pass
255 
 
256 
  def getAllCategories(self, ):
257 
    pass
258 
 
259 
  def getAllSimilarItems(self, itemId):
260 
    """
261 
    Returns the list of similar items.
262 
 
263 
    Parameters:
264 
     - itemId
265 
    """
266 
    pass
267 
 
268 
  def addSimilarItem(self, itemId, catalogItemId):
269 
    """
270 
    Adds similar item.
271 
 
272 
    Parameters:
273 
     - itemId
274 
     - catalogItemId
275 
    """
276 
    pass
277 
 
6512 kshitij.so 278 
  def addTag(self, displayName, itemId):
279 
    """
280 
    Tag Related
281 
 
282 
    Parameters:
283 
     - displayName
284 
     - itemId
285 
    """
286 
    pass
287 
 
288 
  def deleteEntityTag(self, displayName, itemId):
289 
    """
290 
    Parameters:
291 
     - displayName
292 
     - itemId
293 
    """
294 
    pass
295 
 
296 
  def deleteTag(self, displayName):
297 
    """
298 
    Parameters:
299 
     - displayName
300 
    """
301 
    pass
302 
 
303 
  def getAllTags(self, ):
304 
    pass
305 
 
306 
  def getAllEntitiesByTagName(self, displayName):
307 
    """
308 
    Parameters:
309 
     - displayName
310 
    """
311 
    pass
312 
 
6845 amit.gupta 313 
  def getAllEntityTags(self, ):
314 
    pass
315 
 
8590 kshitij.so 316 
  def addBanner(self, bannerCongregate):
6850 kshitij.so 317 
    """
8579 kshitij.so 318 
    Banner Related
319 
 
6850 kshitij.so 320 
    Parameters:
8590 kshitij.so 321 
     - bannerCongregate
6850 kshitij.so 322 
    """
323 
    pass
324 
 
8579 kshitij.so 325 
  def updateBanner(self, banner):
326 
    """
327 
    Parameters:
328 
     - banner
329 
    """
330 
    pass
331 
 
6850 kshitij.so 332 
  def getAllBanners(self, ):
333 
    pass
334 
 
9155 kshitij.so 335 
  def deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 336 
    """
337 
    Parameters:
338 
     - bannerName
9155 kshitij.so 339 
     - bannerType
6850 kshitij.so 340 
    """
341 
    pass
342 
 
9155 kshitij.so 343 
  def getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 344 
    """
345 
    Parameters:
346 
     - bannerName
9155 kshitij.so 347 
     - bannerType
6850 kshitij.so 348 
    """
349 
    pass
350 
 
351 
  def getActiveBanners(self, ):
352 
    pass
353 
 
8579 kshitij.so 354 
  def addBannerMap(self, bannerMaps):
6849 kshitij.so 355 
    """
356 
    Parameters:
8579 kshitij.so 357 
     - bannerMaps
6849 kshitij.so 358 
    """
359 
    pass
360 
 
8579 kshitij.so 361 
  def updateBannerMap(self, bannerMap):
362 
    """
363 
    Parameters:
364 
     - bannerMap
365 
    """
366 
    pass
367 
 
6849 kshitij.so 368 
  def deleteBannerMap(self, bannerName):
369 
    """
370 
    Parameters:
371 
     - bannerName
372 
    """
373 
    pass
374 
 
9155 kshitij.so 375 
  def getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 376 
    """
377 
    Parameters:
378 
     - bannerName
9155 kshitij.so 379 
     - bannerType
6849 kshitij.so 380 
    """
381 
    pass
382 
 
8579 kshitij.so 383 
  def addBannerUri(self, bannerUriMappings):
384 
    """
385 
    Parameters:
386 
     - bannerUriMappings
387 
    """
388 
    pass
389 
 
9155 kshitij.so 390 
  def getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 391 
    """
392 
    Parameters:
393 
     - bannerName
9155 kshitij.so 394 
     - bannerType
8579 kshitij.so 395 
    """
396 
    pass
397 
 
398 
  def addCampaign(self, campaign):
399 
    """
400 
    Parameters:
401 
     - campaign
402 
    """
403 
    pass
404 
 
405 
  def getCampaigns(self, campaignName):
406 
    """
407 
    Parameters:
408 
     - campaignName
409 
    """
410 
    pass
411 
 
412 
  def deleteCampaign(self, campaignId):
413 
    """
414 
    Parameters:
415 
     - campaignId
416 
    """
417 
    pass
418 
 
419 
  def getAllCampaigns(self, ):
420 
    pass
421 
 
9155 kshitij.so 422 
  def getActiveBannersForMobileSite(self, ):
423 
    pass
424 
 
5944 mandeep.dh 425 
  def deleteSimilarItem(self, itemId, catalogItemId):
426 
    """
427 
    Delete similar item.
428 
 
429 
    Parameters:
430 
     - itemId
431 
     - catalogItemId
432 
    """
433 
    pass
434 
 
435 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
436 
    """
437 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
438 
    If yes, returns the itemId else returns 0
439 
 
440 
    Parameters:
441 
     - brand
442 
     - modelNumber
443 
     - modelName
444 
     - color
445 
    """
446 
    pass
447 
 
448 
  def validateRiskyStatus(self, itemId):
449 
    """
450 
    Check wether item is risky and change status if inventory is not available for risky items
451 
 
452 
    Parameters:
453 
     - itemId
454 
    """
455 
    pass
456 
 
457 
  def changeItemRiskyFlag(self, itemId, risky):
458 
    """
459 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
460 
 
461 
    Parameters:
462 
     - itemId
463 
     - risky
464 
    """
465 
    pass
466 
 
467 
  def getItemsByRiskyFlag(self, ):
468 
    """
469 
    Returns list of items marked as risky.
470 
    """
471 
    pass
472 
 
473 
  def getItemsForMasterSheet(self, category, brand):
474 
    """
475 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
476 
 
477 
    Parameters:
478 
     - category
479 
     - brand
480 
    """
481 
    pass
482 
 
483 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
484 
    """
485 
    Returns list of catalog ids of items with same similarity index as of the given itemId
486 
 
487 
    Parameters:
488 
     - beginIndex
489 
     - totalItems
490 
     - itemId
491 
    """
492 
    pass
493 
 
494 
  def addProductNotification(self, itemId, email):
495 
    """
496 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
497 
 
498 
    Parameters:
499 
     - itemId
500 
     - email
501 
    """
502 
    pass
503 
 
504 
  def sendProductNotifications(self, ):
505 
    """
506 
    Send the product notifications to the users for items which has stock.
507 
    """
508 
    pass
509 
 
510 
  def getAllBrandsByCategory(self, categoryId):
511 
    """
512 
    Returns list of brand names for a given category Id
513 
 
514 
    Parameters:
515 
     - categoryId
516 
    """
517 
    pass
518 
 
519 
  def getAllBrands(self, ):
520 
    """
521 
    Returns list of brand names
522 
    """
523 
    pass
524 
 
525 
  def getAllSources(self, ):
526 
    """
527 
    Return list of all sources
528 
    """
529 
    pass
530 
 
531 
  def getItemPricingBySource(self, itemId, sourceId):
532 
    """
533 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
534 
 
535 
    Parameters:
536 
     - itemId
537 
     - sourceId
538 
    """
539 
    pass
540 
 
541 
  def addSourceItemPricing(self, sourceItemPricing):
542 
    """
543 
    Adds prices to be displayed corresponding to the item if user comes from a source.
544 
    If item is not found or source is not found, it will throw exception.
545 
 
546 
    Parameters:
547 
     - sourceItemPricing
548 
    """
549 
    pass
550 
 
551 
  def getAllSourcePricing(self, itemId):
552 
    """
553 
    Returns the list of source pricing information of an item.
554 
    Raises an exception if item not found corresponding to itemId
555 
 
556 
    Parameters:
557 
     - itemId
558 
    """
559 
    pass
560 
 
561 
  def getItemForSource(self, item_id, sourceId):
562 
    """
563 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
564 
 
565 
    Parameters:
566 
     - item_id
567 
     - sourceId
568 
    """
569 
    pass
570 
 
571 
  def searchItemsInRange(self, searchTerms, offset, limit):
572 
    """
573 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
574 
 
575 
    Parameters:
576 
     - searchTerms
577 
     - offset
578 
     - limit
579 
    """
580 
    pass
581 
 
582 
  def getSearchResultCount(self, searchTerms):
583 
    """
584 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
585 
 
586 
    Parameters:
587 
     - searchTerms
588 
    """
589 
    pass
590 
 
591 
  def getProductNotifications(self, startDateTime):
592 
    """
593 
    Returns a list of product notifications added after a supplied datetime
594 
 
595 
    Parameters:
596 
     - startDateTime
597 
    """
598 
    pass
599 
 
7897 amar.kumar 600 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 601 
    """
602 
    Returns a list of count of requests for product notification against each item
603 
 
604 
    Parameters:
605 
     - startDateTime
7897 amar.kumar 606 
     - categoryId
5944 mandeep.dh 607 
    """
608 
    pass
609 
 
610 
  def addAuthorizationLog(self, itemId, username, reason):
611 
    """
612 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
613 
 
614 
    Parameters:
615 
     - itemId
616 
     - username
617 
     - reason
618 
    """
619 
    pass
620 
 
621 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
622 
    """
623 
    Parameters:
624 
     - catalog_item_id
625 
     - voucherType
626 
     - voucherAmount
627 
    """
628 
    pass
629 
 
630 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
631 
    """
632 
    Parameters:
633 
     - catalog_item_id
634 
     - voucherType
635 
    """
636 
    pass
637 
 
638 
  def getVoucherAmount(self, itemId, voucherType):
639 
    """
640 
    Parameters:
641 
     - itemId
642 
     - voucherType
643 
    """
644 
    pass
645 
 
646 
  def getAllItemVouchers(self, itemId):
647 
    """
648 
    Parameters:
649 
     - itemId
650 
    """
651 
    pass
652 
 
653 
  def isValidCatalogItemId(self, catalog_item_id):
654 
    """
655 
    Parameters:
656 
     - catalog_item_id
657 
    """
658 
    pass
659 
 
7330 amit.gupta 660 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 661 
    """
662 
    Parameters:
663 
     - itemId
7330 amit.gupta 664 
     - stateId
6039 amit.gupta 665 
     - price
666 
    """
667 
    pass
5944 mandeep.dh 668 
 
6039 amit.gupta 669 
  def getVatAmountForItem(self, itemId, price):
670 
    """
671 
    Parameters:
672 
     - itemId
673 
     - price
674 
    """
675 
    pass
676 
 
6531 vikram.rag 677 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
678 
    """
679 
    Parameters:
680 
     - offset
681 
     - limit
682 
    """
683 
    pass
6039 amit.gupta 684 
 
6821 amar.kumar 685 
  def getAllAliveItems(self, ):
686 
    pass
687 
 
6921 anupam.sin 688 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 689 
    """
690 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 691 
 
6805 anupam.sin 692 
    Parameters:
693 
     - itemId
6921 anupam.sin 694 
     - price
6805 anupam.sin 695 
     - insurerId
696 
     - quantity
697 
    """
698 
    pass
699 
 
700 
  def getInsurer(self, insurerId):
701 
    """
702 
    Parameters:
703 
     - insurerId
704 
    """
705 
    pass
706 
 
6838 vikram.rag 707 
  def getAllInsurers(self, ):
708 
    pass
6805 anupam.sin 709 
 
6962 rajveer 710 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
711 
    """
712 
    Parameters:
713 
     - insurerId
714 
     - amount
715 
    """
716 
    pass
6838 vikram.rag 717 
 
7190 amar.kumar 718 
  def getFreebieForItem(self, itemId):
719 
    """
720 
    Parameters:
721 
     - itemId
722 
    """
723 
    pass
6962 rajveer 724 
 
7190 amar.kumar 725 
  def addOrUpdateFreebieForItem(self, freebieItem):
726 
    """
727 
    Parameters:
728 
     - freebieItem
729 
    """
730 
    pass
731 
 
7272 amit.gupta 732 
  def addOrUpdateBrandInfo(self, brandInfo):
733 
    """
734 
    Parameters:
735 
     - brandInfo
736 
    """
737 
    pass
738 
 
739 
  def getBrandInfo(self, ):
740 
    pass
741 
 
7256 rajveer 742 
  def getStorePricing(self, itemId):
743 
    """
744 
    Parameters:
745 
     - itemId
746 
    """
747 
    pass
7190 amar.kumar 748 
 
7306 rajveer 749 
  def getStorePricings(self, itemIds):
750 
    """
751 
    Parameters:
752 
     - itemIds
753 
    """
754 
    pass
755 
 
7382 rajveer 756 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 757 
    """
758 
    Parameters:
759 
     - sp
7382 rajveer 760 
     - allColors
7265 rajveer 761 
    """
762 
    pass
7256 rajveer 763 
 
7281 kshitij.so 764 
  def getAllAmazonListedItems(self, ):
765 
    pass
7265 rajveer 766 
 
8619 kshitij.so 767 
  def searchAmazonItems(self, searchTerm, offset, limit):
768 
    """
769 
    Parameters:
770 
     - searchTerm
771 
     - offset
772 
     - limit
773 
    """
774 
    pass
775 
 
776 
  def getAmazonSearchResultCount(self, searchTerm):
777 
    """
778 
    Parameters:
779 
     - searchTerm
780 
    """
781 
    pass
782 
 
783 
  def getCountForAmazonlistedItems(self, ):
784 
    pass
785 
 
7281 kshitij.so 786 
  def getAmazonItemDetails(self, itemId):
787 
    """
788 
    Parameters:
789 
     - itemId
790 
    """
791 
    pass
792 
 
8168 kshitij.so 793 
  def updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 794 
    """
795 
    Parameters:
8168 kshitij.so 796 
     - amazonlisted
7281 kshitij.so 797 
    """
798 
    pass
799 
 
800 
  def addAmazonItem(self, amazonlisted):
801 
    """
802 
    Parameters:
803 
     - amazonlisted
804 
    """
805 
    pass
806 
 
7291 vikram.rag 807 
  def getAsinItems(self, ):
808 
    pass
7281 kshitij.so 809 
 
7291 vikram.rag 810 
  def getAllFbaListedItems(self, ):
811 
    pass
812 
 
813 
  def getAllNonFbaListedItems(self, ):
814 
    pass
815 
 
7460 kshitij.so 816 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
817 
    """
818 
    Parameters:
819 
     - itemId
820 
     - holdInventory
821 
     - defaultInventory
822 
    """
823 
    pass
7291 vikram.rag 824 
 
7770 kshitij.so 825 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
826 
    """
827 
    Parameters:
828 
     - type
829 
     - sku
830 
     - timestamp
831 
    """
832 
    pass
7460 kshitij.so 833 
 
7897 amar.kumar 834 
  def getAllParentCategories(self, ):
835 
    pass
7770 kshitij.so 836 
 
7977 kshitij.so 837 
  def addPageViewEvent(self, pageViewEvents):
838 
    """
839 
    Parameters:
840 
     - pageViewEvents
841 
    """
842 
    pass
7897 amar.kumar 843 
 
7977 kshitij.so 844 
  def addCartEvent(self, cartEvents):
845 
    """
846 
    Parameters:
847 
     - cartEvents
848 
    """
849 
    pass
850 
 
8182 amar.kumar 851 
  def addEbayItem(self, ebayItem):
852 
    """
853 
    Parameters:
854 
     - ebayItem
855 
    """
856 
    pass
857 
 
858 
  def getEbayItem(self, listingId):
859 
    """
860 
    Parameters:
861 
     - listingId
862 
    """
863 
    pass
864 
 
865 
  def updateEbayItem(self, ebayItem):
866 
    """
867 
    Parameters:
868 
     - ebayItem
869 
    """
870 
    pass
871 
 
8139 kshitij.so 872 
  def getAmazonListedItems(self, offset, limit):
873 
    """
874 
    Parameters:
875 
     - offset
876 
     - limit
877 
    """
878 
    pass
7977 kshitij.so 879 
 
8168 kshitij.so 880 
  def updateAmazonAttributesInBulk(self, amazonlisted):
881 
    """
882 
    Parameters:
883 
     - amazonlisted
884 
    """
885 
    pass
8139 kshitij.so 886 
 
8379 vikram.rag 887 
  def getAllItemstoListOnFba(self, ):
888 
    pass
8168 kshitij.so 889 
 
8379 vikram.rag 890 
  def getAllItemstoListOnNonFba(self, ):
891 
    pass
892 
 
8616 vikram.rag 893 
  def getAllSnapdealListedActiveItems(self, ):
894 
    pass
8379 vikram.rag 895 
 
8619 kshitij.so 896 
  def updateAsin(self, item):
897 
    """
898 
    Parameters:
899 
     - item
900 
    """
901 
    pass
8616 vikram.rag 902 
 
8739 vikram.rag 903 
  def addOrUpdateSnapdealItem(self, snapdealitem):
904 
    """
905 
    Parameters:
906 
     - snapdealitem
907 
    """
908 
    pass
8619 kshitij.so 909 
 
8739 vikram.rag 910 
  def getSnapdealItem(self, item_id):
911 
    """
912 
    Parameters:
913 
     - item_id
914 
    """
915 
    pass
916 
 
917 
  def getAllSnapdealItems(self, ):
918 
    pass
919 
 
920 
 
5944 mandeep.dh 921 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
922 
  def __init__(self, iprot, oprot=None):
923 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
924 
 
925 
  def addItem(self, item):
926 
    """
927 
    Availability and inventory attributes
928 
 
929 
    Parameters:
930 
     - item
931 
    """
932 
    self.send_addItem(item)
933 
    return self.recv_addItem()
934 
 
935 
  def send_addItem(self, item):
936 
    self._oprot.writeMessageBegin('addItem', TMessageType.CALL, self._seqid)
937 
    args = addItem_args()
938 
    args.item = item
939 
    args.write(self._oprot)
940 
    self._oprot.writeMessageEnd()
941 
    self._oprot.trans.flush()
942 
 
943 
  def recv_addItem(self, ):
944 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
945 
    if mtype == TMessageType.EXCEPTION:
946 
      x = TApplicationException()
947 
      x.read(self._iprot)
948 
      self._iprot.readMessageEnd()
949 
      raise x
950 
    result = addItem_result()
951 
    result.read(self._iprot)
952 
    self._iprot.readMessageEnd()
953 
    if result.success is not None:
954 
      return result.success
955 
    if result.cex is not None:
956 
      raise result.cex
957 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItem failed: unknown result");
958 
 
959 
  def updateItem(self, item):
960 
    """
961 
    Parameters:
962 
     - item
963 
    """
964 
    self.send_updateItem(item)
965 
    return self.recv_updateItem()
966 
 
967 
  def send_updateItem(self, item):
968 
    self._oprot.writeMessageBegin('updateItem', TMessageType.CALL, self._seqid)
969 
    args = updateItem_args()
970 
    args.item = item
971 
    args.write(self._oprot)
972 
    self._oprot.writeMessageEnd()
973 
    self._oprot.trans.flush()
974 
 
975 
  def recv_updateItem(self, ):
976 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
977 
    if mtype == TMessageType.EXCEPTION:
978 
      x = TApplicationException()
979 
      x.read(self._iprot)
980 
      self._iprot.readMessageEnd()
981 
      raise x
982 
    result = updateItem_result()
983 
    result.read(self._iprot)
984 
    self._iprot.readMessageEnd()
985 
    if result.success is not None:
986 
      return result.success
987 
    if result.cex is not None:
988 
      raise result.cex
989 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItem failed: unknown result");
990 
 
991 
  def isActive(self, itemId):
992 
    """
993 
    Checks if the item given to the corresponding itemId is active. If it's active,
994 
    whether it's risky and if it's risky, its inventory position.
995 
 
996 
    Parameters:
997 
     - itemId
998 
    """
999 
    self.send_isActive(itemId)
1000 
    return self.recv_isActive()
1001 
 
1002 
  def send_isActive(self, itemId):
1003 
    self._oprot.writeMessageBegin('isActive', TMessageType.CALL, self._seqid)
1004 
    args = isActive_args()
1005 
    args.itemId = itemId
1006 
    args.write(self._oprot)
1007 
    self._oprot.writeMessageEnd()
1008 
    self._oprot.trans.flush()
1009 
 
1010 
  def recv_isActive(self, ):
1011 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1012 
    if mtype == TMessageType.EXCEPTION:
1013 
      x = TApplicationException()
1014 
      x.read(self._iprot)
1015 
      self._iprot.readMessageEnd()
1016 
      raise x
1017 
    result = isActive_result()
1018 
    result.read(self._iprot)
1019 
    self._iprot.readMessageEnd()
1020 
    if result.success is not None:
1021 
      return result.success
1022 
    if result.isex is not None:
1023 
      raise result.isex
1024 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isActive failed: unknown result");
1025 
 
7438 amit.gupta 1026 
  def getItemsStatus(self, itemIds):
1027 
    """
1028 
    Parameters:
1029 
     - itemIds
1030 
    """
1031 
    self.send_getItemsStatus(itemIds)
1032 
    return self.recv_getItemsStatus()
1033 
 
1034 
  def send_getItemsStatus(self, itemIds):
1035 
    self._oprot.writeMessageBegin('getItemsStatus', TMessageType.CALL, self._seqid)
1036 
    args = getItemsStatus_args()
1037 
    args.itemIds = itemIds
1038 
    args.write(self._oprot)
1039 
    self._oprot.writeMessageEnd()
1040 
    self._oprot.trans.flush()
1041 
 
1042 
  def recv_getItemsStatus(self, ):
1043 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1044 
    if mtype == TMessageType.EXCEPTION:
1045 
      x = TApplicationException()
1046 
      x.read(self._iprot)
1047 
      self._iprot.readMessageEnd()
1048 
      raise x
1049 
    result = getItemsStatus_result()
1050 
    result.read(self._iprot)
1051 
    self._iprot.readMessageEnd()
1052 
    if result.success is not None:
1053 
      return result.success
1054 
    if result.isex is not None:
1055 
      raise result.isex
1056 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsStatus failed: unknown result");
1057 
 
5944 mandeep.dh 1058 
  def getItemStatusDescription(self, itemId):
1059 
    """
1060 
    Parameters:
1061 
     - itemId
1062 
    """
1063 
    self.send_getItemStatusDescription(itemId)
1064 
    return self.recv_getItemStatusDescription()
1065 
 
1066 
  def send_getItemStatusDescription(self, itemId):
1067 
    self._oprot.writeMessageBegin('getItemStatusDescription', TMessageType.CALL, self._seqid)
1068 
    args = getItemStatusDescription_args()
1069 
    args.itemId = itemId
1070 
    args.write(self._oprot)
1071 
    self._oprot.writeMessageEnd()
1072 
    self._oprot.trans.flush()
1073 
 
1074 
  def recv_getItemStatusDescription(self, ):
1075 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1076 
    if mtype == TMessageType.EXCEPTION:
1077 
      x = TApplicationException()
1078 
      x.read(self._iprot)
1079 
      self._iprot.readMessageEnd()
1080 
      raise x
1081 
    result = getItemStatusDescription_result()
1082 
    result.read(self._iprot)
1083 
    self._iprot.readMessageEnd()
1084 
    if result.success is not None:
1085 
      return result.success
1086 
    if result.isex is not None:
1087 
      raise result.isex
1088 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStatusDescription failed: unknown result");
1089 
 
1090 
  def startItemOn(self, item_id, timestamp):
1091 
    """
1092 
    Parameters:
1093 
     - item_id
1094 
     - timestamp
1095 
    """
1096 
    self.send_startItemOn(item_id, timestamp)
1097 
    self.recv_startItemOn()
1098 
 
1099 
  def send_startItemOn(self, item_id, timestamp):
1100 
    self._oprot.writeMessageBegin('startItemOn', TMessageType.CALL, self._seqid)
1101 
    args = startItemOn_args()
1102 
    args.item_id = item_id
1103 
    args.timestamp = timestamp
1104 
    args.write(self._oprot)
1105 
    self._oprot.writeMessageEnd()
1106 
    self._oprot.trans.flush()
1107 
 
1108 
  def recv_startItemOn(self, ):
1109 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1110 
    if mtype == TMessageType.EXCEPTION:
1111 
      x = TApplicationException()
1112 
      x.read(self._iprot)
1113 
      self._iprot.readMessageEnd()
1114 
      raise x
1115 
    result = startItemOn_result()
1116 
    result.read(self._iprot)
1117 
    self._iprot.readMessageEnd()
1118 
    if result.cex is not None:
1119 
      raise result.cex
1120 
    return
1121 
 
1122 
  def retireItemOn(self, item_id, timestamp):
1123 
    """
1124 
    Parameters:
1125 
     - item_id
1126 
     - timestamp
1127 
    """
1128 
    self.send_retireItemOn(item_id, timestamp)
1129 
    self.recv_retireItemOn()
1130 
 
1131 
  def send_retireItemOn(self, item_id, timestamp):
1132 
    self._oprot.writeMessageBegin('retireItemOn', TMessageType.CALL, self._seqid)
1133 
    args = retireItemOn_args()
1134 
    args.item_id = item_id
1135 
    args.timestamp = timestamp
1136 
    args.write(self._oprot)
1137 
    self._oprot.writeMessageEnd()
1138 
    self._oprot.trans.flush()
1139 
 
1140 
  def recv_retireItemOn(self, ):
1141 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1142 
    if mtype == TMessageType.EXCEPTION:
1143 
      x = TApplicationException()
1144 
      x.read(self._iprot)
1145 
      self._iprot.readMessageEnd()
1146 
      raise x
1147 
    result = retireItemOn_result()
1148 
    result.read(self._iprot)
1149 
    self._iprot.readMessageEnd()
1150 
    if result.cex is not None:
1151 
      raise result.cex
1152 
    return
1153 
 
1154 
  def changeItemStatus(self, item_id, timestamp, newstatus):
1155 
    """
1156 
    Parameters:
1157 
     - item_id
1158 
     - timestamp
1159 
     - newstatus
1160 
    """
1161 
    self.send_changeItemStatus(item_id, timestamp, newstatus)
1162 
    self.recv_changeItemStatus()
1163 
 
1164 
  def send_changeItemStatus(self, item_id, timestamp, newstatus):
1165 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
1166 
    args = changeItemStatus_args()
1167 
    args.item_id = item_id
1168 
    args.timestamp = timestamp
1169 
    args.newstatus = newstatus
1170 
    args.write(self._oprot)
1171 
    self._oprot.writeMessageEnd()
1172 
    self._oprot.trans.flush()
1173 
 
1174 
  def recv_changeItemStatus(self, ):
1175 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1176 
    if mtype == TMessageType.EXCEPTION:
1177 
      x = TApplicationException()
1178 
      x.read(self._iprot)
1179 
      self._iprot.readMessageEnd()
1180 
      raise x
1181 
    result = changeItemStatus_result()
1182 
    result.read(self._iprot)
1183 
    self._iprot.readMessageEnd()
1184 
    if result.cex is not None:
1185 
      raise result.cex
1186 
    return
1187 
 
1188 
  def getItem(self, item_id):
1189 
    """
1190 
    Parameters:
1191 
     - item_id
1192 
    """
1193 
    self.send_getItem(item_id)
1194 
    return self.recv_getItem()
1195 
 
1196 
  def send_getItem(self, item_id):
1197 
    self._oprot.writeMessageBegin('getItem', TMessageType.CALL, self._seqid)
1198 
    args = getItem_args()
1199 
    args.item_id = item_id
1200 
    args.write(self._oprot)
1201 
    self._oprot.writeMessageEnd()
1202 
    self._oprot.trans.flush()
1203 
 
1204 
  def recv_getItem(self, ):
1205 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1206 
    if mtype == TMessageType.EXCEPTION:
1207 
      x = TApplicationException()
1208 
      x.read(self._iprot)
1209 
      self._iprot.readMessageEnd()
1210 
      raise x
1211 
    result = getItem_result()
1212 
    result.read(self._iprot)
1213 
    self._iprot.readMessageEnd()
1214 
    if result.success is not None:
1215 
      return result.success
1216 
    if result.cex is not None:
1217 
      raise result.cex
1218 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItem failed: unknown result");
1219 
 
1220 
  def getItemsByCatalogId(self, catalog_item_id):
1221 
    """
1222 
    Parameters:
1223 
     - catalog_item_id
1224 
    """
1225 
    self.send_getItemsByCatalogId(catalog_item_id)
1226 
    return self.recv_getItemsByCatalogId()
1227 
 
1228 
  def send_getItemsByCatalogId(self, catalog_item_id):
1229 
    self._oprot.writeMessageBegin('getItemsByCatalogId', TMessageType.CALL, self._seqid)
1230 
    args = getItemsByCatalogId_args()
1231 
    args.catalog_item_id = catalog_item_id
1232 
    args.write(self._oprot)
1233 
    self._oprot.writeMessageEnd()
1234 
    self._oprot.trans.flush()
1235 
 
1236 
  def recv_getItemsByCatalogId(self, ):
1237 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1238 
    if mtype == TMessageType.EXCEPTION:
1239 
      x = TApplicationException()
1240 
      x.read(self._iprot)
1241 
      self._iprot.readMessageEnd()
1242 
      raise x
1243 
    result = getItemsByCatalogId_result()
1244 
    result.read(self._iprot)
1245 
    self._iprot.readMessageEnd()
1246 
    if result.success is not None:
1247 
      return result.success
1248 
    if result.cex is not None:
1249 
      raise result.cex
1250 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByCatalogId failed: unknown result");
1251 
 
1252 
  def getValidItemsByCatalogId(self, catalog_item_id):
1253 
    """
1254 
    Parameters:
1255 
     - catalog_item_id
1256 
    """
1257 
    self.send_getValidItemsByCatalogId(catalog_item_id)
1258 
    return self.recv_getValidItemsByCatalogId()
1259 
 
1260 
  def send_getValidItemsByCatalogId(self, catalog_item_id):
1261 
    self._oprot.writeMessageBegin('getValidItemsByCatalogId', TMessageType.CALL, self._seqid)
1262 
    args = getValidItemsByCatalogId_args()
1263 
    args.catalog_item_id = catalog_item_id
1264 
    args.write(self._oprot)
1265 
    self._oprot.writeMessageEnd()
1266 
    self._oprot.trans.flush()
1267 
 
1268 
  def recv_getValidItemsByCatalogId(self, ):
1269 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1270 
    if mtype == TMessageType.EXCEPTION:
1271 
      x = TApplicationException()
1272 
      x.read(self._iprot)
1273 
      self._iprot.readMessageEnd()
1274 
      raise x
1275 
    result = getValidItemsByCatalogId_result()
1276 
    result.read(self._iprot)
1277 
    self._iprot.readMessageEnd()
1278 
    if result.success is not None:
1279 
      return result.success
1280 
    if result.cex is not None:
1281 
      raise result.cex
1282 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidItemsByCatalogId failed: unknown result");
1283 
 
1284 
  def getAllItems(self, isActive):
1285 
    """
1286 
    Parameters:
1287 
     - isActive
1288 
    """
1289 
    self.send_getAllItems(isActive)
1290 
    return self.recv_getAllItems()
1291 
 
1292 
  def send_getAllItems(self, isActive):
1293 
    self._oprot.writeMessageBegin('getAllItems', TMessageType.CALL, self._seqid)
1294 
    args = getAllItems_args()
1295 
    args.isActive = isActive
1296 
    args.write(self._oprot)
1297 
    self._oprot.writeMessageEnd()
1298 
    self._oprot.trans.flush()
1299 
 
1300 
  def recv_getAllItems(self, ):
1301 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1302 
    if mtype == TMessageType.EXCEPTION:
1303 
      x = TApplicationException()
1304 
      x.read(self._iprot)
1305 
      self._iprot.readMessageEnd()
1306 
      raise x
1307 
    result = getAllItems_result()
1308 
    result.read(self._iprot)
1309 
    self._iprot.readMessageEnd()
1310 
    if result.success is not None:
1311 
      return result.success
1312 
    if result.cex is not None:
1313 
      raise result.cex
1314 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItems failed: unknown result");
1315 
 
1316 
  def getAllItemsByStatus(self, itemStatus):
1317 
    """
1318 
    Parameters:
1319 
     - itemStatus
1320 
    """
1321 
    self.send_getAllItemsByStatus(itemStatus)
1322 
    return self.recv_getAllItemsByStatus()
1323 
 
1324 
  def send_getAllItemsByStatus(self, itemStatus):
1325 
    self._oprot.writeMessageBegin('getAllItemsByStatus', TMessageType.CALL, self._seqid)
1326 
    args = getAllItemsByStatus_args()
1327 
    args.itemStatus = itemStatus
1328 
    args.write(self._oprot)
1329 
    self._oprot.writeMessageEnd()
1330 
    self._oprot.trans.flush()
1331 
 
1332 
  def recv_getAllItemsByStatus(self, ):
1333 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1334 
    if mtype == TMessageType.EXCEPTION:
1335 
      x = TApplicationException()
1336 
      x.read(self._iprot)
1337 
      self._iprot.readMessageEnd()
1338 
      raise x
1339 
    result = getAllItemsByStatus_result()
1340 
    result.read(self._iprot)
1341 
    self._iprot.readMessageEnd()
1342 
    if result.success is not None:
1343 
      return result.success
1344 
    if result.cex is not None:
1345 
      raise result.cex
1346 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatus failed: unknown result");
1347 
 
1348 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1349 
    """
1350 
    Parameters:
1351 
     - entityId
1352 
     - category
1353 
     - brand
1354 
     - modelName
1355 
     - modelNumber
1356 
    """
1357 
    self.send_markItemAsContentComplete(entityId, category, brand, modelName, modelNumber)
1358 
    return self.recv_markItemAsContentComplete()
1359 
 
1360 
  def send_markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1361 
    self._oprot.writeMessageBegin('markItemAsContentComplete', TMessageType.CALL, self._seqid)
1362 
    args = markItemAsContentComplete_args()
1363 
    args.entityId = entityId
1364 
    args.category = category
1365 
    args.brand = brand
1366 
    args.modelName = modelName
1367 
    args.modelNumber = modelNumber
1368 
    args.write(self._oprot)
1369 
    self._oprot.writeMessageEnd()
1370 
    self._oprot.trans.flush()
1371 
 
1372 
  def recv_markItemAsContentComplete(self, ):
1373 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1374 
    if mtype == TMessageType.EXCEPTION:
1375 
      x = TApplicationException()
1376 
      x.read(self._iprot)
1377 
      self._iprot.readMessageEnd()
1378 
      raise x
1379 
    result = markItemAsContentComplete_result()
1380 
    result.read(self._iprot)
1381 
    self._iprot.readMessageEnd()
1382 
    if result.success is not None:
1383 
      return result.success
1384 
    if result.cex is not None:
1385 
      raise result.cex
1386 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markItemAsContentComplete failed: unknown result");
1387 
 
1388 
  def getAllItemsInRange(self, offset, limit):
1389 
    """
1390 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
1391 
 
1392 
    Parameters:
1393 
     - offset
1394 
     - limit
1395 
    """
1396 
    self.send_getAllItemsInRange(offset, limit)
1397 
    return self.recv_getAllItemsInRange()
1398 
 
1399 
  def send_getAllItemsInRange(self, offset, limit):
1400 
    self._oprot.writeMessageBegin('getAllItemsInRange', TMessageType.CALL, self._seqid)
1401 
    args = getAllItemsInRange_args()
1402 
    args.offset = offset
1403 
    args.limit = limit
1404 
    args.write(self._oprot)
1405 
    self._oprot.writeMessageEnd()
1406 
    self._oprot.trans.flush()
1407 
 
1408 
  def recv_getAllItemsInRange(self, ):
1409 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1410 
    if mtype == TMessageType.EXCEPTION:
1411 
      x = TApplicationException()
1412 
      x.read(self._iprot)
1413 
      self._iprot.readMessageEnd()
1414 
      raise x
1415 
    result = getAllItemsInRange_result()
1416 
    result.read(self._iprot)
1417 
    self._iprot.readMessageEnd()
1418 
    if result.success is not None:
1419 
      return result.success
1420 
    if result.cex is not None:
1421 
      raise result.cex
1422 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsInRange failed: unknown result");
1423 
 
1424 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1425 
    """
1426 
    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.
1427 
 
1428 
    Parameters:
1429 
     - itemStatus
1430 
     - offset
1431 
     - limit
1432 
    """
1433 
    self.send_getAllItemsByStatusInRange(itemStatus, offset, limit)
1434 
    return self.recv_getAllItemsByStatusInRange()
1435 
 
1436 
  def send_getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1437 
    self._oprot.writeMessageBegin('getAllItemsByStatusInRange', TMessageType.CALL, self._seqid)
1438 
    args = getAllItemsByStatusInRange_args()
1439 
    args.itemStatus = itemStatus
1440 
    args.offset = offset
1441 
    args.limit = limit
1442 
    args.write(self._oprot)
1443 
    self._oprot.writeMessageEnd()
1444 
    self._oprot.trans.flush()
1445 
 
1446 
  def recv_getAllItemsByStatusInRange(self, ):
1447 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1448 
    if mtype == TMessageType.EXCEPTION:
1449 
      x = TApplicationException()
1450 
      x.read(self._iprot)
1451 
      self._iprot.readMessageEnd()
1452 
      raise x
1453 
    result = getAllItemsByStatusInRange_result()
1454 
    result.read(self._iprot)
1455 
    self._iprot.readMessageEnd()
1456 
    if result.success is not None:
1457 
      return result.success
1458 
    if result.cex is not None:
1459 
      raise result.cex
1460 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatusInRange failed: unknown result");
1461 
 
1462 
  def getItemCountByStatus(self, useStatus, itemStatus):
1463 
    """
1464 
    Gets a count of all items by status
1465 
 
1466 
    Parameters:
1467 
     - useStatus
1468 
     - itemStatus
1469 
    """
1470 
    self.send_getItemCountByStatus(useStatus, itemStatus)
1471 
    return self.recv_getItemCountByStatus()
1472 
 
1473 
  def send_getItemCountByStatus(self, useStatus, itemStatus):
1474 
    self._oprot.writeMessageBegin('getItemCountByStatus', TMessageType.CALL, self._seqid)
1475 
    args = getItemCountByStatus_args()
1476 
    args.useStatus = useStatus
1477 
    args.itemStatus = itemStatus
1478 
    args.write(self._oprot)
1479 
    self._oprot.writeMessageEnd()
1480 
    self._oprot.trans.flush()
1481 
 
1482 
  def recv_getItemCountByStatus(self, ):
1483 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1484 
    if mtype == TMessageType.EXCEPTION:
1485 
      x = TApplicationException()
1486 
      x.read(self._iprot)
1487 
      self._iprot.readMessageEnd()
1488 
      raise x
1489 
    result = getItemCountByStatus_result()
1490 
    result.read(self._iprot)
1491 
    self._iprot.readMessageEnd()
1492 
    if result.success is not None:
1493 
      return result.success
1494 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemCountByStatus failed: unknown result");
1495 
 
1496 
  def getBestSellers(self, ):
1497 
    self.send_getBestSellers()
1498 
    return self.recv_getBestSellers()
1499 
 
1500 
  def send_getBestSellers(self, ):
1501 
    self._oprot.writeMessageBegin('getBestSellers', TMessageType.CALL, self._seqid)
1502 
    args = getBestSellers_args()
1503 
    args.write(self._oprot)
1504 
    self._oprot.writeMessageEnd()
1505 
    self._oprot.trans.flush()
1506 
 
1507 
  def recv_getBestSellers(self, ):
1508 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1509 
    if mtype == TMessageType.EXCEPTION:
1510 
      x = TApplicationException()
1511 
      x.read(self._iprot)
1512 
      self._iprot.readMessageEnd()
1513 
      raise x
1514 
    result = getBestSellers_result()
1515 
    result.read(self._iprot)
1516 
    self._iprot.readMessageEnd()
1517 
    if result.success is not None:
1518 
      return result.success
1519 
    if result.isex is not None:
1520 
      raise result.isex
1521 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellers failed: unknown result");
1522 
 
1523 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1524 
    """
1525 
    Parameters:
1526 
     - beginIndex
1527 
     - totalItems
1528 
     - brand
1529 
     - category
1530 
    """
1531 
    self.send_getBestSellersCatalogIds(beginIndex, totalItems, brand, category)
1532 
    return self.recv_getBestSellersCatalogIds()
1533 
 
1534 
  def send_getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1535 
    self._oprot.writeMessageBegin('getBestSellersCatalogIds', TMessageType.CALL, self._seqid)
1536 
    args = getBestSellersCatalogIds_args()
1537 
    args.beginIndex = beginIndex
1538 
    args.totalItems = totalItems
1539 
    args.brand = brand
1540 
    args.category = category
1541 
    args.write(self._oprot)
1542 
    self._oprot.writeMessageEnd()
1543 
    self._oprot.trans.flush()
1544 
 
1545 
  def recv_getBestSellersCatalogIds(self, ):
1546 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1547 
    if mtype == TMessageType.EXCEPTION:
1548 
      x = TApplicationException()
1549 
      x.read(self._iprot)
1550 
      self._iprot.readMessageEnd()
1551 
      raise x
1552 
    result = getBestSellersCatalogIds_result()
1553 
    result.read(self._iprot)
1554 
    self._iprot.readMessageEnd()
1555 
    if result.success is not None:
1556 
      return result.success
1557 
    if result.cex is not None:
1558 
      raise result.cex
1559 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCatalogIds failed: unknown result");
1560 
 
1561 
  def getBestSellersCount(self, ):
1562 
    self.send_getBestSellersCount()
1563 
    return self.recv_getBestSellersCount()
1564 
 
1565 
  def send_getBestSellersCount(self, ):
1566 
    self._oprot.writeMessageBegin('getBestSellersCount', TMessageType.CALL, self._seqid)
1567 
    args = getBestSellersCount_args()
1568 
    args.write(self._oprot)
1569 
    self._oprot.writeMessageEnd()
1570 
    self._oprot.trans.flush()
1571 
 
1572 
  def recv_getBestSellersCount(self, ):
1573 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1574 
    if mtype == TMessageType.EXCEPTION:
1575 
      x = TApplicationException()
1576 
      x.read(self._iprot)
1577 
      self._iprot.readMessageEnd()
1578 
      raise x
1579 
    result = getBestSellersCount_result()
1580 
    result.read(self._iprot)
1581 
    self._iprot.readMessageEnd()
1582 
    if result.success is not None:
1583 
      return result.success
1584 
    if result.cex is not None:
1585 
      raise result.cex
1586 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCount failed: unknown result");
1587 
 
1588 
  def getBestDeals(self, ):
1589 
    self.send_getBestDeals()
1590 
    return self.recv_getBestDeals()
1591 
 
1592 
  def send_getBestDeals(self, ):
1593 
    self._oprot.writeMessageBegin('getBestDeals', TMessageType.CALL, self._seqid)
1594 
    args = getBestDeals_args()
1595 
    args.write(self._oprot)
1596 
    self._oprot.writeMessageEnd()
1597 
    self._oprot.trans.flush()
1598 
 
1599 
  def recv_getBestDeals(self, ):
1600 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1601 
    if mtype == TMessageType.EXCEPTION:
1602 
      x = TApplicationException()
1603 
      x.read(self._iprot)
1604 
      self._iprot.readMessageEnd()
1605 
      raise x
1606 
    result = getBestDeals_result()
1607 
    result.read(self._iprot)
1608 
    self._iprot.readMessageEnd()
1609 
    if result.success is not None:
1610 
      return result.success
1611 
    if result.isex is not None:
1612 
      raise result.isex
1613 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDeals failed: unknown result");
1614 
 
1615 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1616 
    """
1617 
    Parameters:
1618 
     - beginIndex
1619 
     - totalItems
1620 
     - brand
1621 
     - category
1622 
    """
1623 
    self.send_getBestDealsCatalogIds(beginIndex, totalItems, brand, category)
1624 
    return self.recv_getBestDealsCatalogIds()
1625 
 
1626 
  def send_getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1627 
    self._oprot.writeMessageBegin('getBestDealsCatalogIds', TMessageType.CALL, self._seqid)
1628 
    args = getBestDealsCatalogIds_args()
1629 
    args.beginIndex = beginIndex
1630 
    args.totalItems = totalItems
1631 
    args.brand = brand
1632 
    args.category = category
1633 
    args.write(self._oprot)
1634 
    self._oprot.writeMessageEnd()
1635 
    self._oprot.trans.flush()
1636 
 
1637 
  def recv_getBestDealsCatalogIds(self, ):
1638 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1639 
    if mtype == TMessageType.EXCEPTION:
1640 
      x = TApplicationException()
1641 
      x.read(self._iprot)
1642 
      self._iprot.readMessageEnd()
1643 
      raise x
1644 
    result = getBestDealsCatalogIds_result()
1645 
    result.read(self._iprot)
1646 
    self._iprot.readMessageEnd()
1647 
    if result.success is not None:
1648 
      return result.success
1649 
    if result.cex is not None:
1650 
      raise result.cex
1651 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCatalogIds failed: unknown result");
1652 
 
1653 
  def getBestDealsCount(self, ):
1654 
    self.send_getBestDealsCount()
1655 
    return self.recv_getBestDealsCount()
1656 
 
1657 
  def send_getBestDealsCount(self, ):
1658 
    self._oprot.writeMessageBegin('getBestDealsCount', TMessageType.CALL, self._seqid)
1659 
    args = getBestDealsCount_args()
1660 
    args.write(self._oprot)
1661 
    self._oprot.writeMessageEnd()
1662 
    self._oprot.trans.flush()
1663 
 
1664 
  def recv_getBestDealsCount(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 = getBestDealsCount_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, "getBestDealsCount failed: unknown result");
1679 
 
1680 
  def getComingSoon(self, ):
1681 
    self.send_getComingSoon()
1682 
    return self.recv_getComingSoon()
1683 
 
1684 
  def send_getComingSoon(self, ):
1685 
    self._oprot.writeMessageBegin('getComingSoon', TMessageType.CALL, self._seqid)
1686 
    args = getComingSoon_args()
1687 
    args.write(self._oprot)
1688 
    self._oprot.writeMessageEnd()
1689 
    self._oprot.trans.flush()
1690 
 
1691 
  def recv_getComingSoon(self, ):
1692 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1693 
    if mtype == TMessageType.EXCEPTION:
1694 
      x = TApplicationException()
1695 
      x.read(self._iprot)
1696 
      self._iprot.readMessageEnd()
1697 
      raise x
1698 
    result = getComingSoon_result()
1699 
    result.read(self._iprot)
1700 
    self._iprot.readMessageEnd()
1701 
    if result.success is not None:
1702 
      return result.success
1703 
    if result.isex is not None:
1704 
      raise result.isex
1705 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoon failed: unknown result");
1706 
 
1707 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1708 
    """
1709 
    Parameters:
1710 
     - beginIndex
1711 
     - totalItems
1712 
     - brand
1713 
     - category
1714 
    """
1715 
    self.send_getComingSoonCatalogIds(beginIndex, totalItems, brand, category)
1716 
    return self.recv_getComingSoonCatalogIds()
1717 
 
1718 
  def send_getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1719 
    self._oprot.writeMessageBegin('getComingSoonCatalogIds', TMessageType.CALL, self._seqid)
1720 
    args = getComingSoonCatalogIds_args()
1721 
    args.beginIndex = beginIndex
1722 
    args.totalItems = totalItems
1723 
    args.brand = brand
1724 
    args.category = category
1725 
    args.write(self._oprot)
1726 
    self._oprot.writeMessageEnd()
1727 
    self._oprot.trans.flush()
1728 
 
1729 
  def recv_getComingSoonCatalogIds(self, ):
1730 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1731 
    if mtype == TMessageType.EXCEPTION:
1732 
      x = TApplicationException()
1733 
      x.read(self._iprot)
1734 
      self._iprot.readMessageEnd()
1735 
      raise x
1736 
    result = getComingSoonCatalogIds_result()
1737 
    result.read(self._iprot)
1738 
    self._iprot.readMessageEnd()
1739 
    if result.success is not None:
1740 
      return result.success
1741 
    if result.cex is not None:
1742 
      raise result.cex
1743 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCatalogIds failed: unknown result");
1744 
 
1745 
  def getComingSoonCount(self, ):
1746 
    self.send_getComingSoonCount()
1747 
    return self.recv_getComingSoonCount()
1748 
 
1749 
  def send_getComingSoonCount(self, ):
1750 
    self._oprot.writeMessageBegin('getComingSoonCount', TMessageType.CALL, self._seqid)
1751 
    args = getComingSoonCount_args()
1752 
    args.write(self._oprot)
1753 
    self._oprot.writeMessageEnd()
1754 
    self._oprot.trans.flush()
1755 
 
1756 
  def recv_getComingSoonCount(self, ):
1757 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1758 
    if mtype == TMessageType.EXCEPTION:
1759 
      x = TApplicationException()
1760 
      x.read(self._iprot)
1761 
      self._iprot.readMessageEnd()
1762 
      raise x
1763 
    result = getComingSoonCount_result()
1764 
    result.read(self._iprot)
1765 
    self._iprot.readMessageEnd()
1766 
    if result.success is not None:
1767 
      return result.success
1768 
    if result.cex is not None:
1769 
      raise result.cex
1770 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCount failed: unknown result");
1771 
 
1772 
  def getLatestArrivals(self, ):
1773 
    """
1774 
    Returns a list of items sorted in the descending order by start date.
1775 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
1776 
    """
1777 
    self.send_getLatestArrivals()
1778 
    return self.recv_getLatestArrivals()
1779 
 
1780 
  def send_getLatestArrivals(self, ):
1781 
    self._oprot.writeMessageBegin('getLatestArrivals', TMessageType.CALL, self._seqid)
1782 
    args = getLatestArrivals_args()
1783 
    args.write(self._oprot)
1784 
    self._oprot.writeMessageEnd()
1785 
    self._oprot.trans.flush()
1786 
 
1787 
  def recv_getLatestArrivals(self, ):
1788 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1789 
    if mtype == TMessageType.EXCEPTION:
1790 
      x = TApplicationException()
1791 
      x.read(self._iprot)
1792 
      self._iprot.readMessageEnd()
1793 
      raise x
1794 
    result = getLatestArrivals_result()
1795 
    result.read(self._iprot)
1796 
    self._iprot.readMessageEnd()
1797 
    if result.success is not None:
1798 
      return result.success
1799 
    if result.isex is not None:
1800 
      raise result.isex
1801 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivals failed: unknown result");
1802 
 
1803 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1804 
    """
1805 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
1806 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
1807 
 
1808 
    Parameters:
1809 
     - beginIndex
1810 
     - totalItems
1811 
     - brand
1812 
     - categories
1813 
    """
1814 
    self.send_getLatestArrivalsCatalogIds(beginIndex, totalItems, brand, categories)
1815 
    return self.recv_getLatestArrivalsCatalogIds()
1816 
 
1817 
  def send_getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1818 
    self._oprot.writeMessageBegin('getLatestArrivalsCatalogIds', TMessageType.CALL, self._seqid)
1819 
    args = getLatestArrivalsCatalogIds_args()
1820 
    args.beginIndex = beginIndex
1821 
    args.totalItems = totalItems
1822 
    args.brand = brand
1823 
    args.categories = categories
1824 
    args.write(self._oprot)
1825 
    self._oprot.writeMessageEnd()
1826 
    self._oprot.trans.flush()
1827 
 
1828 
  def recv_getLatestArrivalsCatalogIds(self, ):
1829 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1830 
    if mtype == TMessageType.EXCEPTION:
1831 
      x = TApplicationException()
1832 
      x.read(self._iprot)
1833 
      self._iprot.readMessageEnd()
1834 
      raise x
1835 
    result = getLatestArrivalsCatalogIds_result()
1836 
    result.read(self._iprot)
1837 
    self._iprot.readMessageEnd()
1838 
    if result.success is not None:
1839 
      return result.success
1840 
    if result.cex is not None:
1841 
      raise result.cex
1842 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCatalogIds failed: unknown result");
1843 
 
1844 
  def getLatestArrivalsCount(self, ):
1845 
    """
1846 
    Get the total number of latest arrivals we are willing to show.
1847 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
1848 
    """
1849 
    self.send_getLatestArrivalsCount()
1850 
    return self.recv_getLatestArrivalsCount()
1851 
 
1852 
  def send_getLatestArrivalsCount(self, ):
1853 
    self._oprot.writeMessageBegin('getLatestArrivalsCount', TMessageType.CALL, self._seqid)
1854 
    args = getLatestArrivalsCount_args()
1855 
    args.write(self._oprot)
1856 
    self._oprot.writeMessageEnd()
1857 
    self._oprot.trans.flush()
1858 
 
1859 
  def recv_getLatestArrivalsCount(self, ):
1860 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1861 
    if mtype == TMessageType.EXCEPTION:
1862 
      x = TApplicationException()
1863 
      x.read(self._iprot)
1864 
      self._iprot.readMessageEnd()
1865 
      raise x
1866 
    result = getLatestArrivalsCount_result()
1867 
    result.read(self._iprot)
1868 
    self._iprot.readMessageEnd()
1869 
    if result.success is not None:
1870 
      return result.success
1871 
    if result.cex is not None:
1872 
      raise result.cex
1873 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCount failed: unknown result");
1874 
 
1875 
  def generateNewEntityID(self, ):
1876 
    self.send_generateNewEntityID()
1877 
    return self.recv_generateNewEntityID()
1878 
 
1879 
  def send_generateNewEntityID(self, ):
1880 
    self._oprot.writeMessageBegin('generateNewEntityID', TMessageType.CALL, self._seqid)
1881 
    args = generateNewEntityID_args()
1882 
    args.write(self._oprot)
1883 
    self._oprot.writeMessageEnd()
1884 
    self._oprot.trans.flush()
1885 
 
1886 
  def recv_generateNewEntityID(self, ):
1887 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1888 
    if mtype == TMessageType.EXCEPTION:
1889 
      x = TApplicationException()
1890 
      x.read(self._iprot)
1891 
      self._iprot.readMessageEnd()
1892 
      raise x
1893 
    result = generateNewEntityID_result()
1894 
    result.read(self._iprot)
1895 
    self._iprot.readMessageEnd()
1896 
    if result.success is not None:
1897 
      return result.success
1898 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateNewEntityID failed: unknown result");
1899 
 
1900 
  def addCategory(self, category):
1901 
    """
1902 
    All category related functions
1903 
 
1904 
    Parameters:
1905 
     - category
1906 
    """
1907 
    self.send_addCategory(category)
1908 
    return self.recv_addCategory()
1909 
 
1910 
  def send_addCategory(self, category):
1911 
    self._oprot.writeMessageBegin('addCategory', TMessageType.CALL, self._seqid)
1912 
    args = addCategory_args()
1913 
    args.category = category
1914 
    args.write(self._oprot)
1915 
    self._oprot.writeMessageEnd()
1916 
    self._oprot.trans.flush()
1917 
 
1918 
  def recv_addCategory(self, ):
1919 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1920 
    if mtype == TMessageType.EXCEPTION:
1921 
      x = TApplicationException()
1922 
      x.read(self._iprot)
1923 
      self._iprot.readMessageEnd()
1924 
      raise x
1925 
    result = addCategory_result()
1926 
    result.read(self._iprot)
1927 
    self._iprot.readMessageEnd()
1928 
    if result.success is not None:
1929 
      return result.success
1930 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addCategory failed: unknown result");
1931 
 
1932 
  def getCategory(self, id):
1933 
    """
1934 
    Parameters:
1935 
     - id
1936 
    """
1937 
    self.send_getCategory(id)
1938 
    return self.recv_getCategory()
1939 
 
1940 
  def send_getCategory(self, id):
1941 
    self._oprot.writeMessageBegin('getCategory', TMessageType.CALL, self._seqid)
1942 
    args = getCategory_args()
1943 
    args.id = id
1944 
    args.write(self._oprot)
1945 
    self._oprot.writeMessageEnd()
1946 
    self._oprot.trans.flush()
1947 
 
1948 
  def recv_getCategory(self, ):
1949 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1950 
    if mtype == TMessageType.EXCEPTION:
1951 
      x = TApplicationException()
1952 
      x.read(self._iprot)
1953 
      self._iprot.readMessageEnd()
1954 
      raise x
1955 
    result = getCategory_result()
1956 
    result.read(self._iprot)
1957 
    self._iprot.readMessageEnd()
1958 
    if result.success is not None:
1959 
      return result.success
1960 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCategory failed: unknown result");
1961 
 
1962 
  def getAllCategories(self, ):
1963 
    self.send_getAllCategories()
1964 
    return self.recv_getAllCategories()
1965 
 
1966 
  def send_getAllCategories(self, ):
1967 
    self._oprot.writeMessageBegin('getAllCategories', TMessageType.CALL, self._seqid)
1968 
    args = getAllCategories_args()
1969 
    args.write(self._oprot)
1970 
    self._oprot.writeMessageEnd()
1971 
    self._oprot.trans.flush()
1972 
 
1973 
  def recv_getAllCategories(self, ):
1974 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1975 
    if mtype == TMessageType.EXCEPTION:
1976 
      x = TApplicationException()
1977 
      x.read(self._iprot)
1978 
      self._iprot.readMessageEnd()
1979 
      raise x
1980 
    result = getAllCategories_result()
1981 
    result.read(self._iprot)
1982 
    self._iprot.readMessageEnd()
1983 
    if result.success is not None:
1984 
      return result.success
1985 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCategories failed: unknown result");
1986 
 
1987 
  def getAllSimilarItems(self, itemId):
1988 
    """
1989 
    Returns the list of similar items.
1990 
 
1991 
    Parameters:
1992 
     - itemId
1993 
    """
1994 
    self.send_getAllSimilarItems(itemId)
1995 
    return self.recv_getAllSimilarItems()
1996 
 
1997 
  def send_getAllSimilarItems(self, itemId):
1998 
    self._oprot.writeMessageBegin('getAllSimilarItems', TMessageType.CALL, self._seqid)
1999 
    args = getAllSimilarItems_args()
2000 
    args.itemId = itemId
2001 
    args.write(self._oprot)
2002 
    self._oprot.writeMessageEnd()
2003 
    self._oprot.trans.flush()
2004 
 
2005 
  def recv_getAllSimilarItems(self, ):
2006 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2007 
    if mtype == TMessageType.EXCEPTION:
2008 
      x = TApplicationException()
2009 
      x.read(self._iprot)
2010 
      self._iprot.readMessageEnd()
2011 
      raise x
2012 
    result = getAllSimilarItems_result()
2013 
    result.read(self._iprot)
2014 
    self._iprot.readMessageEnd()
2015 
    if result.success is not None:
2016 
      return result.success
2017 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSimilarItems failed: unknown result");
2018 
 
2019 
  def addSimilarItem(self, itemId, catalogItemId):
2020 
    """
2021 
    Adds similar item.
2022 
 
2023 
    Parameters:
2024 
     - itemId
2025 
     - catalogItemId
2026 
    """
2027 
    self.send_addSimilarItem(itemId, catalogItemId)
2028 
    return self.recv_addSimilarItem()
2029 
 
2030 
  def send_addSimilarItem(self, itemId, catalogItemId):
2031 
    self._oprot.writeMessageBegin('addSimilarItem', TMessageType.CALL, self._seqid)
2032 
    args = addSimilarItem_args()
2033 
    args.itemId = itemId
2034 
    args.catalogItemId = catalogItemId
2035 
    args.write(self._oprot)
2036 
    self._oprot.writeMessageEnd()
2037 
    self._oprot.trans.flush()
2038 
 
2039 
  def recv_addSimilarItem(self, ):
2040 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2041 
    if mtype == TMessageType.EXCEPTION:
2042 
      x = TApplicationException()
2043 
      x.read(self._iprot)
2044 
      self._iprot.readMessageEnd()
2045 
      raise x
2046 
    result = addSimilarItem_result()
2047 
    result.read(self._iprot)
2048 
    self._iprot.readMessageEnd()
2049 
    if result.success is not None:
2050 
      return result.success
2051 
    if result.cex is not None:
2052 
      raise result.cex
2053 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSimilarItem failed: unknown result");
2054 
 
6512 kshitij.so 2055 
  def addTag(self, displayName, itemId):
2056 
    """
2057 
    Tag Related
2058 
 
2059 
    Parameters:
2060 
     - displayName
2061 
     - itemId
2062 
    """
2063 
    self.send_addTag(displayName, itemId)
2064 
    return self.recv_addTag()
2065 
 
2066 
  def send_addTag(self, displayName, itemId):
2067 
    self._oprot.writeMessageBegin('addTag', TMessageType.CALL, self._seqid)
2068 
    args = addTag_args()
2069 
    args.displayName = displayName
2070 
    args.itemId = itemId
2071 
    args.write(self._oprot)
2072 
    self._oprot.writeMessageEnd()
2073 
    self._oprot.trans.flush()
2074 
 
2075 
  def recv_addTag(self, ):
2076 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2077 
    if mtype == TMessageType.EXCEPTION:
2078 
      x = TApplicationException()
2079 
      x.read(self._iprot)
2080 
      self._iprot.readMessageEnd()
2081 
      raise x
2082 
    result = addTag_result()
2083 
    result.read(self._iprot)
2084 
    self._iprot.readMessageEnd()
2085 
    if result.success is not None:
2086 
      return result.success
2087 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTag failed: unknown result");
2088 
 
2089 
  def deleteEntityTag(self, displayName, itemId):
2090 
    """
2091 
    Parameters:
2092 
     - displayName
2093 
     - itemId
2094 
    """
2095 
    self.send_deleteEntityTag(displayName, itemId)
2096 
    return self.recv_deleteEntityTag()
2097 
 
2098 
  def send_deleteEntityTag(self, displayName, itemId):
2099 
    self._oprot.writeMessageBegin('deleteEntityTag', TMessageType.CALL, self._seqid)
2100 
    args = deleteEntityTag_args()
2101 
    args.displayName = displayName
2102 
    args.itemId = itemId
2103 
    args.write(self._oprot)
2104 
    self._oprot.writeMessageEnd()
2105 
    self._oprot.trans.flush()
2106 
 
2107 
  def recv_deleteEntityTag(self, ):
2108 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2109 
    if mtype == TMessageType.EXCEPTION:
2110 
      x = TApplicationException()
2111 
      x.read(self._iprot)
2112 
      self._iprot.readMessageEnd()
2113 
      raise x
2114 
    result = deleteEntityTag_result()
2115 
    result.read(self._iprot)
2116 
    self._iprot.readMessageEnd()
2117 
    if result.success is not None:
2118 
      return result.success
2119 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteEntityTag failed: unknown result");
2120 
 
2121 
  def deleteTag(self, displayName):
2122 
    """
2123 
    Parameters:
2124 
     - displayName
2125 
    """
2126 
    self.send_deleteTag(displayName)
2127 
    return self.recv_deleteTag()
2128 
 
2129 
  def send_deleteTag(self, displayName):
2130 
    self._oprot.writeMessageBegin('deleteTag', TMessageType.CALL, self._seqid)
2131 
    args = deleteTag_args()
2132 
    args.displayName = displayName
2133 
    args.write(self._oprot)
2134 
    self._oprot.writeMessageEnd()
2135 
    self._oprot.trans.flush()
2136 
 
2137 
  def recv_deleteTag(self, ):
2138 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2139 
    if mtype == TMessageType.EXCEPTION:
2140 
      x = TApplicationException()
2141 
      x.read(self._iprot)
2142 
      self._iprot.readMessageEnd()
2143 
      raise x
2144 
    result = deleteTag_result()
2145 
    result.read(self._iprot)
2146 
    self._iprot.readMessageEnd()
2147 
    if result.success is not None:
2148 
      return result.success
2149 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteTag failed: unknown result");
2150 
 
2151 
  def getAllTags(self, ):
2152 
    self.send_getAllTags()
2153 
    return self.recv_getAllTags()
2154 
 
2155 
  def send_getAllTags(self, ):
2156 
    self._oprot.writeMessageBegin('getAllTags', TMessageType.CALL, self._seqid)
2157 
    args = getAllTags_args()
2158 
    args.write(self._oprot)
2159 
    self._oprot.writeMessageEnd()
2160 
    self._oprot.trans.flush()
2161 
 
2162 
  def recv_getAllTags(self, ):
2163 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2164 
    if mtype == TMessageType.EXCEPTION:
2165 
      x = TApplicationException()
2166 
      x.read(self._iprot)
2167 
      self._iprot.readMessageEnd()
2168 
      raise x
2169 
    result = getAllTags_result()
2170 
    result.read(self._iprot)
2171 
    self._iprot.readMessageEnd()
2172 
    if result.success is not None:
2173 
      return result.success
2174 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllTags failed: unknown result");
2175 
 
2176 
  def getAllEntitiesByTagName(self, displayName):
2177 
    """
2178 
    Parameters:
2179 
     - displayName
2180 
    """
2181 
    self.send_getAllEntitiesByTagName(displayName)
2182 
    return self.recv_getAllEntitiesByTagName()
2183 
 
2184 
  def send_getAllEntitiesByTagName(self, displayName):
2185 
    self._oprot.writeMessageBegin('getAllEntitiesByTagName', TMessageType.CALL, self._seqid)
2186 
    args = getAllEntitiesByTagName_args()
2187 
    args.displayName = displayName
2188 
    args.write(self._oprot)
2189 
    self._oprot.writeMessageEnd()
2190 
    self._oprot.trans.flush()
2191 
 
2192 
  def recv_getAllEntitiesByTagName(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 = getAllEntitiesByTagName_result()
2200 
    result.read(self._iprot)
2201 
    self._iprot.readMessageEnd()
2202 
    if result.success is not None:
2203 
      return result.success
2204 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntitiesByTagName failed: unknown result");
2205 
 
6845 amit.gupta 2206 
  def getAllEntityTags(self, ):
2207 
    self.send_getAllEntityTags()
2208 
    return self.recv_getAllEntityTags()
2209 
 
2210 
  def send_getAllEntityTags(self, ):
2211 
    self._oprot.writeMessageBegin('getAllEntityTags', TMessageType.CALL, self._seqid)
2212 
    args = getAllEntityTags_args()
2213 
    args.write(self._oprot)
2214 
    self._oprot.writeMessageEnd()
2215 
    self._oprot.trans.flush()
2216 
 
2217 
  def recv_getAllEntityTags(self, ):
2218 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2219 
    if mtype == TMessageType.EXCEPTION:
2220 
      x = TApplicationException()
2221 
      x.read(self._iprot)
2222 
      self._iprot.readMessageEnd()
2223 
      raise x
2224 
    result = getAllEntityTags_result()
2225 
    result.read(self._iprot)
2226 
    self._iprot.readMessageEnd()
2227 
    if result.success is not None:
2228 
      return result.success
2229 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntityTags failed: unknown result");
2230 
 
8590 kshitij.so 2231 
  def addBanner(self, bannerCongregate):
6850 kshitij.so 2232 
    """
8579 kshitij.so 2233 
    Banner Related
2234 
 
6850 kshitij.so 2235 
    Parameters:
8590 kshitij.so 2236 
     - bannerCongregate
6850 kshitij.so 2237 
    """
8590 kshitij.so 2238 
    self.send_addBanner(bannerCongregate)
2239 
    self.recv_addBanner()
6850 kshitij.so 2240 
 
8590 kshitij.so 2241 
  def send_addBanner(self, bannerCongregate):
6850 kshitij.so 2242 
    self._oprot.writeMessageBegin('addBanner', TMessageType.CALL, self._seqid)
2243 
    args = addBanner_args()
8590 kshitij.so 2244 
    args.bannerCongregate = bannerCongregate
6850 kshitij.so 2245 
    args.write(self._oprot)
2246 
    self._oprot.writeMessageEnd()
2247 
    self._oprot.trans.flush()
2248 
 
2249 
  def recv_addBanner(self, ):
2250 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2251 
    if mtype == TMessageType.EXCEPTION:
2252 
      x = TApplicationException()
2253 
      x.read(self._iprot)
2254 
      self._iprot.readMessageEnd()
2255 
      raise x
2256 
    result = addBanner_result()
2257 
    result.read(self._iprot)
2258 
    self._iprot.readMessageEnd()
8590 kshitij.so 2259 
    return
6850 kshitij.so 2260 
 
8579 kshitij.so 2261 
  def updateBanner(self, banner):
2262 
    """
2263 
    Parameters:
2264 
     - banner
2265 
    """
2266 
    self.send_updateBanner(banner)
2267 
    return self.recv_updateBanner()
2268 
 
2269 
  def send_updateBanner(self, banner):
2270 
    self._oprot.writeMessageBegin('updateBanner', TMessageType.CALL, self._seqid)
2271 
    args = updateBanner_args()
2272 
    args.banner = banner
2273 
    args.write(self._oprot)
2274 
    self._oprot.writeMessageEnd()
2275 
    self._oprot.trans.flush()
2276 
 
2277 
  def recv_updateBanner(self, ):
2278 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2279 
    if mtype == TMessageType.EXCEPTION:
2280 
      x = TApplicationException()
2281 
      x.read(self._iprot)
2282 
      self._iprot.readMessageEnd()
2283 
      raise x
2284 
    result = updateBanner_result()
2285 
    result.read(self._iprot)
2286 
    self._iprot.readMessageEnd()
2287 
    if result.success is not None:
2288 
      return result.success
2289 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBanner failed: unknown result");
2290 
 
6850 kshitij.so 2291 
  def getAllBanners(self, ):
2292 
    self.send_getAllBanners()
2293 
    return self.recv_getAllBanners()
2294 
 
2295 
  def send_getAllBanners(self, ):
2296 
    self._oprot.writeMessageBegin('getAllBanners', TMessageType.CALL, self._seqid)
2297 
    args = getAllBanners_args()
2298 
    args.write(self._oprot)
2299 
    self._oprot.writeMessageEnd()
2300 
    self._oprot.trans.flush()
2301 
 
2302 
  def recv_getAllBanners(self, ):
2303 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2304 
    if mtype == TMessageType.EXCEPTION:
2305 
      x = TApplicationException()
2306 
      x.read(self._iprot)
2307 
      self._iprot.readMessageEnd()
2308 
      raise x
2309 
    result = getAllBanners_result()
2310 
    result.read(self._iprot)
2311 
    self._iprot.readMessageEnd()
2312 
    if result.success is not None:
2313 
      return result.success
2314 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBanners failed: unknown result");
2315 
 
9155 kshitij.so 2316 
  def deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 2317 
    """
2318 
    Parameters:
2319 
     - bannerName
9155 kshitij.so 2320 
     - bannerType
6850 kshitij.so 2321 
    """
9155 kshitij.so 2322 
    self.send_deleteBanner(bannerName, bannerType)
6850 kshitij.so 2323 
    return self.recv_deleteBanner()
2324 
 
9155 kshitij.so 2325 
  def send_deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 2326 
    self._oprot.writeMessageBegin('deleteBanner', TMessageType.CALL, self._seqid)
2327 
    args = deleteBanner_args()
2328 
    args.bannerName = bannerName
9155 kshitij.so 2329 
    args.bannerType = bannerType
6850 kshitij.so 2330 
    args.write(self._oprot)
2331 
    self._oprot.writeMessageEnd()
2332 
    self._oprot.trans.flush()
2333 
 
2334 
  def recv_deleteBanner(self, ):
2335 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2336 
    if mtype == TMessageType.EXCEPTION:
2337 
      x = TApplicationException()
2338 
      x.read(self._iprot)
2339 
      self._iprot.readMessageEnd()
2340 
      raise x
2341 
    result = deleteBanner_result()
2342 
    result.read(self._iprot)
2343 
    self._iprot.readMessageEnd()
2344 
    if result.success is not None:
2345 
      return result.success
2346 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBanner failed: unknown result");
2347 
 
9155 kshitij.so 2348 
  def getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 2349 
    """
2350 
    Parameters:
2351 
     - bannerName
9155 kshitij.so 2352 
     - bannerType
6850 kshitij.so 2353 
    """
9155 kshitij.so 2354 
    self.send_getBannerDetails(bannerName, bannerType)
6850 kshitij.so 2355 
    return self.recv_getBannerDetails()
2356 
 
9155 kshitij.so 2357 
  def send_getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 2358 
    self._oprot.writeMessageBegin('getBannerDetails', TMessageType.CALL, self._seqid)
2359 
    args = getBannerDetails_args()
2360 
    args.bannerName = bannerName
9155 kshitij.so 2361 
    args.bannerType = bannerType
6850 kshitij.so 2362 
    args.write(self._oprot)
2363 
    self._oprot.writeMessageEnd()
2364 
    self._oprot.trans.flush()
2365 
 
2366 
  def recv_getBannerDetails(self, ):
2367 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2368 
    if mtype == TMessageType.EXCEPTION:
2369 
      x = TApplicationException()
2370 
      x.read(self._iprot)
2371 
      self._iprot.readMessageEnd()
2372 
      raise x
2373 
    result = getBannerDetails_result()
2374 
    result.read(self._iprot)
2375 
    self._iprot.readMessageEnd()
2376 
    if result.success is not None:
2377 
      return result.success
2378 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerDetails failed: unknown result");
2379 
 
2380 
  def getActiveBanners(self, ):
2381 
    self.send_getActiveBanners()
2382 
    return self.recv_getActiveBanners()
2383 
 
2384 
  def send_getActiveBanners(self, ):
2385 
    self._oprot.writeMessageBegin('getActiveBanners', TMessageType.CALL, self._seqid)
2386 
    args = getActiveBanners_args()
2387 
    args.write(self._oprot)
2388 
    self._oprot.writeMessageEnd()
2389 
    self._oprot.trans.flush()
2390 
 
2391 
  def recv_getActiveBanners(self, ):
2392 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2393 
    if mtype == TMessageType.EXCEPTION:
2394 
      x = TApplicationException()
2395 
      x.read(self._iprot)
2396 
      self._iprot.readMessageEnd()
2397 
      raise x
2398 
    result = getActiveBanners_result()
2399 
    result.read(self._iprot)
2400 
    self._iprot.readMessageEnd()
2401 
    if result.success is not None:
2402 
      return result.success
2403 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBanners failed: unknown result");
2404 
 
8579 kshitij.so 2405 
  def addBannerMap(self, bannerMaps):
6849 kshitij.so 2406 
    """
2407 
    Parameters:
8579 kshitij.so 2408 
     - bannerMaps
6849 kshitij.so 2409 
    """
8579 kshitij.so 2410 
    self.send_addBannerMap(bannerMaps)
6849 kshitij.so 2411 
    return self.recv_addBannerMap()
2412 
 
8579 kshitij.so 2413 
  def send_addBannerMap(self, bannerMaps):
6849 kshitij.so 2414 
    self._oprot.writeMessageBegin('addBannerMap', TMessageType.CALL, self._seqid)
2415 
    args = addBannerMap_args()
8579 kshitij.so 2416 
    args.bannerMaps = bannerMaps
6849 kshitij.so 2417 
    args.write(self._oprot)
2418 
    self._oprot.writeMessageEnd()
2419 
    self._oprot.trans.flush()
2420 
 
2421 
  def recv_addBannerMap(self, ):
2422 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2423 
    if mtype == TMessageType.EXCEPTION:
2424 
      x = TApplicationException()
2425 
      x.read(self._iprot)
2426 
      self._iprot.readMessageEnd()
2427 
      raise x
2428 
    result = addBannerMap_result()
2429 
    result.read(self._iprot)
2430 
    self._iprot.readMessageEnd()
2431 
    if result.success is not None:
2432 
      return result.success
2433 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBannerMap failed: unknown result");
2434 
 
8579 kshitij.so 2435 
  def updateBannerMap(self, bannerMap):
2436 
    """
2437 
    Parameters:
2438 
     - bannerMap
2439 
    """
2440 
    self.send_updateBannerMap(bannerMap)
2441 
    return self.recv_updateBannerMap()
2442 
 
2443 
  def send_updateBannerMap(self, bannerMap):
2444 
    self._oprot.writeMessageBegin('updateBannerMap', TMessageType.CALL, self._seqid)
2445 
    args = updateBannerMap_args()
2446 
    args.bannerMap = bannerMap
2447 
    args.write(self._oprot)
2448 
    self._oprot.writeMessageEnd()
2449 
    self._oprot.trans.flush()
2450 
 
2451 
  def recv_updateBannerMap(self, ):
2452 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2453 
    if mtype == TMessageType.EXCEPTION:
2454 
      x = TApplicationException()
2455 
      x.read(self._iprot)
2456 
      self._iprot.readMessageEnd()
2457 
      raise x
2458 
    result = updateBannerMap_result()
2459 
    result.read(self._iprot)
2460 
    self._iprot.readMessageEnd()
2461 
    if result.success is not None:
2462 
      return result.success
2463 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBannerMap failed: unknown result");
2464 
 
6849 kshitij.so 2465 
  def deleteBannerMap(self, bannerName):
2466 
    """
2467 
    Parameters:
2468 
     - bannerName
2469 
    """
2470 
    self.send_deleteBannerMap(bannerName)
2471 
    return self.recv_deleteBannerMap()
2472 
 
2473 
  def send_deleteBannerMap(self, bannerName):
2474 
    self._oprot.writeMessageBegin('deleteBannerMap', TMessageType.CALL, self._seqid)
2475 
    args = deleteBannerMap_args()
2476 
    args.bannerName = bannerName
2477 
    args.write(self._oprot)
2478 
    self._oprot.writeMessageEnd()
2479 
    self._oprot.trans.flush()
2480 
 
2481 
  def recv_deleteBannerMap(self, ):
2482 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2483 
    if mtype == TMessageType.EXCEPTION:
2484 
      x = TApplicationException()
2485 
      x.read(self._iprot)
2486 
      self._iprot.readMessageEnd()
2487 
      raise x
2488 
    result = deleteBannerMap_result()
2489 
    result.read(self._iprot)
2490 
    self._iprot.readMessageEnd()
2491 
    if result.success is not None:
2492 
      return result.success
2493 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBannerMap failed: unknown result");
2494 
 
9155 kshitij.so 2495 
  def getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 2496 
    """
2497 
    Parameters:
2498 
     - bannerName
9155 kshitij.so 2499 
     - bannerType
6849 kshitij.so 2500 
    """
9155 kshitij.so 2501 
    self.send_getBannerMapDetails(bannerName, bannerType)
6849 kshitij.so 2502 
    return self.recv_getBannerMapDetails()
2503 
 
9155 kshitij.so 2504 
  def send_getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 2505 
    self._oprot.writeMessageBegin('getBannerMapDetails', TMessageType.CALL, self._seqid)
2506 
    args = getBannerMapDetails_args()
2507 
    args.bannerName = bannerName
9155 kshitij.so 2508 
    args.bannerType = bannerType
6849 kshitij.so 2509 
    args.write(self._oprot)
2510 
    self._oprot.writeMessageEnd()
2511 
    self._oprot.trans.flush()
2512 
 
2513 
  def recv_getBannerMapDetails(self, ):
2514 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2515 
    if mtype == TMessageType.EXCEPTION:
2516 
      x = TApplicationException()
2517 
      x.read(self._iprot)
2518 
      self._iprot.readMessageEnd()
2519 
      raise x
2520 
    result = getBannerMapDetails_result()
2521 
    result.read(self._iprot)
2522 
    self._iprot.readMessageEnd()
2523 
    if result.success is not None:
2524 
      return result.success
2525 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerMapDetails failed: unknown result");
2526 
 
8579 kshitij.so 2527 
  def addBannerUri(self, bannerUriMappings):
2528 
    """
2529 
    Parameters:
2530 
     - bannerUriMappings
2531 
    """
2532 
    self.send_addBannerUri(bannerUriMappings)
2533 
    self.recv_addBannerUri()
2534 
 
2535 
  def send_addBannerUri(self, bannerUriMappings):
2536 
    self._oprot.writeMessageBegin('addBannerUri', TMessageType.CALL, self._seqid)
2537 
    args = addBannerUri_args()
2538 
    args.bannerUriMappings = bannerUriMappings
2539 
    args.write(self._oprot)
2540 
    self._oprot.writeMessageEnd()
2541 
    self._oprot.trans.flush()
2542 
 
2543 
  def recv_addBannerUri(self, ):
2544 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2545 
    if mtype == TMessageType.EXCEPTION:
2546 
      x = TApplicationException()
2547 
      x.read(self._iprot)
2548 
      self._iprot.readMessageEnd()
2549 
      raise x
2550 
    result = addBannerUri_result()
2551 
    result.read(self._iprot)
2552 
    self._iprot.readMessageEnd()
2553 
    return
2554 
 
9155 kshitij.so 2555 
  def getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 2556 
    """
2557 
    Parameters:
2558 
     - bannerName
9155 kshitij.so 2559 
     - bannerType
8579 kshitij.so 2560 
    """
9155 kshitij.so 2561 
    self.send_getUriMapping(bannerName, bannerType)
8579 kshitij.so 2562 
    return self.recv_getUriMapping()
2563 
 
9155 kshitij.so 2564 
  def send_getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 2565 
    self._oprot.writeMessageBegin('getUriMapping', TMessageType.CALL, self._seqid)
2566 
    args = getUriMapping_args()
2567 
    args.bannerName = bannerName
9155 kshitij.so 2568 
    args.bannerType = bannerType
8579 kshitij.so 2569 
    args.write(self._oprot)
2570 
    self._oprot.writeMessageEnd()
2571 
    self._oprot.trans.flush()
2572 
 
2573 
  def recv_getUriMapping(self, ):
2574 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2575 
    if mtype == TMessageType.EXCEPTION:
2576 
      x = TApplicationException()
2577 
      x.read(self._iprot)
2578 
      self._iprot.readMessageEnd()
2579 
      raise x
2580 
    result = getUriMapping_result()
2581 
    result.read(self._iprot)
2582 
    self._iprot.readMessageEnd()
2583 
    if result.success is not None:
2584 
      return result.success
2585 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUriMapping failed: unknown result");
2586 
 
2587 
  def addCampaign(self, campaign):
2588 
    """
2589 
    Parameters:
2590 
     - campaign
2591 
    """
2592 
    self.send_addCampaign(campaign)
2593 
    self.recv_addCampaign()
2594 
 
2595 
  def send_addCampaign(self, campaign):
2596 
    self._oprot.writeMessageBegin('addCampaign', TMessageType.CALL, self._seqid)
2597 
    args = addCampaign_args()
2598 
    args.campaign = campaign
2599 
    args.write(self._oprot)
2600 
    self._oprot.writeMessageEnd()
2601 
    self._oprot.trans.flush()
2602 
 
2603 
  def recv_addCampaign(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 = addCampaign_result()
2611 
    result.read(self._iprot)
2612 
    self._iprot.readMessageEnd()
2613 
    return
2614 
 
2615 
  def getCampaigns(self, campaignName):
2616 
    """
2617 
    Parameters:
2618 
     - campaignName
2619 
    """
2620 
    self.send_getCampaigns(campaignName)
2621 
    return self.recv_getCampaigns()
2622 
 
2623 
  def send_getCampaigns(self, campaignName):
2624 
    self._oprot.writeMessageBegin('getCampaigns', TMessageType.CALL, self._seqid)
2625 
    args = getCampaigns_args()
2626 
    args.campaignName = campaignName
2627 
    args.write(self._oprot)
2628 
    self._oprot.writeMessageEnd()
2629 
    self._oprot.trans.flush()
2630 
 
2631 
  def recv_getCampaigns(self, ):
2632 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2633 
    if mtype == TMessageType.EXCEPTION:
2634 
      x = TApplicationException()
2635 
      x.read(self._iprot)
2636 
      self._iprot.readMessageEnd()
2637 
      raise x
2638 
    result = getCampaigns_result()
2639 
    result.read(self._iprot)
2640 
    self._iprot.readMessageEnd()
2641 
    if result.success is not None:
2642 
      return result.success
2643 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCampaigns failed: unknown result");
2644 
 
2645 
  def deleteCampaign(self, campaignId):
2646 
    """
2647 
    Parameters:
2648 
     - campaignId
2649 
    """
2650 
    self.send_deleteCampaign(campaignId)
2651 
    self.recv_deleteCampaign()
2652 
 
2653 
  def send_deleteCampaign(self, campaignId):
2654 
    self._oprot.writeMessageBegin('deleteCampaign', TMessageType.CALL, self._seqid)
2655 
    args = deleteCampaign_args()
2656 
    args.campaignId = campaignId
2657 
    args.write(self._oprot)
2658 
    self._oprot.writeMessageEnd()
2659 
    self._oprot.trans.flush()
2660 
 
2661 
  def recv_deleteCampaign(self, ):
2662 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2663 
    if mtype == TMessageType.EXCEPTION:
2664 
      x = TApplicationException()
2665 
      x.read(self._iprot)
2666 
      self._iprot.readMessageEnd()
2667 
      raise x
2668 
    result = deleteCampaign_result()
2669 
    result.read(self._iprot)
2670 
    self._iprot.readMessageEnd()
2671 
    return
2672 
 
2673 
  def getAllCampaigns(self, ):
2674 
    self.send_getAllCampaigns()
2675 
    return self.recv_getAllCampaigns()
2676 
 
2677 
  def send_getAllCampaigns(self, ):
2678 
    self._oprot.writeMessageBegin('getAllCampaigns', TMessageType.CALL, self._seqid)
2679 
    args = getAllCampaigns_args()
2680 
    args.write(self._oprot)
2681 
    self._oprot.writeMessageEnd()
2682 
    self._oprot.trans.flush()
2683 
 
2684 
  def recv_getAllCampaigns(self, ):
2685 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2686 
    if mtype == TMessageType.EXCEPTION:
2687 
      x = TApplicationException()
2688 
      x.read(self._iprot)
2689 
      self._iprot.readMessageEnd()
2690 
      raise x
2691 
    result = getAllCampaigns_result()
2692 
    result.read(self._iprot)
2693 
    self._iprot.readMessageEnd()
2694 
    if result.success is not None:
2695 
      return result.success
2696 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCampaigns failed: unknown result");
2697 
 
9155 kshitij.so 2698 
  def getActiveBannersForMobileSite(self, ):
2699 
    self.send_getActiveBannersForMobileSite()
2700 
    return self.recv_getActiveBannersForMobileSite()
2701 
 
2702 
  def send_getActiveBannersForMobileSite(self, ):
2703 
    self._oprot.writeMessageBegin('getActiveBannersForMobileSite', TMessageType.CALL, self._seqid)
2704 
    args = getActiveBannersForMobileSite_args()
2705 
    args.write(self._oprot)
2706 
    self._oprot.writeMessageEnd()
2707 
    self._oprot.trans.flush()
2708 
 
2709 
  def recv_getActiveBannersForMobileSite(self, ):
2710 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2711 
    if mtype == TMessageType.EXCEPTION:
2712 
      x = TApplicationException()
2713 
      x.read(self._iprot)
2714 
      self._iprot.readMessageEnd()
2715 
      raise x
2716 
    result = getActiveBannersForMobileSite_result()
2717 
    result.read(self._iprot)
2718 
    self._iprot.readMessageEnd()
2719 
    if result.success is not None:
2720 
      return result.success
2721 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBannersForMobileSite failed: unknown result");
2722 
 
5944 mandeep.dh 2723 
  def deleteSimilarItem(self, itemId, catalogItemId):
2724 
    """
2725 
    Delete similar item.
2726 
 
2727 
    Parameters:
2728 
     - itemId
2729 
     - catalogItemId
2730 
    """
2731 
    self.send_deleteSimilarItem(itemId, catalogItemId)
2732 
    return self.recv_deleteSimilarItem()
2733 
 
2734 
  def send_deleteSimilarItem(self, itemId, catalogItemId):
2735 
    self._oprot.writeMessageBegin('deleteSimilarItem', TMessageType.CALL, self._seqid)
2736 
    args = deleteSimilarItem_args()
2737 
    args.itemId = itemId
2738 
    args.catalogItemId = catalogItemId
2739 
    args.write(self._oprot)
2740 
    self._oprot.writeMessageEnd()
2741 
    self._oprot.trans.flush()
2742 
 
2743 
  def recv_deleteSimilarItem(self, ):
2744 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2745 
    if mtype == TMessageType.EXCEPTION:
2746 
      x = TApplicationException()
2747 
      x.read(self._iprot)
2748 
      self._iprot.readMessageEnd()
2749 
      raise x
2750 
    result = deleteSimilarItem_result()
2751 
    result.read(self._iprot)
2752 
    self._iprot.readMessageEnd()
2753 
    if result.success is not None:
2754 
      return result.success
2755 
    if result.cex is not None:
2756 
      raise result.cex
2757 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteSimilarItem failed: unknown result");
2758 
 
2759 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
2760 
    """
2761 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
2762 
    If yes, returns the itemId else returns 0
2763 
 
2764 
    Parameters:
2765 
     - brand
2766 
     - modelNumber
2767 
     - modelName
2768 
     - color
2769 
    """
2770 
    self.send_checkSimilarItem(brand, modelNumber, modelName, color)
2771 
    return self.recv_checkSimilarItem()
2772 
 
2773 
  def send_checkSimilarItem(self, brand, modelNumber, modelName, color):
2774 
    self._oprot.writeMessageBegin('checkSimilarItem', TMessageType.CALL, self._seqid)
2775 
    args = checkSimilarItem_args()
2776 
    args.brand = brand
2777 
    args.modelNumber = modelNumber
2778 
    args.modelName = modelName
2779 
    args.color = color
2780 
    args.write(self._oprot)
2781 
    self._oprot.writeMessageEnd()
2782 
    self._oprot.trans.flush()
2783 
 
2784 
  def recv_checkSimilarItem(self, ):
2785 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2786 
    if mtype == TMessageType.EXCEPTION:
2787 
      x = TApplicationException()
2788 
      x.read(self._iprot)
2789 
      self._iprot.readMessageEnd()
2790 
      raise x
2791 
    result = checkSimilarItem_result()
2792 
    result.read(self._iprot)
2793 
    self._iprot.readMessageEnd()
2794 
    if result.success is not None:
2795 
      return result.success
2796 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkSimilarItem failed: unknown result");
2797 
 
2798 
  def validateRiskyStatus(self, itemId):
2799 
    """
2800 
    Check wether item is risky and change status if inventory is not available for risky items
2801 
 
2802 
    Parameters:
2803 
     - itemId
2804 
    """
2805 
    self.send_validateRiskyStatus(itemId)
2806 
    self.recv_validateRiskyStatus()
2807 
 
2808 
  def send_validateRiskyStatus(self, itemId):
2809 
    self._oprot.writeMessageBegin('validateRiskyStatus', TMessageType.CALL, self._seqid)
2810 
    args = validateRiskyStatus_args()
2811 
    args.itemId = itemId
2812 
    args.write(self._oprot)
2813 
    self._oprot.writeMessageEnd()
2814 
    self._oprot.trans.flush()
2815 
 
2816 
  def recv_validateRiskyStatus(self, ):
2817 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2818 
    if mtype == TMessageType.EXCEPTION:
2819 
      x = TApplicationException()
2820 
      x.read(self._iprot)
2821 
      self._iprot.readMessageEnd()
2822 
      raise x
2823 
    result = validateRiskyStatus_result()
2824 
    result.read(self._iprot)
2825 
    self._iprot.readMessageEnd()
2826 
    return
2827 
 
2828 
  def changeItemRiskyFlag(self, itemId, risky):
2829 
    """
2830 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
2831 
 
2832 
    Parameters:
2833 
     - itemId
2834 
     - risky
2835 
    """
2836 
    self.send_changeItemRiskyFlag(itemId, risky)
2837 
    self.recv_changeItemRiskyFlag()
2838 
 
2839 
  def send_changeItemRiskyFlag(self, itemId, risky):
2840 
    self._oprot.writeMessageBegin('changeItemRiskyFlag', TMessageType.CALL, self._seqid)
2841 
    args = changeItemRiskyFlag_args()
2842 
    args.itemId = itemId
2843 
    args.risky = risky
2844 
    args.write(self._oprot)
2845 
    self._oprot.writeMessageEnd()
2846 
    self._oprot.trans.flush()
2847 
 
2848 
  def recv_changeItemRiskyFlag(self, ):
2849 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2850 
    if mtype == TMessageType.EXCEPTION:
2851 
      x = TApplicationException()
2852 
      x.read(self._iprot)
2853 
      self._iprot.readMessageEnd()
2854 
      raise x
2855 
    result = changeItemRiskyFlag_result()
2856 
    result.read(self._iprot)
2857 
    self._iprot.readMessageEnd()
2858 
    return
2859 
 
2860 
  def getItemsByRiskyFlag(self, ):
2861 
    """
2862 
    Returns list of items marked as risky.
2863 
    """
2864 
    self.send_getItemsByRiskyFlag()
2865 
    return self.recv_getItemsByRiskyFlag()
2866 
 
2867 
  def send_getItemsByRiskyFlag(self, ):
2868 
    self._oprot.writeMessageBegin('getItemsByRiskyFlag', TMessageType.CALL, self._seqid)
2869 
    args = getItemsByRiskyFlag_args()
2870 
    args.write(self._oprot)
2871 
    self._oprot.writeMessageEnd()
2872 
    self._oprot.trans.flush()
2873 
 
2874 
  def recv_getItemsByRiskyFlag(self, ):
2875 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2876 
    if mtype == TMessageType.EXCEPTION:
2877 
      x = TApplicationException()
2878 
      x.read(self._iprot)
2879 
      self._iprot.readMessageEnd()
2880 
      raise x
2881 
    result = getItemsByRiskyFlag_result()
2882 
    result.read(self._iprot)
2883 
    self._iprot.readMessageEnd()
2884 
    if result.success is not None:
2885 
      return result.success
2886 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByRiskyFlag failed: unknown result");
2887 
 
2888 
  def getItemsForMasterSheet(self, category, brand):
2889 
    """
2890 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
2891 
 
2892 
    Parameters:
2893 
     - category
2894 
     - brand
2895 
    """
2896 
    self.send_getItemsForMasterSheet(category, brand)
2897 
    return self.recv_getItemsForMasterSheet()
2898 
 
2899 
  def send_getItemsForMasterSheet(self, category, brand):
2900 
    self._oprot.writeMessageBegin('getItemsForMasterSheet', TMessageType.CALL, self._seqid)
2901 
    args = getItemsForMasterSheet_args()
2902 
    args.category = category
2903 
    args.brand = brand
2904 
    args.write(self._oprot)
2905 
    self._oprot.writeMessageEnd()
2906 
    self._oprot.trans.flush()
2907 
 
2908 
  def recv_getItemsForMasterSheet(self, ):
2909 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2910 
    if mtype == TMessageType.EXCEPTION:
2911 
      x = TApplicationException()
2912 
      x.read(self._iprot)
2913 
      self._iprot.readMessageEnd()
2914 
      raise x
2915 
    result = getItemsForMasterSheet_result()
2916 
    result.read(self._iprot)
2917 
    self._iprot.readMessageEnd()
2918 
    if result.success is not None:
2919 
      return result.success
2920 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsForMasterSheet failed: unknown result");
2921 
 
2922 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2923 
    """
2924 
    Returns list of catalog ids of items with same similarity index as of the given itemId
2925 
 
2926 
    Parameters:
2927 
     - beginIndex
2928 
     - totalItems
2929 
     - itemId
2930 
    """
2931 
    self.send_getSimilarItemsCatalogIds(beginIndex, totalItems, itemId)
2932 
    return self.recv_getSimilarItemsCatalogIds()
2933 
 
2934 
  def send_getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2935 
    self._oprot.writeMessageBegin('getSimilarItemsCatalogIds', TMessageType.CALL, self._seqid)
2936 
    args = getSimilarItemsCatalogIds_args()
2937 
    args.beginIndex = beginIndex
2938 
    args.totalItems = totalItems
2939 
    args.itemId = itemId
2940 
    args.write(self._oprot)
2941 
    self._oprot.writeMessageEnd()
2942 
    self._oprot.trans.flush()
2943 
 
2944 
  def recv_getSimilarItemsCatalogIds(self, ):
2945 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2946 
    if mtype == TMessageType.EXCEPTION:
2947 
      x = TApplicationException()
2948 
      x.read(self._iprot)
2949 
      self._iprot.readMessageEnd()
2950 
      raise x
2951 
    result = getSimilarItemsCatalogIds_result()
2952 
    result.read(self._iprot)
2953 
    self._iprot.readMessageEnd()
2954 
    if result.success is not None:
2955 
      return result.success
2956 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSimilarItemsCatalogIds failed: unknown result");
2957 
 
2958 
  def addProductNotification(self, itemId, email):
2959 
    """
2960 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
2961 
 
2962 
    Parameters:
2963 
     - itemId
2964 
     - email
2965 
    """
2966 
    self.send_addProductNotification(itemId, email)
2967 
    return self.recv_addProductNotification()
2968 
 
2969 
  def send_addProductNotification(self, itemId, email):
2970 
    self._oprot.writeMessageBegin('addProductNotification', TMessageType.CALL, self._seqid)
2971 
    args = addProductNotification_args()
2972 
    args.itemId = itemId
2973 
    args.email = email
2974 
    args.write(self._oprot)
2975 
    self._oprot.writeMessageEnd()
2976 
    self._oprot.trans.flush()
2977 
 
2978 
  def recv_addProductNotification(self, ):
2979 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2980 
    if mtype == TMessageType.EXCEPTION:
2981 
      x = TApplicationException()
2982 
      x.read(self._iprot)
2983 
      self._iprot.readMessageEnd()
2984 
      raise x
2985 
    result = addProductNotification_result()
2986 
    result.read(self._iprot)
2987 
    self._iprot.readMessageEnd()
2988 
    if result.success is not None:
2989 
      return result.success
2990 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductNotification failed: unknown result");
2991 
 
2992 
  def sendProductNotifications(self, ):
2993 
    """
2994 
    Send the product notifications to the users for items which has stock.
2995 
    """
2996 
    self.send_sendProductNotifications()
2997 
    return self.recv_sendProductNotifications()
2998 
 
2999 
  def send_sendProductNotifications(self, ):
3000 
    self._oprot.writeMessageBegin('sendProductNotifications', TMessageType.CALL, self._seqid)
3001 
    args = sendProductNotifications_args()
3002 
    args.write(self._oprot)
3003 
    self._oprot.writeMessageEnd()
3004 
    self._oprot.trans.flush()
3005 
 
3006 
  def recv_sendProductNotifications(self, ):
3007 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3008 
    if mtype == TMessageType.EXCEPTION:
3009 
      x = TApplicationException()
3010 
      x.read(self._iprot)
3011 
      self._iprot.readMessageEnd()
3012 
      raise x
3013 
    result = sendProductNotifications_result()
3014 
    result.read(self._iprot)
3015 
    self._iprot.readMessageEnd()
3016 
    if result.success is not None:
3017 
      return result.success
3018 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendProductNotifications failed: unknown result");
3019 
 
3020 
  def getAllBrandsByCategory(self, categoryId):
3021 
    """
3022 
    Returns list of brand names for a given category Id
3023 
 
3024 
    Parameters:
3025 
     - categoryId
3026 
    """
3027 
    self.send_getAllBrandsByCategory(categoryId)
3028 
    return self.recv_getAllBrandsByCategory()
3029 
 
3030 
  def send_getAllBrandsByCategory(self, categoryId):
3031 
    self._oprot.writeMessageBegin('getAllBrandsByCategory', TMessageType.CALL, self._seqid)
3032 
    args = getAllBrandsByCategory_args()
3033 
    args.categoryId = categoryId
3034 
    args.write(self._oprot)
3035 
    self._oprot.writeMessageEnd()
3036 
    self._oprot.trans.flush()
3037 
 
3038 
  def recv_getAllBrandsByCategory(self, ):
3039 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3040 
    if mtype == TMessageType.EXCEPTION:
3041 
      x = TApplicationException()
3042 
      x.read(self._iprot)
3043 
      self._iprot.readMessageEnd()
3044 
      raise x
3045 
    result = getAllBrandsByCategory_result()
3046 
    result.read(self._iprot)
3047 
    self._iprot.readMessageEnd()
3048 
    if result.success is not None:
3049 
      return result.success
3050 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrandsByCategory failed: unknown result");
3051 
 
3052 
  def getAllBrands(self, ):
3053 
    """
3054 
    Returns list of brand names
3055 
    """
3056 
    self.send_getAllBrands()
3057 
    return self.recv_getAllBrands()
3058 
 
3059 
  def send_getAllBrands(self, ):
3060 
    self._oprot.writeMessageBegin('getAllBrands', TMessageType.CALL, self._seqid)
3061 
    args = getAllBrands_args()
3062 
    args.write(self._oprot)
3063 
    self._oprot.writeMessageEnd()
3064 
    self._oprot.trans.flush()
3065 
 
3066 
  def recv_getAllBrands(self, ):
3067 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3068 
    if mtype == TMessageType.EXCEPTION:
3069 
      x = TApplicationException()
3070 
      x.read(self._iprot)
3071 
      self._iprot.readMessageEnd()
3072 
      raise x
3073 
    result = getAllBrands_result()
3074 
    result.read(self._iprot)
3075 
    self._iprot.readMessageEnd()
3076 
    if result.success is not None:
3077 
      return result.success
3078 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrands failed: unknown result");
3079 
 
3080 
  def getAllSources(self, ):
3081 
    """
3082 
    Return list of all sources
3083 
    """
3084 
    self.send_getAllSources()
3085 
    return self.recv_getAllSources()
3086 
 
3087 
  def send_getAllSources(self, ):
3088 
    self._oprot.writeMessageBegin('getAllSources', TMessageType.CALL, self._seqid)
3089 
    args = getAllSources_args()
3090 
    args.write(self._oprot)
3091 
    self._oprot.writeMessageEnd()
3092 
    self._oprot.trans.flush()
3093 
 
3094 
  def recv_getAllSources(self, ):
3095 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3096 
    if mtype == TMessageType.EXCEPTION:
3097 
      x = TApplicationException()
3098 
      x.read(self._iprot)
3099 
      self._iprot.readMessageEnd()
3100 
      raise x
3101 
    result = getAllSources_result()
3102 
    result.read(self._iprot)
3103 
    self._iprot.readMessageEnd()
3104 
    if result.success is not None:
3105 
      return result.success
3106 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSources failed: unknown result");
3107 
 
3108 
  def getItemPricingBySource(self, itemId, sourceId):
3109 
    """
3110 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
3111 
 
3112 
    Parameters:
3113 
     - itemId
3114 
     - sourceId
3115 
    """
3116 
    self.send_getItemPricingBySource(itemId, sourceId)
3117 
    return self.recv_getItemPricingBySource()
3118 
 
3119 
  def send_getItemPricingBySource(self, itemId, sourceId):
3120 
    self._oprot.writeMessageBegin('getItemPricingBySource', TMessageType.CALL, self._seqid)
3121 
    args = getItemPricingBySource_args()
3122 
    args.itemId = itemId
3123 
    args.sourceId = sourceId
3124 
    args.write(self._oprot)
3125 
    self._oprot.writeMessageEnd()
3126 
    self._oprot.trans.flush()
3127 
 
3128 
  def recv_getItemPricingBySource(self, ):
3129 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3130 
    if mtype == TMessageType.EXCEPTION:
3131 
      x = TApplicationException()
3132 
      x.read(self._iprot)
3133 
      self._iprot.readMessageEnd()
3134 
      raise x
3135 
    result = getItemPricingBySource_result()
3136 
    result.read(self._iprot)
3137 
    self._iprot.readMessageEnd()
3138 
    if result.success is not None:
3139 
      return result.success
3140 
    if result.cex is not None:
3141 
      raise result.cex
3142 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricingBySource failed: unknown result");
3143 
 
3144 
  def addSourceItemPricing(self, sourceItemPricing):
3145 
    """
3146 
    Adds prices to be displayed corresponding to the item if user comes from a source.
3147 
    If item is not found or source is not found, it will throw exception.
3148 
 
3149 
    Parameters:
3150 
     - sourceItemPricing
3151 
    """
3152 
    self.send_addSourceItemPricing(sourceItemPricing)
3153 
    self.recv_addSourceItemPricing()
3154 
 
3155 
  def send_addSourceItemPricing(self, sourceItemPricing):
3156 
    self._oprot.writeMessageBegin('addSourceItemPricing', TMessageType.CALL, self._seqid)
3157 
    args = addSourceItemPricing_args()
3158 
    args.sourceItemPricing = sourceItemPricing
3159 
    args.write(self._oprot)
3160 
    self._oprot.writeMessageEnd()
3161 
    self._oprot.trans.flush()
3162 
 
3163 
  def recv_addSourceItemPricing(self, ):
3164 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3165 
    if mtype == TMessageType.EXCEPTION:
3166 
      x = TApplicationException()
3167 
      x.read(self._iprot)
3168 
      self._iprot.readMessageEnd()
3169 
      raise x
3170 
    result = addSourceItemPricing_result()
3171 
    result.read(self._iprot)
3172 
    self._iprot.readMessageEnd()
3173 
    if result.cex is not None:
3174 
      raise result.cex
3175 
    return
3176 
 
3177 
  def getAllSourcePricing(self, itemId):
3178 
    """
3179 
    Returns the list of source pricing information of an item.
3180 
    Raises an exception if item not found corresponding to itemId
3181 
 
3182 
    Parameters:
3183 
     - itemId
3184 
    """
3185 
    self.send_getAllSourcePricing(itemId)
3186 
    return self.recv_getAllSourcePricing()
3187 
 
3188 
  def send_getAllSourcePricing(self, itemId):
3189 
    self._oprot.writeMessageBegin('getAllSourcePricing', TMessageType.CALL, self._seqid)
3190 
    args = getAllSourcePricing_args()
3191 
    args.itemId = itemId
3192 
    args.write(self._oprot)
3193 
    self._oprot.writeMessageEnd()
3194 
    self._oprot.trans.flush()
3195 
 
3196 
  def recv_getAllSourcePricing(self, ):
3197 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3198 
    if mtype == TMessageType.EXCEPTION:
3199 
      x = TApplicationException()
3200 
      x.read(self._iprot)
3201 
      self._iprot.readMessageEnd()
3202 
      raise x
3203 
    result = getAllSourcePricing_result()
3204 
    result.read(self._iprot)
3205 
    self._iprot.readMessageEnd()
3206 
    if result.success is not None:
3207 
      return result.success
3208 
    if result.cex is not None:
3209 
      raise result.cex
3210 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSourcePricing failed: unknown result");
3211 
 
3212 
  def getItemForSource(self, item_id, sourceId):
3213 
    """
3214 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
3215 
 
3216 
    Parameters:
3217 
     - item_id
3218 
     - sourceId
3219 
    """
3220 
    self.send_getItemForSource(item_id, sourceId)
3221 
    return self.recv_getItemForSource()
3222 
 
3223 
  def send_getItemForSource(self, item_id, sourceId):
3224 
    self._oprot.writeMessageBegin('getItemForSource', TMessageType.CALL, self._seqid)
3225 
    args = getItemForSource_args()
3226 
    args.item_id = item_id
3227 
    args.sourceId = sourceId
3228 
    args.write(self._oprot)
3229 
    self._oprot.writeMessageEnd()
3230 
    self._oprot.trans.flush()
3231 
 
3232 
  def recv_getItemForSource(self, ):
3233 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3234 
    if mtype == TMessageType.EXCEPTION:
3235 
      x = TApplicationException()
3236 
      x.read(self._iprot)
3237 
      self._iprot.readMessageEnd()
3238 
      raise x
3239 
    result = getItemForSource_result()
3240 
    result.read(self._iprot)
3241 
    self._iprot.readMessageEnd()
3242 
    if result.success is not None:
3243 
      return result.success
3244 
    if result.cex is not None:
3245 
      raise result.cex
3246 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemForSource failed: unknown result");
3247 
 
3248 
  def searchItemsInRange(self, searchTerms, offset, limit):
3249 
    """
3250 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
3251 
 
3252 
    Parameters:
3253 
     - searchTerms
3254 
     - offset
3255 
     - limit
3256 
    """
3257 
    self.send_searchItemsInRange(searchTerms, offset, limit)
3258 
    return self.recv_searchItemsInRange()
3259 
 
3260 
  def send_searchItemsInRange(self, searchTerms, offset, limit):
3261 
    self._oprot.writeMessageBegin('searchItemsInRange', TMessageType.CALL, self._seqid)
3262 
    args = searchItemsInRange_args()
3263 
    args.searchTerms = searchTerms
3264 
    args.offset = offset
3265 
    args.limit = limit
3266 
    args.write(self._oprot)
3267 
    self._oprot.writeMessageEnd()
3268 
    self._oprot.trans.flush()
3269 
 
3270 
  def recv_searchItemsInRange(self, ):
3271 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3272 
    if mtype == TMessageType.EXCEPTION:
3273 
      x = TApplicationException()
3274 
      x.read(self._iprot)
3275 
      self._iprot.readMessageEnd()
3276 
      raise x
3277 
    result = searchItemsInRange_result()
3278 
    result.read(self._iprot)
3279 
    self._iprot.readMessageEnd()
3280 
    if result.success is not None:
3281 
      return result.success
3282 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchItemsInRange failed: unknown result");
3283 
 
3284 
  def getSearchResultCount(self, searchTerms):
3285 
    """
3286 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
3287 
 
3288 
    Parameters:
3289 
     - searchTerms
3290 
    """
3291 
    self.send_getSearchResultCount(searchTerms)
3292 
    return self.recv_getSearchResultCount()
3293 
 
3294 
  def send_getSearchResultCount(self, searchTerms):
3295 
    self._oprot.writeMessageBegin('getSearchResultCount', TMessageType.CALL, self._seqid)
3296 
    args = getSearchResultCount_args()
3297 
    args.searchTerms = searchTerms
3298 
    args.write(self._oprot)
3299 
    self._oprot.writeMessageEnd()
3300 
    self._oprot.trans.flush()
3301 
 
3302 
  def recv_getSearchResultCount(self, ):
3303 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3304 
    if mtype == TMessageType.EXCEPTION:
3305 
      x = TApplicationException()
3306 
      x.read(self._iprot)
3307 
      self._iprot.readMessageEnd()
3308 
      raise x
3309 
    result = getSearchResultCount_result()
3310 
    result.read(self._iprot)
3311 
    self._iprot.readMessageEnd()
3312 
    if result.success is not None:
3313 
      return result.success
3314 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSearchResultCount failed: unknown result");
3315 
 
3316 
  def getProductNotifications(self, startDateTime):
3317 
    """
3318 
    Returns a list of product notifications added after a supplied datetime
3319 
 
3320 
    Parameters:
3321 
     - startDateTime
3322 
    """
3323 
    self.send_getProductNotifications(startDateTime)
3324 
    return self.recv_getProductNotifications()
3325 
 
3326 
  def send_getProductNotifications(self, startDateTime):
3327 
    self._oprot.writeMessageBegin('getProductNotifications', TMessageType.CALL, self._seqid)
3328 
    args = getProductNotifications_args()
3329 
    args.startDateTime = startDateTime
3330 
    args.write(self._oprot)
3331 
    self._oprot.writeMessageEnd()
3332 
    self._oprot.trans.flush()
3333 
 
3334 
  def recv_getProductNotifications(self, ):
3335 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3336 
    if mtype == TMessageType.EXCEPTION:
3337 
      x = TApplicationException()
3338 
      x.read(self._iprot)
3339 
      self._iprot.readMessageEnd()
3340 
      raise x
3341 
    result = getProductNotifications_result()
3342 
    result.read(self._iprot)
3343 
    self._iprot.readMessageEnd()
3344 
    if result.success is not None:
3345 
      return result.success
3346 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotifications failed: unknown result");
3347 
 
7897 amar.kumar 3348 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3349 
    """
3350 
    Returns a list of count of requests for product notification against each item
3351 
 
3352 
    Parameters:
3353 
     - startDateTime
7897 amar.kumar 3354 
     - categoryId
5944 mandeep.dh 3355 
    """
7897 amar.kumar 3356 
    self.send_getProductNotificationRequestCount(startDateTime, categoryId)
5944 mandeep.dh 3357 
    return self.recv_getProductNotificationRequestCount()
3358 
 
7897 amar.kumar 3359 
  def send_getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3360 
    self._oprot.writeMessageBegin('getProductNotificationRequestCount', TMessageType.CALL, self._seqid)
3361 
    args = getProductNotificationRequestCount_args()
3362 
    args.startDateTime = startDateTime
7897 amar.kumar 3363 
    args.categoryId = categoryId
5944 mandeep.dh 3364 
    args.write(self._oprot)
3365 
    self._oprot.writeMessageEnd()
3366 
    self._oprot.trans.flush()
3367 
 
3368 
  def recv_getProductNotificationRequestCount(self, ):
3369 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3370 
    if mtype == TMessageType.EXCEPTION:
3371 
      x = TApplicationException()
3372 
      x.read(self._iprot)
3373 
      self._iprot.readMessageEnd()
3374 
      raise x
3375 
    result = getProductNotificationRequestCount_result()
3376 
    result.read(self._iprot)
3377 
    self._iprot.readMessageEnd()
3378 
    if result.success is not None:
3379 
      return result.success
3380 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotificationRequestCount failed: unknown result");
3381 
 
3382 
  def addAuthorizationLog(self, itemId, username, reason):
3383 
    """
3384 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
3385 
 
3386 
    Parameters:
3387 
     - itemId
3388 
     - username
3389 
     - reason
3390 
    """
3391 
    self.send_addAuthorizationLog(itemId, username, reason)
3392 
    return self.recv_addAuthorizationLog()
3393 
 
3394 
  def send_addAuthorizationLog(self, itemId, username, reason):
3395 
    self._oprot.writeMessageBegin('addAuthorizationLog', TMessageType.CALL, self._seqid)
3396 
    args = addAuthorizationLog_args()
3397 
    args.itemId = itemId
3398 
    args.username = username
3399 
    args.reason = reason
3400 
    args.write(self._oprot)
3401 
    self._oprot.writeMessageEnd()
3402 
    self._oprot.trans.flush()
3403 
 
3404 
  def recv_addAuthorizationLog(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 = addAuthorizationLog_result()
3412 
    result.read(self._iprot)
3413 
    self._iprot.readMessageEnd()
3414 
    if result.success is not None:
3415 
      return result.success
3416 
    if result.cex is not None:
3417 
      raise result.cex
3418 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAuthorizationLog failed: unknown result");
3419 
 
3420 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3421 
    """
3422 
    Parameters:
3423 
     - catalog_item_id
3424 
     - voucherType
3425 
     - voucherAmount
3426 
    """
3427 
    self.send_addupdateVoucherForItem(catalog_item_id, voucherType, voucherAmount)
3428 
    return self.recv_addupdateVoucherForItem()
3429 
 
3430 
  def send_addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3431 
    self._oprot.writeMessageBegin('addupdateVoucherForItem', TMessageType.CALL, self._seqid)
3432 
    args = addupdateVoucherForItem_args()
3433 
    args.catalog_item_id = catalog_item_id
3434 
    args.voucherType = voucherType
3435 
    args.voucherAmount = voucherAmount
3436 
    args.write(self._oprot)
3437 
    self._oprot.writeMessageEnd()
3438 
    self._oprot.trans.flush()
3439 
 
3440 
  def recv_addupdateVoucherForItem(self, ):
3441 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3442 
    if mtype == TMessageType.EXCEPTION:
3443 
      x = TApplicationException()
3444 
      x.read(self._iprot)
3445 
      self._iprot.readMessageEnd()
3446 
      raise x
3447 
    result = addupdateVoucherForItem_result()
3448 
    result.read(self._iprot)
3449 
    self._iprot.readMessageEnd()
3450 
    if result.success is not None:
3451 
      return result.success
3452 
    if result.cex is not None:
3453 
      raise result.cex
3454 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addupdateVoucherForItem failed: unknown result");
3455 
 
3456 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
3457 
    """
3458 
    Parameters:
3459 
     - catalog_item_id
3460 
     - voucherType
3461 
    """
3462 
    self.send_deleteVoucherForItem(catalog_item_id, voucherType)
3463 
    return self.recv_deleteVoucherForItem()
3464 
 
3465 
  def send_deleteVoucherForItem(self, catalog_item_id, voucherType):
3466 
    self._oprot.writeMessageBegin('deleteVoucherForItem', TMessageType.CALL, self._seqid)
3467 
    args = deleteVoucherForItem_args()
3468 
    args.catalog_item_id = catalog_item_id
3469 
    args.voucherType = voucherType
3470 
    args.write(self._oprot)
3471 
    self._oprot.writeMessageEnd()
3472 
    self._oprot.trans.flush()
3473 
 
3474 
  def recv_deleteVoucherForItem(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 = deleteVoucherForItem_result()
3482 
    result.read(self._iprot)
3483 
    self._iprot.readMessageEnd()
3484 
    if result.success is not None:
3485 
      return result.success
3486 
    if result.cex is not None:
3487 
      raise result.cex
3488 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteVoucherForItem failed: unknown result");
3489 
 
3490 
  def getVoucherAmount(self, itemId, voucherType):
3491 
    """
3492 
    Parameters:
3493 
     - itemId
3494 
     - voucherType
3495 
    """
3496 
    self.send_getVoucherAmount(itemId, voucherType)
3497 
    return self.recv_getVoucherAmount()
3498 
 
3499 
  def send_getVoucherAmount(self, itemId, voucherType):
3500 
    self._oprot.writeMessageBegin('getVoucherAmount', TMessageType.CALL, self._seqid)
3501 
    args = getVoucherAmount_args()
3502 
    args.itemId = itemId
3503 
    args.voucherType = voucherType
3504 
    args.write(self._oprot)
3505 
    self._oprot.writeMessageEnd()
3506 
    self._oprot.trans.flush()
3507 
 
3508 
  def recv_getVoucherAmount(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 = getVoucherAmount_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, "getVoucherAmount failed: unknown result");
3521 
 
3522 
  def getAllItemVouchers(self, itemId):
3523 
    """
3524 
    Parameters:
3525 
     - itemId
3526 
    """
3527 
    self.send_getAllItemVouchers(itemId)
3528 
    return self.recv_getAllItemVouchers()
3529 
 
3530 
  def send_getAllItemVouchers(self, itemId):
3531 
    self._oprot.writeMessageBegin('getAllItemVouchers', TMessageType.CALL, self._seqid)
3532 
    args = getAllItemVouchers_args()
3533 
    args.itemId = itemId
3534 
    args.write(self._oprot)
3535 
    self._oprot.writeMessageEnd()
3536 
    self._oprot.trans.flush()
3537 
 
3538 
  def recv_getAllItemVouchers(self, ):
3539 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3540 
    if mtype == TMessageType.EXCEPTION:
3541 
      x = TApplicationException()
3542 
      x.read(self._iprot)
3543 
      self._iprot.readMessageEnd()
3544 
      raise x
3545 
    result = getAllItemVouchers_result()
3546 
    result.read(self._iprot)
3547 
    self._iprot.readMessageEnd()
3548 
    if result.success is not None:
3549 
      return result.success
3550 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemVouchers failed: unknown result");
3551 
 
3552 
  def isValidCatalogItemId(self, catalog_item_id):
3553 
    """
3554 
    Parameters:
3555 
     - catalog_item_id
3556 
    """
3557 
    self.send_isValidCatalogItemId(catalog_item_id)
3558 
    return self.recv_isValidCatalogItemId()
3559 
 
3560 
  def send_isValidCatalogItemId(self, catalog_item_id):
3561 
    self._oprot.writeMessageBegin('isValidCatalogItemId', TMessageType.CALL, self._seqid)
3562 
    args = isValidCatalogItemId_args()
3563 
    args.catalog_item_id = catalog_item_id
3564 
    args.write(self._oprot)
3565 
    self._oprot.writeMessageEnd()
3566 
    self._oprot.trans.flush()
3567 
 
3568 
  def recv_isValidCatalogItemId(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 = isValidCatalogItemId_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, "isValidCatalogItemId failed: unknown result");
3581 
 
7330 amit.gupta 3582 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3583 
    """
3584 
    Parameters:
3585 
     - itemId
7330 amit.gupta 3586 
     - stateId
6039 amit.gupta 3587 
     - price
3588 
    """
7330 amit.gupta 3589 
    self.send_getVatPercentageForItem(itemId, stateId, price)
6039 amit.gupta 3590 
    return self.recv_getVatPercentageForItem()
5944 mandeep.dh 3591 
 
7330 amit.gupta 3592 
  def send_getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3593 
    self._oprot.writeMessageBegin('getVatPercentageForItem', TMessageType.CALL, self._seqid)
3594 
    args = getVatPercentageForItem_args()
3595 
    args.itemId = itemId
7330 amit.gupta 3596 
    args.stateId = stateId
6039 amit.gupta 3597 
    args.price = price
3598 
    args.write(self._oprot)
3599 
    self._oprot.writeMessageEnd()
3600 
    self._oprot.trans.flush()
3601 
 
3602 
  def recv_getVatPercentageForItem(self, ):
3603 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3604 
    if mtype == TMessageType.EXCEPTION:
3605 
      x = TApplicationException()
3606 
      x.read(self._iprot)
3607 
      self._iprot.readMessageEnd()
3608 
      raise x
3609 
    result = getVatPercentageForItem_result()
3610 
    result.read(self._iprot)
3611 
    self._iprot.readMessageEnd()
3612 
    if result.success is not None:
3613 
      return result.success
7340 amit.gupta 3614 
    if result.cex is not None:
3615 
      raise result.cex
6039 amit.gupta 3616 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatPercentageForItem failed: unknown result");
3617 
 
3618 
  def getVatAmountForItem(self, itemId, price):
3619 
    """
3620 
    Parameters:
3621 
     - itemId
3622 
     - price
3623 
    """
3624 
    self.send_getVatAmountForItem(itemId, price)
3625 
    return self.recv_getVatAmountForItem()
3626 
 
3627 
  def send_getVatAmountForItem(self, itemId, price):
3628 
    self._oprot.writeMessageBegin('getVatAmountForItem', TMessageType.CALL, self._seqid)
3629 
    args = getVatAmountForItem_args()
3630 
    args.itemId = itemId
3631 
    args.price = price
3632 
    args.write(self._oprot)
3633 
    self._oprot.writeMessageEnd()
3634 
    self._oprot.trans.flush()
3635 
 
3636 
  def recv_getVatAmountForItem(self, ):
3637 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3638 
    if mtype == TMessageType.EXCEPTION:
3639 
      x = TApplicationException()
3640 
      x.read(self._iprot)
3641 
      self._iprot.readMessageEnd()
3642 
      raise x
3643 
    result = getVatAmountForItem_result()
3644 
    result.read(self._iprot)
3645 
    self._iprot.readMessageEnd()
3646 
    if result.success is not None:
3647 
      return result.success
3648 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatAmountForItem failed: unknown result");
3649 
 
6531 vikram.rag 3650 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3651 
    """
3652 
    Parameters:
3653 
     - offset
3654 
     - limit
3655 
    """
3656 
    self.send_getAllIgnoredInventoryUpdateItemsList(offset, limit)
3657 
    return self.recv_getAllIgnoredInventoryUpdateItemsList()
6039 amit.gupta 3658 
 
6531 vikram.rag 3659 
  def send_getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3660 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryUpdateItemsList', TMessageType.CALL, self._seqid)
3661 
    args = getAllIgnoredInventoryUpdateItemsList_args()
3662 
    args.offset = offset
3663 
    args.limit = limit
3664 
    args.write(self._oprot)
3665 
    self._oprot.writeMessageEnd()
3666 
    self._oprot.trans.flush()
3667 
 
3668 
  def recv_getAllIgnoredInventoryUpdateItemsList(self, ):
3669 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3670 
    if mtype == TMessageType.EXCEPTION:
3671 
      x = TApplicationException()
3672 
      x.read(self._iprot)
3673 
      self._iprot.readMessageEnd()
3674 
      raise x
3675 
    result = getAllIgnoredInventoryUpdateItemsList_result()
3676 
    result.read(self._iprot)
3677 
    self._iprot.readMessageEnd()
3678 
    if result.success is not None:
3679 
      return result.success
3680 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryUpdateItemsList failed: unknown result");
3681 
 
6821 amar.kumar 3682 
  def getAllAliveItems(self, ):
3683 
    self.send_getAllAliveItems()
3684 
    return self.recv_getAllAliveItems()
3685 
 
3686 
  def send_getAllAliveItems(self, ):
3687 
    self._oprot.writeMessageBegin('getAllAliveItems', TMessageType.CALL, self._seqid)
3688 
    args = getAllAliveItems_args()
3689 
    args.write(self._oprot)
3690 
    self._oprot.writeMessageEnd()
3691 
    self._oprot.trans.flush()
3692 
 
3693 
  def recv_getAllAliveItems(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 = getAllAliveItems_result()
3701 
    result.read(self._iprot)
3702 
    self._iprot.readMessageEnd()
3703 
    if result.success is not None:
3704 
      return result.success
3705 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAliveItems failed: unknown result");
3706 
 
6921 anupam.sin 3707 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3708 
    """
3709 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 3710 
 
6805 anupam.sin 3711 
    Parameters:
3712 
     - itemId
6921 anupam.sin 3713 
     - price
6805 anupam.sin 3714 
     - insurerId
3715 
     - quantity
3716 
    """
6921 anupam.sin 3717 
    self.send_getInsuranceAmount(itemId, price, insurerId, quantity)
6805 anupam.sin 3718 
    return self.recv_getInsuranceAmount()
3719 
 
6921 anupam.sin 3720 
  def send_getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3721 
    self._oprot.writeMessageBegin('getInsuranceAmount', TMessageType.CALL, self._seqid)
3722 
    args = getInsuranceAmount_args()
3723 
    args.itemId = itemId
6921 anupam.sin 3724 
    args.price = price
6805 anupam.sin 3725 
    args.insurerId = insurerId
3726 
    args.quantity = quantity
3727 
    args.write(self._oprot)
3728 
    self._oprot.writeMessageEnd()
3729 
    self._oprot.trans.flush()
3730 
 
3731 
  def recv_getInsuranceAmount(self, ):
3732 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3733 
    if mtype == TMessageType.EXCEPTION:
3734 
      x = TApplicationException()
3735 
      x.read(self._iprot)
3736 
      self._iprot.readMessageEnd()
3737 
      raise x
3738 
    result = getInsuranceAmount_result()
3739 
    result.read(self._iprot)
3740 
    self._iprot.readMessageEnd()
3741 
    if result.success is not None:
3742 
      return result.success
3743 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsuranceAmount failed: unknown result");
3744 
 
3745 
  def getInsurer(self, insurerId):
3746 
    """
3747 
    Parameters:
3748 
     - insurerId
3749 
    """
3750 
    self.send_getInsurer(insurerId)
3751 
    return self.recv_getInsurer()
3752 
 
3753 
  def send_getInsurer(self, insurerId):
3754 
    self._oprot.writeMessageBegin('getInsurer', TMessageType.CALL, self._seqid)
3755 
    args = getInsurer_args()
3756 
    args.insurerId = insurerId
3757 
    args.write(self._oprot)
3758 
    self._oprot.writeMessageEnd()
3759 
    self._oprot.trans.flush()
3760 
 
3761 
  def recv_getInsurer(self, ):
3762 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3763 
    if mtype == TMessageType.EXCEPTION:
3764 
      x = TApplicationException()
3765 
      x.read(self._iprot)
3766 
      self._iprot.readMessageEnd()
3767 
      raise x
3768 
    result = getInsurer_result()
3769 
    result.read(self._iprot)
3770 
    self._iprot.readMessageEnd()
3771 
    if result.success is not None:
3772 
      return result.success
3773 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsurer failed: unknown result");
3774 
 
6838 vikram.rag 3775 
  def getAllInsurers(self, ):
3776 
    self.send_getAllInsurers()
3777 
    return self.recv_getAllInsurers()
6805 anupam.sin 3778 
 
6838 vikram.rag 3779 
  def send_getAllInsurers(self, ):
3780 
    self._oprot.writeMessageBegin('getAllInsurers', TMessageType.CALL, self._seqid)
3781 
    args = getAllInsurers_args()
3782 
    args.write(self._oprot)
3783 
    self._oprot.writeMessageEnd()
3784 
    self._oprot.trans.flush()
3785 
 
3786 
  def recv_getAllInsurers(self, ):
3787 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3788 
    if mtype == TMessageType.EXCEPTION:
3789 
      x = TApplicationException()
3790 
      x.read(self._iprot)
3791 
      self._iprot.readMessageEnd()
3792 
      raise x
3793 
    result = getAllInsurers_result()
3794 
    result.read(self._iprot)
3795 
    self._iprot.readMessageEnd()
3796 
    if result.success is not None:
3797 
      return result.success
3798 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllInsurers failed: unknown result");
3799 
 
6962 rajveer 3800 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
3801 
    """
3802 
    Parameters:
3803 
     - insurerId
3804 
     - amount
3805 
    """
3806 
    self.send_updateInsuranceDeclaredAmount(insurerId, amount)
3807 
    self.recv_updateInsuranceDeclaredAmount()
6838 vikram.rag 3808 
 
6962 rajveer 3809 
  def send_updateInsuranceDeclaredAmount(self, insurerId, amount):
3810 
    self._oprot.writeMessageBegin('updateInsuranceDeclaredAmount', TMessageType.CALL, self._seqid)
3811 
    args = updateInsuranceDeclaredAmount_args()
3812 
    args.insurerId = insurerId
3813 
    args.amount = amount
3814 
    args.write(self._oprot)
3815 
    self._oprot.writeMessageEnd()
3816 
    self._oprot.trans.flush()
3817 
 
3818 
  def recv_updateInsuranceDeclaredAmount(self, ):
3819 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3820 
    if mtype == TMessageType.EXCEPTION:
3821 
      x = TApplicationException()
3822 
      x.read(self._iprot)
3823 
      self._iprot.readMessageEnd()
3824 
      raise x
3825 
    result = updateInsuranceDeclaredAmount_result()
3826 
    result.read(self._iprot)
3827 
    self._iprot.readMessageEnd()
3828 
    return
3829 
 
7190 amar.kumar 3830 
  def getFreebieForItem(self, itemId):
3831 
    """
3832 
    Parameters:
3833 
     - itemId
3834 
    """
3835 
    self.send_getFreebieForItem(itemId)
3836 
    return self.recv_getFreebieForItem()
6962 rajveer 3837 
 
7190 amar.kumar 3838 
  def send_getFreebieForItem(self, itemId):
3839 
    self._oprot.writeMessageBegin('getFreebieForItem', TMessageType.CALL, self._seqid)
3840 
    args = getFreebieForItem_args()
3841 
    args.itemId = itemId
3842 
    args.write(self._oprot)
3843 
    self._oprot.writeMessageEnd()
3844 
    self._oprot.trans.flush()
3845 
 
3846 
  def recv_getFreebieForItem(self, ):
3847 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3848 
    if mtype == TMessageType.EXCEPTION:
3849 
      x = TApplicationException()
3850 
      x.read(self._iprot)
3851 
      self._iprot.readMessageEnd()
3852 
      raise x
3853 
    result = getFreebieForItem_result()
3854 
    result.read(self._iprot)
3855 
    self._iprot.readMessageEnd()
3856 
    if result.success is not None:
3857 
      return result.success
3858 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFreebieForItem failed: unknown result");
3859 
 
3860 
  def addOrUpdateFreebieForItem(self, freebieItem):
3861 
    """
3862 
    Parameters:
3863 
     - freebieItem
3864 
    """
3865 
    self.send_addOrUpdateFreebieForItem(freebieItem)
3866 
    self.recv_addOrUpdateFreebieForItem()
3867 
 
3868 
  def send_addOrUpdateFreebieForItem(self, freebieItem):
3869 
    self._oprot.writeMessageBegin('addOrUpdateFreebieForItem', TMessageType.CALL, self._seqid)
3870 
    args = addOrUpdateFreebieForItem_args()
3871 
    args.freebieItem = freebieItem
3872 
    args.write(self._oprot)
3873 
    self._oprot.writeMessageEnd()
3874 
    self._oprot.trans.flush()
3875 
 
3876 
  def recv_addOrUpdateFreebieForItem(self, ):
3877 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3878 
    if mtype == TMessageType.EXCEPTION:
3879 
      x = TApplicationException()
3880 
      x.read(self._iprot)
3881 
      self._iprot.readMessageEnd()
3882 
      raise x
3883 
    result = addOrUpdateFreebieForItem_result()
3884 
    result.read(self._iprot)
3885 
    self._iprot.readMessageEnd()
3886 
    return
3887 
 
7272 amit.gupta 3888 
  def addOrUpdateBrandInfo(self, brandInfo):
3889 
    """
3890 
    Parameters:
3891 
     - brandInfo
3892 
    """
3893 
    self.send_addOrUpdateBrandInfo(brandInfo)
3894 
    self.recv_addOrUpdateBrandInfo()
3895 
 
3896 
  def send_addOrUpdateBrandInfo(self, brandInfo):
3897 
    self._oprot.writeMessageBegin('addOrUpdateBrandInfo', TMessageType.CALL, self._seqid)
3898 
    args = addOrUpdateBrandInfo_args()
3899 
    args.brandInfo = brandInfo
3900 
    args.write(self._oprot)
3901 
    self._oprot.writeMessageEnd()
3902 
    self._oprot.trans.flush()
3903 
 
3904 
  def recv_addOrUpdateBrandInfo(self, ):
3905 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3906 
    if mtype == TMessageType.EXCEPTION:
3907 
      x = TApplicationException()
3908 
      x.read(self._iprot)
3909 
      self._iprot.readMessageEnd()
3910 
      raise x
3911 
    result = addOrUpdateBrandInfo_result()
3912 
    result.read(self._iprot)
3913 
    self._iprot.readMessageEnd()
3914 
    return
3915 
 
3916 
  def getBrandInfo(self, ):
3917 
    self.send_getBrandInfo()
3918 
    return self.recv_getBrandInfo()
3919 
 
3920 
  def send_getBrandInfo(self, ):
3921 
    self._oprot.writeMessageBegin('getBrandInfo', TMessageType.CALL, self._seqid)
3922 
    args = getBrandInfo_args()
3923 
    args.write(self._oprot)
3924 
    self._oprot.writeMessageEnd()
3925 
    self._oprot.trans.flush()
3926 
 
3927 
  def recv_getBrandInfo(self, ):
3928 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3929 
    if mtype == TMessageType.EXCEPTION:
3930 
      x = TApplicationException()
3931 
      x.read(self._iprot)
3932 
      self._iprot.readMessageEnd()
3933 
      raise x
3934 
    result = getBrandInfo_result()
3935 
    result.read(self._iprot)
3936 
    self._iprot.readMessageEnd()
3937 
    if result.success is not None:
3938 
      return result.success
3939 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrandInfo failed: unknown result");
3940 
 
7256 rajveer 3941 
  def getStorePricing(self, itemId):
3942 
    """
3943 
    Parameters:
3944 
     - itemId
3945 
    """
3946 
    self.send_getStorePricing(itemId)
3947 
    return self.recv_getStorePricing()
7190 amar.kumar 3948 
 
7256 rajveer 3949 
  def send_getStorePricing(self, itemId):
3950 
    self._oprot.writeMessageBegin('getStorePricing', TMessageType.CALL, self._seqid)
3951 
    args = getStorePricing_args()
3952 
    args.itemId = itemId
3953 
    args.write(self._oprot)
3954 
    self._oprot.writeMessageEnd()
3955 
    self._oprot.trans.flush()
3956 
 
3957 
  def recv_getStorePricing(self, ):
3958 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3959 
    if mtype == TMessageType.EXCEPTION:
3960 
      x = TApplicationException()
3961 
      x.read(self._iprot)
3962 
      self._iprot.readMessageEnd()
3963 
      raise x
3964 
    result = getStorePricing_result()
3965 
    result.read(self._iprot)
3966 
    self._iprot.readMessageEnd()
3967 
    if result.success is not None:
3968 
      return result.success
3969 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricing failed: unknown result");
3970 
 
7306 rajveer 3971 
  def getStorePricings(self, itemIds):
3972 
    """
3973 
    Parameters:
3974 
     - itemIds
3975 
    """
3976 
    self.send_getStorePricings(itemIds)
3977 
    return self.recv_getStorePricings()
3978 
 
3979 
  def send_getStorePricings(self, itemIds):
3980 
    self._oprot.writeMessageBegin('getStorePricings', TMessageType.CALL, self._seqid)
3981 
    args = getStorePricings_args()
3982 
    args.itemIds = itemIds
3983 
    args.write(self._oprot)
3984 
    self._oprot.writeMessageEnd()
3985 
    self._oprot.trans.flush()
3986 
 
3987 
  def recv_getStorePricings(self, ):
3988 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3989 
    if mtype == TMessageType.EXCEPTION:
3990 
      x = TApplicationException()
3991 
      x.read(self._iprot)
3992 
      self._iprot.readMessageEnd()
3993 
      raise x
3994 
    result = getStorePricings_result()
3995 
    result.read(self._iprot)
3996 
    self._iprot.readMessageEnd()
3997 
    if result.success is not None:
3998 
      return result.success
3999 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricings failed: unknown result");
4000 
 
7382 rajveer 4001 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 4002 
    """
4003 
    Parameters:
4004 
     - sp
7382 rajveer 4005 
     - allColors
7265 rajveer 4006 
    """
7382 rajveer 4007 
    self.send_updateStorePricing(sp, allColors)
7265 rajveer 4008 
    self.recv_updateStorePricing()
7256 rajveer 4009 
 
7382 rajveer 4010 
  def send_updateStorePricing(self, sp, allColors):
7265 rajveer 4011 
    self._oprot.writeMessageBegin('updateStorePricing', TMessageType.CALL, self._seqid)
4012 
    args = updateStorePricing_args()
4013 
    args.sp = sp
7382 rajveer 4014 
    args.allColors = allColors
7265 rajveer 4015 
    args.write(self._oprot)
4016 
    self._oprot.writeMessageEnd()
4017 
    self._oprot.trans.flush()
4018 
 
4019 
  def recv_updateStorePricing(self, ):
4020 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4021 
    if mtype == TMessageType.EXCEPTION:
4022 
      x = TApplicationException()
4023 
      x.read(self._iprot)
4024 
      self._iprot.readMessageEnd()
4025 
      raise x
4026 
    result = updateStorePricing_result()
4027 
    result.read(self._iprot)
4028 
    self._iprot.readMessageEnd()
4029 
    return
4030 
 
7281 kshitij.so 4031 
  def getAllAmazonListedItems(self, ):
4032 
    self.send_getAllAmazonListedItems()
4033 
    return self.recv_getAllAmazonListedItems()
7265 rajveer 4034 
 
7281 kshitij.so 4035 
  def send_getAllAmazonListedItems(self, ):
4036 
    self._oprot.writeMessageBegin('getAllAmazonListedItems', TMessageType.CALL, self._seqid)
4037 
    args = getAllAmazonListedItems_args()
4038 
    args.write(self._oprot)
4039 
    self._oprot.writeMessageEnd()
4040 
    self._oprot.trans.flush()
4041 
 
4042 
  def recv_getAllAmazonListedItems(self, ):
4043 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4044 
    if mtype == TMessageType.EXCEPTION:
4045 
      x = TApplicationException()
4046 
      x.read(self._iprot)
4047 
      self._iprot.readMessageEnd()
4048 
      raise x
4049 
    result = getAllAmazonListedItems_result()
4050 
    result.read(self._iprot)
4051 
    self._iprot.readMessageEnd()
4052 
    if result.success is not None:
4053 
      return result.success
4054 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonListedItems failed: unknown result");
4055 
 
8619 kshitij.so 4056 
  def searchAmazonItems(self, searchTerm, offset, limit):
4057 
    """
4058 
    Parameters:
4059 
     - searchTerm
4060 
     - offset
4061 
     - limit
4062 
    """
4063 
    self.send_searchAmazonItems(searchTerm, offset, limit)
4064 
    return self.recv_searchAmazonItems()
4065 
 
4066 
  def send_searchAmazonItems(self, searchTerm, offset, limit):
4067 
    self._oprot.writeMessageBegin('searchAmazonItems', TMessageType.CALL, self._seqid)
4068 
    args = searchAmazonItems_args()
4069 
    args.searchTerm = searchTerm
4070 
    args.offset = offset
4071 
    args.limit = limit
4072 
    args.write(self._oprot)
4073 
    self._oprot.writeMessageEnd()
4074 
    self._oprot.trans.flush()
4075 
 
4076 
  def recv_searchAmazonItems(self, ):
4077 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4078 
    if mtype == TMessageType.EXCEPTION:
4079 
      x = TApplicationException()
4080 
      x.read(self._iprot)
4081 
      self._iprot.readMessageEnd()
4082 
      raise x
4083 
    result = searchAmazonItems_result()
4084 
    result.read(self._iprot)
4085 
    self._iprot.readMessageEnd()
4086 
    if result.success is not None:
4087 
      return result.success
4088 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchAmazonItems failed: unknown result");
4089 
 
4090 
  def getAmazonSearchResultCount(self, searchTerm):
4091 
    """
4092 
    Parameters:
4093 
     - searchTerm
4094 
    """
4095 
    self.send_getAmazonSearchResultCount(searchTerm)
4096 
    return self.recv_getAmazonSearchResultCount()
4097 
 
4098 
  def send_getAmazonSearchResultCount(self, searchTerm):
4099 
    self._oprot.writeMessageBegin('getAmazonSearchResultCount', TMessageType.CALL, self._seqid)
4100 
    args = getAmazonSearchResultCount_args()
4101 
    args.searchTerm = searchTerm
4102 
    args.write(self._oprot)
4103 
    self._oprot.writeMessageEnd()
4104 
    self._oprot.trans.flush()
4105 
 
4106 
  def recv_getAmazonSearchResultCount(self, ):
4107 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4108 
    if mtype == TMessageType.EXCEPTION:
4109 
      x = TApplicationException()
4110 
      x.read(self._iprot)
4111 
      self._iprot.readMessageEnd()
4112 
      raise x
4113 
    result = getAmazonSearchResultCount_result()
4114 
    result.read(self._iprot)
4115 
    self._iprot.readMessageEnd()
4116 
    if result.success is not None:
4117 
      return result.success
4118 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonSearchResultCount failed: unknown result");
4119 
 
4120 
  def getCountForAmazonlistedItems(self, ):
4121 
    self.send_getCountForAmazonlistedItems()
4122 
    return self.recv_getCountForAmazonlistedItems()
4123 
 
4124 
  def send_getCountForAmazonlistedItems(self, ):
4125 
    self._oprot.writeMessageBegin('getCountForAmazonlistedItems', TMessageType.CALL, self._seqid)
4126 
    args = getCountForAmazonlistedItems_args()
4127 
    args.write(self._oprot)
4128 
    self._oprot.writeMessageEnd()
4129 
    self._oprot.trans.flush()
4130 
 
4131 
  def recv_getCountForAmazonlistedItems(self, ):
4132 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4133 
    if mtype == TMessageType.EXCEPTION:
4134 
      x = TApplicationException()
4135 
      x.read(self._iprot)
4136 
      self._iprot.readMessageEnd()
4137 
      raise x
4138 
    result = getCountForAmazonlistedItems_result()
4139 
    result.read(self._iprot)
4140 
    self._iprot.readMessageEnd()
4141 
    if result.success is not None:
4142 
      return result.success
4143 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForAmazonlistedItems failed: unknown result");
4144 
 
7281 kshitij.so 4145 
  def getAmazonItemDetails(self, itemId):
4146 
    """
4147 
    Parameters:
4148 
     - itemId
4149 
    """
4150 
    self.send_getAmazonItemDetails(itemId)
4151 
    return self.recv_getAmazonItemDetails()
4152 
 
4153 
  def send_getAmazonItemDetails(self, itemId):
4154 
    self._oprot.writeMessageBegin('getAmazonItemDetails', TMessageType.CALL, self._seqid)
4155 
    args = getAmazonItemDetails_args()
4156 
    args.itemId = itemId
4157 
    args.write(self._oprot)
4158 
    self._oprot.writeMessageEnd()
4159 
    self._oprot.trans.flush()
4160 
 
4161 
  def recv_getAmazonItemDetails(self, ):
4162 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4163 
    if mtype == TMessageType.EXCEPTION:
4164 
      x = TApplicationException()
4165 
      x.read(self._iprot)
4166 
      self._iprot.readMessageEnd()
4167 
      raise x
4168 
    result = getAmazonItemDetails_result()
4169 
    result.read(self._iprot)
4170 
    self._iprot.readMessageEnd()
4171 
    if result.success is not None:
4172 
      return result.success
4173 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonItemDetails failed: unknown result");
4174 
 
8168 kshitij.so 4175 
  def updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4176 
    """
4177 
    Parameters:
8168 kshitij.so 4178 
     - amazonlisted
7281 kshitij.so 4179 
    """
8168 kshitij.so 4180 
    self.send_updateAmazonItemDetails(amazonlisted)
7281 kshitij.so 4181 
    self.recv_updateAmazonItemDetails()
4182 
 
8168 kshitij.so 4183 
  def send_updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4184 
    self._oprot.writeMessageBegin('updateAmazonItemDetails', TMessageType.CALL, self._seqid)
4185 
    args = updateAmazonItemDetails_args()
8168 kshitij.so 4186 
    args.amazonlisted = amazonlisted
7281 kshitij.so 4187 
    args.write(self._oprot)
4188 
    self._oprot.writeMessageEnd()
4189 
    self._oprot.trans.flush()
4190 
 
4191 
  def recv_updateAmazonItemDetails(self, ):
4192 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4193 
    if mtype == TMessageType.EXCEPTION:
4194 
      x = TApplicationException()
4195 
      x.read(self._iprot)
4196 
      self._iprot.readMessageEnd()
4197 
      raise x
4198 
    result = updateAmazonItemDetails_result()
4199 
    result.read(self._iprot)
4200 
    self._iprot.readMessageEnd()
4201 
    return
4202 
 
4203 
  def addAmazonItem(self, amazonlisted):
4204 
    """
4205 
    Parameters:
4206 
     - amazonlisted
4207 
    """
4208 
    self.send_addAmazonItem(amazonlisted)
4209 
    self.recv_addAmazonItem()
4210 
 
4211 
  def send_addAmazonItem(self, amazonlisted):
4212 
    self._oprot.writeMessageBegin('addAmazonItem', TMessageType.CALL, self._seqid)
4213 
    args = addAmazonItem_args()
4214 
    args.amazonlisted = amazonlisted
4215 
    args.write(self._oprot)
4216 
    self._oprot.writeMessageEnd()
4217 
    self._oprot.trans.flush()
4218 
 
4219 
  def recv_addAmazonItem(self, ):
4220 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4221 
    if mtype == TMessageType.EXCEPTION:
4222 
      x = TApplicationException()
4223 
      x.read(self._iprot)
4224 
      self._iprot.readMessageEnd()
4225 
      raise x
4226 
    result = addAmazonItem_result()
4227 
    result.read(self._iprot)
4228 
    self._iprot.readMessageEnd()
4229 
    return
4230 
 
7291 vikram.rag 4231 
  def getAsinItems(self, ):
4232 
    self.send_getAsinItems()
4233 
    return self.recv_getAsinItems()
7281 kshitij.so 4234 
 
7291 vikram.rag 4235 
  def send_getAsinItems(self, ):
4236 
    self._oprot.writeMessageBegin('getAsinItems', TMessageType.CALL, self._seqid)
4237 
    args = getAsinItems_args()
4238 
    args.write(self._oprot)
4239 
    self._oprot.writeMessageEnd()
4240 
    self._oprot.trans.flush()
4241 
 
4242 
  def recv_getAsinItems(self, ):
4243 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4244 
    if mtype == TMessageType.EXCEPTION:
4245 
      x = TApplicationException()
4246 
      x.read(self._iprot)
4247 
      self._iprot.readMessageEnd()
4248 
      raise x
4249 
    result = getAsinItems_result()
4250 
    result.read(self._iprot)
4251 
    self._iprot.readMessageEnd()
4252 
    if result.success is not None:
4253 
      return result.success
4254 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAsinItems failed: unknown result");
4255 
 
4256 
  def getAllFbaListedItems(self, ):
4257 
    self.send_getAllFbaListedItems()
4258 
    return self.recv_getAllFbaListedItems()
4259 
 
4260 
  def send_getAllFbaListedItems(self, ):
4261 
    self._oprot.writeMessageBegin('getAllFbaListedItems', TMessageType.CALL, self._seqid)
4262 
    args = getAllFbaListedItems_args()
4263 
    args.write(self._oprot)
4264 
    self._oprot.writeMessageEnd()
4265 
    self._oprot.trans.flush()
4266 
 
4267 
  def recv_getAllFbaListedItems(self, ):
4268 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4269 
    if mtype == TMessageType.EXCEPTION:
4270 
      x = TApplicationException()
4271 
      x.read(self._iprot)
4272 
      self._iprot.readMessageEnd()
4273 
      raise x
4274 
    result = getAllFbaListedItems_result()
4275 
    result.read(self._iprot)
4276 
    self._iprot.readMessageEnd()
4277 
    if result.success is not None:
4278 
      return result.success
4279 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbaListedItems failed: unknown result");
4280 
 
4281 
  def getAllNonFbaListedItems(self, ):
4282 
    self.send_getAllNonFbaListedItems()
4283 
    return self.recv_getAllNonFbaListedItems()
4284 
 
4285 
  def send_getAllNonFbaListedItems(self, ):
4286 
    self._oprot.writeMessageBegin('getAllNonFbaListedItems', TMessageType.CALL, self._seqid)
4287 
    args = getAllNonFbaListedItems_args()
4288 
    args.write(self._oprot)
4289 
    self._oprot.writeMessageEnd()
4290 
    self._oprot.trans.flush()
4291 
 
4292 
  def recv_getAllNonFbaListedItems(self, ):
4293 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4294 
    if mtype == TMessageType.EXCEPTION:
4295 
      x = TApplicationException()
4296 
      x.read(self._iprot)
4297 
      self._iprot.readMessageEnd()
4298 
      raise x
4299 
    result = getAllNonFbaListedItems_result()
4300 
    result.read(self._iprot)
4301 
    self._iprot.readMessageEnd()
4302 
    if result.success is not None:
4303 
      return result.success
4304 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllNonFbaListedItems failed: unknown result");
4305 
 
7460 kshitij.so 4306 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
4307 
    """
4308 
    Parameters:
4309 
     - itemId
4310 
     - holdInventory
4311 
     - defaultInventory
4312 
    """
4313 
    self.send_updateItemInventory(itemId, holdInventory, defaultInventory)
4314 
    return self.recv_updateItemInventory()
7291 vikram.rag 4315 
 
7460 kshitij.so 4316 
  def send_updateItemInventory(self, itemId, holdInventory, defaultInventory):
4317 
    self._oprot.writeMessageBegin('updateItemInventory', TMessageType.CALL, self._seqid)
4318 
    args = updateItemInventory_args()
4319 
    args.itemId = itemId
4320 
    args.holdInventory = holdInventory
4321 
    args.defaultInventory = defaultInventory
4322 
    args.write(self._oprot)
4323 
    self._oprot.writeMessageEnd()
4324 
    self._oprot.trans.flush()
4325 
 
4326 
  def recv_updateItemInventory(self, ):
4327 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4328 
    if mtype == TMessageType.EXCEPTION:
4329 
      x = TApplicationException()
4330 
      x.read(self._iprot)
4331 
      self._iprot.readMessageEnd()
4332 
      raise x
4333 
    result = updateItemInventory_result()
4334 
    result.read(self._iprot)
4335 
    self._iprot.readMessageEnd()
4336 
    if result.success is not None:
4337 
      return result.success
4338 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItemInventory failed: unknown result");
4339 
 
7770 kshitij.so 4340 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4341 
    """
4342 
    Parameters:
4343 
     - type
4344 
     - sku
4345 
     - timestamp
4346 
    """
4347 
    self.send_updateTimestampForAmazonFeeds(type, sku, timestamp)
4348 
    return self.recv_updateTimestampForAmazonFeeds()
7460 kshitij.so 4349 
 
7770 kshitij.so 4350 
  def send_updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4351 
    self._oprot.writeMessageBegin('updateTimestampForAmazonFeeds', TMessageType.CALL, self._seqid)
4352 
    args = updateTimestampForAmazonFeeds_args()
4353 
    args.type = type
4354 
    args.sku = sku
4355 
    args.timestamp = timestamp
4356 
    args.write(self._oprot)
4357 
    self._oprot.writeMessageEnd()
4358 
    self._oprot.trans.flush()
4359 
 
4360 
  def recv_updateTimestampForAmazonFeeds(self, ):
4361 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4362 
    if mtype == TMessageType.EXCEPTION:
4363 
      x = TApplicationException()
4364 
      x.read(self._iprot)
4365 
      self._iprot.readMessageEnd()
4366 
      raise x
4367 
    result = updateTimestampForAmazonFeeds_result()
4368 
    result.read(self._iprot)
4369 
    self._iprot.readMessageEnd()
4370 
    if result.success is not None:
4371 
      return result.success
4372 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateTimestampForAmazonFeeds failed: unknown result");
4373 
 
7897 amar.kumar 4374 
  def getAllParentCategories(self, ):
4375 
    self.send_getAllParentCategories()
4376 
    return self.recv_getAllParentCategories()
7770 kshitij.so 4377 
 
7897 amar.kumar 4378 
  def send_getAllParentCategories(self, ):
4379 
    self._oprot.writeMessageBegin('getAllParentCategories', TMessageType.CALL, self._seqid)
4380 
    args = getAllParentCategories_args()
4381 
    args.write(self._oprot)
4382 
    self._oprot.writeMessageEnd()
4383 
    self._oprot.trans.flush()
4384 
 
4385 
  def recv_getAllParentCategories(self, ):
4386 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4387 
    if mtype == TMessageType.EXCEPTION:
4388 
      x = TApplicationException()
4389 
      x.read(self._iprot)
4390 
      self._iprot.readMessageEnd()
4391 
      raise x
4392 
    result = getAllParentCategories_result()
4393 
    result.read(self._iprot)
4394 
    self._iprot.readMessageEnd()
4395 
    if result.success is not None:
4396 
      return result.success
4397 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllParentCategories failed: unknown result");
4398 
 
7977 kshitij.so 4399 
  def addPageViewEvent(self, pageViewEvents):
4400 
    """
4401 
    Parameters:
4402 
     - pageViewEvents
4403 
    """
4404 
    self.send_addPageViewEvent(pageViewEvents)
4405 
    self.recv_addPageViewEvent()
7897 amar.kumar 4406 
 
7977 kshitij.so 4407 
  def send_addPageViewEvent(self, pageViewEvents):
4408 
    self._oprot.writeMessageBegin('addPageViewEvent', TMessageType.CALL, self._seqid)
4409 
    args = addPageViewEvent_args()
4410 
    args.pageViewEvents = pageViewEvents
4411 
    args.write(self._oprot)
4412 
    self._oprot.writeMessageEnd()
4413 
    self._oprot.trans.flush()
4414 
 
4415 
  def recv_addPageViewEvent(self, ):
4416 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4417 
    if mtype == TMessageType.EXCEPTION:
4418 
      x = TApplicationException()
4419 
      x.read(self._iprot)
4420 
      self._iprot.readMessageEnd()
4421 
      raise x
4422 
    result = addPageViewEvent_result()
4423 
    result.read(self._iprot)
4424 
    self._iprot.readMessageEnd()
4425 
    return
4426 
 
4427 
  def addCartEvent(self, cartEvents):
4428 
    """
4429 
    Parameters:
4430 
     - cartEvents
4431 
    """
4432 
    self.send_addCartEvent(cartEvents)
4433 
    self.recv_addCartEvent()
4434 
 
4435 
  def send_addCartEvent(self, cartEvents):
4436 
    self._oprot.writeMessageBegin('addCartEvent', TMessageType.CALL, self._seqid)
4437 
    args = addCartEvent_args()
4438 
    args.cartEvents = cartEvents
4439 
    args.write(self._oprot)
4440 
    self._oprot.writeMessageEnd()
4441 
    self._oprot.trans.flush()
4442 
 
4443 
  def recv_addCartEvent(self, ):
4444 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4445 
    if mtype == TMessageType.EXCEPTION:
4446 
      x = TApplicationException()
4447 
      x.read(self._iprot)
4448 
      self._iprot.readMessageEnd()
4449 
      raise x
4450 
    result = addCartEvent_result()
4451 
    result.read(self._iprot)
4452 
    self._iprot.readMessageEnd()
4453 
    return
4454 
 
8182 amar.kumar 4455 
  def addEbayItem(self, ebayItem):
4456 
    """
4457 
    Parameters:
4458 
     - ebayItem
4459 
    """
4460 
    self.send_addEbayItem(ebayItem)
4461 
    self.recv_addEbayItem()
4462 
 
4463 
  def send_addEbayItem(self, ebayItem):
4464 
    self._oprot.writeMessageBegin('addEbayItem', TMessageType.CALL, self._seqid)
4465 
    args = addEbayItem_args()
4466 
    args.ebayItem = ebayItem
4467 
    args.write(self._oprot)
4468 
    self._oprot.writeMessageEnd()
4469 
    self._oprot.trans.flush()
4470 
 
4471 
  def recv_addEbayItem(self, ):
4472 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4473 
    if mtype == TMessageType.EXCEPTION:
4474 
      x = TApplicationException()
4475 
      x.read(self._iprot)
4476 
      self._iprot.readMessageEnd()
4477 
      raise x
4478 
    result = addEbayItem_result()
4479 
    result.read(self._iprot)
4480 
    self._iprot.readMessageEnd()
4481 
    return
4482 
 
4483 
  def getEbayItem(self, listingId):
4484 
    """
4485 
    Parameters:
4486 
     - listingId
4487 
    """
4488 
    self.send_getEbayItem(listingId)
4489 
    return self.recv_getEbayItem()
4490 
 
4491 
  def send_getEbayItem(self, listingId):
4492 
    self._oprot.writeMessageBegin('getEbayItem', TMessageType.CALL, self._seqid)
4493 
    args = getEbayItem_args()
4494 
    args.listingId = listingId
4495 
    args.write(self._oprot)
4496 
    self._oprot.writeMessageEnd()
4497 
    self._oprot.trans.flush()
4498 
 
4499 
  def recv_getEbayItem(self, ):
4500 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4501 
    if mtype == TMessageType.EXCEPTION:
4502 
      x = TApplicationException()
4503 
      x.read(self._iprot)
4504 
      self._iprot.readMessageEnd()
4505 
      raise x
4506 
    result = getEbayItem_result()
4507 
    result.read(self._iprot)
4508 
    self._iprot.readMessageEnd()
4509 
    if result.success is not None:
4510 
      return result.success
4511 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEbayItem failed: unknown result");
4512 
 
4513 
  def updateEbayItem(self, ebayItem):
4514 
    """
4515 
    Parameters:
4516 
     - ebayItem
4517 
    """
4518 
    self.send_updateEbayItem(ebayItem)
4519 
    self.recv_updateEbayItem()
4520 
 
4521 
  def send_updateEbayItem(self, ebayItem):
4522 
    self._oprot.writeMessageBegin('updateEbayItem', TMessageType.CALL, self._seqid)
4523 
    args = updateEbayItem_args()
4524 
    args.ebayItem = ebayItem
4525 
    args.write(self._oprot)
4526 
    self._oprot.writeMessageEnd()
4527 
    self._oprot.trans.flush()
4528 
 
4529 
  def recv_updateEbayItem(self, ):
4530 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4531 
    if mtype == TMessageType.EXCEPTION:
4532 
      x = TApplicationException()
4533 
      x.read(self._iprot)
4534 
      self._iprot.readMessageEnd()
4535 
      raise x
4536 
    result = updateEbayItem_result()
4537 
    result.read(self._iprot)
4538 
    self._iprot.readMessageEnd()
4539 
    return
4540 
 
8139 kshitij.so 4541 
  def getAmazonListedItems(self, offset, limit):
4542 
    """
4543 
    Parameters:
4544 
     - offset
4545 
     - limit
4546 
    """
4547 
    self.send_getAmazonListedItems(offset, limit)
4548 
    return self.recv_getAmazonListedItems()
7977 kshitij.so 4549 
 
8139 kshitij.so 4550 
  def send_getAmazonListedItems(self, offset, limit):
4551 
    self._oprot.writeMessageBegin('getAmazonListedItems', TMessageType.CALL, self._seqid)
4552 
    args = getAmazonListedItems_args()
4553 
    args.offset = offset
4554 
    args.limit = limit
4555 
    args.write(self._oprot)
4556 
    self._oprot.writeMessageEnd()
4557 
    self._oprot.trans.flush()
4558 
 
4559 
  def recv_getAmazonListedItems(self, ):
4560 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4561 
    if mtype == TMessageType.EXCEPTION:
4562 
      x = TApplicationException()
4563 
      x.read(self._iprot)
4564 
      self._iprot.readMessageEnd()
4565 
      raise x
4566 
    result = getAmazonListedItems_result()
4567 
    result.read(self._iprot)
4568 
    self._iprot.readMessageEnd()
4569 
    if result.success is not None:
4570 
      return result.success
4571 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonListedItems failed: unknown result");
4572 
 
8168 kshitij.so 4573 
  def updateAmazonAttributesInBulk(self, amazonlisted):
4574 
    """
4575 
    Parameters:
4576 
     - amazonlisted
4577 
    """
4578 
    self.send_updateAmazonAttributesInBulk(amazonlisted)
4579 
    return self.recv_updateAmazonAttributesInBulk()
8139 kshitij.so 4580 
 
8168 kshitij.so 4581 
  def send_updateAmazonAttributesInBulk(self, amazonlisted):
4582 
    self._oprot.writeMessageBegin('updateAmazonAttributesInBulk', TMessageType.CALL, self._seqid)
4583 
    args = updateAmazonAttributesInBulk_args()
4584 
    args.amazonlisted = amazonlisted
4585 
    args.write(self._oprot)
4586 
    self._oprot.writeMessageEnd()
4587 
    self._oprot.trans.flush()
4588 
 
4589 
  def recv_updateAmazonAttributesInBulk(self, ):
4590 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4591 
    if mtype == TMessageType.EXCEPTION:
4592 
      x = TApplicationException()
4593 
      x.read(self._iprot)
4594 
      self._iprot.readMessageEnd()
4595 
      raise x
4596 
    result = updateAmazonAttributesInBulk_result()
4597 
    result.read(self._iprot)
4598 
    self._iprot.readMessageEnd()
4599 
    if result.success is not None:
4600 
      return result.success
4601 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateAmazonAttributesInBulk failed: unknown result");
4602 
 
8379 vikram.rag 4603 
  def getAllItemstoListOnFba(self, ):
4604 
    self.send_getAllItemstoListOnFba()
4605 
    return self.recv_getAllItemstoListOnFba()
8168 kshitij.so 4606 
 
8379 vikram.rag 4607 
  def send_getAllItemstoListOnFba(self, ):
4608 
    self._oprot.writeMessageBegin('getAllItemstoListOnFba', TMessageType.CALL, self._seqid)
4609 
    args = getAllItemstoListOnFba_args()
4610 
    args.write(self._oprot)
4611 
    self._oprot.writeMessageEnd()
4612 
    self._oprot.trans.flush()
4613 
 
4614 
  def recv_getAllItemstoListOnFba(self, ):
4615 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4616 
    if mtype == TMessageType.EXCEPTION:
4617 
      x = TApplicationException()
4618 
      x.read(self._iprot)
4619 
      self._iprot.readMessageEnd()
4620 
      raise x
4621 
    result = getAllItemstoListOnFba_result()
4622 
    result.read(self._iprot)
4623 
    self._iprot.readMessageEnd()
4624 
    if result.success is not None:
4625 
      return result.success
4626 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnFba failed: unknown result");
4627 
 
4628 
  def getAllItemstoListOnNonFba(self, ):
4629 
    self.send_getAllItemstoListOnNonFba()
4630 
    return self.recv_getAllItemstoListOnNonFba()
4631 
 
4632 
  def send_getAllItemstoListOnNonFba(self, ):
4633 
    self._oprot.writeMessageBegin('getAllItemstoListOnNonFba', TMessageType.CALL, self._seqid)
4634 
    args = getAllItemstoListOnNonFba_args()
4635 
    args.write(self._oprot)
4636 
    self._oprot.writeMessageEnd()
4637 
    self._oprot.trans.flush()
4638 
 
4639 
  def recv_getAllItemstoListOnNonFba(self, ):
4640 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4641 
    if mtype == TMessageType.EXCEPTION:
4642 
      x = TApplicationException()
4643 
      x.read(self._iprot)
4644 
      self._iprot.readMessageEnd()
4645 
      raise x
4646 
    result = getAllItemstoListOnNonFba_result()
4647 
    result.read(self._iprot)
4648 
    self._iprot.readMessageEnd()
4649 
    if result.success is not None:
4650 
      return result.success
4651 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnNonFba failed: unknown result");
4652 
 
8616 vikram.rag 4653 
  def getAllSnapdealListedActiveItems(self, ):
4654 
    self.send_getAllSnapdealListedActiveItems()
4655 
    return self.recv_getAllSnapdealListedActiveItems()
8379 vikram.rag 4656 
 
8616 vikram.rag 4657 
  def send_getAllSnapdealListedActiveItems(self, ):
4658 
    self._oprot.writeMessageBegin('getAllSnapdealListedActiveItems', TMessageType.CALL, self._seqid)
4659 
    args = getAllSnapdealListedActiveItems_args()
4660 
    args.write(self._oprot)
4661 
    self._oprot.writeMessageEnd()
4662 
    self._oprot.trans.flush()
4663 
 
4664 
  def recv_getAllSnapdealListedActiveItems(self, ):
4665 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4666 
    if mtype == TMessageType.EXCEPTION:
4667 
      x = TApplicationException()
4668 
      x.read(self._iprot)
4669 
      self._iprot.readMessageEnd()
4670 
      raise x
4671 
    result = getAllSnapdealListedActiveItems_result()
4672 
    result.read(self._iprot)
4673 
    self._iprot.readMessageEnd()
4674 
    if result.success is not None:
4675 
      return result.success
4676 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSnapdealListedActiveItems failed: unknown result");
4677 
 
8619 kshitij.so 4678 
  def updateAsin(self, item):
4679 
    """
4680 
    Parameters:
4681 
     - item
4682 
    """
4683 
    self.send_updateAsin(item)
4684 
    self.recv_updateAsin()
8616 vikram.rag 4685 
 
8619 kshitij.so 4686 
  def send_updateAsin(self, item):
4687 
    self._oprot.writeMessageBegin('updateAsin', TMessageType.CALL, self._seqid)
4688 
    args = updateAsin_args()
4689 
    args.item = item
4690 
    args.write(self._oprot)
4691 
    self._oprot.writeMessageEnd()
4692 
    self._oprot.trans.flush()
4693 
 
4694 
  def recv_updateAsin(self, ):
4695 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4696 
    if mtype == TMessageType.EXCEPTION:
4697 
      x = TApplicationException()
4698 
      x.read(self._iprot)
4699 
      self._iprot.readMessageEnd()
4700 
      raise x
4701 
    result = updateAsin_result()
4702 
    result.read(self._iprot)
4703 
    self._iprot.readMessageEnd()
4704 
    return
4705 
 
8739 vikram.rag 4706 
  def addOrUpdateSnapdealItem(self, snapdealitem):
4707 
    """
4708 
    Parameters:
4709 
     - snapdealitem
4710 
    """
4711 
    self.send_addOrUpdateSnapdealItem(snapdealitem)
4712 
    return self.recv_addOrUpdateSnapdealItem()
8619 kshitij.so 4713 
 
8739 vikram.rag 4714 
  def send_addOrUpdateSnapdealItem(self, snapdealitem):
4715 
    self._oprot.writeMessageBegin('addOrUpdateSnapdealItem', TMessageType.CALL, self._seqid)
4716 
    args = addOrUpdateSnapdealItem_args()
4717 
    args.snapdealitem = snapdealitem
4718 
    args.write(self._oprot)
4719 
    self._oprot.writeMessageEnd()
4720 
    self._oprot.trans.flush()
4721 
 
4722 
  def recv_addOrUpdateSnapdealItem(self, ):
4723 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4724 
    if mtype == TMessageType.EXCEPTION:
4725 
      x = TApplicationException()
4726 
      x.read(self._iprot)
4727 
      self._iprot.readMessageEnd()
4728 
      raise x
4729 
    result = addOrUpdateSnapdealItem_result()
4730 
    result.read(self._iprot)
4731 
    self._iprot.readMessageEnd()
4732 
    if result.success is not None:
4733 
      return result.success
4734 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addOrUpdateSnapdealItem failed: unknown result");
4735 
 
4736 
  def getSnapdealItem(self, item_id):
4737 
    """
4738 
    Parameters:
4739 
     - item_id
4740 
    """
4741 
    self.send_getSnapdealItem(item_id)
4742 
    return self.recv_getSnapdealItem()
4743 
 
4744 
  def send_getSnapdealItem(self, item_id):
4745 
    self._oprot.writeMessageBegin('getSnapdealItem', TMessageType.CALL, self._seqid)
4746 
    args = getSnapdealItem_args()
4747 
    args.item_id = item_id
4748 
    args.write(self._oprot)
4749 
    self._oprot.writeMessageEnd()
4750 
    self._oprot.trans.flush()
4751 
 
4752 
  def recv_getSnapdealItem(self, ):
4753 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4754 
    if mtype == TMessageType.EXCEPTION:
4755 
      x = TApplicationException()
4756 
      x.read(self._iprot)
4757 
      self._iprot.readMessageEnd()
4758 
      raise x
4759 
    result = getSnapdealItem_result()
4760 
    result.read(self._iprot)
4761 
    self._iprot.readMessageEnd()
4762 
    if result.success is not None:
4763 
      return result.success
4764 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItem failed: unknown result");
4765 
 
4766 
  def getAllSnapdealItems(self, ):
4767 
    self.send_getAllSnapdealItems()
4768 
    return self.recv_getAllSnapdealItems()
4769 
 
4770 
  def send_getAllSnapdealItems(self, ):
4771 
    self._oprot.writeMessageBegin('getAllSnapdealItems', TMessageType.CALL, self._seqid)
4772 
    args = getAllSnapdealItems_args()
4773 
    args.write(self._oprot)
4774 
    self._oprot.writeMessageEnd()
4775 
    self._oprot.trans.flush()
4776 
 
4777 
  def recv_getAllSnapdealItems(self, ):
4778 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4779 
    if mtype == TMessageType.EXCEPTION:
4780 
      x = TApplicationException()
4781 
      x.read(self._iprot)
4782 
      self._iprot.readMessageEnd()
4783 
      raise x
4784 
    result = getAllSnapdealItems_result()
4785 
    result.read(self._iprot)
4786 
    self._iprot.readMessageEnd()
4787 
    if result.success is not None:
4788 
      return result.success
4789 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSnapdealItems failed: unknown result");
4790 
 
4791 
 
5944 mandeep.dh 4792 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
4793 
  def __init__(self, handler):
4794 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
4795 
    self._processMap["addItem"] = Processor.process_addItem
4796 
    self._processMap["updateItem"] = Processor.process_updateItem
4797 
    self._processMap["isActive"] = Processor.process_isActive
7438 amit.gupta 4798 
    self._processMap["getItemsStatus"] = Processor.process_getItemsStatus
5944 mandeep.dh 4799 
    self._processMap["getItemStatusDescription"] = Processor.process_getItemStatusDescription
4800 
    self._processMap["startItemOn"] = Processor.process_startItemOn
4801 
    self._processMap["retireItemOn"] = Processor.process_retireItemOn
4802 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
4803 
    self._processMap["getItem"] = Processor.process_getItem
4804 
    self._processMap["getItemsByCatalogId"] = Processor.process_getItemsByCatalogId
4805 
    self._processMap["getValidItemsByCatalogId"] = Processor.process_getValidItemsByCatalogId
4806 
    self._processMap["getAllItems"] = Processor.process_getAllItems
4807 
    self._processMap["getAllItemsByStatus"] = Processor.process_getAllItemsByStatus
4808 
    self._processMap["markItemAsContentComplete"] = Processor.process_markItemAsContentComplete
4809 
    self._processMap["getAllItemsInRange"] = Processor.process_getAllItemsInRange
4810 
    self._processMap["getAllItemsByStatusInRange"] = Processor.process_getAllItemsByStatusInRange
4811 
    self._processMap["getItemCountByStatus"] = Processor.process_getItemCountByStatus
4812 
    self._processMap["getBestSellers"] = Processor.process_getBestSellers
4813 
    self._processMap["getBestSellersCatalogIds"] = Processor.process_getBestSellersCatalogIds
4814 
    self._processMap["getBestSellersCount"] = Processor.process_getBestSellersCount
4815 
    self._processMap["getBestDeals"] = Processor.process_getBestDeals
4816 
    self._processMap["getBestDealsCatalogIds"] = Processor.process_getBestDealsCatalogIds
4817 
    self._processMap["getBestDealsCount"] = Processor.process_getBestDealsCount
4818 
    self._processMap["getComingSoon"] = Processor.process_getComingSoon
4819 
    self._processMap["getComingSoonCatalogIds"] = Processor.process_getComingSoonCatalogIds
4820 
    self._processMap["getComingSoonCount"] = Processor.process_getComingSoonCount
4821 
    self._processMap["getLatestArrivals"] = Processor.process_getLatestArrivals
4822 
    self._processMap["getLatestArrivalsCatalogIds"] = Processor.process_getLatestArrivalsCatalogIds
4823 
    self._processMap["getLatestArrivalsCount"] = Processor.process_getLatestArrivalsCount
4824 
    self._processMap["generateNewEntityID"] = Processor.process_generateNewEntityID
4825 
    self._processMap["addCategory"] = Processor.process_addCategory
4826 
    self._processMap["getCategory"] = Processor.process_getCategory
4827 
    self._processMap["getAllCategories"] = Processor.process_getAllCategories
4828 
    self._processMap["getAllSimilarItems"] = Processor.process_getAllSimilarItems
4829 
    self._processMap["addSimilarItem"] = Processor.process_addSimilarItem
6512 kshitij.so 4830 
    self._processMap["addTag"] = Processor.process_addTag
4831 
    self._processMap["deleteEntityTag"] = Processor.process_deleteEntityTag
4832 
    self._processMap["deleteTag"] = Processor.process_deleteTag
4833 
    self._processMap["getAllTags"] = Processor.process_getAllTags
4834 
    self._processMap["getAllEntitiesByTagName"] = Processor.process_getAllEntitiesByTagName
6845 amit.gupta 4835 
    self._processMap["getAllEntityTags"] = Processor.process_getAllEntityTags
6850 kshitij.so 4836 
    self._processMap["addBanner"] = Processor.process_addBanner
8579 kshitij.so 4837 
    self._processMap["updateBanner"] = Processor.process_updateBanner
6850 kshitij.so 4838 
    self._processMap["getAllBanners"] = Processor.process_getAllBanners
4839 
    self._processMap["deleteBanner"] = Processor.process_deleteBanner
4840 
    self._processMap["getBannerDetails"] = Processor.process_getBannerDetails
4841 
    self._processMap["getActiveBanners"] = Processor.process_getActiveBanners
6849 kshitij.so 4842 
    self._processMap["addBannerMap"] = Processor.process_addBannerMap
8579 kshitij.so 4843 
    self._processMap["updateBannerMap"] = Processor.process_updateBannerMap
6849 kshitij.so 4844 
    self._processMap["deleteBannerMap"] = Processor.process_deleteBannerMap
4845 
    self._processMap["getBannerMapDetails"] = Processor.process_getBannerMapDetails
8579 kshitij.so 4846 
    self._processMap["addBannerUri"] = Processor.process_addBannerUri
4847 
    self._processMap["getUriMapping"] = Processor.process_getUriMapping
4848 
    self._processMap["addCampaign"] = Processor.process_addCampaign
4849 
    self._processMap["getCampaigns"] = Processor.process_getCampaigns
4850 
    self._processMap["deleteCampaign"] = Processor.process_deleteCampaign
4851 
    self._processMap["getAllCampaigns"] = Processor.process_getAllCampaigns
9155 kshitij.so 4852 
    self._processMap["getActiveBannersForMobileSite"] = Processor.process_getActiveBannersForMobileSite
5944 mandeep.dh 4853 
    self._processMap["deleteSimilarItem"] = Processor.process_deleteSimilarItem
4854 
    self._processMap["checkSimilarItem"] = Processor.process_checkSimilarItem
4855 
    self._processMap["validateRiskyStatus"] = Processor.process_validateRiskyStatus
4856 
    self._processMap["changeItemRiskyFlag"] = Processor.process_changeItemRiskyFlag
4857 
    self._processMap["getItemsByRiskyFlag"] = Processor.process_getItemsByRiskyFlag
4858 
    self._processMap["getItemsForMasterSheet"] = Processor.process_getItemsForMasterSheet
4859 
    self._processMap["getSimilarItemsCatalogIds"] = Processor.process_getSimilarItemsCatalogIds
4860 
    self._processMap["addProductNotification"] = Processor.process_addProductNotification
4861 
    self._processMap["sendProductNotifications"] = Processor.process_sendProductNotifications
4862 
    self._processMap["getAllBrandsByCategory"] = Processor.process_getAllBrandsByCategory
4863 
    self._processMap["getAllBrands"] = Processor.process_getAllBrands
4864 
    self._processMap["getAllSources"] = Processor.process_getAllSources
4865 
    self._processMap["getItemPricingBySource"] = Processor.process_getItemPricingBySource
4866 
    self._processMap["addSourceItemPricing"] = Processor.process_addSourceItemPricing
4867 
    self._processMap["getAllSourcePricing"] = Processor.process_getAllSourcePricing
4868 
    self._processMap["getItemForSource"] = Processor.process_getItemForSource
4869 
    self._processMap["searchItemsInRange"] = Processor.process_searchItemsInRange
4870 
    self._processMap["getSearchResultCount"] = Processor.process_getSearchResultCount
4871 
    self._processMap["getProductNotifications"] = Processor.process_getProductNotifications
4872 
    self._processMap["getProductNotificationRequestCount"] = Processor.process_getProductNotificationRequestCount
4873 
    self._processMap["addAuthorizationLog"] = Processor.process_addAuthorizationLog
4874 
    self._processMap["addupdateVoucherForItem"] = Processor.process_addupdateVoucherForItem
4875 
    self._processMap["deleteVoucherForItem"] = Processor.process_deleteVoucherForItem
4876 
    self._processMap["getVoucherAmount"] = Processor.process_getVoucherAmount
4877 
    self._processMap["getAllItemVouchers"] = Processor.process_getAllItemVouchers
4878 
    self._processMap["isValidCatalogItemId"] = Processor.process_isValidCatalogItemId
6039 amit.gupta 4879 
    self._processMap["getVatPercentageForItem"] = Processor.process_getVatPercentageForItem
4880 
    self._processMap["getVatAmountForItem"] = Processor.process_getVatAmountForItem
6531 vikram.rag 4881 
    self._processMap["getAllIgnoredInventoryUpdateItemsList"] = Processor.process_getAllIgnoredInventoryUpdateItemsList
6821 amar.kumar 4882 
    self._processMap["getAllAliveItems"] = Processor.process_getAllAliveItems
6805 anupam.sin 4883 
    self._processMap["getInsuranceAmount"] = Processor.process_getInsuranceAmount
4884 
    self._processMap["getInsurer"] = Processor.process_getInsurer
6838 vikram.rag 4885 
    self._processMap["getAllInsurers"] = Processor.process_getAllInsurers
6962 rajveer 4886 
    self._processMap["updateInsuranceDeclaredAmount"] = Processor.process_updateInsuranceDeclaredAmount
7190 amar.kumar 4887 
    self._processMap["getFreebieForItem"] = Processor.process_getFreebieForItem
4888 
    self._processMap["addOrUpdateFreebieForItem"] = Processor.process_addOrUpdateFreebieForItem
7272 amit.gupta 4889 
    self._processMap["addOrUpdateBrandInfo"] = Processor.process_addOrUpdateBrandInfo
4890 
    self._processMap["getBrandInfo"] = Processor.process_getBrandInfo
7256 rajveer 4891 
    self._processMap["getStorePricing"] = Processor.process_getStorePricing
7306 rajveer 4892 
    self._processMap["getStorePricings"] = Processor.process_getStorePricings
7265 rajveer 4893 
    self._processMap["updateStorePricing"] = Processor.process_updateStorePricing
7281 kshitij.so 4894 
    self._processMap["getAllAmazonListedItems"] = Processor.process_getAllAmazonListedItems
8619 kshitij.so 4895 
    self._processMap["searchAmazonItems"] = Processor.process_searchAmazonItems
4896 
    self._processMap["getAmazonSearchResultCount"] = Processor.process_getAmazonSearchResultCount
4897 
    self._processMap["getCountForAmazonlistedItems"] = Processor.process_getCountForAmazonlistedItems
7281 kshitij.so 4898 
    self._processMap["getAmazonItemDetails"] = Processor.process_getAmazonItemDetails
4899 
    self._processMap["updateAmazonItemDetails"] = Processor.process_updateAmazonItemDetails
4900 
    self._processMap["addAmazonItem"] = Processor.process_addAmazonItem
7291 vikram.rag 4901 
    self._processMap["getAsinItems"] = Processor.process_getAsinItems
4902 
    self._processMap["getAllFbaListedItems"] = Processor.process_getAllFbaListedItems
4903 
    self._processMap["getAllNonFbaListedItems"] = Processor.process_getAllNonFbaListedItems
7460 kshitij.so 4904 
    self._processMap["updateItemInventory"] = Processor.process_updateItemInventory
7770 kshitij.so 4905 
    self._processMap["updateTimestampForAmazonFeeds"] = Processor.process_updateTimestampForAmazonFeeds
7897 amar.kumar 4906 
    self._processMap["getAllParentCategories"] = Processor.process_getAllParentCategories
7977 kshitij.so 4907 
    self._processMap["addPageViewEvent"] = Processor.process_addPageViewEvent
4908 
    self._processMap["addCartEvent"] = Processor.process_addCartEvent
8182 amar.kumar 4909 
    self._processMap["addEbayItem"] = Processor.process_addEbayItem
4910 
    self._processMap["getEbayItem"] = Processor.process_getEbayItem
4911 
    self._processMap["updateEbayItem"] = Processor.process_updateEbayItem
8139 kshitij.so 4912 
    self._processMap["getAmazonListedItems"] = Processor.process_getAmazonListedItems
8168 kshitij.so 4913 
    self._processMap["updateAmazonAttributesInBulk"] = Processor.process_updateAmazonAttributesInBulk
8379 vikram.rag 4914 
    self._processMap["getAllItemstoListOnFba"] = Processor.process_getAllItemstoListOnFba
4915 
    self._processMap["getAllItemstoListOnNonFba"] = Processor.process_getAllItemstoListOnNonFba
8616 vikram.rag 4916 
    self._processMap["getAllSnapdealListedActiveItems"] = Processor.process_getAllSnapdealListedActiveItems
8619 kshitij.so 4917 
    self._processMap["updateAsin"] = Processor.process_updateAsin
8739 vikram.rag 4918 
    self._processMap["addOrUpdateSnapdealItem"] = Processor.process_addOrUpdateSnapdealItem
4919 
    self._processMap["getSnapdealItem"] = Processor.process_getSnapdealItem
4920 
    self._processMap["getAllSnapdealItems"] = Processor.process_getAllSnapdealItems
5944 mandeep.dh 4921 
 
4922 
  def process(self, iprot, oprot):
4923 
    (name, type, seqid) = iprot.readMessageBegin()
4924 
    if name not in self._processMap:
4925 
      iprot.skip(TType.STRUCT)
4926 
      iprot.readMessageEnd()
4927 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
4928 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
4929 
      x.write(oprot)
4930 
      oprot.writeMessageEnd()
4931 
      oprot.trans.flush()
4932 
      return
4933 
    else:
4934 
      self._processMap[name](self, seqid, iprot, oprot)
4935 
    return True
4936 
 
4937 
  def process_addItem(self, seqid, iprot, oprot):
4938 
    args = addItem_args()
4939 
    args.read(iprot)
4940 
    iprot.readMessageEnd()
4941 
    result = addItem_result()
4942 
    try:
4943 
      result.success = self._handler.addItem(args.item)
4944 
    except CatalogServiceException, cex:
4945 
      result.cex = cex
4946 
    oprot.writeMessageBegin("addItem", TMessageType.REPLY, seqid)
4947 
    result.write(oprot)
4948 
    oprot.writeMessageEnd()
4949 
    oprot.trans.flush()
4950 
 
4951 
  def process_updateItem(self, seqid, iprot, oprot):
4952 
    args = updateItem_args()
4953 
    args.read(iprot)
4954 
    iprot.readMessageEnd()
4955 
    result = updateItem_result()
4956 
    try:
4957 
      result.success = self._handler.updateItem(args.item)
4958 
    except CatalogServiceException, cex:
4959 
      result.cex = cex
4960 
    oprot.writeMessageBegin("updateItem", TMessageType.REPLY, seqid)
4961 
    result.write(oprot)
4962 
    oprot.writeMessageEnd()
4963 
    oprot.trans.flush()
4964 
 
4965 
  def process_isActive(self, seqid, iprot, oprot):
4966 
    args = isActive_args()
4967 
    args.read(iprot)
4968 
    iprot.readMessageEnd()
4969 
    result = isActive_result()
4970 
    try:
4971 
      result.success = self._handler.isActive(args.itemId)
4972 
    except CatalogServiceException, isex:
4973 
      result.isex = isex
4974 
    oprot.writeMessageBegin("isActive", TMessageType.REPLY, seqid)
4975 
    result.write(oprot)
4976 
    oprot.writeMessageEnd()
4977 
    oprot.trans.flush()
4978 
 
7438 amit.gupta 4979 
  def process_getItemsStatus(self, seqid, iprot, oprot):
4980 
    args = getItemsStatus_args()
4981 
    args.read(iprot)
4982 
    iprot.readMessageEnd()
4983 
    result = getItemsStatus_result()
4984 
    try:
4985 
      result.success = self._handler.getItemsStatus(args.itemIds)
4986 
    except CatalogServiceException, isex:
4987 
      result.isex = isex
4988 
    oprot.writeMessageBegin("getItemsStatus", TMessageType.REPLY, seqid)
4989 
    result.write(oprot)
4990 
    oprot.writeMessageEnd()
4991 
    oprot.trans.flush()
4992 
 
5944 mandeep.dh 4993 
  def process_getItemStatusDescription(self, seqid, iprot, oprot):
4994 
    args = getItemStatusDescription_args()
4995 
    args.read(iprot)
4996 
    iprot.readMessageEnd()
4997 
    result = getItemStatusDescription_result()
4998 
    try:
4999 
      result.success = self._handler.getItemStatusDescription(args.itemId)
5000 
    except CatalogServiceException, isex:
5001 
      result.isex = isex
5002 
    oprot.writeMessageBegin("getItemStatusDescription", TMessageType.REPLY, seqid)
5003 
    result.write(oprot)
5004 
    oprot.writeMessageEnd()
5005 
    oprot.trans.flush()
5006 
 
5007 
  def process_startItemOn(self, seqid, iprot, oprot):
5008 
    args = startItemOn_args()
5009 
    args.read(iprot)
5010 
    iprot.readMessageEnd()
5011 
    result = startItemOn_result()
5012 
    try:
5013 
      self._handler.startItemOn(args.item_id, args.timestamp)
5014 
    except CatalogServiceException, cex:
5015 
      result.cex = cex
5016 
    oprot.writeMessageBegin("startItemOn", TMessageType.REPLY, seqid)
5017 
    result.write(oprot)
5018 
    oprot.writeMessageEnd()
5019 
    oprot.trans.flush()
5020 
 
5021 
  def process_retireItemOn(self, seqid, iprot, oprot):
5022 
    args = retireItemOn_args()
5023 
    args.read(iprot)
5024 
    iprot.readMessageEnd()
5025 
    result = retireItemOn_result()
5026 
    try:
5027 
      self._handler.retireItemOn(args.item_id, args.timestamp)
5028 
    except CatalogServiceException, cex:
5029 
      result.cex = cex
5030 
    oprot.writeMessageBegin("retireItemOn", TMessageType.REPLY, seqid)
5031 
    result.write(oprot)
5032 
    oprot.writeMessageEnd()
5033 
    oprot.trans.flush()
5034 
 
5035 
  def process_changeItemStatus(self, seqid, iprot, oprot):
5036 
    args = changeItemStatus_args()
5037 
    args.read(iprot)
5038 
    iprot.readMessageEnd()
5039 
    result = changeItemStatus_result()
5040 
    try:
5041 
      self._handler.changeItemStatus(args.item_id, args.timestamp, args.newstatus)
5042 
    except CatalogServiceException, cex:
5043 
      result.cex = cex
5044 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
5045 
    result.write(oprot)
5046 
    oprot.writeMessageEnd()
5047 
    oprot.trans.flush()
5048 
 
5049 
  def process_getItem(self, seqid, iprot, oprot):
5050 
    args = getItem_args()
5051 
    args.read(iprot)
5052 
    iprot.readMessageEnd()
5053 
    result = getItem_result()
5054 
    try:
5055 
      result.success = self._handler.getItem(args.item_id)
5056 
    except CatalogServiceException, cex:
5057 
      result.cex = cex
5058 
    oprot.writeMessageBegin("getItem", TMessageType.REPLY, seqid)
5059 
    result.write(oprot)
5060 
    oprot.writeMessageEnd()
5061 
    oprot.trans.flush()
5062 
 
5063 
  def process_getItemsByCatalogId(self, seqid, iprot, oprot):
5064 
    args = getItemsByCatalogId_args()
5065 
    args.read(iprot)
5066 
    iprot.readMessageEnd()
5067 
    result = getItemsByCatalogId_result()
5068 
    try:
5069 
      result.success = self._handler.getItemsByCatalogId(args.catalog_item_id)
5070 
    except CatalogServiceException, cex:
5071 
      result.cex = cex
5072 
    oprot.writeMessageBegin("getItemsByCatalogId", TMessageType.REPLY, seqid)
5073 
    result.write(oprot)
5074 
    oprot.writeMessageEnd()
5075 
    oprot.trans.flush()
5076 
 
5077 
  def process_getValidItemsByCatalogId(self, seqid, iprot, oprot):
5078 
    args = getValidItemsByCatalogId_args()
5079 
    args.read(iprot)
5080 
    iprot.readMessageEnd()
5081 
    result = getValidItemsByCatalogId_result()
5082 
    try:
5083 
      result.success = self._handler.getValidItemsByCatalogId(args.catalog_item_id)
5084 
    except CatalogServiceException, cex:
5085 
      result.cex = cex
5086 
    oprot.writeMessageBegin("getValidItemsByCatalogId", TMessageType.REPLY, seqid)
5087 
    result.write(oprot)
5088 
    oprot.writeMessageEnd()
5089 
    oprot.trans.flush()
5090 
 
5091 
  def process_getAllItems(self, seqid, iprot, oprot):
5092 
    args = getAllItems_args()
5093 
    args.read(iprot)
5094 
    iprot.readMessageEnd()
5095 
    result = getAllItems_result()
5096 
    try:
5097 
      result.success = self._handler.getAllItems(args.isActive)
5098 
    except CatalogServiceException, cex:
5099 
      result.cex = cex
5100 
    oprot.writeMessageBegin("getAllItems", TMessageType.REPLY, seqid)
5101 
    result.write(oprot)
5102 
    oprot.writeMessageEnd()
5103 
    oprot.trans.flush()
5104 
 
5105 
  def process_getAllItemsByStatus(self, seqid, iprot, oprot):
5106 
    args = getAllItemsByStatus_args()
5107 
    args.read(iprot)
5108 
    iprot.readMessageEnd()
5109 
    result = getAllItemsByStatus_result()
5110 
    try:
5111 
      result.success = self._handler.getAllItemsByStatus(args.itemStatus)
5112 
    except CatalogServiceException, cex:
5113 
      result.cex = cex
5114 
    oprot.writeMessageBegin("getAllItemsByStatus", TMessageType.REPLY, seqid)
5115 
    result.write(oprot)
5116 
    oprot.writeMessageEnd()
5117 
    oprot.trans.flush()
5118 
 
5119 
  def process_markItemAsContentComplete(self, seqid, iprot, oprot):
5120 
    args = markItemAsContentComplete_args()
5121 
    args.read(iprot)
5122 
    iprot.readMessageEnd()
5123 
    result = markItemAsContentComplete_result()
5124 
    try:
5125 
      result.success = self._handler.markItemAsContentComplete(args.entityId, args.category, args.brand, args.modelName, args.modelNumber)
5126 
    except CatalogServiceException, cex:
5127 
      result.cex = cex
5128 
    oprot.writeMessageBegin("markItemAsContentComplete", TMessageType.REPLY, seqid)
5129 
    result.write(oprot)
5130 
    oprot.writeMessageEnd()
5131 
    oprot.trans.flush()
5132 
 
5133 
  def process_getAllItemsInRange(self, seqid, iprot, oprot):
5134 
    args = getAllItemsInRange_args()
5135 
    args.read(iprot)
5136 
    iprot.readMessageEnd()
5137 
    result = getAllItemsInRange_result()
5138 
    try:
5139 
      result.success = self._handler.getAllItemsInRange(args.offset, args.limit)
5140 
    except CatalogServiceException, cex:
5141 
      result.cex = cex
5142 
    oprot.writeMessageBegin("getAllItemsInRange", TMessageType.REPLY, seqid)
5143 
    result.write(oprot)
5144 
    oprot.writeMessageEnd()
5145 
    oprot.trans.flush()
5146 
 
5147 
  def process_getAllItemsByStatusInRange(self, seqid, iprot, oprot):
5148 
    args = getAllItemsByStatusInRange_args()
5149 
    args.read(iprot)
5150 
    iprot.readMessageEnd()
5151 
    result = getAllItemsByStatusInRange_result()
5152 
    try:
5153 
      result.success = self._handler.getAllItemsByStatusInRange(args.itemStatus, args.offset, args.limit)
5154 
    except CatalogServiceException, cex:
5155 
      result.cex = cex
5156 
    oprot.writeMessageBegin("getAllItemsByStatusInRange", TMessageType.REPLY, seqid)
5157 
    result.write(oprot)
5158 
    oprot.writeMessageEnd()
5159 
    oprot.trans.flush()
5160 
 
5161 
  def process_getItemCountByStatus(self, seqid, iprot, oprot):
5162 
    args = getItemCountByStatus_args()
5163 
    args.read(iprot)
5164 
    iprot.readMessageEnd()
5165 
    result = getItemCountByStatus_result()
5166 
    result.success = self._handler.getItemCountByStatus(args.useStatus, args.itemStatus)
5167 
    oprot.writeMessageBegin("getItemCountByStatus", TMessageType.REPLY, seqid)
5168 
    result.write(oprot)
5169 
    oprot.writeMessageEnd()
5170 
    oprot.trans.flush()
5171 
 
5172 
  def process_getBestSellers(self, seqid, iprot, oprot):
5173 
    args = getBestSellers_args()
5174 
    args.read(iprot)
5175 
    iprot.readMessageEnd()
5176 
    result = getBestSellers_result()
5177 
    try:
5178 
      result.success = self._handler.getBestSellers()
5179 
    except CatalogServiceException, isex:
5180 
      result.isex = isex
5181 
    oprot.writeMessageBegin("getBestSellers", TMessageType.REPLY, seqid)
5182 
    result.write(oprot)
5183 
    oprot.writeMessageEnd()
5184 
    oprot.trans.flush()
5185 
 
5186 
  def process_getBestSellersCatalogIds(self, seqid, iprot, oprot):
5187 
    args = getBestSellersCatalogIds_args()
5188 
    args.read(iprot)
5189 
    iprot.readMessageEnd()
5190 
    result = getBestSellersCatalogIds_result()
5191 
    try:
5192 
      result.success = self._handler.getBestSellersCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
5193 
    except CatalogServiceException, cex:
5194 
      result.cex = cex
5195 
    oprot.writeMessageBegin("getBestSellersCatalogIds", TMessageType.REPLY, seqid)
5196 
    result.write(oprot)
5197 
    oprot.writeMessageEnd()
5198 
    oprot.trans.flush()
5199 
 
5200 
  def process_getBestSellersCount(self, seqid, iprot, oprot):
5201 
    args = getBestSellersCount_args()
5202 
    args.read(iprot)
5203 
    iprot.readMessageEnd()
5204 
    result = getBestSellersCount_result()
5205 
    try:
5206 
      result.success = self._handler.getBestSellersCount()
5207 
    except CatalogServiceException, cex:
5208 
      result.cex = cex
5209 
    oprot.writeMessageBegin("getBestSellersCount", TMessageType.REPLY, seqid)
5210 
    result.write(oprot)
5211 
    oprot.writeMessageEnd()
5212 
    oprot.trans.flush()
5213 
 
5214 
  def process_getBestDeals(self, seqid, iprot, oprot):
5215 
    args = getBestDeals_args()
5216 
    args.read(iprot)
5217 
    iprot.readMessageEnd()
5218 
    result = getBestDeals_result()
5219 
    try:
5220 
      result.success = self._handler.getBestDeals()
5221 
    except CatalogServiceException, isex:
5222 
      result.isex = isex
5223 
    oprot.writeMessageBegin("getBestDeals", TMessageType.REPLY, seqid)
5224 
    result.write(oprot)
5225 
    oprot.writeMessageEnd()
5226 
    oprot.trans.flush()
5227 
 
5228 
  def process_getBestDealsCatalogIds(self, seqid, iprot, oprot):
5229 
    args = getBestDealsCatalogIds_args()
5230 
    args.read(iprot)
5231 
    iprot.readMessageEnd()
5232 
    result = getBestDealsCatalogIds_result()
5233 
    try:
5234 
      result.success = self._handler.getBestDealsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
5235 
    except CatalogServiceException, cex:
5236 
      result.cex = cex
5237 
    oprot.writeMessageBegin("getBestDealsCatalogIds", TMessageType.REPLY, seqid)
5238 
    result.write(oprot)
5239 
    oprot.writeMessageEnd()
5240 
    oprot.trans.flush()
5241 
 
5242 
  def process_getBestDealsCount(self, seqid, iprot, oprot):
5243 
    args = getBestDealsCount_args()
5244 
    args.read(iprot)
5245 
    iprot.readMessageEnd()
5246 
    result = getBestDealsCount_result()
5247 
    try:
5248 
      result.success = self._handler.getBestDealsCount()
5249 
    except CatalogServiceException, cex:
5250 
      result.cex = cex
5251 
    oprot.writeMessageBegin("getBestDealsCount", TMessageType.REPLY, seqid)
5252 
    result.write(oprot)
5253 
    oprot.writeMessageEnd()
5254 
    oprot.trans.flush()
5255 
 
5256 
  def process_getComingSoon(self, seqid, iprot, oprot):
5257 
    args = getComingSoon_args()
5258 
    args.read(iprot)
5259 
    iprot.readMessageEnd()
5260 
    result = getComingSoon_result()
5261 
    try:
5262 
      result.success = self._handler.getComingSoon()
5263 
    except CatalogServiceException, isex:
5264 
      result.isex = isex
5265 
    oprot.writeMessageBegin("getComingSoon", TMessageType.REPLY, seqid)
5266 
    result.write(oprot)
5267 
    oprot.writeMessageEnd()
5268 
    oprot.trans.flush()
5269 
 
5270 
  def process_getComingSoonCatalogIds(self, seqid, iprot, oprot):
5271 
    args = getComingSoonCatalogIds_args()
5272 
    args.read(iprot)
5273 
    iprot.readMessageEnd()
5274 
    result = getComingSoonCatalogIds_result()
5275 
    try:
5276 
      result.success = self._handler.getComingSoonCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
5277 
    except CatalogServiceException, cex:
5278 
      result.cex = cex
5279 
    oprot.writeMessageBegin("getComingSoonCatalogIds", TMessageType.REPLY, seqid)
5280 
    result.write(oprot)
5281 
    oprot.writeMessageEnd()
5282 
    oprot.trans.flush()
5283 
 
5284 
  def process_getComingSoonCount(self, seqid, iprot, oprot):
5285 
    args = getComingSoonCount_args()
5286 
    args.read(iprot)
5287 
    iprot.readMessageEnd()
5288 
    result = getComingSoonCount_result()
5289 
    try:
5290 
      result.success = self._handler.getComingSoonCount()
5291 
    except CatalogServiceException, cex:
5292 
      result.cex = cex
5293 
    oprot.writeMessageBegin("getComingSoonCount", TMessageType.REPLY, seqid)
5294 
    result.write(oprot)
5295 
    oprot.writeMessageEnd()
5296 
    oprot.trans.flush()
5297 
 
5298 
  def process_getLatestArrivals(self, seqid, iprot, oprot):
5299 
    args = getLatestArrivals_args()
5300 
    args.read(iprot)
5301 
    iprot.readMessageEnd()
5302 
    result = getLatestArrivals_result()
5303 
    try:
5304 
      result.success = self._handler.getLatestArrivals()
5305 
    except CatalogServiceException, isex:
5306 
      result.isex = isex
5307 
    oprot.writeMessageBegin("getLatestArrivals", TMessageType.REPLY, seqid)
5308 
    result.write(oprot)
5309 
    oprot.writeMessageEnd()
5310 
    oprot.trans.flush()
5311 
 
5312 
  def process_getLatestArrivalsCatalogIds(self, seqid, iprot, oprot):
5313 
    args = getLatestArrivalsCatalogIds_args()
5314 
    args.read(iprot)
5315 
    iprot.readMessageEnd()
5316 
    result = getLatestArrivalsCatalogIds_result()
5317 
    try:
5318 
      result.success = self._handler.getLatestArrivalsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.categories)
5319 
    except CatalogServiceException, cex:
5320 
      result.cex = cex
5321 
    oprot.writeMessageBegin("getLatestArrivalsCatalogIds", TMessageType.REPLY, seqid)
5322 
    result.write(oprot)
5323 
    oprot.writeMessageEnd()
5324 
    oprot.trans.flush()
5325 
 
5326 
  def process_getLatestArrivalsCount(self, seqid, iprot, oprot):
5327 
    args = getLatestArrivalsCount_args()
5328 
    args.read(iprot)
5329 
    iprot.readMessageEnd()
5330 
    result = getLatestArrivalsCount_result()
5331 
    try:
5332 
      result.success = self._handler.getLatestArrivalsCount()
5333 
    except CatalogServiceException, cex:
5334 
      result.cex = cex
5335 
    oprot.writeMessageBegin("getLatestArrivalsCount", TMessageType.REPLY, seqid)
5336 
    result.write(oprot)
5337 
    oprot.writeMessageEnd()
5338 
    oprot.trans.flush()
5339 
 
5340 
  def process_generateNewEntityID(self, seqid, iprot, oprot):
5341 
    args = generateNewEntityID_args()
5342 
    args.read(iprot)
5343 
    iprot.readMessageEnd()
5344 
    result = generateNewEntityID_result()
5345 
    result.success = self._handler.generateNewEntityID()
5346 
    oprot.writeMessageBegin("generateNewEntityID", TMessageType.REPLY, seqid)
5347 
    result.write(oprot)
5348 
    oprot.writeMessageEnd()
5349 
    oprot.trans.flush()
5350 
 
5351 
  def process_addCategory(self, seqid, iprot, oprot):
5352 
    args = addCategory_args()
5353 
    args.read(iprot)
5354 
    iprot.readMessageEnd()
5355 
    result = addCategory_result()
5356 
    result.success = self._handler.addCategory(args.category)
5357 
    oprot.writeMessageBegin("addCategory", TMessageType.REPLY, seqid)
5358 
    result.write(oprot)
5359 
    oprot.writeMessageEnd()
5360 
    oprot.trans.flush()
5361 
 
5362 
  def process_getCategory(self, seqid, iprot, oprot):
5363 
    args = getCategory_args()
5364 
    args.read(iprot)
5365 
    iprot.readMessageEnd()
5366 
    result = getCategory_result()
5367 
    result.success = self._handler.getCategory(args.id)
5368 
    oprot.writeMessageBegin("getCategory", TMessageType.REPLY, seqid)
5369 
    result.write(oprot)
5370 
    oprot.writeMessageEnd()
5371 
    oprot.trans.flush()
5372 
 
5373 
  def process_getAllCategories(self, seqid, iprot, oprot):
5374 
    args = getAllCategories_args()
5375 
    args.read(iprot)
5376 
    iprot.readMessageEnd()
5377 
    result = getAllCategories_result()
5378 
    result.success = self._handler.getAllCategories()
5379 
    oprot.writeMessageBegin("getAllCategories", TMessageType.REPLY, seqid)
5380 
    result.write(oprot)
5381 
    oprot.writeMessageEnd()
5382 
    oprot.trans.flush()
5383 
 
5384 
  def process_getAllSimilarItems(self, seqid, iprot, oprot):
5385 
    args = getAllSimilarItems_args()
5386 
    args.read(iprot)
5387 
    iprot.readMessageEnd()
5388 
    result = getAllSimilarItems_result()
5389 
    result.success = self._handler.getAllSimilarItems(args.itemId)
5390 
    oprot.writeMessageBegin("getAllSimilarItems", TMessageType.REPLY, seqid)
5391 
    result.write(oprot)
5392 
    oprot.writeMessageEnd()
5393 
    oprot.trans.flush()
5394 
 
5395 
  def process_addSimilarItem(self, seqid, iprot, oprot):
5396 
    args = addSimilarItem_args()
5397 
    args.read(iprot)
5398 
    iprot.readMessageEnd()
5399 
    result = addSimilarItem_result()
5400 
    try:
5401 
      result.success = self._handler.addSimilarItem(args.itemId, args.catalogItemId)
5402 
    except CatalogServiceException, cex:
5403 
      result.cex = cex
5404 
    oprot.writeMessageBegin("addSimilarItem", TMessageType.REPLY, seqid)
5405 
    result.write(oprot)
5406 
    oprot.writeMessageEnd()
5407 
    oprot.trans.flush()
5408 
 
6512 kshitij.so 5409 
  def process_addTag(self, seqid, iprot, oprot):
5410 
    args = addTag_args()
5411 
    args.read(iprot)
5412 
    iprot.readMessageEnd()
5413 
    result = addTag_result()
5414 
    result.success = self._handler.addTag(args.displayName, args.itemId)
5415 
    oprot.writeMessageBegin("addTag", TMessageType.REPLY, seqid)
5416 
    result.write(oprot)
5417 
    oprot.writeMessageEnd()
5418 
    oprot.trans.flush()
5419 
 
5420 
  def process_deleteEntityTag(self, seqid, iprot, oprot):
5421 
    args = deleteEntityTag_args()
5422 
    args.read(iprot)
5423 
    iprot.readMessageEnd()
5424 
    result = deleteEntityTag_result()
5425 
    result.success = self._handler.deleteEntityTag(args.displayName, args.itemId)
5426 
    oprot.writeMessageBegin("deleteEntityTag", TMessageType.REPLY, seqid)
5427 
    result.write(oprot)
5428 
    oprot.writeMessageEnd()
5429 
    oprot.trans.flush()
5430 
 
5431 
  def process_deleteTag(self, seqid, iprot, oprot):
5432 
    args = deleteTag_args()
5433 
    args.read(iprot)
5434 
    iprot.readMessageEnd()
5435 
    result = deleteTag_result()
5436 
    result.success = self._handler.deleteTag(args.displayName)
5437 
    oprot.writeMessageBegin("deleteTag", TMessageType.REPLY, seqid)
5438 
    result.write(oprot)
5439 
    oprot.writeMessageEnd()
5440 
    oprot.trans.flush()
5441 
 
5442 
  def process_getAllTags(self, seqid, iprot, oprot):
5443 
    args = getAllTags_args()
5444 
    args.read(iprot)
5445 
    iprot.readMessageEnd()
5446 
    result = getAllTags_result()
5447 
    result.success = self._handler.getAllTags()
5448 
    oprot.writeMessageBegin("getAllTags", TMessageType.REPLY, seqid)
5449 
    result.write(oprot)
5450 
    oprot.writeMessageEnd()
5451 
    oprot.trans.flush()
5452 
 
5453 
  def process_getAllEntitiesByTagName(self, seqid, iprot, oprot):
5454 
    args = getAllEntitiesByTagName_args()
5455 
    args.read(iprot)
5456 
    iprot.readMessageEnd()
5457 
    result = getAllEntitiesByTagName_result()
5458 
    result.success = self._handler.getAllEntitiesByTagName(args.displayName)
5459 
    oprot.writeMessageBegin("getAllEntitiesByTagName", TMessageType.REPLY, seqid)
5460 
    result.write(oprot)
5461 
    oprot.writeMessageEnd()
5462 
    oprot.trans.flush()
5463 
 
6845 amit.gupta 5464 
  def process_getAllEntityTags(self, seqid, iprot, oprot):
5465 
    args = getAllEntityTags_args()
5466 
    args.read(iprot)
5467 
    iprot.readMessageEnd()
5468 
    result = getAllEntityTags_result()
5469 
    result.success = self._handler.getAllEntityTags()
5470 
    oprot.writeMessageBegin("getAllEntityTags", TMessageType.REPLY, seqid)
5471 
    result.write(oprot)
5472 
    oprot.writeMessageEnd()
5473 
    oprot.trans.flush()
5474 
 
6850 kshitij.so 5475 
  def process_addBanner(self, seqid, iprot, oprot):
5476 
    args = addBanner_args()
5477 
    args.read(iprot)
5478 
    iprot.readMessageEnd()
5479 
    result = addBanner_result()
8590 kshitij.so 5480 
    self._handler.addBanner(args.bannerCongregate)
6850 kshitij.so 5481 
    oprot.writeMessageBegin("addBanner", TMessageType.REPLY, seqid)
5482 
    result.write(oprot)
5483 
    oprot.writeMessageEnd()
5484 
    oprot.trans.flush()
5485 
 
8579 kshitij.so 5486 
  def process_updateBanner(self, seqid, iprot, oprot):
5487 
    args = updateBanner_args()
5488 
    args.read(iprot)
5489 
    iprot.readMessageEnd()
5490 
    result = updateBanner_result()
5491 
    result.success = self._handler.updateBanner(args.banner)
5492 
    oprot.writeMessageBegin("updateBanner", TMessageType.REPLY, seqid)
5493 
    result.write(oprot)
5494 
    oprot.writeMessageEnd()
5495 
    oprot.trans.flush()
5496 
 
6850 kshitij.so 5497 
  def process_getAllBanners(self, seqid, iprot, oprot):
5498 
    args = getAllBanners_args()
5499 
    args.read(iprot)
5500 
    iprot.readMessageEnd()
5501 
    result = getAllBanners_result()
5502 
    result.success = self._handler.getAllBanners()
5503 
    oprot.writeMessageBegin("getAllBanners", TMessageType.REPLY, seqid)
5504 
    result.write(oprot)
5505 
    oprot.writeMessageEnd()
5506 
    oprot.trans.flush()
5507 
 
5508 
  def process_deleteBanner(self, seqid, iprot, oprot):
5509 
    args = deleteBanner_args()
5510 
    args.read(iprot)
5511 
    iprot.readMessageEnd()
5512 
    result = deleteBanner_result()
9155 kshitij.so 5513 
    result.success = self._handler.deleteBanner(args.bannerName, args.bannerType)
6850 kshitij.so 5514 
    oprot.writeMessageBegin("deleteBanner", TMessageType.REPLY, seqid)
5515 
    result.write(oprot)
5516 
    oprot.writeMessageEnd()
5517 
    oprot.trans.flush()
5518 
 
5519 
  def process_getBannerDetails(self, seqid, iprot, oprot):
5520 
    args = getBannerDetails_args()
5521 
    args.read(iprot)
5522 
    iprot.readMessageEnd()
5523 
    result = getBannerDetails_result()
9155 kshitij.so 5524 
    result.success = self._handler.getBannerDetails(args.bannerName, args.bannerType)
6850 kshitij.so 5525 
    oprot.writeMessageBegin("getBannerDetails", TMessageType.REPLY, seqid)
5526 
    result.write(oprot)
5527 
    oprot.writeMessageEnd()
5528 
    oprot.trans.flush()
5529 
 
5530 
  def process_getActiveBanners(self, seqid, iprot, oprot):
5531 
    args = getActiveBanners_args()
5532 
    args.read(iprot)
5533 
    iprot.readMessageEnd()
5534 
    result = getActiveBanners_result()
5535 
    result.success = self._handler.getActiveBanners()
5536 
    oprot.writeMessageBegin("getActiveBanners", TMessageType.REPLY, seqid)
5537 
    result.write(oprot)
5538 
    oprot.writeMessageEnd()
5539 
    oprot.trans.flush()
5540 
 
6849 kshitij.so 5541 
  def process_addBannerMap(self, seqid, iprot, oprot):
5542 
    args = addBannerMap_args()
5543 
    args.read(iprot)
5544 
    iprot.readMessageEnd()
5545 
    result = addBannerMap_result()
8579 kshitij.so 5546 
    result.success = self._handler.addBannerMap(args.bannerMaps)
6849 kshitij.so 5547 
    oprot.writeMessageBegin("addBannerMap", TMessageType.REPLY, seqid)
5548 
    result.write(oprot)
5549 
    oprot.writeMessageEnd()
5550 
    oprot.trans.flush()
5551 
 
8579 kshitij.so 5552 
  def process_updateBannerMap(self, seqid, iprot, oprot):
5553 
    args = updateBannerMap_args()
5554 
    args.read(iprot)
5555 
    iprot.readMessageEnd()
5556 
    result = updateBannerMap_result()
5557 
    result.success = self._handler.updateBannerMap(args.bannerMap)
5558 
    oprot.writeMessageBegin("updateBannerMap", TMessageType.REPLY, seqid)
5559 
    result.write(oprot)
5560 
    oprot.writeMessageEnd()
5561 
    oprot.trans.flush()
5562 
 
6849 kshitij.so 5563 
  def process_deleteBannerMap(self, seqid, iprot, oprot):
5564 
    args = deleteBannerMap_args()
5565 
    args.read(iprot)
5566 
    iprot.readMessageEnd()
5567 
    result = deleteBannerMap_result()
5568 
    result.success = self._handler.deleteBannerMap(args.bannerName)
5569 
    oprot.writeMessageBegin("deleteBannerMap", TMessageType.REPLY, seqid)
5570 
    result.write(oprot)
5571 
    oprot.writeMessageEnd()
5572 
    oprot.trans.flush()
5573 
 
5574 
  def process_getBannerMapDetails(self, seqid, iprot, oprot):
5575 
    args = getBannerMapDetails_args()
5576 
    args.read(iprot)
5577 
    iprot.readMessageEnd()
5578 
    result = getBannerMapDetails_result()
9155 kshitij.so 5579 
    result.success = self._handler.getBannerMapDetails(args.bannerName, args.bannerType)
6849 kshitij.so 5580 
    oprot.writeMessageBegin("getBannerMapDetails", TMessageType.REPLY, seqid)
5581 
    result.write(oprot)
5582 
    oprot.writeMessageEnd()
5583 
    oprot.trans.flush()
5584 
 
8579 kshitij.so 5585 
  def process_addBannerUri(self, seqid, iprot, oprot):
5586 
    args = addBannerUri_args()
5587 
    args.read(iprot)
5588 
    iprot.readMessageEnd()
5589 
    result = addBannerUri_result()
5590 
    self._handler.addBannerUri(args.bannerUriMappings)
5591 
    oprot.writeMessageBegin("addBannerUri", TMessageType.REPLY, seqid)
5592 
    result.write(oprot)
5593 
    oprot.writeMessageEnd()
5594 
    oprot.trans.flush()
5595 
 
5596 
  def process_getUriMapping(self, seqid, iprot, oprot):
5597 
    args = getUriMapping_args()
5598 
    args.read(iprot)
5599 
    iprot.readMessageEnd()
5600 
    result = getUriMapping_result()
9155 kshitij.so 5601 
    result.success = self._handler.getUriMapping(args.bannerName, args.bannerType)
8579 kshitij.so 5602 
    oprot.writeMessageBegin("getUriMapping", TMessageType.REPLY, seqid)
5603 
    result.write(oprot)
5604 
    oprot.writeMessageEnd()
5605 
    oprot.trans.flush()
5606 
 
5607 
  def process_addCampaign(self, seqid, iprot, oprot):
5608 
    args = addCampaign_args()
5609 
    args.read(iprot)
5610 
    iprot.readMessageEnd()
5611 
    result = addCampaign_result()
5612 
    self._handler.addCampaign(args.campaign)
5613 
    oprot.writeMessageBegin("addCampaign", TMessageType.REPLY, seqid)
5614 
    result.write(oprot)
5615 
    oprot.writeMessageEnd()
5616 
    oprot.trans.flush()
5617 
 
5618 
  def process_getCampaigns(self, seqid, iprot, oprot):
5619 
    args = getCampaigns_args()
5620 
    args.read(iprot)
5621 
    iprot.readMessageEnd()
5622 
    result = getCampaigns_result()
5623 
    result.success = self._handler.getCampaigns(args.campaignName)
5624 
    oprot.writeMessageBegin("getCampaigns", TMessageType.REPLY, seqid)
5625 
    result.write(oprot)
5626 
    oprot.writeMessageEnd()
5627 
    oprot.trans.flush()
5628 
 
5629 
  def process_deleteCampaign(self, seqid, iprot, oprot):
5630 
    args = deleteCampaign_args()
5631 
    args.read(iprot)
5632 
    iprot.readMessageEnd()
5633 
    result = deleteCampaign_result()
5634 
    self._handler.deleteCampaign(args.campaignId)
5635 
    oprot.writeMessageBegin("deleteCampaign", TMessageType.REPLY, seqid)
5636 
    result.write(oprot)
5637 
    oprot.writeMessageEnd()
5638 
    oprot.trans.flush()
5639 
 
5640 
  def process_getAllCampaigns(self, seqid, iprot, oprot):
5641 
    args = getAllCampaigns_args()
5642 
    args.read(iprot)
5643 
    iprot.readMessageEnd()
5644 
    result = getAllCampaigns_result()
5645 
    result.success = self._handler.getAllCampaigns()
5646 
    oprot.writeMessageBegin("getAllCampaigns", TMessageType.REPLY, seqid)
5647 
    result.write(oprot)
5648 
    oprot.writeMessageEnd()
5649 
    oprot.trans.flush()
5650 
 
9155 kshitij.so 5651 
  def process_getActiveBannersForMobileSite(self, seqid, iprot, oprot):
5652 
    args = getActiveBannersForMobileSite_args()
5653 
    args.read(iprot)
5654 
    iprot.readMessageEnd()
5655 
    result = getActiveBannersForMobileSite_result()
5656 
    result.success = self._handler.getActiveBannersForMobileSite()
5657 
    oprot.writeMessageBegin("getActiveBannersForMobileSite", TMessageType.REPLY, seqid)
5658 
    result.write(oprot)
5659 
    oprot.writeMessageEnd()
5660 
    oprot.trans.flush()
5661 
 
5944 mandeep.dh 5662 
  def process_deleteSimilarItem(self, seqid, iprot, oprot):
5663 
    args = deleteSimilarItem_args()
5664 
    args.read(iprot)
5665 
    iprot.readMessageEnd()
5666 
    result = deleteSimilarItem_result()
5667 
    try:
5668 
      result.success = self._handler.deleteSimilarItem(args.itemId, args.catalogItemId)
5669 
    except CatalogServiceException, cex:
5670 
      result.cex = cex
5671 
    oprot.writeMessageBegin("deleteSimilarItem", TMessageType.REPLY, seqid)
5672 
    result.write(oprot)
5673 
    oprot.writeMessageEnd()
5674 
    oprot.trans.flush()
5675 
 
5676 
  def process_checkSimilarItem(self, seqid, iprot, oprot):
5677 
    args = checkSimilarItem_args()
5678 
    args.read(iprot)
5679 
    iprot.readMessageEnd()
5680 
    result = checkSimilarItem_result()
5681 
    result.success = self._handler.checkSimilarItem(args.brand, args.modelNumber, args.modelName, args.color)
5682 
    oprot.writeMessageBegin("checkSimilarItem", TMessageType.REPLY, seqid)
5683 
    result.write(oprot)
5684 
    oprot.writeMessageEnd()
5685 
    oprot.trans.flush()
5686 
 
5687 
  def process_validateRiskyStatus(self, seqid, iprot, oprot):
5688 
    args = validateRiskyStatus_args()
5689 
    args.read(iprot)
5690 
    iprot.readMessageEnd()
5691 
    result = validateRiskyStatus_result()
5692 
    self._handler.validateRiskyStatus(args.itemId)
5693 
    oprot.writeMessageBegin("validateRiskyStatus", TMessageType.REPLY, seqid)
5694 
    result.write(oprot)
5695 
    oprot.writeMessageEnd()
5696 
    oprot.trans.flush()
5697 
 
5698 
  def process_changeItemRiskyFlag(self, seqid, iprot, oprot):
5699 
    args = changeItemRiskyFlag_args()
5700 
    args.read(iprot)
5701 
    iprot.readMessageEnd()
5702 
    result = changeItemRiskyFlag_result()
5703 
    self._handler.changeItemRiskyFlag(args.itemId, args.risky)
5704 
    oprot.writeMessageBegin("changeItemRiskyFlag", TMessageType.REPLY, seqid)
5705 
    result.write(oprot)
5706 
    oprot.writeMessageEnd()
5707 
    oprot.trans.flush()
5708 
 
5709 
  def process_getItemsByRiskyFlag(self, seqid, iprot, oprot):
5710 
    args = getItemsByRiskyFlag_args()
5711 
    args.read(iprot)
5712 
    iprot.readMessageEnd()
5713 
    result = getItemsByRiskyFlag_result()
5714 
    result.success = self._handler.getItemsByRiskyFlag()
5715 
    oprot.writeMessageBegin("getItemsByRiskyFlag", TMessageType.REPLY, seqid)
5716 
    result.write(oprot)
5717 
    oprot.writeMessageEnd()
5718 
    oprot.trans.flush()
5719 
 
5720 
  def process_getItemsForMasterSheet(self, seqid, iprot, oprot):
5721 
    args = getItemsForMasterSheet_args()
5722 
    args.read(iprot)
5723 
    iprot.readMessageEnd()
5724 
    result = getItemsForMasterSheet_result()
5725 
    result.success = self._handler.getItemsForMasterSheet(args.category, args.brand)
5726 
    oprot.writeMessageBegin("getItemsForMasterSheet", TMessageType.REPLY, seqid)
5727 
    result.write(oprot)
5728 
    oprot.writeMessageEnd()
5729 
    oprot.trans.flush()
5730 
 
5731 
  def process_getSimilarItemsCatalogIds(self, seqid, iprot, oprot):
5732 
    args = getSimilarItemsCatalogIds_args()
5733 
    args.read(iprot)
5734 
    iprot.readMessageEnd()
5735 
    result = getSimilarItemsCatalogIds_result()
5736 
    result.success = self._handler.getSimilarItemsCatalogIds(args.beginIndex, args.totalItems, args.itemId)
5737 
    oprot.writeMessageBegin("getSimilarItemsCatalogIds", TMessageType.REPLY, seqid)
5738 
    result.write(oprot)
5739 
    oprot.writeMessageEnd()
5740 
    oprot.trans.flush()
5741 
 
5742 
  def process_addProductNotification(self, seqid, iprot, oprot):
5743 
    args = addProductNotification_args()
5744 
    args.read(iprot)
5745 
    iprot.readMessageEnd()
5746 
    result = addProductNotification_result()
5747 
    result.success = self._handler.addProductNotification(args.itemId, args.email)
5748 
    oprot.writeMessageBegin("addProductNotification", TMessageType.REPLY, seqid)
5749 
    result.write(oprot)
5750 
    oprot.writeMessageEnd()
5751 
    oprot.trans.flush()
5752 
 
5753 
  def process_sendProductNotifications(self, seqid, iprot, oprot):
5754 
    args = sendProductNotifications_args()
5755 
    args.read(iprot)
5756 
    iprot.readMessageEnd()
5757 
    result = sendProductNotifications_result()
5758 
    result.success = self._handler.sendProductNotifications()
5759 
    oprot.writeMessageBegin("sendProductNotifications", TMessageType.REPLY, seqid)
5760 
    result.write(oprot)
5761 
    oprot.writeMessageEnd()
5762 
    oprot.trans.flush()
5763 
 
5764 
  def process_getAllBrandsByCategory(self, seqid, iprot, oprot):
5765 
    args = getAllBrandsByCategory_args()
5766 
    args.read(iprot)
5767 
    iprot.readMessageEnd()
5768 
    result = getAllBrandsByCategory_result()
5769 
    result.success = self._handler.getAllBrandsByCategory(args.categoryId)
5770 
    oprot.writeMessageBegin("getAllBrandsByCategory", TMessageType.REPLY, seqid)
5771 
    result.write(oprot)
5772 
    oprot.writeMessageEnd()
5773 
    oprot.trans.flush()
5774 
 
5775 
  def process_getAllBrands(self, seqid, iprot, oprot):
5776 
    args = getAllBrands_args()
5777 
    args.read(iprot)
5778 
    iprot.readMessageEnd()
5779 
    result = getAllBrands_result()
5780 
    result.success = self._handler.getAllBrands()
5781 
    oprot.writeMessageBegin("getAllBrands", TMessageType.REPLY, seqid)
5782 
    result.write(oprot)
5783 
    oprot.writeMessageEnd()
5784 
    oprot.trans.flush()
5785 
 
5786 
  def process_getAllSources(self, seqid, iprot, oprot):
5787 
    args = getAllSources_args()
5788 
    args.read(iprot)
5789 
    iprot.readMessageEnd()
5790 
    result = getAllSources_result()
5791 
    result.success = self._handler.getAllSources()
5792 
    oprot.writeMessageBegin("getAllSources", TMessageType.REPLY, seqid)
5793 
    result.write(oprot)
5794 
    oprot.writeMessageEnd()
5795 
    oprot.trans.flush()
5796 
 
5797 
  def process_getItemPricingBySource(self, seqid, iprot, oprot):
5798 
    args = getItemPricingBySource_args()
5799 
    args.read(iprot)
5800 
    iprot.readMessageEnd()
5801 
    result = getItemPricingBySource_result()
5802 
    try:
5803 
      result.success = self._handler.getItemPricingBySource(args.itemId, args.sourceId)
5804 
    except CatalogServiceException, cex:
5805 
      result.cex = cex
5806 
    oprot.writeMessageBegin("getItemPricingBySource", TMessageType.REPLY, seqid)
5807 
    result.write(oprot)
5808 
    oprot.writeMessageEnd()
5809 
    oprot.trans.flush()
5810 
 
5811 
  def process_addSourceItemPricing(self, seqid, iprot, oprot):
5812 
    args = addSourceItemPricing_args()
5813 
    args.read(iprot)
5814 
    iprot.readMessageEnd()
5815 
    result = addSourceItemPricing_result()
5816 
    try:
5817 
      self._handler.addSourceItemPricing(args.sourceItemPricing)
5818 
    except CatalogServiceException, cex:
5819 
      result.cex = cex
5820 
    oprot.writeMessageBegin("addSourceItemPricing", TMessageType.REPLY, seqid)
5821 
    result.write(oprot)
5822 
    oprot.writeMessageEnd()
5823 
    oprot.trans.flush()
5824 
 
5825 
  def process_getAllSourcePricing(self, seqid, iprot, oprot):
5826 
    args = getAllSourcePricing_args()
5827 
    args.read(iprot)
5828 
    iprot.readMessageEnd()
5829 
    result = getAllSourcePricing_result()
5830 
    try:
5831 
      result.success = self._handler.getAllSourcePricing(args.itemId)
5832 
    except CatalogServiceException, cex:
5833 
      result.cex = cex
5834 
    oprot.writeMessageBegin("getAllSourcePricing", TMessageType.REPLY, seqid)
5835 
    result.write(oprot)
5836 
    oprot.writeMessageEnd()
5837 
    oprot.trans.flush()
5838 
 
5839 
  def process_getItemForSource(self, seqid, iprot, oprot):
5840 
    args = getItemForSource_args()
5841 
    args.read(iprot)
5842 
    iprot.readMessageEnd()
5843 
    result = getItemForSource_result()
5844 
    try:
5845 
      result.success = self._handler.getItemForSource(args.item_id, args.sourceId)
5846 
    except CatalogServiceException, cex:
5847 
      result.cex = cex
5848 
    oprot.writeMessageBegin("getItemForSource", TMessageType.REPLY, seqid)
5849 
    result.write(oprot)
5850 
    oprot.writeMessageEnd()
5851 
    oprot.trans.flush()
5852 
 
5853 
  def process_searchItemsInRange(self, seqid, iprot, oprot):
5854 
    args = searchItemsInRange_args()
5855 
    args.read(iprot)
5856 
    iprot.readMessageEnd()
5857 
    result = searchItemsInRange_result()
5858 
    result.success = self._handler.searchItemsInRange(args.searchTerms, args.offset, args.limit)
5859 
    oprot.writeMessageBegin("searchItemsInRange", TMessageType.REPLY, seqid)
5860 
    result.write(oprot)
5861 
    oprot.writeMessageEnd()
5862 
    oprot.trans.flush()
5863 
 
5864 
  def process_getSearchResultCount(self, seqid, iprot, oprot):
5865 
    args = getSearchResultCount_args()
5866 
    args.read(iprot)
5867 
    iprot.readMessageEnd()
5868 
    result = getSearchResultCount_result()
5869 
    result.success = self._handler.getSearchResultCount(args.searchTerms)
5870 
    oprot.writeMessageBegin("getSearchResultCount", TMessageType.REPLY, seqid)
5871 
    result.write(oprot)
5872 
    oprot.writeMessageEnd()
5873 
    oprot.trans.flush()
5874 
 
5875 
  def process_getProductNotifications(self, seqid, iprot, oprot):
5876 
    args = getProductNotifications_args()
5877 
    args.read(iprot)
5878 
    iprot.readMessageEnd()
5879 
    result = getProductNotifications_result()
5880 
    result.success = self._handler.getProductNotifications(args.startDateTime)
5881 
    oprot.writeMessageBegin("getProductNotifications", TMessageType.REPLY, seqid)
5882 
    result.write(oprot)
5883 
    oprot.writeMessageEnd()
5884 
    oprot.trans.flush()
5885 
 
5886 
  def process_getProductNotificationRequestCount(self, seqid, iprot, oprot):
5887 
    args = getProductNotificationRequestCount_args()
5888 
    args.read(iprot)
5889 
    iprot.readMessageEnd()
5890 
    result = getProductNotificationRequestCount_result()
7897 amar.kumar 5891 
    result.success = self._handler.getProductNotificationRequestCount(args.startDateTime, args.categoryId)
5944 mandeep.dh 5892 
    oprot.writeMessageBegin("getProductNotificationRequestCount", TMessageType.REPLY, seqid)
5893 
    result.write(oprot)
5894 
    oprot.writeMessageEnd()
5895 
    oprot.trans.flush()
5896 
 
5897 
  def process_addAuthorizationLog(self, seqid, iprot, oprot):
5898 
    args = addAuthorizationLog_args()
5899 
    args.read(iprot)
5900 
    iprot.readMessageEnd()
5901 
    result = addAuthorizationLog_result()
5902 
    try:
5903 
      result.success = self._handler.addAuthorizationLog(args.itemId, args.username, args.reason)
5904 
    except CatalogServiceException, cex:
5905 
      result.cex = cex
5906 
    oprot.writeMessageBegin("addAuthorizationLog", TMessageType.REPLY, seqid)
5907 
    result.write(oprot)
5908 
    oprot.writeMessageEnd()
5909 
    oprot.trans.flush()
5910 
 
5911 
  def process_addupdateVoucherForItem(self, seqid, iprot, oprot):
5912 
    args = addupdateVoucherForItem_args()
5913 
    args.read(iprot)
5914 
    iprot.readMessageEnd()
5915 
    result = addupdateVoucherForItem_result()
5916 
    try:
5917 
      result.success = self._handler.addupdateVoucherForItem(args.catalog_item_id, args.voucherType, args.voucherAmount)
5918 
    except CatalogServiceException, cex:
5919 
      result.cex = cex
5920 
    oprot.writeMessageBegin("addupdateVoucherForItem", TMessageType.REPLY, seqid)
5921 
    result.write(oprot)
5922 
    oprot.writeMessageEnd()
5923 
    oprot.trans.flush()
5924 
 
5925 
  def process_deleteVoucherForItem(self, seqid, iprot, oprot):
5926 
    args = deleteVoucherForItem_args()
5927 
    args.read(iprot)
5928 
    iprot.readMessageEnd()
5929 
    result = deleteVoucherForItem_result()
5930 
    try:
5931 
      result.success = self._handler.deleteVoucherForItem(args.catalog_item_id, args.voucherType)
5932 
    except CatalogServiceException, cex:
5933 
      result.cex = cex
5934 
    oprot.writeMessageBegin("deleteVoucherForItem", TMessageType.REPLY, seqid)
5935 
    result.write(oprot)
5936 
    oprot.writeMessageEnd()
5937 
    oprot.trans.flush()
5938 
 
5939 
  def process_getVoucherAmount(self, seqid, iprot, oprot):
5940 
    args = getVoucherAmount_args()
5941 
    args.read(iprot)
5942 
    iprot.readMessageEnd()
5943 
    result = getVoucherAmount_result()
5944 
    result.success = self._handler.getVoucherAmount(args.itemId, args.voucherType)
5945 
    oprot.writeMessageBegin("getVoucherAmount", TMessageType.REPLY, seqid)
5946 
    result.write(oprot)
5947 
    oprot.writeMessageEnd()
5948 
    oprot.trans.flush()
5949 
 
5950 
  def process_getAllItemVouchers(self, seqid, iprot, oprot):
5951 
    args = getAllItemVouchers_args()
5952 
    args.read(iprot)
5953 
    iprot.readMessageEnd()
5954 
    result = getAllItemVouchers_result()
5955 
    result.success = self._handler.getAllItemVouchers(args.itemId)
5956 
    oprot.writeMessageBegin("getAllItemVouchers", TMessageType.REPLY, seqid)
5957 
    result.write(oprot)
5958 
    oprot.writeMessageEnd()
5959 
    oprot.trans.flush()
5960 
 
5961 
  def process_isValidCatalogItemId(self, seqid, iprot, oprot):
5962 
    args = isValidCatalogItemId_args()
5963 
    args.read(iprot)
5964 
    iprot.readMessageEnd()
5965 
    result = isValidCatalogItemId_result()
5966 
    result.success = self._handler.isValidCatalogItemId(args.catalog_item_id)
5967 
    oprot.writeMessageBegin("isValidCatalogItemId", TMessageType.REPLY, seqid)
5968 
    result.write(oprot)
5969 
    oprot.writeMessageEnd()
5970 
    oprot.trans.flush()
5971 
 
6039 amit.gupta 5972 
  def process_getVatPercentageForItem(self, seqid, iprot, oprot):
5973 
    args = getVatPercentageForItem_args()
5974 
    args.read(iprot)
5975 
    iprot.readMessageEnd()
5976 
    result = getVatPercentageForItem_result()
7340 amit.gupta 5977 
    try:
5978 
      result.success = self._handler.getVatPercentageForItem(args.itemId, args.stateId, args.price)
5979 
    except CatalogServiceException, cex:
5980 
      result.cex = cex
6039 amit.gupta 5981 
    oprot.writeMessageBegin("getVatPercentageForItem", TMessageType.REPLY, seqid)
5982 
    result.write(oprot)
5983 
    oprot.writeMessageEnd()
5984 
    oprot.trans.flush()
5944 mandeep.dh 5985 
 
6039 amit.gupta 5986 
  def process_getVatAmountForItem(self, seqid, iprot, oprot):
5987 
    args = getVatAmountForItem_args()
5988 
    args.read(iprot)
5989 
    iprot.readMessageEnd()
5990 
    result = getVatAmountForItem_result()
5991 
    result.success = self._handler.getVatAmountForItem(args.itemId, args.price)
5992 
    oprot.writeMessageBegin("getVatAmountForItem", TMessageType.REPLY, seqid)
5993 
    result.write(oprot)
5994 
    oprot.writeMessageEnd()
5995 
    oprot.trans.flush()
5996 
 
6531 vikram.rag 5997 
  def process_getAllIgnoredInventoryUpdateItemsList(self, seqid, iprot, oprot):
5998 
    args = getAllIgnoredInventoryUpdateItemsList_args()
5999 
    args.read(iprot)
6000 
    iprot.readMessageEnd()
6001 
    result = getAllIgnoredInventoryUpdateItemsList_result()
6002 
    result.success = self._handler.getAllIgnoredInventoryUpdateItemsList(args.offset, args.limit)
6003 
    oprot.writeMessageBegin("getAllIgnoredInventoryUpdateItemsList", TMessageType.REPLY, seqid)
6004 
    result.write(oprot)
6005 
    oprot.writeMessageEnd()
6006 
    oprot.trans.flush()
6039 amit.gupta 6007 
 
6821 amar.kumar 6008 
  def process_getAllAliveItems(self, seqid, iprot, oprot):
6009 
    args = getAllAliveItems_args()
6010 
    args.read(iprot)
6011 
    iprot.readMessageEnd()
6012 
    result = getAllAliveItems_result()
6013 
    result.success = self._handler.getAllAliveItems()
6014 
    oprot.writeMessageBegin("getAllAliveItems", TMessageType.REPLY, seqid)
6015 
    result.write(oprot)
6016 
    oprot.writeMessageEnd()
6017 
    oprot.trans.flush()
6018 
 
6805 anupam.sin 6019 
  def process_getInsuranceAmount(self, seqid, iprot, oprot):
6020 
    args = getInsuranceAmount_args()
6021 
    args.read(iprot)
6022 
    iprot.readMessageEnd()
6023 
    result = getInsuranceAmount_result()
6921 anupam.sin 6024 
    result.success = self._handler.getInsuranceAmount(args.itemId, args.price, args.insurerId, args.quantity)
6805 anupam.sin 6025 
    oprot.writeMessageBegin("getInsuranceAmount", TMessageType.REPLY, seqid)
6026 
    result.write(oprot)
6027 
    oprot.writeMessageEnd()
6028 
    oprot.trans.flush()
6531 vikram.rag 6029 
 
6805 anupam.sin 6030 
  def process_getInsurer(self, seqid, iprot, oprot):
6031 
    args = getInsurer_args()
6032 
    args.read(iprot)
6033 
    iprot.readMessageEnd()
6034 
    result = getInsurer_result()
6035 
    result.success = self._handler.getInsurer(args.insurerId)
6036 
    oprot.writeMessageBegin("getInsurer", TMessageType.REPLY, seqid)
6037 
    result.write(oprot)
6038 
    oprot.writeMessageEnd()
6039 
    oprot.trans.flush()
6040 
 
6838 vikram.rag 6041 
  def process_getAllInsurers(self, seqid, iprot, oprot):
6042 
    args = getAllInsurers_args()
6043 
    args.read(iprot)
6044 
    iprot.readMessageEnd()
6045 
    result = getAllInsurers_result()
6046 
    result.success = self._handler.getAllInsurers()
6047 
    oprot.writeMessageBegin("getAllInsurers", TMessageType.REPLY, seqid)
6048 
    result.write(oprot)
6049 
    oprot.writeMessageEnd()
6050 
    oprot.trans.flush()
6805 anupam.sin 6051 
 
6962 rajveer 6052 
  def process_updateInsuranceDeclaredAmount(self, seqid, iprot, oprot):
6053 
    args = updateInsuranceDeclaredAmount_args()
6054 
    args.read(iprot)
6055 
    iprot.readMessageEnd()
6056 
    result = updateInsuranceDeclaredAmount_result()
6057 
    self._handler.updateInsuranceDeclaredAmount(args.insurerId, args.amount)
6058 
    oprot.writeMessageBegin("updateInsuranceDeclaredAmount", TMessageType.REPLY, seqid)
6059 
    result.write(oprot)
6060 
    oprot.writeMessageEnd()
6061 
    oprot.trans.flush()
6838 vikram.rag 6062 
 
7190 amar.kumar 6063 
  def process_getFreebieForItem(self, seqid, iprot, oprot):
6064 
    args = getFreebieForItem_args()
6065 
    args.read(iprot)
6066 
    iprot.readMessageEnd()
6067 
    result = getFreebieForItem_result()
6068 
    result.success = self._handler.getFreebieForItem(args.itemId)
6069 
    oprot.writeMessageBegin("getFreebieForItem", TMessageType.REPLY, seqid)
6070 
    result.write(oprot)
6071 
    oprot.writeMessageEnd()
6072 
    oprot.trans.flush()
6962 rajveer 6073 
 
7190 amar.kumar 6074 
  def process_addOrUpdateFreebieForItem(self, seqid, iprot, oprot):
6075 
    args = addOrUpdateFreebieForItem_args()
6076 
    args.read(iprot)
6077 
    iprot.readMessageEnd()
6078 
    result = addOrUpdateFreebieForItem_result()
6079 
    self._handler.addOrUpdateFreebieForItem(args.freebieItem)
6080 
    oprot.writeMessageBegin("addOrUpdateFreebieForItem", TMessageType.REPLY, seqid)
6081 
    result.write(oprot)
6082 
    oprot.writeMessageEnd()
6083 
    oprot.trans.flush()
6084 
 
7272 amit.gupta 6085 
  def process_addOrUpdateBrandInfo(self, seqid, iprot, oprot):
6086 
    args = addOrUpdateBrandInfo_args()
6087 
    args.read(iprot)
6088 
    iprot.readMessageEnd()
6089 
    result = addOrUpdateBrandInfo_result()
6090 
    self._handler.addOrUpdateBrandInfo(args.brandInfo)
6091 
    oprot.writeMessageBegin("addOrUpdateBrandInfo", TMessageType.REPLY, seqid)
6092 
    result.write(oprot)
6093 
    oprot.writeMessageEnd()
6094 
    oprot.trans.flush()
6095 
 
6096 
  def process_getBrandInfo(self, seqid, iprot, oprot):
6097 
    args = getBrandInfo_args()
6098 
    args.read(iprot)
6099 
    iprot.readMessageEnd()
6100 
    result = getBrandInfo_result()
6101 
    result.success = self._handler.getBrandInfo()
6102 
    oprot.writeMessageBegin("getBrandInfo", TMessageType.REPLY, seqid)
6103 
    result.write(oprot)
6104 
    oprot.writeMessageEnd()
6105 
    oprot.trans.flush()
6106 
 
7256 rajveer 6107 
  def process_getStorePricing(self, seqid, iprot, oprot):
6108 
    args = getStorePricing_args()
6109 
    args.read(iprot)
6110 
    iprot.readMessageEnd()
6111 
    result = getStorePricing_result()
6112 
    result.success = self._handler.getStorePricing(args.itemId)
6113 
    oprot.writeMessageBegin("getStorePricing", TMessageType.REPLY, seqid)
6114 
    result.write(oprot)
6115 
    oprot.writeMessageEnd()
6116 
    oprot.trans.flush()
7190 amar.kumar 6117 
 
7306 rajveer 6118 
  def process_getStorePricings(self, seqid, iprot, oprot):
6119 
    args = getStorePricings_args()
6120 
    args.read(iprot)
6121 
    iprot.readMessageEnd()
6122 
    result = getStorePricings_result()
6123 
    result.success = self._handler.getStorePricings(args.itemIds)
6124 
    oprot.writeMessageBegin("getStorePricings", TMessageType.REPLY, seqid)
6125 
    result.write(oprot)
6126 
    oprot.writeMessageEnd()
6127 
    oprot.trans.flush()
6128 
 
7265 rajveer 6129 
  def process_updateStorePricing(self, seqid, iprot, oprot):
6130 
    args = updateStorePricing_args()
6131 
    args.read(iprot)
6132 
    iprot.readMessageEnd()
6133 
    result = updateStorePricing_result()
7382 rajveer 6134 
    self._handler.updateStorePricing(args.sp, args.allColors)
7265 rajveer 6135 
    oprot.writeMessageBegin("updateStorePricing", TMessageType.REPLY, seqid)
6136 
    result.write(oprot)
6137 
    oprot.writeMessageEnd()
6138 
    oprot.trans.flush()
7256 rajveer 6139 
 
7281 kshitij.so 6140 
  def process_getAllAmazonListedItems(self, seqid, iprot, oprot):
6141 
    args = getAllAmazonListedItems_args()
6142 
    args.read(iprot)
6143 
    iprot.readMessageEnd()
6144 
    result = getAllAmazonListedItems_result()
6145 
    result.success = self._handler.getAllAmazonListedItems()
6146 
    oprot.writeMessageBegin("getAllAmazonListedItems", TMessageType.REPLY, seqid)
6147 
    result.write(oprot)
6148 
    oprot.writeMessageEnd()
6149 
    oprot.trans.flush()
7265 rajveer 6150 
 
8619 kshitij.so 6151 
  def process_searchAmazonItems(self, seqid, iprot, oprot):
6152 
    args = searchAmazonItems_args()
6153 
    args.read(iprot)
6154 
    iprot.readMessageEnd()
6155 
    result = searchAmazonItems_result()
6156 
    result.success = self._handler.searchAmazonItems(args.searchTerm, args.offset, args.limit)
6157 
    oprot.writeMessageBegin("searchAmazonItems", TMessageType.REPLY, seqid)
6158 
    result.write(oprot)
6159 
    oprot.writeMessageEnd()
6160 
    oprot.trans.flush()
6161 
 
6162 
  def process_getAmazonSearchResultCount(self, seqid, iprot, oprot):
6163 
    args = getAmazonSearchResultCount_args()
6164 
    args.read(iprot)
6165 
    iprot.readMessageEnd()
6166 
    result = getAmazonSearchResultCount_result()
6167 
    result.success = self._handler.getAmazonSearchResultCount(args.searchTerm)
6168 
    oprot.writeMessageBegin("getAmazonSearchResultCount", TMessageType.REPLY, seqid)
6169 
    result.write(oprot)
6170 
    oprot.writeMessageEnd()
6171 
    oprot.trans.flush()
6172 
 
6173 
  def process_getCountForAmazonlistedItems(self, seqid, iprot, oprot):
6174 
    args = getCountForAmazonlistedItems_args()
6175 
    args.read(iprot)
6176 
    iprot.readMessageEnd()
6177 
    result = getCountForAmazonlistedItems_result()
6178 
    result.success = self._handler.getCountForAmazonlistedItems()
6179 
    oprot.writeMessageBegin("getCountForAmazonlistedItems", TMessageType.REPLY, seqid)
6180 
    result.write(oprot)
6181 
    oprot.writeMessageEnd()
6182 
    oprot.trans.flush()
6183 
 
7281 kshitij.so 6184 
  def process_getAmazonItemDetails(self, seqid, iprot, oprot):
6185 
    args = getAmazonItemDetails_args()
6186 
    args.read(iprot)
6187 
    iprot.readMessageEnd()
6188 
    result = getAmazonItemDetails_result()
6189 
    result.success = self._handler.getAmazonItemDetails(args.itemId)
6190 
    oprot.writeMessageBegin("getAmazonItemDetails", TMessageType.REPLY, seqid)
6191 
    result.write(oprot)
6192 
    oprot.writeMessageEnd()
6193 
    oprot.trans.flush()
6194 
 
6195 
  def process_updateAmazonItemDetails(self, seqid, iprot, oprot):
6196 
    args = updateAmazonItemDetails_args()
6197 
    args.read(iprot)
6198 
    iprot.readMessageEnd()
6199 
    result = updateAmazonItemDetails_result()
8168 kshitij.so 6200 
    self._handler.updateAmazonItemDetails(args.amazonlisted)
7281 kshitij.so 6201 
    oprot.writeMessageBegin("updateAmazonItemDetails", TMessageType.REPLY, seqid)
6202 
    result.write(oprot)
6203 
    oprot.writeMessageEnd()
6204 
    oprot.trans.flush()
6205 
 
6206 
  def process_addAmazonItem(self, seqid, iprot, oprot):
6207 
    args = addAmazonItem_args()
6208 
    args.read(iprot)
6209 
    iprot.readMessageEnd()
6210 
    result = addAmazonItem_result()
6211 
    self._handler.addAmazonItem(args.amazonlisted)
6212 
    oprot.writeMessageBegin("addAmazonItem", TMessageType.REPLY, seqid)
6213 
    result.write(oprot)
6214 
    oprot.writeMessageEnd()
6215 
    oprot.trans.flush()
6216 
 
7291 vikram.rag 6217 
  def process_getAsinItems(self, seqid, iprot, oprot):
6218 
    args = getAsinItems_args()
6219 
    args.read(iprot)
6220 
    iprot.readMessageEnd()
6221 
    result = getAsinItems_result()
6222 
    result.success = self._handler.getAsinItems()
6223 
    oprot.writeMessageBegin("getAsinItems", TMessageType.REPLY, seqid)
6224 
    result.write(oprot)
6225 
    oprot.writeMessageEnd()
6226 
    oprot.trans.flush()
7281 kshitij.so 6227 
 
7291 vikram.rag 6228 
  def process_getAllFbaListedItems(self, seqid, iprot, oprot):
6229 
    args = getAllFbaListedItems_args()
6230 
    args.read(iprot)
6231 
    iprot.readMessageEnd()
6232 
    result = getAllFbaListedItems_result()
6233 
    result.success = self._handler.getAllFbaListedItems()
6234 
    oprot.writeMessageBegin("getAllFbaListedItems", TMessageType.REPLY, seqid)
6235 
    result.write(oprot)
6236 
    oprot.writeMessageEnd()
6237 
    oprot.trans.flush()
6238 
 
6239 
  def process_getAllNonFbaListedItems(self, seqid, iprot, oprot):
6240 
    args = getAllNonFbaListedItems_args()
6241 
    args.read(iprot)
6242 
    iprot.readMessageEnd()
6243 
    result = getAllNonFbaListedItems_result()
6244 
    result.success = self._handler.getAllNonFbaListedItems()
6245 
    oprot.writeMessageBegin("getAllNonFbaListedItems", TMessageType.REPLY, seqid)
6246 
    result.write(oprot)
6247 
    oprot.writeMessageEnd()
6248 
    oprot.trans.flush()
6249 
 
7460 kshitij.so 6250 
  def process_updateItemInventory(self, seqid, iprot, oprot):
6251 
    args = updateItemInventory_args()
6252 
    args.read(iprot)
6253 
    iprot.readMessageEnd()
6254 
    result = updateItemInventory_result()
6255 
    result.success = self._handler.updateItemInventory(args.itemId, args.holdInventory, args.defaultInventory)
6256 
    oprot.writeMessageBegin("updateItemInventory", TMessageType.REPLY, seqid)
6257 
    result.write(oprot)
6258 
    oprot.writeMessageEnd()
6259 
    oprot.trans.flush()
7291 vikram.rag 6260 
 
7770 kshitij.so 6261 
  def process_updateTimestampForAmazonFeeds(self, seqid, iprot, oprot):
6262 
    args = updateTimestampForAmazonFeeds_args()
6263 
    args.read(iprot)
6264 
    iprot.readMessageEnd()
6265 
    result = updateTimestampForAmazonFeeds_result()
6266 
    result.success = self._handler.updateTimestampForAmazonFeeds(args.type, args.sku, args.timestamp)
6267 
    oprot.writeMessageBegin("updateTimestampForAmazonFeeds", TMessageType.REPLY, seqid)
6268 
    result.write(oprot)
6269 
    oprot.writeMessageEnd()
6270 
    oprot.trans.flush()
7460 kshitij.so 6271 
 
7897 amar.kumar 6272 
  def process_getAllParentCategories(self, seqid, iprot, oprot):
6273 
    args = getAllParentCategories_args()
6274 
    args.read(iprot)
6275 
    iprot.readMessageEnd()
6276 
    result = getAllParentCategories_result()
6277 
    result.success = self._handler.getAllParentCategories()
6278 
    oprot.writeMessageBegin("getAllParentCategories", TMessageType.REPLY, seqid)
6279 
    result.write(oprot)
6280 
    oprot.writeMessageEnd()
6281 
    oprot.trans.flush()
7770 kshitij.so 6282 
 
7977 kshitij.so 6283 
  def process_addPageViewEvent(self, seqid, iprot, oprot):
6284 
    args = addPageViewEvent_args()
6285 
    args.read(iprot)
6286 
    iprot.readMessageEnd()
6287 
    result = addPageViewEvent_result()
6288 
    self._handler.addPageViewEvent(args.pageViewEvents)
6289 
    oprot.writeMessageBegin("addPageViewEvent", TMessageType.REPLY, seqid)
6290 
    result.write(oprot)
6291 
    oprot.writeMessageEnd()
6292 
    oprot.trans.flush()
7897 amar.kumar 6293 
 
7977 kshitij.so 6294 
  def process_addCartEvent(self, seqid, iprot, oprot):
6295 
    args = addCartEvent_args()
6296 
    args.read(iprot)
6297 
    iprot.readMessageEnd()
6298 
    result = addCartEvent_result()
6299 
    self._handler.addCartEvent(args.cartEvents)
6300 
    oprot.writeMessageBegin("addCartEvent", TMessageType.REPLY, seqid)
6301 
    result.write(oprot)
6302 
    oprot.writeMessageEnd()
6303 
    oprot.trans.flush()
6304 
 
8182 amar.kumar 6305 
  def process_addEbayItem(self, seqid, iprot, oprot):
6306 
    args = addEbayItem_args()
6307 
    args.read(iprot)
6308 
    iprot.readMessageEnd()
6309 
    result = addEbayItem_result()
6310 
    self._handler.addEbayItem(args.ebayItem)
6311 
    oprot.writeMessageBegin("addEbayItem", TMessageType.REPLY, seqid)
6312 
    result.write(oprot)
6313 
    oprot.writeMessageEnd()
6314 
    oprot.trans.flush()
6315 
 
6316 
  def process_getEbayItem(self, seqid, iprot, oprot):
6317 
    args = getEbayItem_args()
6318 
    args.read(iprot)
6319 
    iprot.readMessageEnd()
6320 
    result = getEbayItem_result()
6321 
    result.success = self._handler.getEbayItem(args.listingId)
6322 
    oprot.writeMessageBegin("getEbayItem", TMessageType.REPLY, seqid)
6323 
    result.write(oprot)
6324 
    oprot.writeMessageEnd()
6325 
    oprot.trans.flush()
6326 
 
6327 
  def process_updateEbayItem(self, seqid, iprot, oprot):
6328 
    args = updateEbayItem_args()
6329 
    args.read(iprot)
6330 
    iprot.readMessageEnd()
6331 
    result = updateEbayItem_result()
6332 
    self._handler.updateEbayItem(args.ebayItem)
6333 
    oprot.writeMessageBegin("updateEbayItem", TMessageType.REPLY, seqid)
6334 
    result.write(oprot)
6335 
    oprot.writeMessageEnd()
6336 
    oprot.trans.flush()
6337 
 
8139 kshitij.so 6338 
  def process_getAmazonListedItems(self, seqid, iprot, oprot):
6339 
    args = getAmazonListedItems_args()
6340 
    args.read(iprot)
6341 
    iprot.readMessageEnd()
6342 
    result = getAmazonListedItems_result()
6343 
    result.success = self._handler.getAmazonListedItems(args.offset, args.limit)
6344 
    oprot.writeMessageBegin("getAmazonListedItems", TMessageType.REPLY, seqid)
6345 
    result.write(oprot)
6346 
    oprot.writeMessageEnd()
6347 
    oprot.trans.flush()
7977 kshitij.so 6348 
 
8168 kshitij.so 6349 
  def process_updateAmazonAttributesInBulk(self, seqid, iprot, oprot):
6350 
    args = updateAmazonAttributesInBulk_args()
6351 
    args.read(iprot)
6352 
    iprot.readMessageEnd()
6353 
    result = updateAmazonAttributesInBulk_result()
6354 
    result.success = self._handler.updateAmazonAttributesInBulk(args.amazonlisted)
6355 
    oprot.writeMessageBegin("updateAmazonAttributesInBulk", TMessageType.REPLY, seqid)
6356 
    result.write(oprot)
6357 
    oprot.writeMessageEnd()
6358 
    oprot.trans.flush()
8139 kshitij.so 6359 
 
8379 vikram.rag 6360 
  def process_getAllItemstoListOnFba(self, seqid, iprot, oprot):
6361 
    args = getAllItemstoListOnFba_args()
6362 
    args.read(iprot)
6363 
    iprot.readMessageEnd()
6364 
    result = getAllItemstoListOnFba_result()
6365 
    result.success = self._handler.getAllItemstoListOnFba()
6366 
    oprot.writeMessageBegin("getAllItemstoListOnFba", TMessageType.REPLY, seqid)
6367 
    result.write(oprot)
6368 
    oprot.writeMessageEnd()
6369 
    oprot.trans.flush()
8168 kshitij.so 6370 
 
8379 vikram.rag 6371 
  def process_getAllItemstoListOnNonFba(self, seqid, iprot, oprot):
6372 
    args = getAllItemstoListOnNonFba_args()
6373 
    args.read(iprot)
6374 
    iprot.readMessageEnd()
6375 
    result = getAllItemstoListOnNonFba_result()
6376 
    result.success = self._handler.getAllItemstoListOnNonFba()
6377 
    oprot.writeMessageBegin("getAllItemstoListOnNonFba", TMessageType.REPLY, seqid)
6378 
    result.write(oprot)
6379 
    oprot.writeMessageEnd()
6380 
    oprot.trans.flush()
6381 
 
8616 vikram.rag 6382 
  def process_getAllSnapdealListedActiveItems(self, seqid, iprot, oprot):
6383 
    args = getAllSnapdealListedActiveItems_args()
6384 
    args.read(iprot)
6385 
    iprot.readMessageEnd()
6386 
    result = getAllSnapdealListedActiveItems_result()
6387 
    result.success = self._handler.getAllSnapdealListedActiveItems()
6388 
    oprot.writeMessageBegin("getAllSnapdealListedActiveItems", TMessageType.REPLY, seqid)
6389 
    result.write(oprot)
6390 
    oprot.writeMessageEnd()
6391 
    oprot.trans.flush()
8379 vikram.rag 6392 
 
8619 kshitij.so 6393 
  def process_updateAsin(self, seqid, iprot, oprot):
6394 
    args = updateAsin_args()
6395 
    args.read(iprot)
6396 
    iprot.readMessageEnd()
6397 
    result = updateAsin_result()
6398 
    self._handler.updateAsin(args.item)
6399 
    oprot.writeMessageBegin("updateAsin", TMessageType.REPLY, seqid)
6400 
    result.write(oprot)
6401 
    oprot.writeMessageEnd()
6402 
    oprot.trans.flush()
8616 vikram.rag 6403 
 
8739 vikram.rag 6404 
  def process_addOrUpdateSnapdealItem(self, seqid, iprot, oprot):
6405 
    args = addOrUpdateSnapdealItem_args()
6406 
    args.read(iprot)
6407 
    iprot.readMessageEnd()
6408 
    result = addOrUpdateSnapdealItem_result()
6409 
    result.success = self._handler.addOrUpdateSnapdealItem(args.snapdealitem)
6410 
    oprot.writeMessageBegin("addOrUpdateSnapdealItem", TMessageType.REPLY, seqid)
6411 
    result.write(oprot)
6412 
    oprot.writeMessageEnd()
6413 
    oprot.trans.flush()
8619 kshitij.so 6414 
 
8739 vikram.rag 6415 
  def process_getSnapdealItem(self, seqid, iprot, oprot):
6416 
    args = getSnapdealItem_args()
6417 
    args.read(iprot)
6418 
    iprot.readMessageEnd()
6419 
    result = getSnapdealItem_result()
6420 
    result.success = self._handler.getSnapdealItem(args.item_id)
6421 
    oprot.writeMessageBegin("getSnapdealItem", TMessageType.REPLY, seqid)
6422 
    result.write(oprot)
6423 
    oprot.writeMessageEnd()
6424 
    oprot.trans.flush()
6425 
 
6426 
  def process_getAllSnapdealItems(self, seqid, iprot, oprot):
6427 
    args = getAllSnapdealItems_args()
6428 
    args.read(iprot)
6429 
    iprot.readMessageEnd()
6430 
    result = getAllSnapdealItems_result()
6431 
    result.success = self._handler.getAllSnapdealItems()
6432 
    oprot.writeMessageBegin("getAllSnapdealItems", TMessageType.REPLY, seqid)
6433 
    result.write(oprot)
6434 
    oprot.writeMessageEnd()
6435 
    oprot.trans.flush()
6436 
 
6437 
 
5944 mandeep.dh 6438 
# HELPER FUNCTIONS AND STRUCTURES
6439 
 
6440 
class addItem_args:
6441 
  """
6442 
  Attributes:
6443 
   - item
6444 
  """
6445 
 
6446 
  thrift_spec = (
6447 
    None, # 0
6448 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
6449 
  )
6450 
 
6451 
  def __init__(self, item=None,):
6452 
    self.item = item
6453 
 
6454 
  def read(self, iprot):
6455 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6456 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6457 
      return
6458 
    iprot.readStructBegin()
6459 
    while True:
6460 
      (fname, ftype, fid) = iprot.readFieldBegin()
6461 
      if ftype == TType.STOP:
6462 
        break
6463 
      if fid == 1:
6464 
        if ftype == TType.STRUCT:
6465 
          self.item = Item()
6466 
          self.item.read(iprot)
6467 
        else:
6468 
          iprot.skip(ftype)
6469 
      else:
6470 
        iprot.skip(ftype)
6471 
      iprot.readFieldEnd()
6472 
    iprot.readStructEnd()
6473 
 
6474 
  def write(self, oprot):
6475 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6476 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6477 
      return
6478 
    oprot.writeStructBegin('addItem_args')
6479 
    if self.item is not None:
6480 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
6481 
      self.item.write(oprot)
6482 
      oprot.writeFieldEnd()
6483 
    oprot.writeFieldStop()
6484 
    oprot.writeStructEnd()
6485 
 
6486 
  def validate(self):
6487 
    return
6488 
 
6489 
 
6490 
  def __repr__(self):
6491 
    L = ['%s=%r' % (key, value)
6492 
      for key, value in self.__dict__.iteritems()]
6493 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6494 
 
6495 
  def __eq__(self, other):
6496 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6497 
 
6498 
  def __ne__(self, other):
6499 
    return not (self == other)
6500 
 
6501 
class addItem_result:
6502 
  """
6503 
  Attributes:
6504 
   - success
6505 
   - cex
6506 
  """
6507 
 
6508 
  thrift_spec = (
6509 
    (0, TType.I64, 'success', None, None, ), # 0
6510 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6511 
  )
6512 
 
6513 
  def __init__(self, success=None, cex=None,):
6514 
    self.success = success
6515 
    self.cex = cex
6516 
 
6517 
  def read(self, iprot):
6518 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6519 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6520 
      return
6521 
    iprot.readStructBegin()
6522 
    while True:
6523 
      (fname, ftype, fid) = iprot.readFieldBegin()
6524 
      if ftype == TType.STOP:
6525 
        break
6526 
      if fid == 0:
6527 
        if ftype == TType.I64:
6528 
          self.success = iprot.readI64();
6529 
        else:
6530 
          iprot.skip(ftype)
6531 
      elif fid == 1:
6532 
        if ftype == TType.STRUCT:
6533 
          self.cex = CatalogServiceException()
6534 
          self.cex.read(iprot)
6535 
        else:
6536 
          iprot.skip(ftype)
6537 
      else:
6538 
        iprot.skip(ftype)
6539 
      iprot.readFieldEnd()
6540 
    iprot.readStructEnd()
6541 
 
6542 
  def write(self, oprot):
6543 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6544 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6545 
      return
6546 
    oprot.writeStructBegin('addItem_result')
6547 
    if self.success is not None:
6548 
      oprot.writeFieldBegin('success', TType.I64, 0)
6549 
      oprot.writeI64(self.success)
6550 
      oprot.writeFieldEnd()
6551 
    if self.cex is not None:
6552 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6553 
      self.cex.write(oprot)
6554 
      oprot.writeFieldEnd()
6555 
    oprot.writeFieldStop()
6556 
    oprot.writeStructEnd()
6557 
 
6558 
  def validate(self):
6559 
    return
6560 
 
6561 
 
6562 
  def __repr__(self):
6563 
    L = ['%s=%r' % (key, value)
6564 
      for key, value in self.__dict__.iteritems()]
6565 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6566 
 
6567 
  def __eq__(self, other):
6568 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6569 
 
6570 
  def __ne__(self, other):
6571 
    return not (self == other)
6572 
 
6573 
class updateItem_args:
6574 
  """
6575 
  Attributes:
6576 
   - item
6577 
  """
6578 
 
6579 
  thrift_spec = (
6580 
    None, # 0
6581 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
6582 
  )
6583 
 
6584 
  def __init__(self, item=None,):
6585 
    self.item = item
6586 
 
6587 
  def read(self, iprot):
6588 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6589 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6590 
      return
6591 
    iprot.readStructBegin()
6592 
    while True:
6593 
      (fname, ftype, fid) = iprot.readFieldBegin()
6594 
      if ftype == TType.STOP:
6595 
        break
6596 
      if fid == 1:
6597 
        if ftype == TType.STRUCT:
6598 
          self.item = Item()
6599 
          self.item.read(iprot)
6600 
        else:
6601 
          iprot.skip(ftype)
6602 
      else:
6603 
        iprot.skip(ftype)
6604 
      iprot.readFieldEnd()
6605 
    iprot.readStructEnd()
6606 
 
6607 
  def write(self, oprot):
6608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6610 
      return
6611 
    oprot.writeStructBegin('updateItem_args')
6612 
    if self.item is not None:
6613 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
6614 
      self.item.write(oprot)
6615 
      oprot.writeFieldEnd()
6616 
    oprot.writeFieldStop()
6617 
    oprot.writeStructEnd()
6618 
 
6619 
  def validate(self):
6620 
    return
6621 
 
6622 
 
6623 
  def __repr__(self):
6624 
    L = ['%s=%r' % (key, value)
6625 
      for key, value in self.__dict__.iteritems()]
6626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6627 
 
6628 
  def __eq__(self, other):
6629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6630 
 
6631 
  def __ne__(self, other):
6632 
    return not (self == other)
6633 
 
6634 
class updateItem_result:
6635 
  """
6636 
  Attributes:
6637 
   - success
6638 
   - cex
6639 
  """
6640 
 
6641 
  thrift_spec = (
6642 
    (0, TType.I64, 'success', None, None, ), # 0
6643 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6644 
  )
6645 
 
6646 
  def __init__(self, success=None, cex=None,):
6647 
    self.success = success
6648 
    self.cex = cex
6649 
 
6650 
  def read(self, iprot):
6651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6653 
      return
6654 
    iprot.readStructBegin()
6655 
    while True:
6656 
      (fname, ftype, fid) = iprot.readFieldBegin()
6657 
      if ftype == TType.STOP:
6658 
        break
6659 
      if fid == 0:
6660 
        if ftype == TType.I64:
6661 
          self.success = iprot.readI64();
6662 
        else:
6663 
          iprot.skip(ftype)
6664 
      elif fid == 1:
6665 
        if ftype == TType.STRUCT:
6666 
          self.cex = CatalogServiceException()
6667 
          self.cex.read(iprot)
6668 
        else:
6669 
          iprot.skip(ftype)
6670 
      else:
6671 
        iprot.skip(ftype)
6672 
      iprot.readFieldEnd()
6673 
    iprot.readStructEnd()
6674 
 
6675 
  def write(self, oprot):
6676 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6677 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6678 
      return
6679 
    oprot.writeStructBegin('updateItem_result')
6680 
    if self.success is not None:
6681 
      oprot.writeFieldBegin('success', TType.I64, 0)
6682 
      oprot.writeI64(self.success)
6683 
      oprot.writeFieldEnd()
6684 
    if self.cex is not None:
6685 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6686 
      self.cex.write(oprot)
6687 
      oprot.writeFieldEnd()
6688 
    oprot.writeFieldStop()
6689 
    oprot.writeStructEnd()
6690 
 
6691 
  def validate(self):
6692 
    return
6693 
 
6694 
 
6695 
  def __repr__(self):
6696 
    L = ['%s=%r' % (key, value)
6697 
      for key, value in self.__dict__.iteritems()]
6698 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6699 
 
6700 
  def __eq__(self, other):
6701 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6702 
 
6703 
  def __ne__(self, other):
6704 
    return not (self == other)
6705 
 
6706 
class isActive_args:
6707 
  """
6708 
  Attributes:
6709 
   - itemId
6710 
  """
6711 
 
6712 
  thrift_spec = (
6713 
    None, # 0
6714 
    (1, TType.I64, 'itemId', None, None, ), # 1
6715 
  )
6716 
 
6717 
  def __init__(self, itemId=None,):
6718 
    self.itemId = itemId
6719 
 
6720 
  def read(self, iprot):
6721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6723 
      return
6724 
    iprot.readStructBegin()
6725 
    while True:
6726 
      (fname, ftype, fid) = iprot.readFieldBegin()
6727 
      if ftype == TType.STOP:
6728 
        break
6729 
      if fid == 1:
6730 
        if ftype == TType.I64:
6731 
          self.itemId = iprot.readI64();
6732 
        else:
6733 
          iprot.skip(ftype)
6734 
      else:
6735 
        iprot.skip(ftype)
6736 
      iprot.readFieldEnd()
6737 
    iprot.readStructEnd()
6738 
 
6739 
  def write(self, oprot):
6740 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6741 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6742 
      return
6743 
    oprot.writeStructBegin('isActive_args')
6744 
    if self.itemId is not None:
6745 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
6746 
      oprot.writeI64(self.itemId)
6747 
      oprot.writeFieldEnd()
6748 
    oprot.writeFieldStop()
6749 
    oprot.writeStructEnd()
6750 
 
6751 
  def validate(self):
6752 
    return
6753 
 
6754 
 
6755 
  def __repr__(self):
6756 
    L = ['%s=%r' % (key, value)
6757 
      for key, value in self.__dict__.iteritems()]
6758 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6759 
 
6760 
  def __eq__(self, other):
6761 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6762 
 
6763 
  def __ne__(self, other):
6764 
    return not (self == other)
6765 
 
6766 
class isActive_result:
6767 
  """
6768 
  Attributes:
6769 
   - success
6770 
   - isex
6771 
  """
6772 
 
6773 
  thrift_spec = (
6774 
    (0, TType.STRUCT, 'success', (ItemShippingInfo, ItemShippingInfo.thrift_spec), None, ), # 0
6775 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6776 
  )
6777 
 
6778 
  def __init__(self, success=None, isex=None,):
6779 
    self.success = success
6780 
    self.isex = isex
6781 
 
6782 
  def read(self, iprot):
6783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6785 
      return
6786 
    iprot.readStructBegin()
6787 
    while True:
6788 
      (fname, ftype, fid) = iprot.readFieldBegin()
6789 
      if ftype == TType.STOP:
6790 
        break
6791 
      if fid == 0:
6792 
        if ftype == TType.STRUCT:
6793 
          self.success = ItemShippingInfo()
6794 
          self.success.read(iprot)
6795 
        else:
6796 
          iprot.skip(ftype)
6797 
      elif fid == 1:
6798 
        if ftype == TType.STRUCT:
6799 
          self.isex = CatalogServiceException()
6800 
          self.isex.read(iprot)
6801 
        else:
6802 
          iprot.skip(ftype)
6803 
      else:
6804 
        iprot.skip(ftype)
6805 
      iprot.readFieldEnd()
6806 
    iprot.readStructEnd()
6807 
 
6808 
  def write(self, oprot):
6809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6811 
      return
6812 
    oprot.writeStructBegin('isActive_result')
6813 
    if self.success is not None:
6814 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6815 
      self.success.write(oprot)
6816 
      oprot.writeFieldEnd()
6817 
    if self.isex is not None:
6818 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
6819 
      self.isex.write(oprot)
6820 
      oprot.writeFieldEnd()
6821 
    oprot.writeFieldStop()
6822 
    oprot.writeStructEnd()
6823 
 
6824 
  def validate(self):
6825 
    return
6826 
 
6827 
 
6828 
  def __repr__(self):
6829 
    L = ['%s=%r' % (key, value)
6830 
      for key, value in self.__dict__.iteritems()]
6831 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6832 
 
6833 
  def __eq__(self, other):
6834 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6835 
 
6836 
  def __ne__(self, other):
6837 
    return not (self == other)
6838 
 
7438 amit.gupta 6839 
class getItemsStatus_args:
6840 
  """
6841 
  Attributes:
6842 
   - itemIds
6843 
  """
6844 
 
6845 
  thrift_spec = (
6846 
    None, # 0
6847 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
6848 
  )
6849 
 
6850 
  def __init__(self, itemIds=None,):
6851 
    self.itemIds = itemIds
6852 
 
6853 
  def read(self, iprot):
6854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6856 
      return
6857 
    iprot.readStructBegin()
6858 
    while True:
6859 
      (fname, ftype, fid) = iprot.readFieldBegin()
6860 
      if ftype == TType.STOP:
6861 
        break
6862 
      if fid == 1:
6863 
        if ftype == TType.LIST:
6864 
          self.itemIds = []
8590 kshitij.so 6865 
          (_etype33, _size30) = iprot.readListBegin()
6866 
          for _i34 in xrange(_size30):
6867 
            _elem35 = iprot.readI64();
6868 
            self.itemIds.append(_elem35)
7438 amit.gupta 6869 
          iprot.readListEnd()
6870 
        else:
6871 
          iprot.skip(ftype)
6872 
      else:
6873 
        iprot.skip(ftype)
6874 
      iprot.readFieldEnd()
6875 
    iprot.readStructEnd()
6876 
 
6877 
  def write(self, oprot):
6878 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6879 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6880 
      return
6881 
    oprot.writeStructBegin('getItemsStatus_args')
6882 
    if self.itemIds is not None:
6883 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
6884 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
8590 kshitij.so 6885 
      for iter36 in self.itemIds:
6886 
        oprot.writeI64(iter36)
7438 amit.gupta 6887 
      oprot.writeListEnd()
6888 
      oprot.writeFieldEnd()
6889 
    oprot.writeFieldStop()
6890 
    oprot.writeStructEnd()
6891 
 
6892 
  def validate(self):
6893 
    return
6894 
 
6895 
 
6896 
  def __repr__(self):
6897 
    L = ['%s=%r' % (key, value)
6898 
      for key, value in self.__dict__.iteritems()]
6899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6900 
 
6901 
  def __eq__(self, other):
6902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6903 
 
6904 
  def __ne__(self, other):
6905 
    return not (self == other)
6906 
 
6907 
class getItemsStatus_result:
6908 
  """
6909 
  Attributes:
6910 
   - success
6911 
   - isex
6912 
  """
6913 
 
6914 
  thrift_spec = (
6915 
    (0, TType.MAP, 'success', (TType.I64,None,TType.BOOL,None), None, ), # 0
6916 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6917 
  )
6918 
 
6919 
  def __init__(self, success=None, isex=None,):
6920 
    self.success = success
6921 
    self.isex = isex
6922 
 
6923 
  def read(self, iprot):
6924 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6925 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6926 
      return
6927 
    iprot.readStructBegin()
6928 
    while True:
6929 
      (fname, ftype, fid) = iprot.readFieldBegin()
6930 
      if ftype == TType.STOP:
6931 
        break
6932 
      if fid == 0:
6933 
        if ftype == TType.MAP:
6934 
          self.success = {}
8590 kshitij.so 6935 
          (_ktype38, _vtype39, _size37 ) = iprot.readMapBegin()
6936 
          for _i41 in xrange(_size37):
6937 
            _key42 = iprot.readI64();
6938 
            _val43 = iprot.readBool();
6939 
            self.success[_key42] = _val43
7438 amit.gupta 6940 
          iprot.readMapEnd()
6941 
        else:
6942 
          iprot.skip(ftype)
6943 
      elif fid == 1:
6944 
        if ftype == TType.STRUCT:
6945 
          self.isex = CatalogServiceException()
6946 
          self.isex.read(iprot)
6947 
        else:
6948 
          iprot.skip(ftype)
6949 
      else:
6950 
        iprot.skip(ftype)
6951 
      iprot.readFieldEnd()
6952 
    iprot.readStructEnd()
6953 
 
6954 
  def write(self, oprot):
6955 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6956 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6957 
      return
6958 
    oprot.writeStructBegin('getItemsStatus_result')
6959 
    if self.success is not None:
6960 
      oprot.writeFieldBegin('success', TType.MAP, 0)
6961 
      oprot.writeMapBegin(TType.I64, TType.BOOL, len(self.success))
8590 kshitij.so 6962 
      for kiter44,viter45 in self.success.items():
6963 
        oprot.writeI64(kiter44)
6964 
        oprot.writeBool(viter45)
7438 amit.gupta 6965 
      oprot.writeMapEnd()
6966 
      oprot.writeFieldEnd()
6967 
    if self.isex is not None:
6968 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
6969 
      self.isex.write(oprot)
6970 
      oprot.writeFieldEnd()
6971 
    oprot.writeFieldStop()
6972 
    oprot.writeStructEnd()
6973 
 
6974 
  def validate(self):
6975 
    return
6976 
 
6977 
 
6978 
  def __repr__(self):
6979 
    L = ['%s=%r' % (key, value)
6980 
      for key, value in self.__dict__.iteritems()]
6981 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6982 
 
6983 
  def __eq__(self, other):
6984 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6985 
 
6986 
  def __ne__(self, other):
6987 
    return not (self == other)
6988 
 
5944 mandeep.dh 6989 
class getItemStatusDescription_args:
6990 
  """
6991 
  Attributes:
6992 
   - itemId
6993 
  """
6994 
 
6995 
  thrift_spec = (
6996 
    None, # 0
6997 
    (1, TType.I64, 'itemId', None, None, ), # 1
6998 
  )
6999 
 
7000 
  def __init__(self, itemId=None,):
7001 
    self.itemId = itemId
7002 
 
7003 
  def read(self, iprot):
7004 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7005 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7006 
      return
7007 
    iprot.readStructBegin()
7008 
    while True:
7009 
      (fname, ftype, fid) = iprot.readFieldBegin()
7010 
      if ftype == TType.STOP:
7011 
        break
7012 
      if fid == 1:
7013 
        if ftype == TType.I64:
7014 
          self.itemId = iprot.readI64();
7015 
        else:
7016 
          iprot.skip(ftype)
7017 
      else:
7018 
        iprot.skip(ftype)
7019 
      iprot.readFieldEnd()
7020 
    iprot.readStructEnd()
7021 
 
7022 
  def write(self, oprot):
7023 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7024 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7025 
      return
7026 
    oprot.writeStructBegin('getItemStatusDescription_args')
7027 
    if self.itemId is not None:
7028 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
7029 
      oprot.writeI64(self.itemId)
7030 
      oprot.writeFieldEnd()
7031 
    oprot.writeFieldStop()
7032 
    oprot.writeStructEnd()
7033 
 
7034 
  def validate(self):
7035 
    return
7036 
 
7037 
 
7038 
  def __repr__(self):
7039 
    L = ['%s=%r' % (key, value)
7040 
      for key, value in self.__dict__.iteritems()]
7041 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7042 
 
7043 
  def __eq__(self, other):
7044 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7045 
 
7046 
  def __ne__(self, other):
7047 
    return not (self == other)
7048 
 
7049 
class getItemStatusDescription_result:
7050 
  """
7051 
  Attributes:
7052 
   - success
7053 
   - isex
7054 
  """
7055 
 
7056 
  thrift_spec = (
7057 
    (0, TType.STRING, 'success', None, None, ), # 0
7058 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7059 
  )
7060 
 
7061 
  def __init__(self, success=None, isex=None,):
7062 
    self.success = success
7063 
    self.isex = isex
7064 
 
7065 
  def read(self, iprot):
7066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7068 
      return
7069 
    iprot.readStructBegin()
7070 
    while True:
7071 
      (fname, ftype, fid) = iprot.readFieldBegin()
7072 
      if ftype == TType.STOP:
7073 
        break
7074 
      if fid == 0:
7075 
        if ftype == TType.STRING:
7076 
          self.success = iprot.readString();
7077 
        else:
7078 
          iprot.skip(ftype)
7079 
      elif fid == 1:
7080 
        if ftype == TType.STRUCT:
7081 
          self.isex = CatalogServiceException()
7082 
          self.isex.read(iprot)
7083 
        else:
7084 
          iprot.skip(ftype)
7085 
      else:
7086 
        iprot.skip(ftype)
7087 
      iprot.readFieldEnd()
7088 
    iprot.readStructEnd()
7089 
 
7090 
  def write(self, oprot):
7091 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7092 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7093 
      return
7094 
    oprot.writeStructBegin('getItemStatusDescription_result')
7095 
    if self.success is not None:
7096 
      oprot.writeFieldBegin('success', TType.STRING, 0)
7097 
      oprot.writeString(self.success)
7098 
      oprot.writeFieldEnd()
7099 
    if self.isex is not None:
7100 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7101 
      self.isex.write(oprot)
7102 
      oprot.writeFieldEnd()
7103 
    oprot.writeFieldStop()
7104 
    oprot.writeStructEnd()
7105 
 
7106 
  def validate(self):
7107 
    return
7108 
 
7109 
 
7110 
  def __repr__(self):
7111 
    L = ['%s=%r' % (key, value)
7112 
      for key, value in self.__dict__.iteritems()]
7113 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7114 
 
7115 
  def __eq__(self, other):
7116 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7117 
 
7118 
  def __ne__(self, other):
7119 
    return not (self == other)
7120 
 
7121 
class startItemOn_args:
7122 
  """
7123 
  Attributes:
7124 
   - item_id
7125 
   - timestamp
7126 
  """
7127 
 
7128 
  thrift_spec = (
7129 
    None, # 0
7130 
    (1, TType.I64, 'item_id', None, None, ), # 1
7131 
    (2, TType.I64, 'timestamp', None, None, ), # 2
7132 
  )
7133 
 
7134 
  def __init__(self, item_id=None, timestamp=None,):
7135 
    self.item_id = item_id
7136 
    self.timestamp = timestamp
7137 
 
7138 
  def read(self, iprot):
7139 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7140 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7141 
      return
7142 
    iprot.readStructBegin()
7143 
    while True:
7144 
      (fname, ftype, fid) = iprot.readFieldBegin()
7145 
      if ftype == TType.STOP:
7146 
        break
7147 
      if fid == 1:
7148 
        if ftype == TType.I64:
7149 
          self.item_id = iprot.readI64();
7150 
        else:
7151 
          iprot.skip(ftype)
7152 
      elif fid == 2:
7153 
        if ftype == TType.I64:
7154 
          self.timestamp = iprot.readI64();
7155 
        else:
7156 
          iprot.skip(ftype)
7157 
      else:
7158 
        iprot.skip(ftype)
7159 
      iprot.readFieldEnd()
7160 
    iprot.readStructEnd()
7161 
 
7162 
  def write(self, oprot):
7163 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7164 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7165 
      return
7166 
    oprot.writeStructBegin('startItemOn_args')
7167 
    if self.item_id is not None:
7168 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
7169 
      oprot.writeI64(self.item_id)
7170 
      oprot.writeFieldEnd()
7171 
    if self.timestamp is not None:
7172 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
7173 
      oprot.writeI64(self.timestamp)
7174 
      oprot.writeFieldEnd()
7175 
    oprot.writeFieldStop()
7176 
    oprot.writeStructEnd()
7177 
 
7178 
  def validate(self):
7179 
    return
7180 
 
7181 
 
7182 
  def __repr__(self):
7183 
    L = ['%s=%r' % (key, value)
7184 
      for key, value in self.__dict__.iteritems()]
7185 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7186 
 
7187 
  def __eq__(self, other):
7188 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7189 
 
7190 
  def __ne__(self, other):
7191 
    return not (self == other)
7192 
 
7193 
class startItemOn_result:
7194 
  """
7195 
  Attributes:
7196 
   - cex
7197 
  """
7198 
 
7199 
  thrift_spec = (
7200 
    None, # 0
7201 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7202 
  )
7203 
 
7204 
  def __init__(self, cex=None,):
7205 
    self.cex = cex
7206 
 
7207 
  def read(self, iprot):
7208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7210 
      return
7211 
    iprot.readStructBegin()
7212 
    while True:
7213 
      (fname, ftype, fid) = iprot.readFieldBegin()
7214 
      if ftype == TType.STOP:
7215 
        break
7216 
      if fid == 1:
7217 
        if ftype == TType.STRUCT:
7218 
          self.cex = CatalogServiceException()
7219 
          self.cex.read(iprot)
7220 
        else:
7221 
          iprot.skip(ftype)
7222 
      else:
7223 
        iprot.skip(ftype)
7224 
      iprot.readFieldEnd()
7225 
    iprot.readStructEnd()
7226 
 
7227 
  def write(self, oprot):
7228 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7229 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7230 
      return
7231 
    oprot.writeStructBegin('startItemOn_result')
7232 
    if self.cex is not None:
7233 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7234 
      self.cex.write(oprot)
7235 
      oprot.writeFieldEnd()
7236 
    oprot.writeFieldStop()
7237 
    oprot.writeStructEnd()
7238 
 
7239 
  def validate(self):
7240 
    return
7241 
 
7242 
 
7243 
  def __repr__(self):
7244 
    L = ['%s=%r' % (key, value)
7245 
      for key, value in self.__dict__.iteritems()]
7246 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7247 
 
7248 
  def __eq__(self, other):
7249 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7250 
 
7251 
  def __ne__(self, other):
7252 
    return not (self == other)
7253 
 
7254 
class retireItemOn_args:
7255 
  """
7256 
  Attributes:
7257 
   - item_id
7258 
   - timestamp
7259 
  """
7260 
 
7261 
  thrift_spec = (
7262 
    None, # 0
7263 
    (1, TType.I64, 'item_id', None, None, ), # 1
7264 
    (2, TType.I64, 'timestamp', None, None, ), # 2
7265 
  )
7266 
 
7267 
  def __init__(self, item_id=None, timestamp=None,):
7268 
    self.item_id = item_id
7269 
    self.timestamp = timestamp
7270 
 
7271 
  def read(self, iprot):
7272 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7273 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7274 
      return
7275 
    iprot.readStructBegin()
7276 
    while True:
7277 
      (fname, ftype, fid) = iprot.readFieldBegin()
7278 
      if ftype == TType.STOP:
7279 
        break
7280 
      if fid == 1:
7281 
        if ftype == TType.I64:
7282 
          self.item_id = iprot.readI64();
7283 
        else:
7284 
          iprot.skip(ftype)
7285 
      elif fid == 2:
7286 
        if ftype == TType.I64:
7287 
          self.timestamp = iprot.readI64();
7288 
        else:
7289 
          iprot.skip(ftype)
7290 
      else:
7291 
        iprot.skip(ftype)
7292 
      iprot.readFieldEnd()
7293 
    iprot.readStructEnd()
7294 
 
7295 
  def write(self, oprot):
7296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7298 
      return
7299 
    oprot.writeStructBegin('retireItemOn_args')
7300 
    if self.item_id is not None:
7301 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
7302 
      oprot.writeI64(self.item_id)
7303 
      oprot.writeFieldEnd()
7304 
    if self.timestamp is not None:
7305 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
7306 
      oprot.writeI64(self.timestamp)
7307 
      oprot.writeFieldEnd()
7308 
    oprot.writeFieldStop()
7309 
    oprot.writeStructEnd()
7310 
 
7311 
  def validate(self):
7312 
    return
7313 
 
7314 
 
7315 
  def __repr__(self):
7316 
    L = ['%s=%r' % (key, value)
7317 
      for key, value in self.__dict__.iteritems()]
7318 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7319 
 
7320 
  def __eq__(self, other):
7321 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7322 
 
7323 
  def __ne__(self, other):
7324 
    return not (self == other)
7325 
 
7326 
class retireItemOn_result:
7327 
  """
7328 
  Attributes:
7329 
   - cex
7330 
  """
7331 
 
7332 
  thrift_spec = (
7333 
    None, # 0
7334 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7335 
  )
7336 
 
7337 
  def __init__(self, cex=None,):
7338 
    self.cex = cex
7339 
 
7340 
  def read(self, iprot):
7341 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7342 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7343 
      return
7344 
    iprot.readStructBegin()
7345 
    while True:
7346 
      (fname, ftype, fid) = iprot.readFieldBegin()
7347 
      if ftype == TType.STOP:
7348 
        break
7349 
      if fid == 1:
7350 
        if ftype == TType.STRUCT:
7351 
          self.cex = CatalogServiceException()
7352 
          self.cex.read(iprot)
7353 
        else:
7354 
          iprot.skip(ftype)
7355 
      else:
7356 
        iprot.skip(ftype)
7357 
      iprot.readFieldEnd()
7358 
    iprot.readStructEnd()
7359 
 
7360 
  def write(self, oprot):
7361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7363 
      return
7364 
    oprot.writeStructBegin('retireItemOn_result')
7365 
    if self.cex is not None:
7366 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7367 
      self.cex.write(oprot)
7368 
      oprot.writeFieldEnd()
7369 
    oprot.writeFieldStop()
7370 
    oprot.writeStructEnd()
7371 
 
7372 
  def validate(self):
7373 
    return
7374 
 
7375 
 
7376 
  def __repr__(self):
7377 
    L = ['%s=%r' % (key, value)
7378 
      for key, value in self.__dict__.iteritems()]
7379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7380 
 
7381 
  def __eq__(self, other):
7382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7383 
 
7384 
  def __ne__(self, other):
7385 
    return not (self == other)
7386 
 
7387 
class changeItemStatus_args:
7388 
  """
7389 
  Attributes:
7390 
   - item_id
7391 
   - timestamp
7392 
   - newstatus
7393 
  """
7394 
 
7395 
  thrift_spec = (
7396 
    None, # 0
7397 
    (1, TType.I64, 'item_id', None, None, ), # 1
7398 
    (2, TType.I64, 'timestamp', None, None, ), # 2
7399 
    (3, TType.I32, 'newstatus', None, None, ), # 3
7400 
  )
7401 
 
7402 
  def __init__(self, item_id=None, timestamp=None, newstatus=None,):
7403 
    self.item_id = item_id
7404 
    self.timestamp = timestamp
7405 
    self.newstatus = newstatus
7406 
 
7407 
  def read(self, iprot):
7408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7410 
      return
7411 
    iprot.readStructBegin()
7412 
    while True:
7413 
      (fname, ftype, fid) = iprot.readFieldBegin()
7414 
      if ftype == TType.STOP:
7415 
        break
7416 
      if fid == 1:
7417 
        if ftype == TType.I64:
7418 
          self.item_id = iprot.readI64();
7419 
        else:
7420 
          iprot.skip(ftype)
7421 
      elif fid == 2:
7422 
        if ftype == TType.I64:
7423 
          self.timestamp = iprot.readI64();
7424 
        else:
7425 
          iprot.skip(ftype)
7426 
      elif fid == 3:
7427 
        if ftype == TType.I32:
7428 
          self.newstatus = iprot.readI32();
7429 
        else:
7430 
          iprot.skip(ftype)
7431 
      else:
7432 
        iprot.skip(ftype)
7433 
      iprot.readFieldEnd()
7434 
    iprot.readStructEnd()
7435 
 
7436 
  def write(self, oprot):
7437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7439 
      return
7440 
    oprot.writeStructBegin('changeItemStatus_args')
7441 
    if self.item_id is not None:
7442 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
7443 
      oprot.writeI64(self.item_id)
7444 
      oprot.writeFieldEnd()
7445 
    if self.timestamp is not None:
7446 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
7447 
      oprot.writeI64(self.timestamp)
7448 
      oprot.writeFieldEnd()
7449 
    if self.newstatus is not None:
7450 
      oprot.writeFieldBegin('newstatus', TType.I32, 3)
7451 
      oprot.writeI32(self.newstatus)
7452 
      oprot.writeFieldEnd()
7453 
    oprot.writeFieldStop()
7454 
    oprot.writeStructEnd()
7455 
 
7456 
  def validate(self):
7457 
    return
7458 
 
7459 
 
7460 
  def __repr__(self):
7461 
    L = ['%s=%r' % (key, value)
7462 
      for key, value in self.__dict__.iteritems()]
7463 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7464 
 
7465 
  def __eq__(self, other):
7466 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7467 
 
7468 
  def __ne__(self, other):
7469 
    return not (self == other)
7470 
 
7471 
class changeItemStatus_result:
7472 
  """
7473 
  Attributes:
7474 
   - cex
7475 
  """
7476 
 
7477 
  thrift_spec = (
7478 
    None, # 0
7479 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7480 
  )
7481 
 
7482 
  def __init__(self, cex=None,):
7483 
    self.cex = cex
7484 
 
7485 
  def read(self, iprot):
7486 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7487 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7488 
      return
7489 
    iprot.readStructBegin()
7490 
    while True:
7491 
      (fname, ftype, fid) = iprot.readFieldBegin()
7492 
      if ftype == TType.STOP:
7493 
        break
7494 
      if fid == 1:
7495 
        if ftype == TType.STRUCT:
7496 
          self.cex = CatalogServiceException()
7497 
          self.cex.read(iprot)
7498 
        else:
7499 
          iprot.skip(ftype)
7500 
      else:
7501 
        iprot.skip(ftype)
7502 
      iprot.readFieldEnd()
7503 
    iprot.readStructEnd()
7504 
 
7505 
  def write(self, oprot):
7506 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7507 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7508 
      return
7509 
    oprot.writeStructBegin('changeItemStatus_result')
7510 
    if self.cex is not None:
7511 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7512 
      self.cex.write(oprot)
7513 
      oprot.writeFieldEnd()
7514 
    oprot.writeFieldStop()
7515 
    oprot.writeStructEnd()
7516 
 
7517 
  def validate(self):
7518 
    return
7519 
 
7520 
 
7521 
  def __repr__(self):
7522 
    L = ['%s=%r' % (key, value)
7523 
      for key, value in self.__dict__.iteritems()]
7524 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7525 
 
7526 
  def __eq__(self, other):
7527 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7528 
 
7529 
  def __ne__(self, other):
7530 
    return not (self == other)
7531 
 
7532 
class getItem_args:
7533 
  """
7534 
  Attributes:
7535 
   - item_id
7536 
  """
7537 
 
7538 
  thrift_spec = (
7539 
    None, # 0
7540 
    (1, TType.I64, 'item_id', None, None, ), # 1
7541 
  )
7542 
 
7543 
  def __init__(self, item_id=None,):
7544 
    self.item_id = item_id
7545 
 
7546 
  def read(self, iprot):
7547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7549 
      return
7550 
    iprot.readStructBegin()
7551 
    while True:
7552 
      (fname, ftype, fid) = iprot.readFieldBegin()
7553 
      if ftype == TType.STOP:
7554 
        break
7555 
      if fid == 1:
7556 
        if ftype == TType.I64:
7557 
          self.item_id = iprot.readI64();
7558 
        else:
7559 
          iprot.skip(ftype)
7560 
      else:
7561 
        iprot.skip(ftype)
7562 
      iprot.readFieldEnd()
7563 
    iprot.readStructEnd()
7564 
 
7565 
  def write(self, oprot):
7566 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7567 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7568 
      return
7569 
    oprot.writeStructBegin('getItem_args')
7570 
    if self.item_id is not None:
7571 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
7572 
      oprot.writeI64(self.item_id)
7573 
      oprot.writeFieldEnd()
7574 
    oprot.writeFieldStop()
7575 
    oprot.writeStructEnd()
7576 
 
7577 
  def validate(self):
7578 
    return
7579 
 
7580 
 
7581 
  def __repr__(self):
7582 
    L = ['%s=%r' % (key, value)
7583 
      for key, value in self.__dict__.iteritems()]
7584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7585 
 
7586 
  def __eq__(self, other):
7587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7588 
 
7589 
  def __ne__(self, other):
7590 
    return not (self == other)
7591 
 
7592 
class getItem_result:
7593 
  """
7594 
  Attributes:
7595 
   - success
7596 
   - cex
7597 
  """
7598 
 
7599 
  thrift_spec = (
7600 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
7601 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7602 
  )
7603 
 
7604 
  def __init__(self, success=None, cex=None,):
7605 
    self.success = success
7606 
    self.cex = cex
7607 
 
7608 
  def read(self, iprot):
7609 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7610 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7611 
      return
7612 
    iprot.readStructBegin()
7613 
    while True:
7614 
      (fname, ftype, fid) = iprot.readFieldBegin()
7615 
      if ftype == TType.STOP:
7616 
        break
7617 
      if fid == 0:
7618 
        if ftype == TType.STRUCT:
7619 
          self.success = Item()
7620 
          self.success.read(iprot)
7621 
        else:
7622 
          iprot.skip(ftype)
7623 
      elif fid == 1:
7624 
        if ftype == TType.STRUCT:
7625 
          self.cex = CatalogServiceException()
7626 
          self.cex.read(iprot)
7627 
        else:
7628 
          iprot.skip(ftype)
7629 
      else:
7630 
        iprot.skip(ftype)
7631 
      iprot.readFieldEnd()
7632 
    iprot.readStructEnd()
7633 
 
7634 
  def write(self, oprot):
7635 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7636 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7637 
      return
7638 
    oprot.writeStructBegin('getItem_result')
7639 
    if self.success is not None:
7640 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7641 
      self.success.write(oprot)
7642 
      oprot.writeFieldEnd()
7643 
    if self.cex is not None:
7644 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7645 
      self.cex.write(oprot)
7646 
      oprot.writeFieldEnd()
7647 
    oprot.writeFieldStop()
7648 
    oprot.writeStructEnd()
7649 
 
7650 
  def validate(self):
7651 
    return
7652 
 
7653 
 
7654 
  def __repr__(self):
7655 
    L = ['%s=%r' % (key, value)
7656 
      for key, value in self.__dict__.iteritems()]
7657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7658 
 
7659 
  def __eq__(self, other):
7660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7661 
 
7662 
  def __ne__(self, other):
7663 
    return not (self == other)
7664 
 
7665 
class getItemsByCatalogId_args:
7666 
  """
7667 
  Attributes:
7668 
   - catalog_item_id
7669 
  """
7670 
 
7671 
  thrift_spec = (
7672 
    None, # 0
7673 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
7674 
  )
7675 
 
7676 
  def __init__(self, catalog_item_id=None,):
7677 
    self.catalog_item_id = catalog_item_id
7678 
 
7679 
  def read(self, iprot):
7680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7682 
      return
7683 
    iprot.readStructBegin()
7684 
    while True:
7685 
      (fname, ftype, fid) = iprot.readFieldBegin()
7686 
      if ftype == TType.STOP:
7687 
        break
7688 
      if fid == 1:
7689 
        if ftype == TType.I64:
7690 
          self.catalog_item_id = iprot.readI64();
7691 
        else:
7692 
          iprot.skip(ftype)
7693 
      else:
7694 
        iprot.skip(ftype)
7695 
      iprot.readFieldEnd()
7696 
    iprot.readStructEnd()
7697 
 
7698 
  def write(self, oprot):
7699 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7700 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7701 
      return
7702 
    oprot.writeStructBegin('getItemsByCatalogId_args')
7703 
    if self.catalog_item_id is not None:
7704 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
7705 
      oprot.writeI64(self.catalog_item_id)
7706 
      oprot.writeFieldEnd()
7707 
    oprot.writeFieldStop()
7708 
    oprot.writeStructEnd()
7709 
 
7710 
  def validate(self):
7711 
    return
7712 
 
7713 
 
7714 
  def __repr__(self):
7715 
    L = ['%s=%r' % (key, value)
7716 
      for key, value in self.__dict__.iteritems()]
7717 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7718 
 
7719 
  def __eq__(self, other):
7720 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7721 
 
7722 
  def __ne__(self, other):
7723 
    return not (self == other)
7724 
 
7725 
class getItemsByCatalogId_result:
7726 
  """
7727 
  Attributes:
7728 
   - success
7729 
   - cex
7730 
  """
7731 
 
7732 
  thrift_spec = (
7733 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7734 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7735 
  )
7736 
 
7737 
  def __init__(self, success=None, cex=None,):
7738 
    self.success = success
7739 
    self.cex = cex
7740 
 
7741 
  def read(self, iprot):
7742 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7743 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7744 
      return
7745 
    iprot.readStructBegin()
7746 
    while True:
7747 
      (fname, ftype, fid) = iprot.readFieldBegin()
7748 
      if ftype == TType.STOP:
7749 
        break
7750 
      if fid == 0:
7751 
        if ftype == TType.LIST:
7752 
          self.success = []
8590 kshitij.so 7753 
          (_etype49, _size46) = iprot.readListBegin()
7754 
          for _i50 in xrange(_size46):
7755 
            _elem51 = Item()
7756 
            _elem51.read(iprot)
7757 
            self.success.append(_elem51)
5944 mandeep.dh 7758 
          iprot.readListEnd()
7759 
        else:
7760 
          iprot.skip(ftype)
7761 
      elif fid == 1:
7762 
        if ftype == TType.STRUCT:
7763 
          self.cex = CatalogServiceException()
7764 
          self.cex.read(iprot)
7765 
        else:
7766 
          iprot.skip(ftype)
7767 
      else:
7768 
        iprot.skip(ftype)
7769 
      iprot.readFieldEnd()
7770 
    iprot.readStructEnd()
7771 
 
7772 
  def write(self, oprot):
7773 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7774 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7775 
      return
7776 
    oprot.writeStructBegin('getItemsByCatalogId_result')
7777 
    if self.success is not None:
7778 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7779 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 7780 
      for iter52 in self.success:
7781 
        iter52.write(oprot)
5944 mandeep.dh 7782 
      oprot.writeListEnd()
7783 
      oprot.writeFieldEnd()
7784 
    if self.cex is not None:
7785 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7786 
      self.cex.write(oprot)
7787 
      oprot.writeFieldEnd()
7788 
    oprot.writeFieldStop()
7789 
    oprot.writeStructEnd()
7790 
 
7791 
  def validate(self):
7792 
    return
7793 
 
7794 
 
7795 
  def __repr__(self):
7796 
    L = ['%s=%r' % (key, value)
7797 
      for key, value in self.__dict__.iteritems()]
7798 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7799 
 
7800 
  def __eq__(self, other):
7801 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7802 
 
7803 
  def __ne__(self, other):
7804 
    return not (self == other)
7805 
 
7806 
class getValidItemsByCatalogId_args:
7807 
  """
7808 
  Attributes:
7809 
   - catalog_item_id
7810 
  """
7811 
 
7812 
  thrift_spec = (
7813 
    None, # 0
7814 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
7815 
  )
7816 
 
7817 
  def __init__(self, catalog_item_id=None,):
7818 
    self.catalog_item_id = catalog_item_id
7819 
 
7820 
  def read(self, iprot):
7821 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7822 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7823 
      return
7824 
    iprot.readStructBegin()
7825 
    while True:
7826 
      (fname, ftype, fid) = iprot.readFieldBegin()
7827 
      if ftype == TType.STOP:
7828 
        break
7829 
      if fid == 1:
7830 
        if ftype == TType.I64:
7831 
          self.catalog_item_id = iprot.readI64();
7832 
        else:
7833 
          iprot.skip(ftype)
7834 
      else:
7835 
        iprot.skip(ftype)
7836 
      iprot.readFieldEnd()
7837 
    iprot.readStructEnd()
7838 
 
7839 
  def write(self, oprot):
7840 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7841 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7842 
      return
7843 
    oprot.writeStructBegin('getValidItemsByCatalogId_args')
7844 
    if self.catalog_item_id is not None:
7845 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
7846 
      oprot.writeI64(self.catalog_item_id)
7847 
      oprot.writeFieldEnd()
7848 
    oprot.writeFieldStop()
7849 
    oprot.writeStructEnd()
7850 
 
7851 
  def validate(self):
7852 
    return
7853 
 
7854 
 
7855 
  def __repr__(self):
7856 
    L = ['%s=%r' % (key, value)
7857 
      for key, value in self.__dict__.iteritems()]
7858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7859 
 
7860 
  def __eq__(self, other):
7861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7862 
 
7863 
  def __ne__(self, other):
7864 
    return not (self == other)
7865 
 
7866 
class getValidItemsByCatalogId_result:
7867 
  """
7868 
  Attributes:
7869 
   - success
7870 
   - cex
7871 
  """
7872 
 
7873 
  thrift_spec = (
7874 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7875 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7876 
  )
7877 
 
7878 
  def __init__(self, success=None, cex=None,):
7879 
    self.success = success
7880 
    self.cex = cex
7881 
 
7882 
  def read(self, iprot):
7883 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7884 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7885 
      return
7886 
    iprot.readStructBegin()
7887 
    while True:
7888 
      (fname, ftype, fid) = iprot.readFieldBegin()
7889 
      if ftype == TType.STOP:
7890 
        break
7891 
      if fid == 0:
7892 
        if ftype == TType.LIST:
7893 
          self.success = []
8590 kshitij.so 7894 
          (_etype56, _size53) = iprot.readListBegin()
7895 
          for _i57 in xrange(_size53):
7896 
            _elem58 = Item()
7897 
            _elem58.read(iprot)
7898 
            self.success.append(_elem58)
5944 mandeep.dh 7899 
          iprot.readListEnd()
7900 
        else:
7901 
          iprot.skip(ftype)
7902 
      elif fid == 1:
7903 
        if ftype == TType.STRUCT:
7904 
          self.cex = CatalogServiceException()
7905 
          self.cex.read(iprot)
7906 
        else:
7907 
          iprot.skip(ftype)
7908 
      else:
7909 
        iprot.skip(ftype)
7910 
      iprot.readFieldEnd()
7911 
    iprot.readStructEnd()
7912 
 
7913 
  def write(self, oprot):
7914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7916 
      return
7917 
    oprot.writeStructBegin('getValidItemsByCatalogId_result')
7918 
    if self.success is not None:
7919 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7920 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 7921 
      for iter59 in self.success:
7922 
        iter59.write(oprot)
5944 mandeep.dh 7923 
      oprot.writeListEnd()
7924 
      oprot.writeFieldEnd()
7925 
    if self.cex is not None:
7926 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7927 
      self.cex.write(oprot)
7928 
      oprot.writeFieldEnd()
7929 
    oprot.writeFieldStop()
7930 
    oprot.writeStructEnd()
7931 
 
7932 
  def validate(self):
7933 
    return
7934 
 
7935 
 
7936 
  def __repr__(self):
7937 
    L = ['%s=%r' % (key, value)
7938 
      for key, value in self.__dict__.iteritems()]
7939 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7940 
 
7941 
  def __eq__(self, other):
7942 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7943 
 
7944 
  def __ne__(self, other):
7945 
    return not (self == other)
7946 
 
7947 
class getAllItems_args:
7948 
  """
7949 
  Attributes:
7950 
   - isActive
7951 
  """
7952 
 
7953 
  thrift_spec = (
7954 
    None, # 0
7955 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
7956 
  )
7957 
 
7958 
  def __init__(self, isActive=None,):
7959 
    self.isActive = isActive
7960 
 
7961 
  def read(self, iprot):
7962 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7963 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7964 
      return
7965 
    iprot.readStructBegin()
7966 
    while True:
7967 
      (fname, ftype, fid) = iprot.readFieldBegin()
7968 
      if ftype == TType.STOP:
7969 
        break
7970 
      if fid == 1:
7971 
        if ftype == TType.BOOL:
7972 
          self.isActive = iprot.readBool();
7973 
        else:
7974 
          iprot.skip(ftype)
7975 
      else:
7976 
        iprot.skip(ftype)
7977 
      iprot.readFieldEnd()
7978 
    iprot.readStructEnd()
7979 
 
7980 
  def write(self, oprot):
7981 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7982 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7983 
      return
7984 
    oprot.writeStructBegin('getAllItems_args')
7985 
    if self.isActive is not None:
7986 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
7987 
      oprot.writeBool(self.isActive)
7988 
      oprot.writeFieldEnd()
7989 
    oprot.writeFieldStop()
7990 
    oprot.writeStructEnd()
7991 
 
7992 
  def validate(self):
7993 
    return
7994 
 
7995 
 
7996 
  def __repr__(self):
7997 
    L = ['%s=%r' % (key, value)
7998 
      for key, value in self.__dict__.iteritems()]
7999 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8000 
 
8001 
  def __eq__(self, other):
8002 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8003 
 
8004 
  def __ne__(self, other):
8005 
    return not (self == other)
8006 
 
8007 
class getAllItems_result:
8008 
  """
8009 
  Attributes:
8010 
   - success
8011 
   - cex
8012 
  """
8013 
 
8014 
  thrift_spec = (
8015 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8016 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8017 
  )
8018 
 
8019 
  def __init__(self, success=None, cex=None,):
8020 
    self.success = success
8021 
    self.cex = cex
8022 
 
8023 
  def read(self, iprot):
8024 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8025 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8026 
      return
8027 
    iprot.readStructBegin()
8028 
    while True:
8029 
      (fname, ftype, fid) = iprot.readFieldBegin()
8030 
      if ftype == TType.STOP:
8031 
        break
8032 
      if fid == 0:
8033 
        if ftype == TType.LIST:
8034 
          self.success = []
8590 kshitij.so 8035 
          (_etype63, _size60) = iprot.readListBegin()
8036 
          for _i64 in xrange(_size60):
8037 
            _elem65 = Item()
8038 
            _elem65.read(iprot)
8039 
            self.success.append(_elem65)
5944 mandeep.dh 8040 
          iprot.readListEnd()
8041 
        else:
8042 
          iprot.skip(ftype)
8043 
      elif fid == 1:
8044 
        if ftype == TType.STRUCT:
8045 
          self.cex = CatalogServiceException()
8046 
          self.cex.read(iprot)
8047 
        else:
8048 
          iprot.skip(ftype)
8049 
      else:
8050 
        iprot.skip(ftype)
8051 
      iprot.readFieldEnd()
8052 
    iprot.readStructEnd()
8053 
 
8054 
  def write(self, oprot):
8055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8057 
      return
8058 
    oprot.writeStructBegin('getAllItems_result')
8059 
    if self.success is not None:
8060 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8061 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8062 
      for iter66 in self.success:
8063 
        iter66.write(oprot)
5944 mandeep.dh 8064 
      oprot.writeListEnd()
8065 
      oprot.writeFieldEnd()
8066 
    if self.cex is not None:
8067 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8068 
      self.cex.write(oprot)
8069 
      oprot.writeFieldEnd()
8070 
    oprot.writeFieldStop()
8071 
    oprot.writeStructEnd()
8072 
 
8073 
  def validate(self):
8074 
    return
8075 
 
8076 
 
8077 
  def __repr__(self):
8078 
    L = ['%s=%r' % (key, value)
8079 
      for key, value in self.__dict__.iteritems()]
8080 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8081 
 
8082 
  def __eq__(self, other):
8083 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8084 
 
8085 
  def __ne__(self, other):
8086 
    return not (self == other)
8087 
 
8088 
class getAllItemsByStatus_args:
8089 
  """
8090 
  Attributes:
8091 
   - itemStatus
8092 
  """
8093 
 
8094 
  thrift_spec = (
8095 
    None, # 0
8096 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
8097 
  )
8098 
 
8099 
  def __init__(self, itemStatus=None,):
8100 
    self.itemStatus = itemStatus
8101 
 
8102 
  def read(self, iprot):
8103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8105 
      return
8106 
    iprot.readStructBegin()
8107 
    while True:
8108 
      (fname, ftype, fid) = iprot.readFieldBegin()
8109 
      if ftype == TType.STOP:
8110 
        break
8111 
      if fid == 1:
8112 
        if ftype == TType.I32:
8113 
          self.itemStatus = iprot.readI32();
8114 
        else:
8115 
          iprot.skip(ftype)
8116 
      else:
8117 
        iprot.skip(ftype)
8118 
      iprot.readFieldEnd()
8119 
    iprot.readStructEnd()
8120 
 
8121 
  def write(self, oprot):
8122 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8123 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8124 
      return
8125 
    oprot.writeStructBegin('getAllItemsByStatus_args')
8126 
    if self.itemStatus is not None:
8127 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
8128 
      oprot.writeI32(self.itemStatus)
8129 
      oprot.writeFieldEnd()
8130 
    oprot.writeFieldStop()
8131 
    oprot.writeStructEnd()
8132 
 
8133 
  def validate(self):
8134 
    return
8135 
 
8136 
 
8137 
  def __repr__(self):
8138 
    L = ['%s=%r' % (key, value)
8139 
      for key, value in self.__dict__.iteritems()]
8140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8141 
 
8142 
  def __eq__(self, other):
8143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8144 
 
8145 
  def __ne__(self, other):
8146 
    return not (self == other)
8147 
 
8148 
class getAllItemsByStatus_result:
8149 
  """
8150 
  Attributes:
8151 
   - success
8152 
   - cex
8153 
  """
8154 
 
8155 
  thrift_spec = (
8156 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8157 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8158 
  )
8159 
 
8160 
  def __init__(self, success=None, cex=None,):
8161 
    self.success = success
8162 
    self.cex = cex
8163 
 
8164 
  def read(self, iprot):
8165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8167 
      return
8168 
    iprot.readStructBegin()
8169 
    while True:
8170 
      (fname, ftype, fid) = iprot.readFieldBegin()
8171 
      if ftype == TType.STOP:
8172 
        break
8173 
      if fid == 0:
8174 
        if ftype == TType.LIST:
8175 
          self.success = []
8590 kshitij.so 8176 
          (_etype70, _size67) = iprot.readListBegin()
8177 
          for _i71 in xrange(_size67):
8178 
            _elem72 = Item()
8179 
            _elem72.read(iprot)
8180 
            self.success.append(_elem72)
5944 mandeep.dh 8181 
          iprot.readListEnd()
8182 
        else:
8183 
          iprot.skip(ftype)
8184 
      elif fid == 1:
8185 
        if ftype == TType.STRUCT:
8186 
          self.cex = CatalogServiceException()
8187 
          self.cex.read(iprot)
8188 
        else:
8189 
          iprot.skip(ftype)
8190 
      else:
8191 
        iprot.skip(ftype)
8192 
      iprot.readFieldEnd()
8193 
    iprot.readStructEnd()
8194 
 
8195 
  def write(self, oprot):
8196 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8197 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8198 
      return
8199 
    oprot.writeStructBegin('getAllItemsByStatus_result')
8200 
    if self.success is not None:
8201 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8202 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8203 
      for iter73 in self.success:
8204 
        iter73.write(oprot)
5944 mandeep.dh 8205 
      oprot.writeListEnd()
8206 
      oprot.writeFieldEnd()
8207 
    if self.cex is not None:
8208 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8209 
      self.cex.write(oprot)
8210 
      oprot.writeFieldEnd()
8211 
    oprot.writeFieldStop()
8212 
    oprot.writeStructEnd()
8213 
 
8214 
  def validate(self):
8215 
    return
8216 
 
8217 
 
8218 
  def __repr__(self):
8219 
    L = ['%s=%r' % (key, value)
8220 
      for key, value in self.__dict__.iteritems()]
8221 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8222 
 
8223 
  def __eq__(self, other):
8224 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8225 
 
8226 
  def __ne__(self, other):
8227 
    return not (self == other)
8228 
 
8229 
class markItemAsContentComplete_args:
8230 
  """
8231 
  Attributes:
8232 
   - entityId
8233 
   - category
8234 
   - brand
8235 
   - modelName
8236 
   - modelNumber
8237 
  """
8238 
 
8239 
  thrift_spec = (
8240 
    None, # 0
8241 
    (1, TType.I64, 'entityId', None, None, ), # 1
8242 
    (2, TType.I64, 'category', None, None, ), # 2
8243 
    (3, TType.STRING, 'brand', None, None, ), # 3
8244 
    (4, TType.STRING, 'modelName', None, None, ), # 4
8245 
    (5, TType.STRING, 'modelNumber', None, None, ), # 5
8246 
  )
8247 
 
8248 
  def __init__(self, entityId=None, category=None, brand=None, modelName=None, modelNumber=None,):
8249 
    self.entityId = entityId
8250 
    self.category = category
8251 
    self.brand = brand
8252 
    self.modelName = modelName
8253 
    self.modelNumber = modelNumber
8254 
 
8255 
  def read(self, iprot):
8256 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8257 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8258 
      return
8259 
    iprot.readStructBegin()
8260 
    while True:
8261 
      (fname, ftype, fid) = iprot.readFieldBegin()
8262 
      if ftype == TType.STOP:
8263 
        break
8264 
      if fid == 1:
8265 
        if ftype == TType.I64:
8266 
          self.entityId = iprot.readI64();
8267 
        else:
8268 
          iprot.skip(ftype)
8269 
      elif fid == 2:
8270 
        if ftype == TType.I64:
8271 
          self.category = iprot.readI64();
8272 
        else:
8273 
          iprot.skip(ftype)
8274 
      elif fid == 3:
8275 
        if ftype == TType.STRING:
8276 
          self.brand = iprot.readString();
8277 
        else:
8278 
          iprot.skip(ftype)
8279 
      elif fid == 4:
8280 
        if ftype == TType.STRING:
8281 
          self.modelName = iprot.readString();
8282 
        else:
8283 
          iprot.skip(ftype)
8284 
      elif fid == 5:
8285 
        if ftype == TType.STRING:
8286 
          self.modelNumber = iprot.readString();
8287 
        else:
8288 
          iprot.skip(ftype)
8289 
      else:
8290 
        iprot.skip(ftype)
8291 
      iprot.readFieldEnd()
8292 
    iprot.readStructEnd()
8293 
 
8294 
  def write(self, oprot):
8295 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8296 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8297 
      return
8298 
    oprot.writeStructBegin('markItemAsContentComplete_args')
8299 
    if self.entityId is not None:
8300 
      oprot.writeFieldBegin('entityId', TType.I64, 1)
8301 
      oprot.writeI64(self.entityId)
8302 
      oprot.writeFieldEnd()
8303 
    if self.category is not None:
8304 
      oprot.writeFieldBegin('category', TType.I64, 2)
8305 
      oprot.writeI64(self.category)
8306 
      oprot.writeFieldEnd()
8307 
    if self.brand is not None:
8308 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8309 
      oprot.writeString(self.brand)
8310 
      oprot.writeFieldEnd()
8311 
    if self.modelName is not None:
8312 
      oprot.writeFieldBegin('modelName', TType.STRING, 4)
8313 
      oprot.writeString(self.modelName)
8314 
      oprot.writeFieldEnd()
8315 
    if self.modelNumber is not None:
8316 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 5)
8317 
      oprot.writeString(self.modelNumber)
8318 
      oprot.writeFieldEnd()
8319 
    oprot.writeFieldStop()
8320 
    oprot.writeStructEnd()
8321 
 
8322 
  def validate(self):
8323 
    return
8324 
 
8325 
 
8326 
  def __repr__(self):
8327 
    L = ['%s=%r' % (key, value)
8328 
      for key, value in self.__dict__.iteritems()]
8329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8330 
 
8331 
  def __eq__(self, other):
8332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8333 
 
8334 
  def __ne__(self, other):
8335 
    return not (self == other)
8336 
 
8337 
class markItemAsContentComplete_result:
8338 
  """
8339 
  Attributes:
8340 
   - success
8341 
   - cex
8342 
  """
8343 
 
8344 
  thrift_spec = (
8345 
    (0, TType.BOOL, 'success', None, None, ), # 0
8346 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8347 
  )
8348 
 
8349 
  def __init__(self, success=None, cex=None,):
8350 
    self.success = success
8351 
    self.cex = cex
8352 
 
8353 
  def read(self, iprot):
8354 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8355 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8356 
      return
8357 
    iprot.readStructBegin()
8358 
    while True:
8359 
      (fname, ftype, fid) = iprot.readFieldBegin()
8360 
      if ftype == TType.STOP:
8361 
        break
8362 
      if fid == 0:
8363 
        if ftype == TType.BOOL:
8364 
          self.success = iprot.readBool();
8365 
        else:
8366 
          iprot.skip(ftype)
8367 
      elif fid == 1:
8368 
        if ftype == TType.STRUCT:
8369 
          self.cex = CatalogServiceException()
8370 
          self.cex.read(iprot)
8371 
        else:
8372 
          iprot.skip(ftype)
8373 
      else:
8374 
        iprot.skip(ftype)
8375 
      iprot.readFieldEnd()
8376 
    iprot.readStructEnd()
8377 
 
8378 
  def write(self, oprot):
8379 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8380 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8381 
      return
8382 
    oprot.writeStructBegin('markItemAsContentComplete_result')
8383 
    if self.success is not None:
8384 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8385 
      oprot.writeBool(self.success)
8386 
      oprot.writeFieldEnd()
8387 
    if self.cex is not None:
8388 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8389 
      self.cex.write(oprot)
8390 
      oprot.writeFieldEnd()
8391 
    oprot.writeFieldStop()
8392 
    oprot.writeStructEnd()
8393 
 
8394 
  def validate(self):
8395 
    return
8396 
 
8397 
 
8398 
  def __repr__(self):
8399 
    L = ['%s=%r' % (key, value)
8400 
      for key, value in self.__dict__.iteritems()]
8401 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8402 
 
8403 
  def __eq__(self, other):
8404 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8405 
 
8406 
  def __ne__(self, other):
8407 
    return not (self == other)
8408 
 
8409 
class getAllItemsInRange_args:
8410 
  """
8411 
  Attributes:
8412 
   - offset
8413 
   - limit
8414 
  """
8415 
 
8416 
  thrift_spec = (
8417 
    None, # 0
8418 
    (1, TType.I64, 'offset', None, None, ), # 1
8419 
    (2, TType.I64, 'limit', None, None, ), # 2
8420 
  )
8421 
 
8422 
  def __init__(self, offset=None, limit=None,):
8423 
    self.offset = offset
8424 
    self.limit = limit
8425 
 
8426 
  def read(self, iprot):
8427 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8428 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8429 
      return
8430 
    iprot.readStructBegin()
8431 
    while True:
8432 
      (fname, ftype, fid) = iprot.readFieldBegin()
8433 
      if ftype == TType.STOP:
8434 
        break
8435 
      if fid == 1:
8436 
        if ftype == TType.I64:
8437 
          self.offset = iprot.readI64();
8438 
        else:
8439 
          iprot.skip(ftype)
8440 
      elif fid == 2:
8441 
        if ftype == TType.I64:
8442 
          self.limit = iprot.readI64();
8443 
        else:
8444 
          iprot.skip(ftype)
8445 
      else:
8446 
        iprot.skip(ftype)
8447 
      iprot.readFieldEnd()
8448 
    iprot.readStructEnd()
8449 
 
8450 
  def write(self, oprot):
8451 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8452 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8453 
      return
8454 
    oprot.writeStructBegin('getAllItemsInRange_args')
8455 
    if self.offset is not None:
8456 
      oprot.writeFieldBegin('offset', TType.I64, 1)
8457 
      oprot.writeI64(self.offset)
8458 
      oprot.writeFieldEnd()
8459 
    if self.limit is not None:
8460 
      oprot.writeFieldBegin('limit', TType.I64, 2)
8461 
      oprot.writeI64(self.limit)
8462 
      oprot.writeFieldEnd()
8463 
    oprot.writeFieldStop()
8464 
    oprot.writeStructEnd()
8465 
 
8466 
  def validate(self):
8467 
    return
8468 
 
8469 
 
8470 
  def __repr__(self):
8471 
    L = ['%s=%r' % (key, value)
8472 
      for key, value in self.__dict__.iteritems()]
8473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8474 
 
8475 
  def __eq__(self, other):
8476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8477 
 
8478 
  def __ne__(self, other):
8479 
    return not (self == other)
8480 
 
8481 
class getAllItemsInRange_result:
8482 
  """
8483 
  Attributes:
8484 
   - success
8485 
   - cex
8486 
  """
8487 
 
8488 
  thrift_spec = (
8489 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8490 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8491 
  )
8492 
 
8493 
  def __init__(self, success=None, cex=None,):
8494 
    self.success = success
8495 
    self.cex = cex
8496 
 
8497 
  def read(self, iprot):
8498 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8499 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8500 
      return
8501 
    iprot.readStructBegin()
8502 
    while True:
8503 
      (fname, ftype, fid) = iprot.readFieldBegin()
8504 
      if ftype == TType.STOP:
8505 
        break
8506 
      if fid == 0:
8507 
        if ftype == TType.LIST:
8508 
          self.success = []
8590 kshitij.so 8509 
          (_etype77, _size74) = iprot.readListBegin()
8510 
          for _i78 in xrange(_size74):
8511 
            _elem79 = Item()
8512 
            _elem79.read(iprot)
8513 
            self.success.append(_elem79)
5944 mandeep.dh 8514 
          iprot.readListEnd()
8515 
        else:
8516 
          iprot.skip(ftype)
8517 
      elif fid == 1:
8518 
        if ftype == TType.STRUCT:
8519 
          self.cex = CatalogServiceException()
8520 
          self.cex.read(iprot)
8521 
        else:
8522 
          iprot.skip(ftype)
8523 
      else:
8524 
        iprot.skip(ftype)
8525 
      iprot.readFieldEnd()
8526 
    iprot.readStructEnd()
8527 
 
8528 
  def write(self, oprot):
8529 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8530 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8531 
      return
8532 
    oprot.writeStructBegin('getAllItemsInRange_result')
8533 
    if self.success is not None:
8534 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8535 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8536 
      for iter80 in self.success:
8537 
        iter80.write(oprot)
5944 mandeep.dh 8538 
      oprot.writeListEnd()
8539 
      oprot.writeFieldEnd()
8540 
    if self.cex is not None:
8541 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8542 
      self.cex.write(oprot)
8543 
      oprot.writeFieldEnd()
8544 
    oprot.writeFieldStop()
8545 
    oprot.writeStructEnd()
8546 
 
8547 
  def validate(self):
8548 
    return
8549 
 
8550 
 
8551 
  def __repr__(self):
8552 
    L = ['%s=%r' % (key, value)
8553 
      for key, value in self.__dict__.iteritems()]
8554 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8555 
 
8556 
  def __eq__(self, other):
8557 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8558 
 
8559 
  def __ne__(self, other):
8560 
    return not (self == other)
8561 
 
8562 
class getAllItemsByStatusInRange_args:
8563 
  """
8564 
  Attributes:
8565 
   - itemStatus
8566 
   - offset
8567 
   - limit
8568 
  """
8569 
 
8570 
  thrift_spec = (
8571 
    None, # 0
8572 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
8573 
    (2, TType.I64, 'offset', None, None, ), # 2
8574 
    (3, TType.I64, 'limit', None, None, ), # 3
8575 
  )
8576 
 
8577 
  def __init__(self, itemStatus=None, offset=None, limit=None,):
8578 
    self.itemStatus = itemStatus
8579 
    self.offset = offset
8580 
    self.limit = limit
8581 
 
8582 
  def read(self, iprot):
8583 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8584 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8585 
      return
8586 
    iprot.readStructBegin()
8587 
    while True:
8588 
      (fname, ftype, fid) = iprot.readFieldBegin()
8589 
      if ftype == TType.STOP:
8590 
        break
8591 
      if fid == 1:
8592 
        if ftype == TType.I32:
8593 
          self.itemStatus = iprot.readI32();
8594 
        else:
8595 
          iprot.skip(ftype)
8596 
      elif fid == 2:
8597 
        if ftype == TType.I64:
8598 
          self.offset = iprot.readI64();
8599 
        else:
8600 
          iprot.skip(ftype)
8601 
      elif fid == 3:
8602 
        if ftype == TType.I64:
8603 
          self.limit = iprot.readI64();
8604 
        else:
8605 
          iprot.skip(ftype)
8606 
      else:
8607 
        iprot.skip(ftype)
8608 
      iprot.readFieldEnd()
8609 
    iprot.readStructEnd()
8610 
 
8611 
  def write(self, oprot):
8612 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8613 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8614 
      return
8615 
    oprot.writeStructBegin('getAllItemsByStatusInRange_args')
8616 
    if self.itemStatus is not None:
8617 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
8618 
      oprot.writeI32(self.itemStatus)
8619 
      oprot.writeFieldEnd()
8620 
    if self.offset is not None:
8621 
      oprot.writeFieldBegin('offset', TType.I64, 2)
8622 
      oprot.writeI64(self.offset)
8623 
      oprot.writeFieldEnd()
8624 
    if self.limit is not None:
8625 
      oprot.writeFieldBegin('limit', TType.I64, 3)
8626 
      oprot.writeI64(self.limit)
8627 
      oprot.writeFieldEnd()
8628 
    oprot.writeFieldStop()
8629 
    oprot.writeStructEnd()
8630 
 
8631 
  def validate(self):
8632 
    return
8633 
 
8634 
 
8635 
  def __repr__(self):
8636 
    L = ['%s=%r' % (key, value)
8637 
      for key, value in self.__dict__.iteritems()]
8638 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8639 
 
8640 
  def __eq__(self, other):
8641 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8642 
 
8643 
  def __ne__(self, other):
8644 
    return not (self == other)
8645 
 
8646 
class getAllItemsByStatusInRange_result:
8647 
  """
8648 
  Attributes:
8649 
   - success
8650 
   - cex
8651 
  """
8652 
 
8653 
  thrift_spec = (
8654 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8655 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8656 
  )
8657 
 
8658 
  def __init__(self, success=None, cex=None,):
8659 
    self.success = success
8660 
    self.cex = cex
8661 
 
8662 
  def read(self, iprot):
8663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8665 
      return
8666 
    iprot.readStructBegin()
8667 
    while True:
8668 
      (fname, ftype, fid) = iprot.readFieldBegin()
8669 
      if ftype == TType.STOP:
8670 
        break
8671 
      if fid == 0:
8672 
        if ftype == TType.LIST:
8673 
          self.success = []
8590 kshitij.so 8674 
          (_etype84, _size81) = iprot.readListBegin()
8675 
          for _i85 in xrange(_size81):
8676 
            _elem86 = Item()
8677 
            _elem86.read(iprot)
8678 
            self.success.append(_elem86)
5944 mandeep.dh 8679 
          iprot.readListEnd()
8680 
        else:
8681 
          iprot.skip(ftype)
8682 
      elif fid == 1:
8683 
        if ftype == TType.STRUCT:
8684 
          self.cex = CatalogServiceException()
8685 
          self.cex.read(iprot)
8686 
        else:
8687 
          iprot.skip(ftype)
8688 
      else:
8689 
        iprot.skip(ftype)
8690 
      iprot.readFieldEnd()
8691 
    iprot.readStructEnd()
8692 
 
8693 
  def write(self, oprot):
8694 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8695 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8696 
      return
8697 
    oprot.writeStructBegin('getAllItemsByStatusInRange_result')
8698 
    if self.success is not None:
8699 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8700 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8701 
      for iter87 in self.success:
8702 
        iter87.write(oprot)
5944 mandeep.dh 8703 
      oprot.writeListEnd()
8704 
      oprot.writeFieldEnd()
8705 
    if self.cex is not None:
8706 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8707 
      self.cex.write(oprot)
8708 
      oprot.writeFieldEnd()
8709 
    oprot.writeFieldStop()
8710 
    oprot.writeStructEnd()
8711 
 
8712 
  def validate(self):
8713 
    return
8714 
 
8715 
 
8716 
  def __repr__(self):
8717 
    L = ['%s=%r' % (key, value)
8718 
      for key, value in self.__dict__.iteritems()]
8719 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8720 
 
8721 
  def __eq__(self, other):
8722 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8723 
 
8724 
  def __ne__(self, other):
8725 
    return not (self == other)
8726 
 
8727 
class getItemCountByStatus_args:
8728 
  """
8729 
  Attributes:
8730 
   - useStatus
8731 
   - itemStatus
8732 
  """
8733 
 
8734 
  thrift_spec = (
8735 
    None, # 0
8736 
    (1, TType.BOOL, 'useStatus', None, None, ), # 1
8737 
    (2, TType.I32, 'itemStatus', None, None, ), # 2
8738 
  )
8739 
 
8740 
  def __init__(self, useStatus=None, itemStatus=None,):
8741 
    self.useStatus = useStatus
8742 
    self.itemStatus = itemStatus
8743 
 
8744 
  def read(self, iprot):
8745 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8746 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8747 
      return
8748 
    iprot.readStructBegin()
8749 
    while True:
8750 
      (fname, ftype, fid) = iprot.readFieldBegin()
8751 
      if ftype == TType.STOP:
8752 
        break
8753 
      if fid == 1:
8754 
        if ftype == TType.BOOL:
8755 
          self.useStatus = iprot.readBool();
8756 
        else:
8757 
          iprot.skip(ftype)
8758 
      elif fid == 2:
8759 
        if ftype == TType.I32:
8760 
          self.itemStatus = iprot.readI32();
8761 
        else:
8762 
          iprot.skip(ftype)
8763 
      else:
8764 
        iprot.skip(ftype)
8765 
      iprot.readFieldEnd()
8766 
    iprot.readStructEnd()
8767 
 
8768 
  def write(self, oprot):
8769 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8770 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8771 
      return
8772 
    oprot.writeStructBegin('getItemCountByStatus_args')
8773 
    if self.useStatus is not None:
8774 
      oprot.writeFieldBegin('useStatus', TType.BOOL, 1)
8775 
      oprot.writeBool(self.useStatus)
8776 
      oprot.writeFieldEnd()
8777 
    if self.itemStatus is not None:
8778 
      oprot.writeFieldBegin('itemStatus', TType.I32, 2)
8779 
      oprot.writeI32(self.itemStatus)
8780 
      oprot.writeFieldEnd()
8781 
    oprot.writeFieldStop()
8782 
    oprot.writeStructEnd()
8783 
 
8784 
  def validate(self):
8785 
    return
8786 
 
8787 
 
8788 
  def __repr__(self):
8789 
    L = ['%s=%r' % (key, value)
8790 
      for key, value in self.__dict__.iteritems()]
8791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8792 
 
8793 
  def __eq__(self, other):
8794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8795 
 
8796 
  def __ne__(self, other):
8797 
    return not (self == other)
8798 
 
8799 
class getItemCountByStatus_result:
8800 
  """
8801 
  Attributes:
8802 
   - success
8803 
  """
8804 
 
8805 
  thrift_spec = (
8806 
    (0, TType.I32, 'success', None, None, ), # 0
8807 
  )
8808 
 
8809 
  def __init__(self, success=None,):
8810 
    self.success = success
8811 
 
8812 
  def read(self, iprot):
8813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8815 
      return
8816 
    iprot.readStructBegin()
8817 
    while True:
8818 
      (fname, ftype, fid) = iprot.readFieldBegin()
8819 
      if ftype == TType.STOP:
8820 
        break
8821 
      if fid == 0:
8822 
        if ftype == TType.I32:
8823 
          self.success = iprot.readI32();
8824 
        else:
8825 
          iprot.skip(ftype)
8826 
      else:
8827 
        iprot.skip(ftype)
8828 
      iprot.readFieldEnd()
8829 
    iprot.readStructEnd()
8830 
 
8831 
  def write(self, oprot):
8832 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8833 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8834 
      return
8835 
    oprot.writeStructBegin('getItemCountByStatus_result')
8836 
    if self.success is not None:
8837 
      oprot.writeFieldBegin('success', TType.I32, 0)
8838 
      oprot.writeI32(self.success)
8839 
      oprot.writeFieldEnd()
8840 
    oprot.writeFieldStop()
8841 
    oprot.writeStructEnd()
8842 
 
8843 
  def validate(self):
8844 
    return
8845 
 
8846 
 
8847 
  def __repr__(self):
8848 
    L = ['%s=%r' % (key, value)
8849 
      for key, value in self.__dict__.iteritems()]
8850 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8851 
 
8852 
  def __eq__(self, other):
8853 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8854 
 
8855 
  def __ne__(self, other):
8856 
    return not (self == other)
8857 
 
8858 
class getBestSellers_args:
8859 
 
8860 
  thrift_spec = (
8861 
  )
8862 
 
8863 
  def read(self, iprot):
8864 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8865 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8866 
      return
8867 
    iprot.readStructBegin()
8868 
    while True:
8869 
      (fname, ftype, fid) = iprot.readFieldBegin()
8870 
      if ftype == TType.STOP:
8871 
        break
8872 
      else:
8873 
        iprot.skip(ftype)
8874 
      iprot.readFieldEnd()
8875 
    iprot.readStructEnd()
8876 
 
8877 
  def write(self, oprot):
8878 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8879 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8880 
      return
8881 
    oprot.writeStructBegin('getBestSellers_args')
8882 
    oprot.writeFieldStop()
8883 
    oprot.writeStructEnd()
8884 
 
8885 
  def validate(self):
8886 
    return
8887 
 
8888 
 
8889 
  def __repr__(self):
8890 
    L = ['%s=%r' % (key, value)
8891 
      for key, value in self.__dict__.iteritems()]
8892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8893 
 
8894 
  def __eq__(self, other):
8895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8896 
 
8897 
  def __ne__(self, other):
8898 
    return not (self == other)
8899 
 
8900 
class getBestSellers_result:
8901 
  """
8902 
  Attributes:
8903 
   - success
8904 
   - isex
8905 
  """
8906 
 
8907 
  thrift_spec = (
8908 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8909 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8910 
  )
8911 
 
8912 
  def __init__(self, success=None, isex=None,):
8913 
    self.success = success
8914 
    self.isex = isex
8915 
 
8916 
  def read(self, iprot):
8917 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8918 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8919 
      return
8920 
    iprot.readStructBegin()
8921 
    while True:
8922 
      (fname, ftype, fid) = iprot.readFieldBegin()
8923 
      if ftype == TType.STOP:
8924 
        break
8925 
      if fid == 0:
8926 
        if ftype == TType.LIST:
8927 
          self.success = []
8590 kshitij.so 8928 
          (_etype91, _size88) = iprot.readListBegin()
8929 
          for _i92 in xrange(_size88):
8930 
            _elem93 = Item()
8931 
            _elem93.read(iprot)
8932 
            self.success.append(_elem93)
5944 mandeep.dh 8933 
          iprot.readListEnd()
8934 
        else:
8935 
          iprot.skip(ftype)
8936 
      elif fid == 1:
8937 
        if ftype == TType.STRUCT:
8938 
          self.isex = CatalogServiceException()
8939 
          self.isex.read(iprot)
8940 
        else:
8941 
          iprot.skip(ftype)
8942 
      else:
8943 
        iprot.skip(ftype)
8944 
      iprot.readFieldEnd()
8945 
    iprot.readStructEnd()
8946 
 
8947 
  def write(self, oprot):
8948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8950 
      return
8951 
    oprot.writeStructBegin('getBestSellers_result')
8952 
    if self.success is not None:
8953 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8954 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8955 
      for iter94 in self.success:
8956 
        iter94.write(oprot)
5944 mandeep.dh 8957 
      oprot.writeListEnd()
8958 
      oprot.writeFieldEnd()
8959 
    if self.isex is not None:
8960 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8961 
      self.isex.write(oprot)
8962 
      oprot.writeFieldEnd()
8963 
    oprot.writeFieldStop()
8964 
    oprot.writeStructEnd()
8965 
 
8966 
  def validate(self):
8967 
    return
8968 
 
8969 
 
8970 
  def __repr__(self):
8971 
    L = ['%s=%r' % (key, value)
8972 
      for key, value in self.__dict__.iteritems()]
8973 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8974 
 
8975 
  def __eq__(self, other):
8976 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8977 
 
8978 
  def __ne__(self, other):
8979 
    return not (self == other)
8980 
 
8981 
class getBestSellersCatalogIds_args:
8982 
  """
8983 
  Attributes:
8984 
   - beginIndex
8985 
   - totalItems
8986 
   - brand
8987 
   - category
8988 
  """
8989 
 
8990 
  thrift_spec = (
8991 
    None, # 0
8992 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8993 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8994 
    (3, TType.STRING, 'brand', None, None, ), # 3
8995 
    (4, TType.I64, 'category', None, None, ), # 4
8996 
  )
8997 
 
8998 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
8999 
    self.beginIndex = beginIndex
9000 
    self.totalItems = totalItems
9001 
    self.brand = brand
9002 
    self.category = category
9003 
 
9004 
  def read(self, iprot):
9005 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9006 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9007 
      return
9008 
    iprot.readStructBegin()
9009 
    while True:
9010 
      (fname, ftype, fid) = iprot.readFieldBegin()
9011 
      if ftype == TType.STOP:
9012 
        break
9013 
      if fid == 1:
9014 
        if ftype == TType.I64:
9015 
          self.beginIndex = iprot.readI64();
9016 
        else:
9017 
          iprot.skip(ftype)
9018 
      elif fid == 2:
9019 
        if ftype == TType.I64:
9020 
          self.totalItems = iprot.readI64();
9021 
        else:
9022 
          iprot.skip(ftype)
9023 
      elif fid == 3:
9024 
        if ftype == TType.STRING:
9025 
          self.brand = iprot.readString();
9026 
        else:
9027 
          iprot.skip(ftype)
9028 
      elif fid == 4:
9029 
        if ftype == TType.I64:
9030 
          self.category = iprot.readI64();
9031 
        else:
9032 
          iprot.skip(ftype)
9033 
      else:
9034 
        iprot.skip(ftype)
9035 
      iprot.readFieldEnd()
9036 
    iprot.readStructEnd()
9037 
 
9038 
  def write(self, oprot):
9039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9041 
      return
9042 
    oprot.writeStructBegin('getBestSellersCatalogIds_args')
9043 
    if self.beginIndex is not None:
9044 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
9045 
      oprot.writeI64(self.beginIndex)
9046 
      oprot.writeFieldEnd()
9047 
    if self.totalItems is not None:
9048 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
9049 
      oprot.writeI64(self.totalItems)
9050 
      oprot.writeFieldEnd()
9051 
    if self.brand is not None:
9052 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9053 
      oprot.writeString(self.brand)
9054 
      oprot.writeFieldEnd()
9055 
    if self.category is not None:
9056 
      oprot.writeFieldBegin('category', TType.I64, 4)
9057 
      oprot.writeI64(self.category)
9058 
      oprot.writeFieldEnd()
9059 
    oprot.writeFieldStop()
9060 
    oprot.writeStructEnd()
9061 
 
9062 
  def validate(self):
9063 
    return
9064 
 
9065 
 
9066 
  def __repr__(self):
9067 
    L = ['%s=%r' % (key, value)
9068 
      for key, value in self.__dict__.iteritems()]
9069 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9070 
 
9071 
  def __eq__(self, other):
9072 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9073 
 
9074 
  def __ne__(self, other):
9075 
    return not (self == other)
9076 
 
9077 
class getBestSellersCatalogIds_result:
9078 
  """
9079 
  Attributes:
9080 
   - success
9081 
   - cex
9082 
  """
9083 
 
9084 
  thrift_spec = (
9085 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9086 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9087 
  )
9088 
 
9089 
  def __init__(self, success=None, cex=None,):
9090 
    self.success = success
9091 
    self.cex = cex
9092 
 
9093 
  def read(self, iprot):
9094 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9095 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9096 
      return
9097 
    iprot.readStructBegin()
9098 
    while True:
9099 
      (fname, ftype, fid) = iprot.readFieldBegin()
9100 
      if ftype == TType.STOP:
9101 
        break
9102 
      if fid == 0:
9103 
        if ftype == TType.LIST:
9104 
          self.success = []
8590 kshitij.so 9105 
          (_etype98, _size95) = iprot.readListBegin()
9106 
          for _i99 in xrange(_size95):
9107 
            _elem100 = iprot.readI64();
9108 
            self.success.append(_elem100)
5944 mandeep.dh 9109 
          iprot.readListEnd()
9110 
        else:
9111 
          iprot.skip(ftype)
9112 
      elif fid == 1:
9113 
        if ftype == TType.STRUCT:
9114 
          self.cex = CatalogServiceException()
9115 
          self.cex.read(iprot)
9116 
        else:
9117 
          iprot.skip(ftype)
9118 
      else:
9119 
        iprot.skip(ftype)
9120 
      iprot.readFieldEnd()
9121 
    iprot.readStructEnd()
9122 
 
9123 
  def write(self, oprot):
9124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9126 
      return
9127 
    oprot.writeStructBegin('getBestSellersCatalogIds_result')
9128 
    if self.success is not None:
9129 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9130 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 9131 
      for iter101 in self.success:
9132 
        oprot.writeI64(iter101)
5944 mandeep.dh 9133 
      oprot.writeListEnd()
9134 
      oprot.writeFieldEnd()
9135 
    if self.cex is not None:
9136 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9137 
      self.cex.write(oprot)
9138 
      oprot.writeFieldEnd()
9139 
    oprot.writeFieldStop()
9140 
    oprot.writeStructEnd()
9141 
 
9142 
  def validate(self):
9143 
    return
9144 
 
9145 
 
9146 
  def __repr__(self):
9147 
    L = ['%s=%r' % (key, value)
9148 
      for key, value in self.__dict__.iteritems()]
9149 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9150 
 
9151 
  def __eq__(self, other):
9152 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9153 
 
9154 
  def __ne__(self, other):
9155 
    return not (self == other)
9156 
 
9157 
class getBestSellersCount_args:
9158 
 
9159 
  thrift_spec = (
9160 
  )
9161 
 
9162 
  def read(self, iprot):
9163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9165 
      return
9166 
    iprot.readStructBegin()
9167 
    while True:
9168 
      (fname, ftype, fid) = iprot.readFieldBegin()
9169 
      if ftype == TType.STOP:
9170 
        break
9171 
      else:
9172 
        iprot.skip(ftype)
9173 
      iprot.readFieldEnd()
9174 
    iprot.readStructEnd()
9175 
 
9176 
  def write(self, oprot):
9177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9179 
      return
9180 
    oprot.writeStructBegin('getBestSellersCount_args')
9181 
    oprot.writeFieldStop()
9182 
    oprot.writeStructEnd()
9183 
 
9184 
  def validate(self):
9185 
    return
9186 
 
9187 
 
9188 
  def __repr__(self):
9189 
    L = ['%s=%r' % (key, value)
9190 
      for key, value in self.__dict__.iteritems()]
9191 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9192 
 
9193 
  def __eq__(self, other):
9194 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9195 
 
9196 
  def __ne__(self, other):
9197 
    return not (self == other)
9198 
 
9199 
class getBestSellersCount_result:
9200 
  """
9201 
  Attributes:
9202 
   - success
9203 
   - cex
9204 
  """
9205 
 
9206 
  thrift_spec = (
9207 
    (0, TType.I64, 'success', None, None, ), # 0
9208 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9209 
  )
9210 
 
9211 
  def __init__(self, success=None, cex=None,):
9212 
    self.success = success
9213 
    self.cex = cex
9214 
 
9215 
  def read(self, iprot):
9216 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9217 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9218 
      return
9219 
    iprot.readStructBegin()
9220 
    while True:
9221 
      (fname, ftype, fid) = iprot.readFieldBegin()
9222 
      if ftype == TType.STOP:
9223 
        break
9224 
      if fid == 0:
9225 
        if ftype == TType.I64:
9226 
          self.success = iprot.readI64();
9227 
        else:
9228 
          iprot.skip(ftype)
9229 
      elif fid == 1:
9230 
        if ftype == TType.STRUCT:
9231 
          self.cex = CatalogServiceException()
9232 
          self.cex.read(iprot)
9233 
        else:
9234 
          iprot.skip(ftype)
9235 
      else:
9236 
        iprot.skip(ftype)
9237 
      iprot.readFieldEnd()
9238 
    iprot.readStructEnd()
9239 
 
9240 
  def write(self, oprot):
9241 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9242 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9243 
      return
9244 
    oprot.writeStructBegin('getBestSellersCount_result')
9245 
    if self.success is not None:
9246 
      oprot.writeFieldBegin('success', TType.I64, 0)
9247 
      oprot.writeI64(self.success)
9248 
      oprot.writeFieldEnd()
9249 
    if self.cex is not None:
9250 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9251 
      self.cex.write(oprot)
9252 
      oprot.writeFieldEnd()
9253 
    oprot.writeFieldStop()
9254 
    oprot.writeStructEnd()
9255 
 
9256 
  def validate(self):
9257 
    return
9258 
 
9259 
 
9260 
  def __repr__(self):
9261 
    L = ['%s=%r' % (key, value)
9262 
      for key, value in self.__dict__.iteritems()]
9263 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9264 
 
9265 
  def __eq__(self, other):
9266 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9267 
 
9268 
  def __ne__(self, other):
9269 
    return not (self == other)
9270 
 
9271 
class getBestDeals_args:
9272 
 
9273 
  thrift_spec = (
9274 
  )
9275 
 
9276 
  def read(self, iprot):
9277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9279 
      return
9280 
    iprot.readStructBegin()
9281 
    while True:
9282 
      (fname, ftype, fid) = iprot.readFieldBegin()
9283 
      if ftype == TType.STOP:
9284 
        break
9285 
      else:
9286 
        iprot.skip(ftype)
9287 
      iprot.readFieldEnd()
9288 
    iprot.readStructEnd()
9289 
 
9290 
  def write(self, oprot):
9291 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9292 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9293 
      return
9294 
    oprot.writeStructBegin('getBestDeals_args')
9295 
    oprot.writeFieldStop()
9296 
    oprot.writeStructEnd()
9297 
 
9298 
  def validate(self):
9299 
    return
9300 
 
9301 
 
9302 
  def __repr__(self):
9303 
    L = ['%s=%r' % (key, value)
9304 
      for key, value in self.__dict__.iteritems()]
9305 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9306 
 
9307 
  def __eq__(self, other):
9308 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9309 
 
9310 
  def __ne__(self, other):
9311 
    return not (self == other)
9312 
 
9313 
class getBestDeals_result:
9314 
  """
9315 
  Attributes:
9316 
   - success
9317 
   - isex
9318 
  """
9319 
 
9320 
  thrift_spec = (
9321 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9322 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9323 
  )
9324 
 
9325 
  def __init__(self, success=None, isex=None,):
9326 
    self.success = success
9327 
    self.isex = isex
9328 
 
9329 
  def read(self, iprot):
9330 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9331 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9332 
      return
9333 
    iprot.readStructBegin()
9334 
    while True:
9335 
      (fname, ftype, fid) = iprot.readFieldBegin()
9336 
      if ftype == TType.STOP:
9337 
        break
9338 
      if fid == 0:
9339 
        if ftype == TType.LIST:
9340 
          self.success = []
8590 kshitij.so 9341 
          (_etype105, _size102) = iprot.readListBegin()
9342 
          for _i106 in xrange(_size102):
9343 
            _elem107 = Item()
9344 
            _elem107.read(iprot)
9345 
            self.success.append(_elem107)
5944 mandeep.dh 9346 
          iprot.readListEnd()
9347 
        else:
9348 
          iprot.skip(ftype)
9349 
      elif fid == 1:
9350 
        if ftype == TType.STRUCT:
9351 
          self.isex = CatalogServiceException()
9352 
          self.isex.read(iprot)
9353 
        else:
9354 
          iprot.skip(ftype)
9355 
      else:
9356 
        iprot.skip(ftype)
9357 
      iprot.readFieldEnd()
9358 
    iprot.readStructEnd()
9359 
 
9360 
  def write(self, oprot):
9361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9363 
      return
9364 
    oprot.writeStructBegin('getBestDeals_result')
9365 
    if self.success is not None:
9366 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9367 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9368 
      for iter108 in self.success:
9369 
        iter108.write(oprot)
5944 mandeep.dh 9370 
      oprot.writeListEnd()
9371 
      oprot.writeFieldEnd()
9372 
    if self.isex is not None:
9373 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
9374 
      self.isex.write(oprot)
9375 
      oprot.writeFieldEnd()
9376 
    oprot.writeFieldStop()
9377 
    oprot.writeStructEnd()
9378 
 
9379 
  def validate(self):
9380 
    return
9381 
 
9382 
 
9383 
  def __repr__(self):
9384 
    L = ['%s=%r' % (key, value)
9385 
      for key, value in self.__dict__.iteritems()]
9386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9387 
 
9388 
  def __eq__(self, other):
9389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9390 
 
9391 
  def __ne__(self, other):
9392 
    return not (self == other)
9393 
 
9394 
class getBestDealsCatalogIds_args:
9395 
  """
9396 
  Attributes:
9397 
   - beginIndex
9398 
   - totalItems
9399 
   - brand
9400 
   - category
9401 
  """
9402 
 
9403 
  thrift_spec = (
9404 
    None, # 0
9405 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
9406 
    (2, TType.I64, 'totalItems', None, None, ), # 2
9407 
    (3, TType.STRING, 'brand', None, None, ), # 3
9408 
    (4, TType.I64, 'category', None, None, ), # 4
9409 
  )
9410 
 
9411 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
9412 
    self.beginIndex = beginIndex
9413 
    self.totalItems = totalItems
9414 
    self.brand = brand
9415 
    self.category = category
9416 
 
9417 
  def read(self, iprot):
9418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9420 
      return
9421 
    iprot.readStructBegin()
9422 
    while True:
9423 
      (fname, ftype, fid) = iprot.readFieldBegin()
9424 
      if ftype == TType.STOP:
9425 
        break
9426 
      if fid == 1:
9427 
        if ftype == TType.I64:
9428 
          self.beginIndex = iprot.readI64();
9429 
        else:
9430 
          iprot.skip(ftype)
9431 
      elif fid == 2:
9432 
        if ftype == TType.I64:
9433 
          self.totalItems = iprot.readI64();
9434 
        else:
9435 
          iprot.skip(ftype)
9436 
      elif fid == 3:
9437 
        if ftype == TType.STRING:
9438 
          self.brand = iprot.readString();
9439 
        else:
9440 
          iprot.skip(ftype)
9441 
      elif fid == 4:
9442 
        if ftype == TType.I64:
9443 
          self.category = iprot.readI64();
9444 
        else:
9445 
          iprot.skip(ftype)
9446 
      else:
9447 
        iprot.skip(ftype)
9448 
      iprot.readFieldEnd()
9449 
    iprot.readStructEnd()
9450 
 
9451 
  def write(self, oprot):
9452 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9453 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9454 
      return
9455 
    oprot.writeStructBegin('getBestDealsCatalogIds_args')
9456 
    if self.beginIndex is not None:
9457 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
9458 
      oprot.writeI64(self.beginIndex)
9459 
      oprot.writeFieldEnd()
9460 
    if self.totalItems is not None:
9461 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
9462 
      oprot.writeI64(self.totalItems)
9463 
      oprot.writeFieldEnd()
9464 
    if self.brand is not None:
9465 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9466 
      oprot.writeString(self.brand)
9467 
      oprot.writeFieldEnd()
9468 
    if self.category is not None:
9469 
      oprot.writeFieldBegin('category', TType.I64, 4)
9470 
      oprot.writeI64(self.category)
9471 
      oprot.writeFieldEnd()
9472 
    oprot.writeFieldStop()
9473 
    oprot.writeStructEnd()
9474 
 
9475 
  def validate(self):
9476 
    return
9477 
 
9478 
 
9479 
  def __repr__(self):
9480 
    L = ['%s=%r' % (key, value)
9481 
      for key, value in self.__dict__.iteritems()]
9482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9483 
 
9484 
  def __eq__(self, other):
9485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9486 
 
9487 
  def __ne__(self, other):
9488 
    return not (self == other)
9489 
 
9490 
class getBestDealsCatalogIds_result:
9491 
  """
9492 
  Attributes:
9493 
   - success
9494 
   - cex
9495 
  """
9496 
 
9497 
  thrift_spec = (
9498 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9499 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9500 
  )
9501 
 
9502 
  def __init__(self, success=None, cex=None,):
9503 
    self.success = success
9504 
    self.cex = cex
9505 
 
9506 
  def read(self, iprot):
9507 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9508 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9509 
      return
9510 
    iprot.readStructBegin()
9511 
    while True:
9512 
      (fname, ftype, fid) = iprot.readFieldBegin()
9513 
      if ftype == TType.STOP:
9514 
        break
9515 
      if fid == 0:
9516 
        if ftype == TType.LIST:
9517 
          self.success = []
8590 kshitij.so 9518 
          (_etype112, _size109) = iprot.readListBegin()
9519 
          for _i113 in xrange(_size109):
9520 
            _elem114 = iprot.readI64();
9521 
            self.success.append(_elem114)
5944 mandeep.dh 9522 
          iprot.readListEnd()
9523 
        else:
9524 
          iprot.skip(ftype)
9525 
      elif fid == 1:
9526 
        if ftype == TType.STRUCT:
9527 
          self.cex = CatalogServiceException()
9528 
          self.cex.read(iprot)
9529 
        else:
9530 
          iprot.skip(ftype)
9531 
      else:
9532 
        iprot.skip(ftype)
9533 
      iprot.readFieldEnd()
9534 
    iprot.readStructEnd()
9535 
 
9536 
  def write(self, oprot):
9537 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9538 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9539 
      return
9540 
    oprot.writeStructBegin('getBestDealsCatalogIds_result')
9541 
    if self.success is not None:
9542 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9543 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 9544 
      for iter115 in self.success:
9545 
        oprot.writeI64(iter115)
5944 mandeep.dh 9546 
      oprot.writeListEnd()
9547 
      oprot.writeFieldEnd()
9548 
    if self.cex is not None:
9549 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9550 
      self.cex.write(oprot)
9551 
      oprot.writeFieldEnd()
9552 
    oprot.writeFieldStop()
9553 
    oprot.writeStructEnd()
9554 
 
9555 
  def validate(self):
9556 
    return
9557 
 
9558 
 
9559 
  def __repr__(self):
9560 
    L = ['%s=%r' % (key, value)
9561 
      for key, value in self.__dict__.iteritems()]
9562 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9563 
 
9564 
  def __eq__(self, other):
9565 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9566 
 
9567 
  def __ne__(self, other):
9568 
    return not (self == other)
9569 
 
9570 
class getBestDealsCount_args:
9571 
 
9572 
  thrift_spec = (
9573 
  )
9574 
 
9575 
  def read(self, iprot):
9576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9578 
      return
9579 
    iprot.readStructBegin()
9580 
    while True:
9581 
      (fname, ftype, fid) = iprot.readFieldBegin()
9582 
      if ftype == TType.STOP:
9583 
        break
9584 
      else:
9585 
        iprot.skip(ftype)
9586 
      iprot.readFieldEnd()
9587 
    iprot.readStructEnd()
9588 
 
9589 
  def write(self, oprot):
9590 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9591 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9592 
      return
9593 
    oprot.writeStructBegin('getBestDealsCount_args')
9594 
    oprot.writeFieldStop()
9595 
    oprot.writeStructEnd()
9596 
 
9597 
  def validate(self):
9598 
    return
9599 
 
9600 
 
9601 
  def __repr__(self):
9602 
    L = ['%s=%r' % (key, value)
9603 
      for key, value in self.__dict__.iteritems()]
9604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9605 
 
9606 
  def __eq__(self, other):
9607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9608 
 
9609 
  def __ne__(self, other):
9610 
    return not (self == other)
9611 
 
9612 
class getBestDealsCount_result:
9613 
  """
9614 
  Attributes:
9615 
   - success
9616 
   - cex
9617 
  """
9618 
 
9619 
  thrift_spec = (
9620 
    (0, TType.I64, 'success', None, None, ), # 0
9621 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9622 
  )
9623 
 
9624 
  def __init__(self, success=None, cex=None,):
9625 
    self.success = success
9626 
    self.cex = cex
9627 
 
9628 
  def read(self, iprot):
9629 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9630 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9631 
      return
9632 
    iprot.readStructBegin()
9633 
    while True:
9634 
      (fname, ftype, fid) = iprot.readFieldBegin()
9635 
      if ftype == TType.STOP:
9636 
        break
9637 
      if fid == 0:
9638 
        if ftype == TType.I64:
9639 
          self.success = iprot.readI64();
9640 
        else:
9641 
          iprot.skip(ftype)
9642 
      elif fid == 1:
9643 
        if ftype == TType.STRUCT:
9644 
          self.cex = CatalogServiceException()
9645 
          self.cex.read(iprot)
9646 
        else:
9647 
          iprot.skip(ftype)
9648 
      else:
9649 
        iprot.skip(ftype)
9650 
      iprot.readFieldEnd()
9651 
    iprot.readStructEnd()
9652 
 
9653 
  def write(self, oprot):
9654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9656 
      return
9657 
    oprot.writeStructBegin('getBestDealsCount_result')
9658 
    if self.success is not None:
9659 
      oprot.writeFieldBegin('success', TType.I64, 0)
9660 
      oprot.writeI64(self.success)
9661 
      oprot.writeFieldEnd()
9662 
    if self.cex is not None:
9663 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9664 
      self.cex.write(oprot)
9665 
      oprot.writeFieldEnd()
9666 
    oprot.writeFieldStop()
9667 
    oprot.writeStructEnd()
9668 
 
9669 
  def validate(self):
9670 
    return
9671 
 
9672 
 
9673 
  def __repr__(self):
9674 
    L = ['%s=%r' % (key, value)
9675 
      for key, value in self.__dict__.iteritems()]
9676 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9677 
 
9678 
  def __eq__(self, other):
9679 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9680 
 
9681 
  def __ne__(self, other):
9682 
    return not (self == other)
9683 
 
9684 
class getComingSoon_args:
9685 
 
9686 
  thrift_spec = (
9687 
  )
9688 
 
9689 
  def read(self, iprot):
9690 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9691 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9692 
      return
9693 
    iprot.readStructBegin()
9694 
    while True:
9695 
      (fname, ftype, fid) = iprot.readFieldBegin()
9696 
      if ftype == TType.STOP:
9697 
        break
9698 
      else:
9699 
        iprot.skip(ftype)
9700 
      iprot.readFieldEnd()
9701 
    iprot.readStructEnd()
9702 
 
9703 
  def write(self, oprot):
9704 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9705 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9706 
      return
9707 
    oprot.writeStructBegin('getComingSoon_args')
9708 
    oprot.writeFieldStop()
9709 
    oprot.writeStructEnd()
9710 
 
9711 
  def validate(self):
9712 
    return
9713 
 
9714 
 
9715 
  def __repr__(self):
9716 
    L = ['%s=%r' % (key, value)
9717 
      for key, value in self.__dict__.iteritems()]
9718 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9719 
 
9720 
  def __eq__(self, other):
9721 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9722 
 
9723 
  def __ne__(self, other):
9724 
    return not (self == other)
9725 
 
9726 
class getComingSoon_result:
9727 
  """
9728 
  Attributes:
9729 
   - success
9730 
   - isex
9731 
  """
9732 
 
9733 
  thrift_spec = (
9734 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9735 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9736 
  )
9737 
 
9738 
  def __init__(self, success=None, isex=None,):
9739 
    self.success = success
9740 
    self.isex = isex
9741 
 
9742 
  def read(self, iprot):
9743 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9744 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9745 
      return
9746 
    iprot.readStructBegin()
9747 
    while True:
9748 
      (fname, ftype, fid) = iprot.readFieldBegin()
9749 
      if ftype == TType.STOP:
9750 
        break
9751 
      if fid == 0:
9752 
        if ftype == TType.LIST:
9753 
          self.success = []
8590 kshitij.so 9754 
          (_etype119, _size116) = iprot.readListBegin()
9755 
          for _i120 in xrange(_size116):
9756 
            _elem121 = Item()
9757 
            _elem121.read(iprot)
9758 
            self.success.append(_elem121)
5944 mandeep.dh 9759 
          iprot.readListEnd()
9760 
        else:
9761 
          iprot.skip(ftype)
9762 
      elif fid == 1:
9763 
        if ftype == TType.STRUCT:
9764 
          self.isex = CatalogServiceException()
9765 
          self.isex.read(iprot)
9766 
        else:
9767 
          iprot.skip(ftype)
9768 
      else:
9769 
        iprot.skip(ftype)
9770 
      iprot.readFieldEnd()
9771 
    iprot.readStructEnd()
9772 
 
9773 
  def write(self, oprot):
9774 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9775 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9776 
      return
9777 
    oprot.writeStructBegin('getComingSoon_result')
9778 
    if self.success is not None:
9779 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9780 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9781 
      for iter122 in self.success:
9782 
        iter122.write(oprot)
5944 mandeep.dh 9783 
      oprot.writeListEnd()
9784 
      oprot.writeFieldEnd()
9785 
    if self.isex is not None:
9786 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
9787 
      self.isex.write(oprot)
9788 
      oprot.writeFieldEnd()
9789 
    oprot.writeFieldStop()
9790 
    oprot.writeStructEnd()
9791 
 
9792 
  def validate(self):
9793 
    return
9794 
 
9795 
 
9796 
  def __repr__(self):
9797 
    L = ['%s=%r' % (key, value)
9798 
      for key, value in self.__dict__.iteritems()]
9799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9800 
 
9801 
  def __eq__(self, other):
9802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9803 
 
9804 
  def __ne__(self, other):
9805 
    return not (self == other)
9806 
 
9807 
class getComingSoonCatalogIds_args:
9808 
  """
9809 
  Attributes:
9810 
   - beginIndex
9811 
   - totalItems
9812 
   - brand
9813 
   - category
9814 
  """
9815 
 
9816 
  thrift_spec = (
9817 
    None, # 0
9818 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
9819 
    (2, TType.I64, 'totalItems', None, None, ), # 2
9820 
    (3, TType.STRING, 'brand', None, None, ), # 3
9821 
    (4, TType.I64, 'category', None, None, ), # 4
9822 
  )
9823 
 
9824 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
9825 
    self.beginIndex = beginIndex
9826 
    self.totalItems = totalItems
9827 
    self.brand = brand
9828 
    self.category = category
9829 
 
9830 
  def read(self, iprot):
9831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9833 
      return
9834 
    iprot.readStructBegin()
9835 
    while True:
9836 
      (fname, ftype, fid) = iprot.readFieldBegin()
9837 
      if ftype == TType.STOP:
9838 
        break
9839 
      if fid == 1:
9840 
        if ftype == TType.I64:
9841 
          self.beginIndex = iprot.readI64();
9842 
        else:
9843 
          iprot.skip(ftype)
9844 
      elif fid == 2:
9845 
        if ftype == TType.I64:
9846 
          self.totalItems = iprot.readI64();
9847 
        else:
9848 
          iprot.skip(ftype)
9849 
      elif fid == 3:
9850 
        if ftype == TType.STRING:
9851 
          self.brand = iprot.readString();
9852 
        else:
9853 
          iprot.skip(ftype)
9854 
      elif fid == 4:
9855 
        if ftype == TType.I64:
9856 
          self.category = iprot.readI64();
9857 
        else:
9858 
          iprot.skip(ftype)
9859 
      else:
9860 
        iprot.skip(ftype)
9861 
      iprot.readFieldEnd()
9862 
    iprot.readStructEnd()
9863 
 
9864 
  def write(self, oprot):
9865 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9866 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9867 
      return
9868 
    oprot.writeStructBegin('getComingSoonCatalogIds_args')
9869 
    if self.beginIndex is not None:
9870 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
9871 
      oprot.writeI64(self.beginIndex)
9872 
      oprot.writeFieldEnd()
9873 
    if self.totalItems is not None:
9874 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
9875 
      oprot.writeI64(self.totalItems)
9876 
      oprot.writeFieldEnd()
9877 
    if self.brand is not None:
9878 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9879 
      oprot.writeString(self.brand)
9880 
      oprot.writeFieldEnd()
9881 
    if self.category is not None:
9882 
      oprot.writeFieldBegin('category', TType.I64, 4)
9883 
      oprot.writeI64(self.category)
9884 
      oprot.writeFieldEnd()
9885 
    oprot.writeFieldStop()
9886 
    oprot.writeStructEnd()
9887 
 
9888 
  def validate(self):
9889 
    return
9890 
 
9891 
 
9892 
  def __repr__(self):
9893 
    L = ['%s=%r' % (key, value)
9894 
      for key, value in self.__dict__.iteritems()]
9895 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9896 
 
9897 
  def __eq__(self, other):
9898 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9899 
 
9900 
  def __ne__(self, other):
9901 
    return not (self == other)
9902 
 
9903 
class getComingSoonCatalogIds_result:
9904 
  """
9905 
  Attributes:
9906 
   - success
9907 
   - cex
9908 
  """
9909 
 
9910 
  thrift_spec = (
9911 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9912 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9913 
  )
9914 
 
9915 
  def __init__(self, success=None, cex=None,):
9916 
    self.success = success
9917 
    self.cex = cex
9918 
 
9919 
  def read(self, iprot):
9920 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9921 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9922 
      return
9923 
    iprot.readStructBegin()
9924 
    while True:
9925 
      (fname, ftype, fid) = iprot.readFieldBegin()
9926 
      if ftype == TType.STOP:
9927 
        break
9928 
      if fid == 0:
9929 
        if ftype == TType.LIST:
9930 
          self.success = []
8590 kshitij.so 9931 
          (_etype126, _size123) = iprot.readListBegin()
9932 
          for _i127 in xrange(_size123):
9933 
            _elem128 = iprot.readI64();
9934 
            self.success.append(_elem128)
5944 mandeep.dh 9935 
          iprot.readListEnd()
9936 
        else:
9937 
          iprot.skip(ftype)
9938 
      elif fid == 1:
9939 
        if ftype == TType.STRUCT:
9940 
          self.cex = CatalogServiceException()
9941 
          self.cex.read(iprot)
9942 
        else:
9943 
          iprot.skip(ftype)
9944 
      else:
9945 
        iprot.skip(ftype)
9946 
      iprot.readFieldEnd()
9947 
    iprot.readStructEnd()
9948 
 
9949 
  def write(self, oprot):
9950 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9951 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9952 
      return
9953 
    oprot.writeStructBegin('getComingSoonCatalogIds_result')
9954 
    if self.success is not None:
9955 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9956 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 9957 
      for iter129 in self.success:
9958 
        oprot.writeI64(iter129)
5944 mandeep.dh 9959 
      oprot.writeListEnd()
9960 
      oprot.writeFieldEnd()
9961 
    if self.cex is not None:
9962 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9963 
      self.cex.write(oprot)
9964 
      oprot.writeFieldEnd()
9965 
    oprot.writeFieldStop()
9966 
    oprot.writeStructEnd()
9967 
 
9968 
  def validate(self):
9969 
    return
9970 
 
9971 
 
9972 
  def __repr__(self):
9973 
    L = ['%s=%r' % (key, value)
9974 
      for key, value in self.__dict__.iteritems()]
9975 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9976 
 
9977 
  def __eq__(self, other):
9978 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9979 
 
9980 
  def __ne__(self, other):
9981 
    return not (self == other)
9982 
 
9983 
class getComingSoonCount_args:
9984 
 
9985 
  thrift_spec = (
9986 
  )
9987 
 
9988 
  def read(self, iprot):
9989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9991 
      return
9992 
    iprot.readStructBegin()
9993 
    while True:
9994 
      (fname, ftype, fid) = iprot.readFieldBegin()
9995 
      if ftype == TType.STOP:
9996 
        break
9997 
      else:
9998 
        iprot.skip(ftype)
9999 
      iprot.readFieldEnd()
10000 
    iprot.readStructEnd()
10001 
 
10002 
  def write(self, oprot):
10003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10005 
      return
10006 
    oprot.writeStructBegin('getComingSoonCount_args')
10007 
    oprot.writeFieldStop()
10008 
    oprot.writeStructEnd()
10009 
 
10010 
  def validate(self):
10011 
    return
10012 
 
10013 
 
10014 
  def __repr__(self):
10015 
    L = ['%s=%r' % (key, value)
10016 
      for key, value in self.__dict__.iteritems()]
10017 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10018 
 
10019 
  def __eq__(self, other):
10020 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10021 
 
10022 
  def __ne__(self, other):
10023 
    return not (self == other)
10024 
 
10025 
class getComingSoonCount_result:
10026 
  """
10027 
  Attributes:
10028 
   - success
10029 
   - cex
10030 
  """
10031 
 
10032 
  thrift_spec = (
10033 
    (0, TType.I64, 'success', None, None, ), # 0
10034 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10035 
  )
10036 
 
10037 
  def __init__(self, success=None, cex=None,):
10038 
    self.success = success
10039 
    self.cex = cex
10040 
 
10041 
  def read(self, iprot):
10042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10044 
      return
10045 
    iprot.readStructBegin()
10046 
    while True:
10047 
      (fname, ftype, fid) = iprot.readFieldBegin()
10048 
      if ftype == TType.STOP:
10049 
        break
10050 
      if fid == 0:
10051 
        if ftype == TType.I64:
10052 
          self.success = iprot.readI64();
10053 
        else:
10054 
          iprot.skip(ftype)
10055 
      elif fid == 1:
10056 
        if ftype == TType.STRUCT:
10057 
          self.cex = CatalogServiceException()
10058 
          self.cex.read(iprot)
10059 
        else:
10060 
          iprot.skip(ftype)
10061 
      else:
10062 
        iprot.skip(ftype)
10063 
      iprot.readFieldEnd()
10064 
    iprot.readStructEnd()
10065 
 
10066 
  def write(self, oprot):
10067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10069 
      return
10070 
    oprot.writeStructBegin('getComingSoonCount_result')
10071 
    if self.success is not None:
10072 
      oprot.writeFieldBegin('success', TType.I64, 0)
10073 
      oprot.writeI64(self.success)
10074 
      oprot.writeFieldEnd()
10075 
    if self.cex is not None:
10076 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10077 
      self.cex.write(oprot)
10078 
      oprot.writeFieldEnd()
10079 
    oprot.writeFieldStop()
10080 
    oprot.writeStructEnd()
10081 
 
10082 
  def validate(self):
10083 
    return
10084 
 
10085 
 
10086 
  def __repr__(self):
10087 
    L = ['%s=%r' % (key, value)
10088 
      for key, value in self.__dict__.iteritems()]
10089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10090 
 
10091 
  def __eq__(self, other):
10092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10093 
 
10094 
  def __ne__(self, other):
10095 
    return not (self == other)
10096 
 
10097 
class getLatestArrivals_args:
10098 
 
10099 
  thrift_spec = (
10100 
  )
10101 
 
10102 
  def read(self, iprot):
10103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10105 
      return
10106 
    iprot.readStructBegin()
10107 
    while True:
10108 
      (fname, ftype, fid) = iprot.readFieldBegin()
10109 
      if ftype == TType.STOP:
10110 
        break
10111 
      else:
10112 
        iprot.skip(ftype)
10113 
      iprot.readFieldEnd()
10114 
    iprot.readStructEnd()
10115 
 
10116 
  def write(self, oprot):
10117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10119 
      return
10120 
    oprot.writeStructBegin('getLatestArrivals_args')
10121 
    oprot.writeFieldStop()
10122 
    oprot.writeStructEnd()
10123 
 
10124 
  def validate(self):
10125 
    return
10126 
 
10127 
 
10128 
  def __repr__(self):
10129 
    L = ['%s=%r' % (key, value)
10130 
      for key, value in self.__dict__.iteritems()]
10131 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10132 
 
10133 
  def __eq__(self, other):
10134 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10135 
 
10136 
  def __ne__(self, other):
10137 
    return not (self == other)
10138 
 
10139 
class getLatestArrivals_result:
10140 
  """
10141 
  Attributes:
10142 
   - success
10143 
   - isex
10144 
  """
10145 
 
10146 
  thrift_spec = (
10147 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10148 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10149 
  )
10150 
 
10151 
  def __init__(self, success=None, isex=None,):
10152 
    self.success = success
10153 
    self.isex = isex
10154 
 
10155 
  def read(self, iprot):
10156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10158 
      return
10159 
    iprot.readStructBegin()
10160 
    while True:
10161 
      (fname, ftype, fid) = iprot.readFieldBegin()
10162 
      if ftype == TType.STOP:
10163 
        break
10164 
      if fid == 0:
10165 
        if ftype == TType.LIST:
10166 
          self.success = []
8590 kshitij.so 10167 
          (_etype133, _size130) = iprot.readListBegin()
10168 
          for _i134 in xrange(_size130):
10169 
            _elem135 = Item()
10170 
            _elem135.read(iprot)
10171 
            self.success.append(_elem135)
5944 mandeep.dh 10172 
          iprot.readListEnd()
10173 
        else:
10174 
          iprot.skip(ftype)
10175 
      elif fid == 1:
10176 
        if ftype == TType.STRUCT:
10177 
          self.isex = CatalogServiceException()
10178 
          self.isex.read(iprot)
10179 
        else:
10180 
          iprot.skip(ftype)
10181 
      else:
10182 
        iprot.skip(ftype)
10183 
      iprot.readFieldEnd()
10184 
    iprot.readStructEnd()
10185 
 
10186 
  def write(self, oprot):
10187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10189 
      return
10190 
    oprot.writeStructBegin('getLatestArrivals_result')
10191 
    if self.success is not None:
10192 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10193 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10194 
      for iter136 in self.success:
10195 
        iter136.write(oprot)
5944 mandeep.dh 10196 
      oprot.writeListEnd()
10197 
      oprot.writeFieldEnd()
10198 
    if self.isex is not None:
10199 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
10200 
      self.isex.write(oprot)
10201 
      oprot.writeFieldEnd()
10202 
    oprot.writeFieldStop()
10203 
    oprot.writeStructEnd()
10204 
 
10205 
  def validate(self):
10206 
    return
10207 
 
10208 
 
10209 
  def __repr__(self):
10210 
    L = ['%s=%r' % (key, value)
10211 
      for key, value in self.__dict__.iteritems()]
10212 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10213 
 
10214 
  def __eq__(self, other):
10215 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10216 
 
10217 
  def __ne__(self, other):
10218 
    return not (self == other)
10219 
 
10220 
class getLatestArrivalsCatalogIds_args:
10221 
  """
10222 
  Attributes:
10223 
   - beginIndex
10224 
   - totalItems
10225 
   - brand
10226 
   - categories
10227 
  """
10228 
 
10229 
  thrift_spec = (
10230 
    None, # 0
10231 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
10232 
    (2, TType.I64, 'totalItems', None, None, ), # 2
10233 
    (3, TType.STRING, 'brand', None, None, ), # 3
10234 
    (4, TType.LIST, 'categories', (TType.I64,None), None, ), # 4
10235 
  )
10236 
 
10237 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, categories=None,):
10238 
    self.beginIndex = beginIndex
10239 
    self.totalItems = totalItems
10240 
    self.brand = brand
10241 
    self.categories = categories
10242 
 
10243 
  def read(self, iprot):
10244 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10245 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10246 
      return
10247 
    iprot.readStructBegin()
10248 
    while True:
10249 
      (fname, ftype, fid) = iprot.readFieldBegin()
10250 
      if ftype == TType.STOP:
10251 
        break
10252 
      if fid == 1:
10253 
        if ftype == TType.I64:
10254 
          self.beginIndex = iprot.readI64();
10255 
        else:
10256 
          iprot.skip(ftype)
10257 
      elif fid == 2:
10258 
        if ftype == TType.I64:
10259 
          self.totalItems = iprot.readI64();
10260 
        else:
10261 
          iprot.skip(ftype)
10262 
      elif fid == 3:
10263 
        if ftype == TType.STRING:
10264 
          self.brand = iprot.readString();
10265 
        else:
10266 
          iprot.skip(ftype)
10267 
      elif fid == 4:
10268 
        if ftype == TType.LIST:
10269 
          self.categories = []
8590 kshitij.so 10270 
          (_etype140, _size137) = iprot.readListBegin()
10271 
          for _i141 in xrange(_size137):
10272 
            _elem142 = iprot.readI64();
10273 
            self.categories.append(_elem142)
5944 mandeep.dh 10274 
          iprot.readListEnd()
10275 
        else:
10276 
          iprot.skip(ftype)
10277 
      else:
10278 
        iprot.skip(ftype)
10279 
      iprot.readFieldEnd()
10280 
    iprot.readStructEnd()
10281 
 
10282 
  def write(self, oprot):
10283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10285 
      return
10286 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_args')
10287 
    if self.beginIndex is not None:
10288 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
10289 
      oprot.writeI64(self.beginIndex)
10290 
      oprot.writeFieldEnd()
10291 
    if self.totalItems is not None:
10292 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
10293 
      oprot.writeI64(self.totalItems)
10294 
      oprot.writeFieldEnd()
10295 
    if self.brand is not None:
10296 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
10297 
      oprot.writeString(self.brand)
10298 
      oprot.writeFieldEnd()
10299 
    if self.categories is not None:
10300 
      oprot.writeFieldBegin('categories', TType.LIST, 4)
10301 
      oprot.writeListBegin(TType.I64, len(self.categories))
8590 kshitij.so 10302 
      for iter143 in self.categories:
10303 
        oprot.writeI64(iter143)
5944 mandeep.dh 10304 
      oprot.writeListEnd()
10305 
      oprot.writeFieldEnd()
10306 
    oprot.writeFieldStop()
10307 
    oprot.writeStructEnd()
10308 
 
10309 
  def validate(self):
10310 
    return
10311 
 
10312 
 
10313 
  def __repr__(self):
10314 
    L = ['%s=%r' % (key, value)
10315 
      for key, value in self.__dict__.iteritems()]
10316 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10317 
 
10318 
  def __eq__(self, other):
10319 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10320 
 
10321 
  def __ne__(self, other):
10322 
    return not (self == other)
10323 
 
10324 
class getLatestArrivalsCatalogIds_result:
10325 
  """
10326 
  Attributes:
10327 
   - success
10328 
   - cex
10329 
  """
10330 
 
10331 
  thrift_spec = (
10332 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10333 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10334 
  )
10335 
 
10336 
  def __init__(self, success=None, cex=None,):
10337 
    self.success = success
10338 
    self.cex = cex
10339 
 
10340 
  def read(self, iprot):
10341 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10342 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10343 
      return
10344 
    iprot.readStructBegin()
10345 
    while True:
10346 
      (fname, ftype, fid) = iprot.readFieldBegin()
10347 
      if ftype == TType.STOP:
10348 
        break
10349 
      if fid == 0:
10350 
        if ftype == TType.LIST:
10351 
          self.success = []
8590 kshitij.so 10352 
          (_etype147, _size144) = iprot.readListBegin()
10353 
          for _i148 in xrange(_size144):
10354 
            _elem149 = iprot.readI64();
10355 
            self.success.append(_elem149)
5944 mandeep.dh 10356 
          iprot.readListEnd()
10357 
        else:
10358 
          iprot.skip(ftype)
10359 
      elif fid == 1:
10360 
        if ftype == TType.STRUCT:
10361 
          self.cex = CatalogServiceException()
10362 
          self.cex.read(iprot)
10363 
        else:
10364 
          iprot.skip(ftype)
10365 
      else:
10366 
        iprot.skip(ftype)
10367 
      iprot.readFieldEnd()
10368 
    iprot.readStructEnd()
10369 
 
10370 
  def write(self, oprot):
10371 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10372 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10373 
      return
10374 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_result')
10375 
    if self.success is not None:
10376 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10377 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 10378 
      for iter150 in self.success:
10379 
        oprot.writeI64(iter150)
5944 mandeep.dh 10380 
      oprot.writeListEnd()
10381 
      oprot.writeFieldEnd()
10382 
    if self.cex is not None:
10383 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10384 
      self.cex.write(oprot)
10385 
      oprot.writeFieldEnd()
10386 
    oprot.writeFieldStop()
10387 
    oprot.writeStructEnd()
10388 
 
10389 
  def validate(self):
10390 
    return
10391 
 
10392 
 
10393 
  def __repr__(self):
10394 
    L = ['%s=%r' % (key, value)
10395 
      for key, value in self.__dict__.iteritems()]
10396 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10397 
 
10398 
  def __eq__(self, other):
10399 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10400 
 
10401 
  def __ne__(self, other):
10402 
    return not (self == other)
10403 
 
10404 
class getLatestArrivalsCount_args:
10405 
 
10406 
  thrift_spec = (
10407 
  )
10408 
 
10409 
  def read(self, iprot):
10410 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10411 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10412 
      return
10413 
    iprot.readStructBegin()
10414 
    while True:
10415 
      (fname, ftype, fid) = iprot.readFieldBegin()
10416 
      if ftype == TType.STOP:
10417 
        break
10418 
      else:
10419 
        iprot.skip(ftype)
10420 
      iprot.readFieldEnd()
10421 
    iprot.readStructEnd()
10422 
 
10423 
  def write(self, oprot):
10424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10426 
      return
10427 
    oprot.writeStructBegin('getLatestArrivalsCount_args')
10428 
    oprot.writeFieldStop()
10429 
    oprot.writeStructEnd()
10430 
 
10431 
  def validate(self):
10432 
    return
10433 
 
10434 
 
10435 
  def __repr__(self):
10436 
    L = ['%s=%r' % (key, value)
10437 
      for key, value in self.__dict__.iteritems()]
10438 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10439 
 
10440 
  def __eq__(self, other):
10441 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10442 
 
10443 
  def __ne__(self, other):
10444 
    return not (self == other)
10445 
 
10446 
class getLatestArrivalsCount_result:
10447 
  """
10448 
  Attributes:
10449 
   - success
10450 
   - cex
10451 
  """
10452 
 
10453 
  thrift_spec = (
10454 
    (0, TType.I64, 'success', None, None, ), # 0
10455 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10456 
  )
10457 
 
10458 
  def __init__(self, success=None, cex=None,):
10459 
    self.success = success
10460 
    self.cex = cex
10461 
 
10462 
  def read(self, iprot):
10463 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10464 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10465 
      return
10466 
    iprot.readStructBegin()
10467 
    while True:
10468 
      (fname, ftype, fid) = iprot.readFieldBegin()
10469 
      if ftype == TType.STOP:
10470 
        break
10471 
      if fid == 0:
10472 
        if ftype == TType.I64:
10473 
          self.success = iprot.readI64();
10474 
        else:
10475 
          iprot.skip(ftype)
10476 
      elif fid == 1:
10477 
        if ftype == TType.STRUCT:
10478 
          self.cex = CatalogServiceException()
10479 
          self.cex.read(iprot)
10480 
        else:
10481 
          iprot.skip(ftype)
10482 
      else:
10483 
        iprot.skip(ftype)
10484 
      iprot.readFieldEnd()
10485 
    iprot.readStructEnd()
10486 
 
10487 
  def write(self, oprot):
10488 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10489 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10490 
      return
10491 
    oprot.writeStructBegin('getLatestArrivalsCount_result')
10492 
    if self.success is not None:
10493 
      oprot.writeFieldBegin('success', TType.I64, 0)
10494 
      oprot.writeI64(self.success)
10495 
      oprot.writeFieldEnd()
10496 
    if self.cex is not None:
10497 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10498 
      self.cex.write(oprot)
10499 
      oprot.writeFieldEnd()
10500 
    oprot.writeFieldStop()
10501 
    oprot.writeStructEnd()
10502 
 
10503 
  def validate(self):
10504 
    return
10505 
 
10506 
 
10507 
  def __repr__(self):
10508 
    L = ['%s=%r' % (key, value)
10509 
      for key, value in self.__dict__.iteritems()]
10510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10511 
 
10512 
  def __eq__(self, other):
10513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10514 
 
10515 
  def __ne__(self, other):
10516 
    return not (self == other)
10517 
 
10518 
class generateNewEntityID_args:
10519 
 
10520 
  thrift_spec = (
10521 
  )
10522 
 
10523 
  def read(self, iprot):
10524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10526 
      return
10527 
    iprot.readStructBegin()
10528 
    while True:
10529 
      (fname, ftype, fid) = iprot.readFieldBegin()
10530 
      if ftype == TType.STOP:
10531 
        break
10532 
      else:
10533 
        iprot.skip(ftype)
10534 
      iprot.readFieldEnd()
10535 
    iprot.readStructEnd()
10536 
 
10537 
  def write(self, oprot):
10538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10540 
      return
10541 
    oprot.writeStructBegin('generateNewEntityID_args')
10542 
    oprot.writeFieldStop()
10543 
    oprot.writeStructEnd()
10544 
 
10545 
  def validate(self):
10546 
    return
10547 
 
10548 
 
10549 
  def __repr__(self):
10550 
    L = ['%s=%r' % (key, value)
10551 
      for key, value in self.__dict__.iteritems()]
10552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10553 
 
10554 
  def __eq__(self, other):
10555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10556 
 
10557 
  def __ne__(self, other):
10558 
    return not (self == other)
10559 
 
10560 
class generateNewEntityID_result:
10561 
  """
10562 
  Attributes:
10563 
   - success
10564 
  """
10565 
 
10566 
  thrift_spec = (
10567 
    (0, TType.I64, 'success', None, None, ), # 0
10568 
  )
10569 
 
10570 
  def __init__(self, success=None,):
10571 
    self.success = success
10572 
 
10573 
  def read(self, iprot):
10574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10576 
      return
10577 
    iprot.readStructBegin()
10578 
    while True:
10579 
      (fname, ftype, fid) = iprot.readFieldBegin()
10580 
      if ftype == TType.STOP:
10581 
        break
10582 
      if fid == 0:
10583 
        if ftype == TType.I64:
10584 
          self.success = iprot.readI64();
10585 
        else:
10586 
          iprot.skip(ftype)
10587 
      else:
10588 
        iprot.skip(ftype)
10589 
      iprot.readFieldEnd()
10590 
    iprot.readStructEnd()
10591 
 
10592 
  def write(self, oprot):
10593 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10594 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10595 
      return
10596 
    oprot.writeStructBegin('generateNewEntityID_result')
10597 
    if self.success is not None:
10598 
      oprot.writeFieldBegin('success', TType.I64, 0)
10599 
      oprot.writeI64(self.success)
10600 
      oprot.writeFieldEnd()
10601 
    oprot.writeFieldStop()
10602 
    oprot.writeStructEnd()
10603 
 
10604 
  def validate(self):
10605 
    return
10606 
 
10607 
 
10608 
  def __repr__(self):
10609 
    L = ['%s=%r' % (key, value)
10610 
      for key, value in self.__dict__.iteritems()]
10611 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10612 
 
10613 
  def __eq__(self, other):
10614 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10615 
 
10616 
  def __ne__(self, other):
10617 
    return not (self == other)
10618 
 
10619 
class addCategory_args:
10620 
  """
10621 
  Attributes:
10622 
   - category
10623 
  """
10624 
 
10625 
  thrift_spec = (
10626 
    None, # 0
10627 
    (1, TType.STRUCT, 'category', (Category, Category.thrift_spec), None, ), # 1
10628 
  )
10629 
 
10630 
  def __init__(self, category=None,):
10631 
    self.category = category
10632 
 
10633 
  def read(self, iprot):
10634 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10635 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10636 
      return
10637 
    iprot.readStructBegin()
10638 
    while True:
10639 
      (fname, ftype, fid) = iprot.readFieldBegin()
10640 
      if ftype == TType.STOP:
10641 
        break
10642 
      if fid == 1:
10643 
        if ftype == TType.STRUCT:
10644 
          self.category = Category()
10645 
          self.category.read(iprot)
10646 
        else:
10647 
          iprot.skip(ftype)
10648 
      else:
10649 
        iprot.skip(ftype)
10650 
      iprot.readFieldEnd()
10651 
    iprot.readStructEnd()
10652 
 
10653 
  def write(self, oprot):
10654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10656 
      return
10657 
    oprot.writeStructBegin('addCategory_args')
10658 
    if self.category is not None:
10659 
      oprot.writeFieldBegin('category', TType.STRUCT, 1)
10660 
      self.category.write(oprot)
10661 
      oprot.writeFieldEnd()
10662 
    oprot.writeFieldStop()
10663 
    oprot.writeStructEnd()
10664 
 
10665 
  def validate(self):
10666 
    return
10667 
 
10668 
 
10669 
  def __repr__(self):
10670 
    L = ['%s=%r' % (key, value)
10671 
      for key, value in self.__dict__.iteritems()]
10672 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10673 
 
10674 
  def __eq__(self, other):
10675 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10676 
 
10677 
  def __ne__(self, other):
10678 
    return not (self == other)
10679 
 
10680 
class addCategory_result:
10681 
  """
10682 
  Attributes:
10683 
   - success
10684 
  """
10685 
 
10686 
  thrift_spec = (
10687 
    (0, TType.BOOL, 'success', None, None, ), # 0
10688 
  )
10689 
 
10690 
  def __init__(self, success=None,):
10691 
    self.success = success
10692 
 
10693 
  def read(self, iprot):
10694 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10695 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10696 
      return
10697 
    iprot.readStructBegin()
10698 
    while True:
10699 
      (fname, ftype, fid) = iprot.readFieldBegin()
10700 
      if ftype == TType.STOP:
10701 
        break
10702 
      if fid == 0:
10703 
        if ftype == TType.BOOL:
10704 
          self.success = iprot.readBool();
10705 
        else:
10706 
          iprot.skip(ftype)
10707 
      else:
10708 
        iprot.skip(ftype)
10709 
      iprot.readFieldEnd()
10710 
    iprot.readStructEnd()
10711 
 
10712 
  def write(self, oprot):
10713 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10714 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10715 
      return
10716 
    oprot.writeStructBegin('addCategory_result')
10717 
    if self.success is not None:
10718 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10719 
      oprot.writeBool(self.success)
10720 
      oprot.writeFieldEnd()
10721 
    oprot.writeFieldStop()
10722 
    oprot.writeStructEnd()
10723 
 
10724 
  def validate(self):
10725 
    return
10726 
 
10727 
 
10728 
  def __repr__(self):
10729 
    L = ['%s=%r' % (key, value)
10730 
      for key, value in self.__dict__.iteritems()]
10731 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10732 
 
10733 
  def __eq__(self, other):
10734 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10735 
 
10736 
  def __ne__(self, other):
10737 
    return not (self == other)
10738 
 
10739 
class getCategory_args:
10740 
  """
10741 
  Attributes:
10742 
   - id
10743 
  """
10744 
 
10745 
  thrift_spec = (
10746 
    None, # 0
10747 
    (1, TType.I64, 'id', None, None, ), # 1
10748 
  )
10749 
 
10750 
  def __init__(self, id=None,):
10751 
    self.id = id
10752 
 
10753 
  def read(self, iprot):
10754 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10755 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10756 
      return
10757 
    iprot.readStructBegin()
10758 
    while True:
10759 
      (fname, ftype, fid) = iprot.readFieldBegin()
10760 
      if ftype == TType.STOP:
10761 
        break
10762 
      if fid == 1:
10763 
        if ftype == TType.I64:
10764 
          self.id = iprot.readI64();
10765 
        else:
10766 
          iprot.skip(ftype)
10767 
      else:
10768 
        iprot.skip(ftype)
10769 
      iprot.readFieldEnd()
10770 
    iprot.readStructEnd()
10771 
 
10772 
  def write(self, oprot):
10773 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10774 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10775 
      return
10776 
    oprot.writeStructBegin('getCategory_args')
10777 
    if self.id is not None:
10778 
      oprot.writeFieldBegin('id', TType.I64, 1)
10779 
      oprot.writeI64(self.id)
10780 
      oprot.writeFieldEnd()
10781 
    oprot.writeFieldStop()
10782 
    oprot.writeStructEnd()
10783 
 
10784 
  def validate(self):
10785 
    return
10786 
 
10787 
 
10788 
  def __repr__(self):
10789 
    L = ['%s=%r' % (key, value)
10790 
      for key, value in self.__dict__.iteritems()]
10791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10792 
 
10793 
  def __eq__(self, other):
10794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10795 
 
10796 
  def __ne__(self, other):
10797 
    return not (self == other)
10798 
 
10799 
class getCategory_result:
10800 
  """
10801 
  Attributes:
10802 
   - success
10803 
  """
10804 
 
10805 
  thrift_spec = (
10806 
    (0, TType.STRUCT, 'success', (Category, Category.thrift_spec), None, ), # 0
10807 
  )
10808 
 
10809 
  def __init__(self, success=None,):
10810 
    self.success = success
10811 
 
10812 
  def read(self, iprot):
10813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10815 
      return
10816 
    iprot.readStructBegin()
10817 
    while True:
10818 
      (fname, ftype, fid) = iprot.readFieldBegin()
10819 
      if ftype == TType.STOP:
10820 
        break
10821 
      if fid == 0:
10822 
        if ftype == TType.STRUCT:
10823 
          self.success = Category()
10824 
          self.success.read(iprot)
10825 
        else:
10826 
          iprot.skip(ftype)
10827 
      else:
10828 
        iprot.skip(ftype)
10829 
      iprot.readFieldEnd()
10830 
    iprot.readStructEnd()
10831 
 
10832 
  def write(self, oprot):
10833 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10834 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10835 
      return
10836 
    oprot.writeStructBegin('getCategory_result')
10837 
    if self.success is not None:
10838 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10839 
      self.success.write(oprot)
10840 
      oprot.writeFieldEnd()
10841 
    oprot.writeFieldStop()
10842 
    oprot.writeStructEnd()
10843 
 
10844 
  def validate(self):
10845 
    return
10846 
 
10847 
 
10848 
  def __repr__(self):
10849 
    L = ['%s=%r' % (key, value)
10850 
      for key, value in self.__dict__.iteritems()]
10851 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10852 
 
10853 
  def __eq__(self, other):
10854 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10855 
 
10856 
  def __ne__(self, other):
10857 
    return not (self == other)
10858 
 
10859 
class getAllCategories_args:
10860 
 
10861 
  thrift_spec = (
10862 
  )
10863 
 
10864 
  def read(self, iprot):
10865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10867 
      return
10868 
    iprot.readStructBegin()
10869 
    while True:
10870 
      (fname, ftype, fid) = iprot.readFieldBegin()
10871 
      if ftype == TType.STOP:
10872 
        break
10873 
      else:
10874 
        iprot.skip(ftype)
10875 
      iprot.readFieldEnd()
10876 
    iprot.readStructEnd()
10877 
 
10878 
  def write(self, oprot):
10879 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10880 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10881 
      return
10882 
    oprot.writeStructBegin('getAllCategories_args')
10883 
    oprot.writeFieldStop()
10884 
    oprot.writeStructEnd()
10885 
 
10886 
  def validate(self):
10887 
    return
10888 
 
10889 
 
10890 
  def __repr__(self):
10891 
    L = ['%s=%r' % (key, value)
10892 
      for key, value in self.__dict__.iteritems()]
10893 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10894 
 
10895 
  def __eq__(self, other):
10896 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10897 
 
10898 
  def __ne__(self, other):
10899 
    return not (self == other)
10900 
 
10901 
class getAllCategories_result:
10902 
  """
10903 
  Attributes:
10904 
   - success
10905 
  """
10906 
 
10907 
  thrift_spec = (
10908 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
10909 
  )
10910 
 
10911 
  def __init__(self, success=None,):
10912 
    self.success = success
10913 
 
10914 
  def read(self, iprot):
10915 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10916 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10917 
      return
10918 
    iprot.readStructBegin()
10919 
    while True:
10920 
      (fname, ftype, fid) = iprot.readFieldBegin()
10921 
      if ftype == TType.STOP:
10922 
        break
10923 
      if fid == 0:
10924 
        if ftype == TType.LIST:
10925 
          self.success = []
8590 kshitij.so 10926 
          (_etype154, _size151) = iprot.readListBegin()
10927 
          for _i155 in xrange(_size151):
10928 
            _elem156 = Category()
10929 
            _elem156.read(iprot)
10930 
            self.success.append(_elem156)
5944 mandeep.dh 10931 
          iprot.readListEnd()
10932 
        else:
10933 
          iprot.skip(ftype)
10934 
      else:
10935 
        iprot.skip(ftype)
10936 
      iprot.readFieldEnd()
10937 
    iprot.readStructEnd()
10938 
 
10939 
  def write(self, oprot):
10940 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10941 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10942 
      return
10943 
    oprot.writeStructBegin('getAllCategories_result')
10944 
    if self.success is not None:
10945 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10946 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10947 
      for iter157 in self.success:
10948 
        iter157.write(oprot)
5944 mandeep.dh 10949 
      oprot.writeListEnd()
10950 
      oprot.writeFieldEnd()
10951 
    oprot.writeFieldStop()
10952 
    oprot.writeStructEnd()
10953 
 
10954 
  def validate(self):
10955 
    return
10956 
 
10957 
 
10958 
  def __repr__(self):
10959 
    L = ['%s=%r' % (key, value)
10960 
      for key, value in self.__dict__.iteritems()]
10961 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10962 
 
10963 
  def __eq__(self, other):
10964 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10965 
 
10966 
  def __ne__(self, other):
10967 
    return not (self == other)
10968 
 
10969 
class getAllSimilarItems_args:
10970 
  """
10971 
  Attributes:
10972 
   - itemId
10973 
  """
10974 
 
10975 
  thrift_spec = (
10976 
    None, # 0
10977 
    (1, TType.I64, 'itemId', None, None, ), # 1
10978 
  )
10979 
 
10980 
  def __init__(self, itemId=None,):
10981 
    self.itemId = itemId
10982 
 
10983 
  def read(self, iprot):
10984 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10985 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10986 
      return
10987 
    iprot.readStructBegin()
10988 
    while True:
10989 
      (fname, ftype, fid) = iprot.readFieldBegin()
10990 
      if ftype == TType.STOP:
10991 
        break
10992 
      if fid == 1:
10993 
        if ftype == TType.I64:
10994 
          self.itemId = iprot.readI64();
10995 
        else:
10996 
          iprot.skip(ftype)
10997 
      else:
10998 
        iprot.skip(ftype)
10999 
      iprot.readFieldEnd()
11000 
    iprot.readStructEnd()
11001 
 
11002 
  def write(self, oprot):
11003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11005 
      return
11006 
    oprot.writeStructBegin('getAllSimilarItems_args')
11007 
    if self.itemId is not None:
11008 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11009 
      oprot.writeI64(self.itemId)
11010 
      oprot.writeFieldEnd()
11011 
    oprot.writeFieldStop()
11012 
    oprot.writeStructEnd()
11013 
 
11014 
  def validate(self):
11015 
    return
11016 
 
11017 
 
11018 
  def __repr__(self):
11019 
    L = ['%s=%r' % (key, value)
11020 
      for key, value in self.__dict__.iteritems()]
11021 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11022 
 
11023 
  def __eq__(self, other):
11024 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11025 
 
11026 
  def __ne__(self, other):
11027 
    return not (self == other)
11028 
 
11029 
class getAllSimilarItems_result:
11030 
  """
11031 
  Attributes:
11032 
   - success
11033 
  """
11034 
 
11035 
  thrift_spec = (
11036 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11037 
  )
11038 
 
11039 
  def __init__(self, success=None,):
11040 
    self.success = success
11041 
 
11042 
  def read(self, iprot):
11043 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11044 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11045 
      return
11046 
    iprot.readStructBegin()
11047 
    while True:
11048 
      (fname, ftype, fid) = iprot.readFieldBegin()
11049 
      if ftype == TType.STOP:
11050 
        break
11051 
      if fid == 0:
11052 
        if ftype == TType.LIST:
11053 
          self.success = []
8590 kshitij.so 11054 
          (_etype161, _size158) = iprot.readListBegin()
11055 
          for _i162 in xrange(_size158):
11056 
            _elem163 = Item()
11057 
            _elem163.read(iprot)
11058 
            self.success.append(_elem163)
5944 mandeep.dh 11059 
          iprot.readListEnd()
11060 
        else:
11061 
          iprot.skip(ftype)
11062 
      else:
11063 
        iprot.skip(ftype)
11064 
      iprot.readFieldEnd()
11065 
    iprot.readStructEnd()
11066 
 
11067 
  def write(self, oprot):
11068 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11069 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11070 
      return
11071 
    oprot.writeStructBegin('getAllSimilarItems_result')
11072 
    if self.success is not None:
11073 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11074 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 11075 
      for iter164 in self.success:
11076 
        iter164.write(oprot)
5944 mandeep.dh 11077 
      oprot.writeListEnd()
11078 
      oprot.writeFieldEnd()
11079 
    oprot.writeFieldStop()
11080 
    oprot.writeStructEnd()
11081 
 
11082 
  def validate(self):
11083 
    return
11084 
 
11085 
 
11086 
  def __repr__(self):
11087 
    L = ['%s=%r' % (key, value)
11088 
      for key, value in self.__dict__.iteritems()]
11089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11090 
 
11091 
  def __eq__(self, other):
11092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11093 
 
11094 
  def __ne__(self, other):
11095 
    return not (self == other)
11096 
 
11097 
class addSimilarItem_args:
11098 
  """
11099 
  Attributes:
11100 
   - itemId
11101 
   - catalogItemId
11102 
  """
11103 
 
11104 
  thrift_spec = (
11105 
    None, # 0
11106 
    (1, TType.I64, 'itemId', None, None, ), # 1
11107 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
11108 
  )
11109 
 
11110 
  def __init__(self, itemId=None, catalogItemId=None,):
11111 
    self.itemId = itemId
11112 
    self.catalogItemId = catalogItemId
11113 
 
11114 
  def read(self, iprot):
11115 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11116 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11117 
      return
11118 
    iprot.readStructBegin()
11119 
    while True:
11120 
      (fname, ftype, fid) = iprot.readFieldBegin()
11121 
      if ftype == TType.STOP:
11122 
        break
11123 
      if fid == 1:
11124 
        if ftype == TType.I64:
11125 
          self.itemId = iprot.readI64();
11126 
        else:
11127 
          iprot.skip(ftype)
11128 
      elif fid == 2:
11129 
        if ftype == TType.I64:
11130 
          self.catalogItemId = iprot.readI64();
11131 
        else:
11132 
          iprot.skip(ftype)
11133 
      else:
11134 
        iprot.skip(ftype)
11135 
      iprot.readFieldEnd()
11136 
    iprot.readStructEnd()
11137 
 
11138 
  def write(self, oprot):
11139 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11140 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11141 
      return
11142 
    oprot.writeStructBegin('addSimilarItem_args')
11143 
    if self.itemId is not None:
11144 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11145 
      oprot.writeI64(self.itemId)
11146 
      oprot.writeFieldEnd()
11147 
    if self.catalogItemId is not None:
11148 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
11149 
      oprot.writeI64(self.catalogItemId)
11150 
      oprot.writeFieldEnd()
11151 
    oprot.writeFieldStop()
11152 
    oprot.writeStructEnd()
11153 
 
11154 
  def validate(self):
11155 
    return
11156 
 
11157 
 
11158 
  def __repr__(self):
11159 
    L = ['%s=%r' % (key, value)
11160 
      for key, value in self.__dict__.iteritems()]
11161 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11162 
 
11163 
  def __eq__(self, other):
11164 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11165 
 
11166 
  def __ne__(self, other):
11167 
    return not (self == other)
11168 
 
11169 
class addSimilarItem_result:
11170 
  """
11171 
  Attributes:
11172 
   - success
11173 
   - cex
11174 
  """
11175 
 
11176 
  thrift_spec = (
11177 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
11178 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11179 
  )
11180 
 
11181 
  def __init__(self, success=None, cex=None,):
11182 
    self.success = success
11183 
    self.cex = cex
11184 
 
11185 
  def read(self, iprot):
11186 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11187 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11188 
      return
11189 
    iprot.readStructBegin()
11190 
    while True:
11191 
      (fname, ftype, fid) = iprot.readFieldBegin()
11192 
      if ftype == TType.STOP:
11193 
        break
11194 
      if fid == 0:
11195 
        if ftype == TType.STRUCT:
11196 
          self.success = Item()
11197 
          self.success.read(iprot)
11198 
        else:
11199 
          iprot.skip(ftype)
11200 
      elif fid == 1:
11201 
        if ftype == TType.STRUCT:
11202 
          self.cex = CatalogServiceException()
11203 
          self.cex.read(iprot)
11204 
        else:
11205 
          iprot.skip(ftype)
11206 
      else:
11207 
        iprot.skip(ftype)
11208 
      iprot.readFieldEnd()
11209 
    iprot.readStructEnd()
11210 
 
11211 
  def write(self, oprot):
11212 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11213 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11214 
      return
11215 
    oprot.writeStructBegin('addSimilarItem_result')
11216 
    if self.success is not None:
11217 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11218 
      self.success.write(oprot)
11219 
      oprot.writeFieldEnd()
11220 
    if self.cex is not None:
11221 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11222 
      self.cex.write(oprot)
11223 
      oprot.writeFieldEnd()
11224 
    oprot.writeFieldStop()
11225 
    oprot.writeStructEnd()
11226 
 
11227 
  def validate(self):
11228 
    return
11229 
 
11230 
 
11231 
  def __repr__(self):
11232 
    L = ['%s=%r' % (key, value)
11233 
      for key, value in self.__dict__.iteritems()]
11234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11235 
 
11236 
  def __eq__(self, other):
11237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11238 
 
11239 
  def __ne__(self, other):
11240 
    return not (self == other)
11241 
 
6512 kshitij.so 11242 
class addTag_args:
11243 
  """
11244 
  Attributes:
11245 
   - displayName
11246 
   - itemId
11247 
  """
11248 
 
11249 
  thrift_spec = (
11250 
    None, # 0
11251 
    (1, TType.STRING, 'displayName', None, None, ), # 1
11252 
    (2, TType.I64, 'itemId', None, None, ), # 2
11253 
  )
11254 
 
11255 
  def __init__(self, displayName=None, itemId=None,):
11256 
    self.displayName = displayName
11257 
    self.itemId = itemId
11258 
 
11259 
  def read(self, iprot):
11260 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11261 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11262 
      return
11263 
    iprot.readStructBegin()
11264 
    while True:
11265 
      (fname, ftype, fid) = iprot.readFieldBegin()
11266 
      if ftype == TType.STOP:
11267 
        break
11268 
      if fid == 1:
11269 
        if ftype == TType.STRING:
11270 
          self.displayName = iprot.readString();
11271 
        else:
11272 
          iprot.skip(ftype)
11273 
      elif fid == 2:
11274 
        if ftype == TType.I64:
11275 
          self.itemId = iprot.readI64();
11276 
        else:
11277 
          iprot.skip(ftype)
11278 
      else:
11279 
        iprot.skip(ftype)
11280 
      iprot.readFieldEnd()
11281 
    iprot.readStructEnd()
11282 
 
11283 
  def write(self, oprot):
11284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11286 
      return
11287 
    oprot.writeStructBegin('addTag_args')
11288 
    if self.displayName is not None:
11289 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
11290 
      oprot.writeString(self.displayName)
11291 
      oprot.writeFieldEnd()
11292 
    if self.itemId is not None:
11293 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11294 
      oprot.writeI64(self.itemId)
11295 
      oprot.writeFieldEnd()
11296 
    oprot.writeFieldStop()
11297 
    oprot.writeStructEnd()
11298 
 
11299 
  def validate(self):
11300 
    return
11301 
 
11302 
 
11303 
  def __repr__(self):
11304 
    L = ['%s=%r' % (key, value)
11305 
      for key, value in self.__dict__.iteritems()]
11306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11307 
 
11308 
  def __eq__(self, other):
11309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11310 
 
11311 
  def __ne__(self, other):
11312 
    return not (self == other)
11313 
 
11314 
class addTag_result:
11315 
  """
11316 
  Attributes:
11317 
   - success
11318 
  """
11319 
 
11320 
  thrift_spec = (
11321 
    (0, TType.BOOL, 'success', None, None, ), # 0
11322 
  )
11323 
 
11324 
  def __init__(self, success=None,):
11325 
    self.success = success
11326 
 
11327 
  def read(self, iprot):
11328 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11329 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11330 
      return
11331 
    iprot.readStructBegin()
11332 
    while True:
11333 
      (fname, ftype, fid) = iprot.readFieldBegin()
11334 
      if ftype == TType.STOP:
11335 
        break
11336 
      if fid == 0:
11337 
        if ftype == TType.BOOL:
11338 
          self.success = iprot.readBool();
11339 
        else:
11340 
          iprot.skip(ftype)
11341 
      else:
11342 
        iprot.skip(ftype)
11343 
      iprot.readFieldEnd()
11344 
    iprot.readStructEnd()
11345 
 
11346 
  def write(self, oprot):
11347 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11348 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11349 
      return
11350 
    oprot.writeStructBegin('addTag_result')
11351 
    if self.success is not None:
11352 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11353 
      oprot.writeBool(self.success)
11354 
      oprot.writeFieldEnd()
11355 
    oprot.writeFieldStop()
11356 
    oprot.writeStructEnd()
11357 
 
11358 
  def validate(self):
11359 
    return
11360 
 
11361 
 
11362 
  def __repr__(self):
11363 
    L = ['%s=%r' % (key, value)
11364 
      for key, value in self.__dict__.iteritems()]
11365 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11366 
 
11367 
  def __eq__(self, other):
11368 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11369 
 
11370 
  def __ne__(self, other):
11371 
    return not (self == other)
11372 
 
11373 
class deleteEntityTag_args:
11374 
  """
11375 
  Attributes:
11376 
   - displayName
11377 
   - itemId
11378 
  """
11379 
 
11380 
  thrift_spec = (
11381 
    None, # 0
11382 
    (1, TType.STRING, 'displayName', None, None, ), # 1
11383 
    (2, TType.I64, 'itemId', None, None, ), # 2
11384 
  )
11385 
 
11386 
  def __init__(self, displayName=None, itemId=None,):
11387 
    self.displayName = displayName
11388 
    self.itemId = itemId
11389 
 
11390 
  def read(self, iprot):
11391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11393 
      return
11394 
    iprot.readStructBegin()
11395 
    while True:
11396 
      (fname, ftype, fid) = iprot.readFieldBegin()
11397 
      if ftype == TType.STOP:
11398 
        break
11399 
      if fid == 1:
11400 
        if ftype == TType.STRING:
11401 
          self.displayName = iprot.readString();
11402 
        else:
11403 
          iprot.skip(ftype)
11404 
      elif fid == 2:
11405 
        if ftype == TType.I64:
11406 
          self.itemId = iprot.readI64();
11407 
        else:
11408 
          iprot.skip(ftype)
11409 
      else:
11410 
        iprot.skip(ftype)
11411 
      iprot.readFieldEnd()
11412 
    iprot.readStructEnd()
11413 
 
11414 
  def write(self, oprot):
11415 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11416 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11417 
      return
11418 
    oprot.writeStructBegin('deleteEntityTag_args')
11419 
    if self.displayName is not None:
11420 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
11421 
      oprot.writeString(self.displayName)
11422 
      oprot.writeFieldEnd()
11423 
    if self.itemId is not None:
11424 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11425 
      oprot.writeI64(self.itemId)
11426 
      oprot.writeFieldEnd()
11427 
    oprot.writeFieldStop()
11428 
    oprot.writeStructEnd()
11429 
 
11430 
  def validate(self):
11431 
    return
11432 
 
11433 
 
11434 
  def __repr__(self):
11435 
    L = ['%s=%r' % (key, value)
11436 
      for key, value in self.__dict__.iteritems()]
11437 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11438 
 
11439 
  def __eq__(self, other):
11440 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11441 
 
11442 
  def __ne__(self, other):
11443 
    return not (self == other)
11444 
 
11445 
class deleteEntityTag_result:
11446 
  """
11447 
  Attributes:
11448 
   - success
11449 
  """
11450 
 
11451 
  thrift_spec = (
11452 
    (0, TType.BOOL, 'success', None, None, ), # 0
11453 
  )
11454 
 
11455 
  def __init__(self, success=None,):
11456 
    self.success = success
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.BOOL:
11469 
          self.success = iprot.readBool();
11470 
        else:
11471 
          iprot.skip(ftype)
11472 
      else:
11473 
        iprot.skip(ftype)
11474 
      iprot.readFieldEnd()
11475 
    iprot.readStructEnd()
11476 
 
11477 
  def write(self, oprot):
11478 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11479 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11480 
      return
11481 
    oprot.writeStructBegin('deleteEntityTag_result')
11482 
    if self.success is not None:
11483 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11484 
      oprot.writeBool(self.success)
11485 
      oprot.writeFieldEnd()
11486 
    oprot.writeFieldStop()
11487 
    oprot.writeStructEnd()
11488 
 
11489 
  def validate(self):
11490 
    return
11491 
 
11492 
 
11493 
  def __repr__(self):
11494 
    L = ['%s=%r' % (key, value)
11495 
      for key, value in self.__dict__.iteritems()]
11496 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11497 
 
11498 
  def __eq__(self, other):
11499 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11500 
 
11501 
  def __ne__(self, other):
11502 
    return not (self == other)
11503 
 
11504 
class deleteTag_args:
11505 
  """
11506 
  Attributes:
11507 
   - displayName
11508 
  """
11509 
 
11510 
  thrift_spec = (
11511 
    None, # 0
11512 
    (1, TType.STRING, 'displayName', None, None, ), # 1
11513 
  )
11514 
 
11515 
  def __init__(self, displayName=None,):
11516 
    self.displayName = displayName
11517 
 
11518 
  def read(self, iprot):
11519 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11520 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11521 
      return
11522 
    iprot.readStructBegin()
11523 
    while True:
11524 
      (fname, ftype, fid) = iprot.readFieldBegin()
11525 
      if ftype == TType.STOP:
11526 
        break
11527 
      if fid == 1:
11528 
        if ftype == TType.STRING:
11529 
          self.displayName = iprot.readString();
11530 
        else:
11531 
          iprot.skip(ftype)
11532 
      else:
11533 
        iprot.skip(ftype)
11534 
      iprot.readFieldEnd()
11535 
    iprot.readStructEnd()
11536 
 
11537 
  def write(self, oprot):
11538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11540 
      return
11541 
    oprot.writeStructBegin('deleteTag_args')
11542 
    if self.displayName is not None:
11543 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
11544 
      oprot.writeString(self.displayName)
11545 
      oprot.writeFieldEnd()
11546 
    oprot.writeFieldStop()
11547 
    oprot.writeStructEnd()
11548 
 
11549 
  def validate(self):
11550 
    return
11551 
 
11552 
 
11553 
  def __repr__(self):
11554 
    L = ['%s=%r' % (key, value)
11555 
      for key, value in self.__dict__.iteritems()]
11556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11557 
 
11558 
  def __eq__(self, other):
11559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11560 
 
11561 
  def __ne__(self, other):
11562 
    return not (self == other)
11563 
 
11564 
class deleteTag_result:
11565 
  """
11566 
  Attributes:
11567 
   - success
11568 
  """
11569 
 
11570 
  thrift_spec = (
11571 
    (0, TType.BOOL, 'success', None, None, ), # 0
11572 
  )
11573 
 
11574 
  def __init__(self, success=None,):
11575 
    self.success = success
11576 
 
11577 
  def read(self, iprot):
11578 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11579 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11580 
      return
11581 
    iprot.readStructBegin()
11582 
    while True:
11583 
      (fname, ftype, fid) = iprot.readFieldBegin()
11584 
      if ftype == TType.STOP:
11585 
        break
11586 
      if fid == 0:
11587 
        if ftype == TType.BOOL:
11588 
          self.success = iprot.readBool();
11589 
        else:
11590 
          iprot.skip(ftype)
11591 
      else:
11592 
        iprot.skip(ftype)
11593 
      iprot.readFieldEnd()
11594 
    iprot.readStructEnd()
11595 
 
11596 
  def write(self, oprot):
11597 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11598 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11599 
      return
11600 
    oprot.writeStructBegin('deleteTag_result')
11601 
    if self.success is not None:
11602 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11603 
      oprot.writeBool(self.success)
11604 
      oprot.writeFieldEnd()
11605 
    oprot.writeFieldStop()
11606 
    oprot.writeStructEnd()
11607 
 
11608 
  def validate(self):
11609 
    return
11610 
 
11611 
 
11612 
  def __repr__(self):
11613 
    L = ['%s=%r' % (key, value)
11614 
      for key, value in self.__dict__.iteritems()]
11615 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11616 
 
11617 
  def __eq__(self, other):
11618 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11619 
 
11620 
  def __ne__(self, other):
11621 
    return not (self == other)
11622 
 
11623 
class getAllTags_args:
11624 
 
11625 
  thrift_spec = (
11626 
  )
11627 
 
11628 
  def read(self, iprot):
11629 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11630 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11631 
      return
11632 
    iprot.readStructBegin()
11633 
    while True:
11634 
      (fname, ftype, fid) = iprot.readFieldBegin()
11635 
      if ftype == TType.STOP:
11636 
        break
11637 
      else:
11638 
        iprot.skip(ftype)
11639 
      iprot.readFieldEnd()
11640 
    iprot.readStructEnd()
11641 
 
11642 
  def write(self, oprot):
11643 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11644 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11645 
      return
11646 
    oprot.writeStructBegin('getAllTags_args')
11647 
    oprot.writeFieldStop()
11648 
    oprot.writeStructEnd()
11649 
 
11650 
  def validate(self):
11651 
    return
11652 
 
11653 
 
11654 
  def __repr__(self):
11655 
    L = ['%s=%r' % (key, value)
11656 
      for key, value in self.__dict__.iteritems()]
11657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11658 
 
11659 
  def __eq__(self, other):
11660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11661 
 
11662 
  def __ne__(self, other):
11663 
    return not (self == other)
11664 
 
11665 
class getAllTags_result:
11666 
  """
11667 
  Attributes:
11668 
   - success
11669 
  """
11670 
 
11671 
  thrift_spec = (
11672 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
11673 
  )
11674 
 
11675 
  def __init__(self, success=None,):
11676 
    self.success = success
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 == 0:
11688 
        if ftype == TType.LIST:
11689 
          self.success = []
8590 kshitij.so 11690 
          (_etype168, _size165) = iprot.readListBegin()
11691 
          for _i169 in xrange(_size165):
11692 
            _elem170 = iprot.readString();
11693 
            self.success.append(_elem170)
6512 kshitij.so 11694 
          iprot.readListEnd()
11695 
        else:
11696 
          iprot.skip(ftype)
11697 
      else:
11698 
        iprot.skip(ftype)
11699 
      iprot.readFieldEnd()
11700 
    iprot.readStructEnd()
11701 
 
11702 
  def write(self, oprot):
11703 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11704 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11705 
      return
11706 
    oprot.writeStructBegin('getAllTags_result')
11707 
    if self.success is not None:
11708 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11709 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 11710 
      for iter171 in self.success:
11711 
        oprot.writeString(iter171)
6512 kshitij.so 11712 
      oprot.writeListEnd()
11713 
      oprot.writeFieldEnd()
11714 
    oprot.writeFieldStop()
11715 
    oprot.writeStructEnd()
11716 
 
11717 
  def validate(self):
11718 
    return
11719 
 
11720 
 
11721 
  def __repr__(self):
11722 
    L = ['%s=%r' % (key, value)
11723 
      for key, value in self.__dict__.iteritems()]
11724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11725 
 
11726 
  def __eq__(self, other):
11727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11728 
 
11729 
  def __ne__(self, other):
11730 
    return not (self == other)
11731 
 
11732 
class getAllEntitiesByTagName_args:
11733 
  """
11734 
  Attributes:
11735 
   - displayName
11736 
  """
11737 
 
11738 
  thrift_spec = (
11739 
    None, # 0
11740 
    (1, TType.STRING, 'displayName', None, None, ), # 1
11741 
  )
11742 
 
11743 
  def __init__(self, displayName=None,):
11744 
    self.displayName = displayName
11745 
 
11746 
  def read(self, iprot):
11747 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11748 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11749 
      return
11750 
    iprot.readStructBegin()
11751 
    while True:
11752 
      (fname, ftype, fid) = iprot.readFieldBegin()
11753 
      if ftype == TType.STOP:
11754 
        break
11755 
      if fid == 1:
11756 
        if ftype == TType.STRING:
11757 
          self.displayName = iprot.readString();
11758 
        else:
11759 
          iprot.skip(ftype)
11760 
      else:
11761 
        iprot.skip(ftype)
11762 
      iprot.readFieldEnd()
11763 
    iprot.readStructEnd()
11764 
 
11765 
  def write(self, oprot):
11766 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11767 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11768 
      return
11769 
    oprot.writeStructBegin('getAllEntitiesByTagName_args')
11770 
    if self.displayName is not None:
11771 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
11772 
      oprot.writeString(self.displayName)
11773 
      oprot.writeFieldEnd()
11774 
    oprot.writeFieldStop()
11775 
    oprot.writeStructEnd()
11776 
 
11777 
  def validate(self):
11778 
    return
11779 
 
11780 
 
11781 
  def __repr__(self):
11782 
    L = ['%s=%r' % (key, value)
11783 
      for key, value in self.__dict__.iteritems()]
11784 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11785 
 
11786 
  def __eq__(self, other):
11787 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11788 
 
11789 
  def __ne__(self, other):
11790 
    return not (self == other)
11791 
 
11792 
class getAllEntitiesByTagName_result:
11793 
  """
11794 
  Attributes:
11795 
   - success
11796 
  """
11797 
 
11798 
  thrift_spec = (
11799 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11800 
  )
11801 
 
11802 
  def __init__(self, success=None,):
11803 
    self.success = success
11804 
 
11805 
  def read(self, iprot):
11806 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11807 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11808 
      return
11809 
    iprot.readStructBegin()
11810 
    while True:
11811 
      (fname, ftype, fid) = iprot.readFieldBegin()
11812 
      if ftype == TType.STOP:
11813 
        break
11814 
      if fid == 0:
11815 
        if ftype == TType.LIST:
11816 
          self.success = []
8590 kshitij.so 11817 
          (_etype175, _size172) = iprot.readListBegin()
11818 
          for _i176 in xrange(_size172):
11819 
            _elem177 = iprot.readI64();
11820 
            self.success.append(_elem177)
6512 kshitij.so 11821 
          iprot.readListEnd()
11822 
        else:
11823 
          iprot.skip(ftype)
11824 
      else:
11825 
        iprot.skip(ftype)
11826 
      iprot.readFieldEnd()
11827 
    iprot.readStructEnd()
11828 
 
11829 
  def write(self, oprot):
11830 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11831 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11832 
      return
11833 
    oprot.writeStructBegin('getAllEntitiesByTagName_result')
11834 
    if self.success is not None:
11835 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11836 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 11837 
      for iter178 in self.success:
11838 
        oprot.writeI64(iter178)
6512 kshitij.so 11839 
      oprot.writeListEnd()
11840 
      oprot.writeFieldEnd()
11841 
    oprot.writeFieldStop()
11842 
    oprot.writeStructEnd()
11843 
 
11844 
  def validate(self):
11845 
    return
11846 
 
11847 
 
11848 
  def __repr__(self):
11849 
    L = ['%s=%r' % (key, value)
11850 
      for key, value in self.__dict__.iteritems()]
11851 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11852 
 
11853 
  def __eq__(self, other):
11854 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11855 
 
11856 
  def __ne__(self, other):
11857 
    return not (self == other)
11858 
 
6845 amit.gupta 11859 
class getAllEntityTags_args:
11860 
 
11861 
  thrift_spec = (
11862 
  )
11863 
 
11864 
  def read(self, iprot):
11865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11867 
      return
11868 
    iprot.readStructBegin()
11869 
    while True:
11870 
      (fname, ftype, fid) = iprot.readFieldBegin()
11871 
      if ftype == TType.STOP:
11872 
        break
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('getAllEntityTags_args')
11883 
    oprot.writeFieldStop()
11884 
    oprot.writeStructEnd()
11885 
 
11886 
  def validate(self):
11887 
    return
11888 
 
11889 
 
11890 
  def __repr__(self):
11891 
    L = ['%s=%r' % (key, value)
11892 
      for key, value in self.__dict__.iteritems()]
11893 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11894 
 
11895 
  def __eq__(self, other):
11896 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11897 
 
11898 
  def __ne__(self, other):
11899 
    return not (self == other)
11900 
 
11901 
class getAllEntityTags_result:
11902 
  """
11903 
  Attributes:
11904 
   - success
11905 
  """
11906 
 
11907 
  thrift_spec = (
11908 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRING,None)), None, ), # 0
11909 
  )
11910 
 
11911 
  def __init__(self, success=None,):
11912 
    self.success = success
11913 
 
11914 
  def read(self, iprot):
11915 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11916 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11917 
      return
11918 
    iprot.readStructBegin()
11919 
    while True:
11920 
      (fname, ftype, fid) = iprot.readFieldBegin()
11921 
      if ftype == TType.STOP:
11922 
        break
11923 
      if fid == 0:
11924 
        if ftype == TType.MAP:
11925 
          self.success = {}
8590 kshitij.so 11926 
          (_ktype180, _vtype181, _size179 ) = iprot.readMapBegin()
11927 
          for _i183 in xrange(_size179):
11928 
            _key184 = iprot.readI64();
11929 
            _val185 = []
11930 
            (_etype189, _size186) = iprot.readListBegin()
11931 
            for _i190 in xrange(_size186):
11932 
              _elem191 = iprot.readString();
11933 
              _val185.append(_elem191)
6845 amit.gupta 11934 
            iprot.readListEnd()
8590 kshitij.so 11935 
            self.success[_key184] = _val185
6845 amit.gupta 11936 
          iprot.readMapEnd()
11937 
        else:
11938 
          iprot.skip(ftype)
11939 
      else:
11940 
        iprot.skip(ftype)
11941 
      iprot.readFieldEnd()
11942 
    iprot.readStructEnd()
11943 
 
11944 
  def write(self, oprot):
11945 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11946 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11947 
      return
11948 
    oprot.writeStructBegin('getAllEntityTags_result')
11949 
    if self.success is not None:
11950 
      oprot.writeFieldBegin('success', TType.MAP, 0)
11951 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
8590 kshitij.so 11952 
      for kiter192,viter193 in self.success.items():
11953 
        oprot.writeI64(kiter192)
11954 
        oprot.writeListBegin(TType.STRING, len(viter193))
11955 
        for iter194 in viter193:
11956 
          oprot.writeString(iter194)
6845 amit.gupta 11957 
        oprot.writeListEnd()
11958 
      oprot.writeMapEnd()
11959 
      oprot.writeFieldEnd()
11960 
    oprot.writeFieldStop()
11961 
    oprot.writeStructEnd()
11962 
 
11963 
  def validate(self):
11964 
    return
11965 
 
11966 
 
11967 
  def __repr__(self):
11968 
    L = ['%s=%r' % (key, value)
11969 
      for key, value in self.__dict__.iteritems()]
11970 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11971 
 
11972 
  def __eq__(self, other):
11973 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11974 
 
11975 
  def __ne__(self, other):
11976 
    return not (self == other)
11977 
 
6850 kshitij.so 11978 
class addBanner_args:
11979 
  """
11980 
  Attributes:
8590 kshitij.so 11981 
   - bannerCongregate
6850 kshitij.so 11982 
  """
11983 
 
11984 
  thrift_spec = (
11985 
    None, # 0
8590 kshitij.so 11986 
    (1, TType.STRUCT, 'bannerCongregate', (BannerCongregate, BannerCongregate.thrift_spec), None, ), # 1
6850 kshitij.so 11987 
  )
11988 
 
8590 kshitij.so 11989 
  def __init__(self, bannerCongregate=None,):
11990 
    self.bannerCongregate = bannerCongregate
6850 kshitij.so 11991 
 
11992 
  def read(self, iprot):
11993 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11994 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11995 
      return
11996 
    iprot.readStructBegin()
11997 
    while True:
11998 
      (fname, ftype, fid) = iprot.readFieldBegin()
11999 
      if ftype == TType.STOP:
12000 
        break
12001 
      if fid == 1:
8579 kshitij.so 12002 
        if ftype == TType.STRUCT:
8590 kshitij.so 12003 
          self.bannerCongregate = BannerCongregate()
12004 
          self.bannerCongregate.read(iprot)
6850 kshitij.so 12005 
        else:
12006 
          iprot.skip(ftype)
8579 kshitij.so 12007 
      else:
12008 
        iprot.skip(ftype)
12009 
      iprot.readFieldEnd()
12010 
    iprot.readStructEnd()
12011 
 
12012 
  def write(self, oprot):
12013 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12014 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12015 
      return
12016 
    oprot.writeStructBegin('addBanner_args')
8590 kshitij.so 12017 
    if self.bannerCongregate is not None:
12018 
      oprot.writeFieldBegin('bannerCongregate', TType.STRUCT, 1)
12019 
      self.bannerCongregate.write(oprot)
8579 kshitij.so 12020 
      oprot.writeFieldEnd()
12021 
    oprot.writeFieldStop()
12022 
    oprot.writeStructEnd()
12023 
 
12024 
  def validate(self):
12025 
    return
12026 
 
12027 
 
12028 
  def __repr__(self):
12029 
    L = ['%s=%r' % (key, value)
12030 
      for key, value in self.__dict__.iteritems()]
12031 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12032 
 
12033 
  def __eq__(self, other):
12034 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12035 
 
12036 
  def __ne__(self, other):
12037 
    return not (self == other)
12038 
 
12039 
class addBanner_result:
12040 
 
12041 
  thrift_spec = (
12042 
  )
12043 
 
12044 
  def read(self, iprot):
12045 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12046 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12047 
      return
12048 
    iprot.readStructBegin()
12049 
    while True:
12050 
      (fname, ftype, fid) = iprot.readFieldBegin()
12051 
      if ftype == TType.STOP:
12052 
        break
12053 
      else:
12054 
        iprot.skip(ftype)
12055 
      iprot.readFieldEnd()
12056 
    iprot.readStructEnd()
12057 
 
12058 
  def write(self, oprot):
12059 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12060 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12061 
      return
12062 
    oprot.writeStructBegin('addBanner_result')
12063 
    oprot.writeFieldStop()
12064 
    oprot.writeStructEnd()
12065 
 
12066 
  def validate(self):
12067 
    return
12068 
 
12069 
 
12070 
  def __repr__(self):
12071 
    L = ['%s=%r' % (key, value)
12072 
      for key, value in self.__dict__.iteritems()]
12073 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12074 
 
12075 
  def __eq__(self, other):
12076 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12077 
 
12078 
  def __ne__(self, other):
12079 
    return not (self == other)
12080 
 
12081 
class updateBanner_args:
12082 
  """
12083 
  Attributes:
12084 
   - banner
12085 
  """
12086 
 
12087 
  thrift_spec = (
12088 
    None, # 0
12089 
    (1, TType.STRUCT, 'banner', (Banner, Banner.thrift_spec), None, ), # 1
12090 
  )
12091 
 
12092 
  def __init__(self, banner=None,):
12093 
    self.banner = banner
12094 
 
12095 
  def read(self, iprot):
12096 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12097 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12098 
      return
12099 
    iprot.readStructBegin()
12100 
    while True:
12101 
      (fname, ftype, fid) = iprot.readFieldBegin()
12102 
      if ftype == TType.STOP:
12103 
        break
12104 
      if fid == 1:
12105 
        if ftype == TType.STRUCT:
12106 
          self.banner = Banner()
12107 
          self.banner.read(iprot)
6850 kshitij.so 12108 
        else:
12109 
          iprot.skip(ftype)
12110 
      else:
12111 
        iprot.skip(ftype)
12112 
      iprot.readFieldEnd()
12113 
    iprot.readStructEnd()
12114 
 
12115 
  def write(self, oprot):
12116 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12117 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12118 
      return
8579 kshitij.so 12119 
    oprot.writeStructBegin('updateBanner_args')
12120 
    if self.banner is not None:
12121 
      oprot.writeFieldBegin('banner', TType.STRUCT, 1)
12122 
      self.banner.write(oprot)
6850 kshitij.so 12123 
      oprot.writeFieldEnd()
12124 
    oprot.writeFieldStop()
12125 
    oprot.writeStructEnd()
12126 
 
12127 
  def validate(self):
12128 
    return
12129 
 
12130 
 
12131 
  def __repr__(self):
12132 
    L = ['%s=%r' % (key, value)
12133 
      for key, value in self.__dict__.iteritems()]
12134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12135 
 
12136 
  def __eq__(self, other):
12137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12138 
 
12139 
  def __ne__(self, other):
12140 
    return not (self == other)
12141 
 
8579 kshitij.so 12142 
class updateBanner_result:
6850 kshitij.so 12143 
  """
12144 
  Attributes:
12145 
   - success
12146 
  """
12147 
 
12148 
  thrift_spec = (
12149 
    (0, TType.BOOL, 'success', None, None, ), # 0
12150 
  )
12151 
 
12152 
  def __init__(self, success=None,):
12153 
    self.success = success
12154 
 
12155 
  def read(self, iprot):
12156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12158 
      return
12159 
    iprot.readStructBegin()
12160 
    while True:
12161 
      (fname, ftype, fid) = iprot.readFieldBegin()
12162 
      if ftype == TType.STOP:
12163 
        break
12164 
      if fid == 0:
12165 
        if ftype == TType.BOOL:
12166 
          self.success = iprot.readBool();
12167 
        else:
12168 
          iprot.skip(ftype)
12169 
      else:
12170 
        iprot.skip(ftype)
12171 
      iprot.readFieldEnd()
12172 
    iprot.readStructEnd()
12173 
 
12174 
  def write(self, oprot):
12175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12177 
      return
8579 kshitij.so 12178 
    oprot.writeStructBegin('updateBanner_result')
6850 kshitij.so 12179 
    if self.success is not None:
12180 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12181 
      oprot.writeBool(self.success)
12182 
      oprot.writeFieldEnd()
12183 
    oprot.writeFieldStop()
12184 
    oprot.writeStructEnd()
12185 
 
12186 
  def validate(self):
12187 
    return
12188 
 
12189 
 
12190 
  def __repr__(self):
12191 
    L = ['%s=%r' % (key, value)
12192 
      for key, value in self.__dict__.iteritems()]
12193 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12194 
 
12195 
  def __eq__(self, other):
12196 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12197 
 
12198 
  def __ne__(self, other):
12199 
    return not (self == other)
12200 
 
12201 
class getAllBanners_args:
12202 
 
12203 
  thrift_spec = (
12204 
  )
12205 
 
12206 
  def read(self, iprot):
12207 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12208 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12209 
      return
12210 
    iprot.readStructBegin()
12211 
    while True:
12212 
      (fname, ftype, fid) = iprot.readFieldBegin()
12213 
      if ftype == TType.STOP:
12214 
        break
12215 
      else:
12216 
        iprot.skip(ftype)
12217 
      iprot.readFieldEnd()
12218 
    iprot.readStructEnd()
12219 
 
12220 
  def write(self, oprot):
12221 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12222 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12223 
      return
12224 
    oprot.writeStructBegin('getAllBanners_args')
12225 
    oprot.writeFieldStop()
12226 
    oprot.writeStructEnd()
12227 
 
12228 
  def validate(self):
12229 
    return
12230 
 
12231 
 
12232 
  def __repr__(self):
12233 
    L = ['%s=%r' % (key, value)
12234 
      for key, value in self.__dict__.iteritems()]
12235 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12236 
 
12237 
  def __eq__(self, other):
12238 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12239 
 
12240 
  def __ne__(self, other):
12241 
    return not (self == other)
12242 
 
12243 
class getAllBanners_result:
12244 
  """
12245 
  Attributes:
12246 
   - success
12247 
  """
12248 
 
12249 
  thrift_spec = (
8579 kshitij.so 12250 
    (0, TType.LIST, 'success', (TType.STRUCT,(Banner, Banner.thrift_spec)), None, ), # 0
6850 kshitij.so 12251 
  )
12252 
 
12253 
  def __init__(self, success=None,):
12254 
    self.success = success
12255 
 
12256 
  def read(self, iprot):
12257 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12258 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12259 
      return
12260 
    iprot.readStructBegin()
12261 
    while True:
12262 
      (fname, ftype, fid) = iprot.readFieldBegin()
12263 
      if ftype == TType.STOP:
12264 
        break
12265 
      if fid == 0:
12266 
        if ftype == TType.LIST:
12267 
          self.success = []
8590 kshitij.so 12268 
          (_etype198, _size195) = iprot.readListBegin()
12269 
          for _i199 in xrange(_size195):
12270 
            _elem200 = Banner()
12271 
            _elem200.read(iprot)
12272 
            self.success.append(_elem200)
6850 kshitij.so 12273 
          iprot.readListEnd()
12274 
        else:
12275 
          iprot.skip(ftype)
12276 
      else:
12277 
        iprot.skip(ftype)
12278 
      iprot.readFieldEnd()
12279 
    iprot.readStructEnd()
12280 
 
12281 
  def write(self, oprot):
12282 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12283 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12284 
      return
12285 
    oprot.writeStructBegin('getAllBanners_result')
12286 
    if self.success is not None:
12287 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8579 kshitij.so 12288 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 12289 
      for iter201 in self.success:
12290 
        iter201.write(oprot)
6850 kshitij.so 12291 
      oprot.writeListEnd()
12292 
      oprot.writeFieldEnd()
12293 
    oprot.writeFieldStop()
12294 
    oprot.writeStructEnd()
12295 
 
12296 
  def validate(self):
12297 
    return
12298 
 
12299 
 
12300 
  def __repr__(self):
12301 
    L = ['%s=%r' % (key, value)
12302 
      for key, value in self.__dict__.iteritems()]
12303 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12304 
 
12305 
  def __eq__(self, other):
12306 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12307 
 
12308 
  def __ne__(self, other):
12309 
    return not (self == other)
12310 
 
12311 
class deleteBanner_args:
12312 
  """
12313 
  Attributes:
12314 
   - bannerName
9155 kshitij.so 12315 
   - bannerType
6850 kshitij.so 12316 
  """
12317 
 
12318 
  thrift_spec = (
12319 
    None, # 0
12320 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 12321 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6850 kshitij.so 12322 
  )
12323 
 
9155 kshitij.so 12324 
  def __init__(self, bannerName=None, bannerType=None,):
6850 kshitij.so 12325 
    self.bannerName = bannerName
9155 kshitij.so 12326 
    self.bannerType = bannerType
6850 kshitij.so 12327 
 
12328 
  def read(self, iprot):
12329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12331 
      return
12332 
    iprot.readStructBegin()
12333 
    while True:
12334 
      (fname, ftype, fid) = iprot.readFieldBegin()
12335 
      if ftype == TType.STOP:
12336 
        break
12337 
      if fid == 1:
12338 
        if ftype == TType.STRING:
12339 
          self.bannerName = iprot.readString();
12340 
        else:
12341 
          iprot.skip(ftype)
9155 kshitij.so 12342 
      elif fid == 2:
12343 
        if ftype == TType.I32:
12344 
          self.bannerType = iprot.readI32();
12345 
        else:
12346 
          iprot.skip(ftype)
6850 kshitij.so 12347 
      else:
12348 
        iprot.skip(ftype)
12349 
      iprot.readFieldEnd()
12350 
    iprot.readStructEnd()
12351 
 
12352 
  def write(self, oprot):
12353 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12354 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12355 
      return
12356 
    oprot.writeStructBegin('deleteBanner_args')
12357 
    if self.bannerName is not None:
12358 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
12359 
      oprot.writeString(self.bannerName)
12360 
      oprot.writeFieldEnd()
9155 kshitij.so 12361 
    if self.bannerType is not None:
12362 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
12363 
      oprot.writeI32(self.bannerType)
12364 
      oprot.writeFieldEnd()
6850 kshitij.so 12365 
    oprot.writeFieldStop()
12366 
    oprot.writeStructEnd()
12367 
 
12368 
  def validate(self):
12369 
    return
12370 
 
12371 
 
12372 
  def __repr__(self):
12373 
    L = ['%s=%r' % (key, value)
12374 
      for key, value in self.__dict__.iteritems()]
12375 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12376 
 
12377 
  def __eq__(self, other):
12378 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12379 
 
12380 
  def __ne__(self, other):
12381 
    return not (self == other)
12382 
 
12383 
class deleteBanner_result:
12384 
  """
12385 
  Attributes:
12386 
   - success
12387 
  """
12388 
 
12389 
  thrift_spec = (
12390 
    (0, TType.BOOL, 'success', None, None, ), # 0
12391 
  )
12392 
 
12393 
  def __init__(self, success=None,):
12394 
    self.success = success
12395 
 
12396 
  def read(self, iprot):
12397 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12398 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12399 
      return
12400 
    iprot.readStructBegin()
12401 
    while True:
12402 
      (fname, ftype, fid) = iprot.readFieldBegin()
12403 
      if ftype == TType.STOP:
12404 
        break
12405 
      if fid == 0:
12406 
        if ftype == TType.BOOL:
12407 
          self.success = iprot.readBool();
12408 
        else:
12409 
          iprot.skip(ftype)
12410 
      else:
12411 
        iprot.skip(ftype)
12412 
      iprot.readFieldEnd()
12413 
    iprot.readStructEnd()
12414 
 
12415 
  def write(self, oprot):
12416 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12417 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12418 
      return
12419 
    oprot.writeStructBegin('deleteBanner_result')
12420 
    if self.success is not None:
12421 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12422 
      oprot.writeBool(self.success)
12423 
      oprot.writeFieldEnd()
12424 
    oprot.writeFieldStop()
12425 
    oprot.writeStructEnd()
12426 
 
12427 
  def validate(self):
12428 
    return
12429 
 
12430 
 
12431 
  def __repr__(self):
12432 
    L = ['%s=%r' % (key, value)
12433 
      for key, value in self.__dict__.iteritems()]
12434 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12435 
 
12436 
  def __eq__(self, other):
12437 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12438 
 
12439 
  def __ne__(self, other):
12440 
    return not (self == other)
12441 
 
12442 
class getBannerDetails_args:
12443 
  """
12444 
  Attributes:
12445 
   - bannerName
9155 kshitij.so 12446 
   - bannerType
6850 kshitij.so 12447 
  """
12448 
 
12449 
  thrift_spec = (
12450 
    None, # 0
12451 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 12452 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6850 kshitij.so 12453 
  )
12454 
 
9155 kshitij.so 12455 
  def __init__(self, bannerName=None, bannerType=None,):
6850 kshitij.so 12456 
    self.bannerName = bannerName
9155 kshitij.so 12457 
    self.bannerType = bannerType
6850 kshitij.so 12458 
 
12459 
  def read(self, iprot):
12460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12462 
      return
12463 
    iprot.readStructBegin()
12464 
    while True:
12465 
      (fname, ftype, fid) = iprot.readFieldBegin()
12466 
      if ftype == TType.STOP:
12467 
        break
12468 
      if fid == 1:
12469 
        if ftype == TType.STRING:
12470 
          self.bannerName = iprot.readString();
12471 
        else:
12472 
          iprot.skip(ftype)
9155 kshitij.so 12473 
      elif fid == 2:
12474 
        if ftype == TType.I32:
12475 
          self.bannerType = iprot.readI32();
12476 
        else:
12477 
          iprot.skip(ftype)
6850 kshitij.so 12478 
      else:
12479 
        iprot.skip(ftype)
12480 
      iprot.readFieldEnd()
12481 
    iprot.readStructEnd()
12482 
 
12483 
  def write(self, oprot):
12484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12486 
      return
12487 
    oprot.writeStructBegin('getBannerDetails_args')
12488 
    if self.bannerName is not None:
12489 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
12490 
      oprot.writeString(self.bannerName)
12491 
      oprot.writeFieldEnd()
9155 kshitij.so 12492 
    if self.bannerType is not None:
12493 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
12494 
      oprot.writeI32(self.bannerType)
12495 
      oprot.writeFieldEnd()
6850 kshitij.so 12496 
    oprot.writeFieldStop()
12497 
    oprot.writeStructEnd()
12498 
 
12499 
  def validate(self):
12500 
    return
12501 
 
12502 
 
12503 
  def __repr__(self):
12504 
    L = ['%s=%r' % (key, value)
12505 
      for key, value in self.__dict__.iteritems()]
12506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12507 
 
12508 
  def __eq__(self, other):
12509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12510 
 
12511 
  def __ne__(self, other):
12512 
    return not (self == other)
12513 
 
12514 
class getBannerDetails_result:
12515 
  """
12516 
  Attributes:
12517 
   - success
12518 
  """
12519 
 
12520 
  thrift_spec = (
12521 
    (0, TType.STRUCT, 'success', (Banner, Banner.thrift_spec), None, ), # 0
12522 
  )
12523 
 
12524 
  def __init__(self, success=None,):
12525 
    self.success = success
12526 
 
12527 
  def read(self, iprot):
12528 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12529 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12530 
      return
12531 
    iprot.readStructBegin()
12532 
    while True:
12533 
      (fname, ftype, fid) = iprot.readFieldBegin()
12534 
      if ftype == TType.STOP:
12535 
        break
12536 
      if fid == 0:
12537 
        if ftype == TType.STRUCT:
12538 
          self.success = Banner()
12539 
          self.success.read(iprot)
12540 
        else:
12541 
          iprot.skip(ftype)
12542 
      else:
12543 
        iprot.skip(ftype)
12544 
      iprot.readFieldEnd()
12545 
    iprot.readStructEnd()
12546 
 
12547 
  def write(self, oprot):
12548 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12549 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12550 
      return
12551 
    oprot.writeStructBegin('getBannerDetails_result')
12552 
    if self.success is not None:
12553 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12554 
      self.success.write(oprot)
12555 
      oprot.writeFieldEnd()
12556 
    oprot.writeFieldStop()
12557 
    oprot.writeStructEnd()
12558 
 
12559 
  def validate(self):
12560 
    return
12561 
 
12562 
 
12563 
  def __repr__(self):
12564 
    L = ['%s=%r' % (key, value)
12565 
      for key, value in self.__dict__.iteritems()]
12566 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12567 
 
12568 
  def __eq__(self, other):
12569 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12570 
 
12571 
  def __ne__(self, other):
12572 
    return not (self == other)
12573 
 
12574 
class getActiveBanners_args:
12575 
 
12576 
  thrift_spec = (
12577 
  )
12578 
 
12579 
  def read(self, iprot):
12580 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12581 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12582 
      return
12583 
    iprot.readStructBegin()
12584 
    while True:
12585 
      (fname, ftype, fid) = iprot.readFieldBegin()
12586 
      if ftype == TType.STOP:
12587 
        break
12588 
      else:
12589 
        iprot.skip(ftype)
12590 
      iprot.readFieldEnd()
12591 
    iprot.readStructEnd()
12592 
 
12593 
  def write(self, oprot):
12594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12596 
      return
12597 
    oprot.writeStructBegin('getActiveBanners_args')
12598 
    oprot.writeFieldStop()
12599 
    oprot.writeStructEnd()
12600 
 
12601 
  def validate(self):
12602 
    return
12603 
 
12604 
 
12605 
  def __repr__(self):
12606 
    L = ['%s=%r' % (key, value)
12607 
      for key, value in self.__dict__.iteritems()]
12608 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12609 
 
12610 
  def __eq__(self, other):
12611 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12612 
 
12613 
  def __ne__(self, other):
12614 
    return not (self == other)
12615 
 
12616 
class getActiveBanners_result:
12617 
  """
12618 
  Attributes:
12619 
   - success
12620 
  """
12621 
 
12622 
  thrift_spec = (
8579 kshitij.so 12623 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
6850 kshitij.so 12624 
  )
12625 
 
12626 
  def __init__(self, success=None,):
12627 
    self.success = success
12628 
 
12629 
  def read(self, iprot):
12630 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12631 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12632 
      return
12633 
    iprot.readStructBegin()
12634 
    while True:
12635 
      (fname, ftype, fid) = iprot.readFieldBegin()
12636 
      if ftype == TType.STOP:
12637 
        break
12638 
      if fid == 0:
8579 kshitij.so 12639 
        if ftype == TType.MAP:
12640 
          self.success = {}
8590 kshitij.so 12641 
          (_ktype203, _vtype204, _size202 ) = iprot.readMapBegin()
12642 
          for _i206 in xrange(_size202):
12643 
            _key207 = iprot.readString();
12644 
            _val208 = []
12645 
            (_etype212, _size209) = iprot.readListBegin()
12646 
            for _i213 in xrange(_size209):
12647 
              _elem214 = Banner()
12648 
              _elem214.read(iprot)
12649 
              _val208.append(_elem214)
8579 kshitij.so 12650 
            iprot.readListEnd()
8590 kshitij.so 12651 
            self.success[_key207] = _val208
8579 kshitij.so 12652 
          iprot.readMapEnd()
6850 kshitij.so 12653 
        else:
12654 
          iprot.skip(ftype)
12655 
      else:
12656 
        iprot.skip(ftype)
12657 
      iprot.readFieldEnd()
12658 
    iprot.readStructEnd()
12659 
 
12660 
  def write(self, oprot):
12661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12663 
      return
12664 
    oprot.writeStructBegin('getActiveBanners_result')
12665 
    if self.success is not None:
8579 kshitij.so 12666 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12667 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
8590 kshitij.so 12668 
      for kiter215,viter216 in self.success.items():
12669 
        oprot.writeString(kiter215)
12670 
        oprot.writeListBegin(TType.STRUCT, len(viter216))
12671 
        for iter217 in viter216:
12672 
          iter217.write(oprot)
8579 kshitij.so 12673 
        oprot.writeListEnd()
12674 
      oprot.writeMapEnd()
6850 kshitij.so 12675 
      oprot.writeFieldEnd()
12676 
    oprot.writeFieldStop()
12677 
    oprot.writeStructEnd()
12678 
 
12679 
  def validate(self):
12680 
    return
12681 
 
12682 
 
12683 
  def __repr__(self):
12684 
    L = ['%s=%r' % (key, value)
12685 
      for key, value in self.__dict__.iteritems()]
12686 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12687 
 
12688 
  def __eq__(self, other):
12689 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12690 
 
12691 
  def __ne__(self, other):
12692 
    return not (self == other)
12693 
 
6849 kshitij.so 12694 
class addBannerMap_args:
12695 
  """
12696 
  Attributes:
8579 kshitij.so 12697 
   - bannerMaps
6849 kshitij.so 12698 
  """
12699 
 
12700 
  thrift_spec = (
12701 
    None, # 0
8579 kshitij.so 12702 
    (1, TType.LIST, 'bannerMaps', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 1
6849 kshitij.so 12703 
  )
12704 
 
8579 kshitij.so 12705 
  def __init__(self, bannerMaps=None,):
12706 
    self.bannerMaps = bannerMaps
6849 kshitij.so 12707 
 
12708 
  def read(self, iprot):
12709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12711 
      return
12712 
    iprot.readStructBegin()
12713 
    while True:
12714 
      (fname, ftype, fid) = iprot.readFieldBegin()
12715 
      if ftype == TType.STOP:
12716 
        break
12717 
      if fid == 1:
8579 kshitij.so 12718 
        if ftype == TType.LIST:
12719 
          self.bannerMaps = []
8590 kshitij.so 12720 
          (_etype221, _size218) = iprot.readListBegin()
12721 
          for _i222 in xrange(_size218):
12722 
            _elem223 = BannerMap()
12723 
            _elem223.read(iprot)
12724 
            self.bannerMaps.append(_elem223)
8579 kshitij.so 12725 
          iprot.readListEnd()
6849 kshitij.so 12726 
        else:
12727 
          iprot.skip(ftype)
8579 kshitij.so 12728 
      else:
12729 
        iprot.skip(ftype)
12730 
      iprot.readFieldEnd()
12731 
    iprot.readStructEnd()
12732 
 
12733 
  def write(self, oprot):
12734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12736 
      return
12737 
    oprot.writeStructBegin('addBannerMap_args')
12738 
    if self.bannerMaps is not None:
12739 
      oprot.writeFieldBegin('bannerMaps', TType.LIST, 1)
12740 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerMaps))
8590 kshitij.so 12741 
      for iter224 in self.bannerMaps:
12742 
        iter224.write(oprot)
8579 kshitij.so 12743 
      oprot.writeListEnd()
12744 
      oprot.writeFieldEnd()
12745 
    oprot.writeFieldStop()
12746 
    oprot.writeStructEnd()
12747 
 
12748 
  def validate(self):
12749 
    return
12750 
 
12751 
 
12752 
  def __repr__(self):
12753 
    L = ['%s=%r' % (key, value)
12754 
      for key, value in self.__dict__.iteritems()]
12755 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12756 
 
12757 
  def __eq__(self, other):
12758 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12759 
 
12760 
  def __ne__(self, other):
12761 
    return not (self == other)
12762 
 
12763 
class addBannerMap_result:
12764 
  """
12765 
  Attributes:
12766 
   - success
12767 
  """
12768 
 
12769 
  thrift_spec = (
12770 
    (0, TType.BOOL, 'success', None, None, ), # 0
12771 
  )
12772 
 
12773 
  def __init__(self, success=None,):
12774 
    self.success = success
12775 
 
12776 
  def read(self, iprot):
12777 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12778 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12779 
      return
12780 
    iprot.readStructBegin()
12781 
    while True:
12782 
      (fname, ftype, fid) = iprot.readFieldBegin()
12783 
      if ftype == TType.STOP:
12784 
        break
12785 
      if fid == 0:
12786 
        if ftype == TType.BOOL:
12787 
          self.success = iprot.readBool();
6849 kshitij.so 12788 
        else:
12789 
          iprot.skip(ftype)
8579 kshitij.so 12790 
      else:
12791 
        iprot.skip(ftype)
12792 
      iprot.readFieldEnd()
12793 
    iprot.readStructEnd()
12794 
 
12795 
  def write(self, oprot):
12796 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12797 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12798 
      return
12799 
    oprot.writeStructBegin('addBannerMap_result')
12800 
    if self.success is not None:
12801 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12802 
      oprot.writeBool(self.success)
12803 
      oprot.writeFieldEnd()
12804 
    oprot.writeFieldStop()
12805 
    oprot.writeStructEnd()
12806 
 
12807 
  def validate(self):
12808 
    return
12809 
 
12810 
 
12811 
  def __repr__(self):
12812 
    L = ['%s=%r' % (key, value)
12813 
      for key, value in self.__dict__.iteritems()]
12814 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12815 
 
12816 
  def __eq__(self, other):
12817 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12818 
 
12819 
  def __ne__(self, other):
12820 
    return not (self == other)
12821 
 
12822 
class updateBannerMap_args:
12823 
  """
12824 
  Attributes:
12825 
   - bannerMap
12826 
  """
12827 
 
12828 
  thrift_spec = (
12829 
    None, # 0
12830 
    (1, TType.STRUCT, 'bannerMap', (BannerMap, BannerMap.thrift_spec), None, ), # 1
12831 
  )
12832 
 
12833 
  def __init__(self, bannerMap=None,):
12834 
    self.bannerMap = bannerMap
12835 
 
12836 
  def read(self, iprot):
12837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12839 
      return
12840 
    iprot.readStructBegin()
12841 
    while True:
12842 
      (fname, ftype, fid) = iprot.readFieldBegin()
12843 
      if ftype == TType.STOP:
12844 
        break
12845 
      if fid == 1:
12846 
        if ftype == TType.STRUCT:
12847 
          self.bannerMap = BannerMap()
12848 
          self.bannerMap.read(iprot)
6849 kshitij.so 12849 
        else:
12850 
          iprot.skip(ftype)
12851 
      else:
12852 
        iprot.skip(ftype)
12853 
      iprot.readFieldEnd()
12854 
    iprot.readStructEnd()
12855 
 
12856 
  def write(self, oprot):
12857 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12858 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12859 
      return
8579 kshitij.so 12860 
    oprot.writeStructBegin('updateBannerMap_args')
12861 
    if self.bannerMap is not None:
12862 
      oprot.writeFieldBegin('bannerMap', TType.STRUCT, 1)
12863 
      self.bannerMap.write(oprot)
6849 kshitij.so 12864 
      oprot.writeFieldEnd()
12865 
    oprot.writeFieldStop()
12866 
    oprot.writeStructEnd()
12867 
 
12868 
  def validate(self):
12869 
    return
12870 
 
12871 
 
12872 
  def __repr__(self):
12873 
    L = ['%s=%r' % (key, value)
12874 
      for key, value in self.__dict__.iteritems()]
12875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12876 
 
12877 
  def __eq__(self, other):
12878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12879 
 
12880 
  def __ne__(self, other):
12881 
    return not (self == other)
12882 
 
8579 kshitij.so 12883 
class updateBannerMap_result:
6849 kshitij.so 12884 
  """
12885 
  Attributes:
12886 
   - success
12887 
  """
12888 
 
12889 
  thrift_spec = (
12890 
    (0, TType.BOOL, 'success', None, None, ), # 0
12891 
  )
12892 
 
12893 
  def __init__(self, success=None,):
12894 
    self.success = success
12895 
 
12896 
  def read(self, iprot):
12897 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12898 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12899 
      return
12900 
    iprot.readStructBegin()
12901 
    while True:
12902 
      (fname, ftype, fid) = iprot.readFieldBegin()
12903 
      if ftype == TType.STOP:
12904 
        break
12905 
      if fid == 0:
12906 
        if ftype == TType.BOOL:
12907 
          self.success = iprot.readBool();
12908 
        else:
12909 
          iprot.skip(ftype)
12910 
      else:
12911 
        iprot.skip(ftype)
12912 
      iprot.readFieldEnd()
12913 
    iprot.readStructEnd()
12914 
 
12915 
  def write(self, oprot):
12916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12918 
      return
8579 kshitij.so 12919 
    oprot.writeStructBegin('updateBannerMap_result')
6849 kshitij.so 12920 
    if self.success is not None:
12921 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12922 
      oprot.writeBool(self.success)
12923 
      oprot.writeFieldEnd()
12924 
    oprot.writeFieldStop()
12925 
    oprot.writeStructEnd()
12926 
 
12927 
  def validate(self):
12928 
    return
12929 
 
12930 
 
12931 
  def __repr__(self):
12932 
    L = ['%s=%r' % (key, value)
12933 
      for key, value in self.__dict__.iteritems()]
12934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12935 
 
12936 
  def __eq__(self, other):
12937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12938 
 
12939 
  def __ne__(self, other):
12940 
    return not (self == other)
12941 
 
12942 
class deleteBannerMap_args:
12943 
  """
12944 
  Attributes:
12945 
   - bannerName
12946 
  """
12947 
 
12948 
  thrift_spec = (
12949 
    None, # 0
12950 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
12951 
  )
12952 
 
12953 
  def __init__(self, bannerName=None,):
12954 
    self.bannerName = bannerName
12955 
 
12956 
  def read(self, iprot):
12957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12959 
      return
12960 
    iprot.readStructBegin()
12961 
    while True:
12962 
      (fname, ftype, fid) = iprot.readFieldBegin()
12963 
      if ftype == TType.STOP:
12964 
        break
12965 
      if fid == 1:
12966 
        if ftype == TType.STRING:
12967 
          self.bannerName = iprot.readString();
12968 
        else:
12969 
          iprot.skip(ftype)
12970 
      else:
12971 
        iprot.skip(ftype)
12972 
      iprot.readFieldEnd()
12973 
    iprot.readStructEnd()
12974 
 
12975 
  def write(self, oprot):
12976 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12977 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12978 
      return
12979 
    oprot.writeStructBegin('deleteBannerMap_args')
12980 
    if self.bannerName is not None:
12981 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
12982 
      oprot.writeString(self.bannerName)
12983 
      oprot.writeFieldEnd()
12984 
    oprot.writeFieldStop()
12985 
    oprot.writeStructEnd()
12986 
 
12987 
  def validate(self):
12988 
    return
12989 
 
12990 
 
12991 
  def __repr__(self):
12992 
    L = ['%s=%r' % (key, value)
12993 
      for key, value in self.__dict__.iteritems()]
12994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12995 
 
12996 
  def __eq__(self, other):
12997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12998 
 
12999 
  def __ne__(self, other):
13000 
    return not (self == other)
13001 
 
13002 
class deleteBannerMap_result:
13003 
  """
13004 
  Attributes:
13005 
   - success
13006 
  """
13007 
 
13008 
  thrift_spec = (
13009 
    (0, TType.BOOL, 'success', None, None, ), # 0
13010 
  )
13011 
 
13012 
  def __init__(self, success=None,):
13013 
    self.success = success
13014 
 
13015 
  def read(self, iprot):
13016 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13017 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13018 
      return
13019 
    iprot.readStructBegin()
13020 
    while True:
13021 
      (fname, ftype, fid) = iprot.readFieldBegin()
13022 
      if ftype == TType.STOP:
13023 
        break
13024 
      if fid == 0:
13025 
        if ftype == TType.BOOL:
13026 
          self.success = iprot.readBool();
13027 
        else:
13028 
          iprot.skip(ftype)
13029 
      else:
13030 
        iprot.skip(ftype)
13031 
      iprot.readFieldEnd()
13032 
    iprot.readStructEnd()
13033 
 
13034 
  def write(self, oprot):
13035 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13036 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13037 
      return
13038 
    oprot.writeStructBegin('deleteBannerMap_result')
13039 
    if self.success is not None:
13040 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13041 
      oprot.writeBool(self.success)
13042 
      oprot.writeFieldEnd()
13043 
    oprot.writeFieldStop()
13044 
    oprot.writeStructEnd()
13045 
 
13046 
  def validate(self):
13047 
    return
13048 
 
13049 
 
13050 
  def __repr__(self):
13051 
    L = ['%s=%r' % (key, value)
13052 
      for key, value in self.__dict__.iteritems()]
13053 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13054 
 
13055 
  def __eq__(self, other):
13056 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13057 
 
13058 
  def __ne__(self, other):
13059 
    return not (self == other)
13060 
 
13061 
class getBannerMapDetails_args:
13062 
  """
13063 
  Attributes:
13064 
   - bannerName
9155 kshitij.so 13065 
   - bannerType
6849 kshitij.so 13066 
  """
13067 
 
13068 
  thrift_spec = (
13069 
    None, # 0
13070 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 13071 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6849 kshitij.so 13072 
  )
13073 
 
9155 kshitij.so 13074 
  def __init__(self, bannerName=None, bannerType=None,):
6849 kshitij.so 13075 
    self.bannerName = bannerName
9155 kshitij.so 13076 
    self.bannerType = bannerType
6849 kshitij.so 13077 
 
13078 
  def read(self, iprot):
13079 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13080 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13081 
      return
13082 
    iprot.readStructBegin()
13083 
    while True:
13084 
      (fname, ftype, fid) = iprot.readFieldBegin()
13085 
      if ftype == TType.STOP:
13086 
        break
13087 
      if fid == 1:
13088 
        if ftype == TType.STRING:
13089 
          self.bannerName = iprot.readString();
13090 
        else:
13091 
          iprot.skip(ftype)
9155 kshitij.so 13092 
      elif fid == 2:
13093 
        if ftype == TType.I32:
13094 
          self.bannerType = iprot.readI32();
13095 
        else:
13096 
          iprot.skip(ftype)
6849 kshitij.so 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('getBannerMapDetails_args')
13107 
    if self.bannerName is not None:
13108 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
13109 
      oprot.writeString(self.bannerName)
13110 
      oprot.writeFieldEnd()
9155 kshitij.so 13111 
    if self.bannerType is not None:
13112 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
13113 
      oprot.writeI32(self.bannerType)
13114 
      oprot.writeFieldEnd()
6849 kshitij.so 13115 
    oprot.writeFieldStop()
13116 
    oprot.writeStructEnd()
13117 
 
13118 
  def validate(self):
13119 
    return
13120 
 
13121 
 
13122 
  def __repr__(self):
13123 
    L = ['%s=%r' % (key, value)
13124 
      for key, value in self.__dict__.iteritems()]
13125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13126 
 
13127 
  def __eq__(self, other):
13128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13129 
 
13130 
  def __ne__(self, other):
13131 
    return not (self == other)
13132 
 
13133 
class getBannerMapDetails_result:
13134 
  """
13135 
  Attributes:
13136 
   - success
13137 
  """
13138 
 
13139 
  thrift_spec = (
13140 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 0
13141 
  )
13142 
 
13143 
  def __init__(self, success=None,):
13144 
    self.success = success
13145 
 
13146 
  def read(self, iprot):
13147 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13148 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13149 
      return
13150 
    iprot.readStructBegin()
13151 
    while True:
13152 
      (fname, ftype, fid) = iprot.readFieldBegin()
13153 
      if ftype == TType.STOP:
13154 
        break
13155 
      if fid == 0:
13156 
        if ftype == TType.LIST:
13157 
          self.success = []
8590 kshitij.so 13158 
          (_etype228, _size225) = iprot.readListBegin()
13159 
          for _i229 in xrange(_size225):
13160 
            _elem230 = BannerMap()
13161 
            _elem230.read(iprot)
13162 
            self.success.append(_elem230)
6849 kshitij.so 13163 
          iprot.readListEnd()
13164 
        else:
13165 
          iprot.skip(ftype)
13166 
      else:
13167 
        iprot.skip(ftype)
13168 
      iprot.readFieldEnd()
13169 
    iprot.readStructEnd()
13170 
 
13171 
  def write(self, oprot):
13172 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13173 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13174 
      return
13175 
    oprot.writeStructBegin('getBannerMapDetails_result')
13176 
    if self.success is not None:
13177 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13178 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 13179 
      for iter231 in self.success:
13180 
        iter231.write(oprot)
6849 kshitij.so 13181 
      oprot.writeListEnd()
13182 
      oprot.writeFieldEnd()
13183 
    oprot.writeFieldStop()
13184 
    oprot.writeStructEnd()
13185 
 
13186 
  def validate(self):
13187 
    return
13188 
 
13189 
 
13190 
  def __repr__(self):
13191 
    L = ['%s=%r' % (key, value)
13192 
      for key, value in self.__dict__.iteritems()]
13193 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13194 
 
13195 
  def __eq__(self, other):
13196 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13197 
 
13198 
  def __ne__(self, other):
13199 
    return not (self == other)
13200 
 
8579 kshitij.so 13201 
class addBannerUri_args:
13202 
  """
13203 
  Attributes:
13204 
   - bannerUriMappings
13205 
  """
13206 
 
13207 
  thrift_spec = (
13208 
    None, # 0
13209 
    (1, TType.LIST, 'bannerUriMappings', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 1
13210 
  )
13211 
 
13212 
  def __init__(self, bannerUriMappings=None,):
13213 
    self.bannerUriMappings = bannerUriMappings
13214 
 
13215 
  def read(self, iprot):
13216 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13217 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13218 
      return
13219 
    iprot.readStructBegin()
13220 
    while True:
13221 
      (fname, ftype, fid) = iprot.readFieldBegin()
13222 
      if ftype == TType.STOP:
13223 
        break
13224 
      if fid == 1:
13225 
        if ftype == TType.LIST:
13226 
          self.bannerUriMappings = []
8590 kshitij.so 13227 
          (_etype235, _size232) = iprot.readListBegin()
13228 
          for _i236 in xrange(_size232):
13229 
            _elem237 = BannerUriMapping()
13230 
            _elem237.read(iprot)
13231 
            self.bannerUriMappings.append(_elem237)
8579 kshitij.so 13232 
          iprot.readListEnd()
13233 
        else:
13234 
          iprot.skip(ftype)
13235 
      else:
13236 
        iprot.skip(ftype)
13237 
      iprot.readFieldEnd()
13238 
    iprot.readStructEnd()
13239 
 
13240 
  def write(self, oprot):
13241 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13242 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13243 
      return
13244 
    oprot.writeStructBegin('addBannerUri_args')
13245 
    if self.bannerUriMappings is not None:
13246 
      oprot.writeFieldBegin('bannerUriMappings', TType.LIST, 1)
13247 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerUriMappings))
8590 kshitij.so 13248 
      for iter238 in self.bannerUriMappings:
13249 
        iter238.write(oprot)
8579 kshitij.so 13250 
      oprot.writeListEnd()
13251 
      oprot.writeFieldEnd()
13252 
    oprot.writeFieldStop()
13253 
    oprot.writeStructEnd()
13254 
 
13255 
  def validate(self):
13256 
    return
13257 
 
13258 
 
13259 
  def __repr__(self):
13260 
    L = ['%s=%r' % (key, value)
13261 
      for key, value in self.__dict__.iteritems()]
13262 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13263 
 
13264 
  def __eq__(self, other):
13265 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13266 
 
13267 
  def __ne__(self, other):
13268 
    return not (self == other)
13269 
 
13270 
class addBannerUri_result:
13271 
 
13272 
  thrift_spec = (
13273 
  )
13274 
 
13275 
  def read(self, iprot):
13276 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13277 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13278 
      return
13279 
    iprot.readStructBegin()
13280 
    while True:
13281 
      (fname, ftype, fid) = iprot.readFieldBegin()
13282 
      if ftype == TType.STOP:
13283 
        break
13284 
      else:
13285 
        iprot.skip(ftype)
13286 
      iprot.readFieldEnd()
13287 
    iprot.readStructEnd()
13288 
 
13289 
  def write(self, oprot):
13290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13292 
      return
13293 
    oprot.writeStructBegin('addBannerUri_result')
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 getUriMapping_args:
13313 
  """
13314 
  Attributes:
13315 
   - bannerName
9155 kshitij.so 13316 
   - bannerType
8579 kshitij.so 13317 
  """
13318 
 
13319 
  thrift_spec = (
13320 
    None, # 0
13321 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 13322 
    (2, TType.I32, 'bannerType', None, None, ), # 2
8579 kshitij.so 13323 
  )
13324 
 
9155 kshitij.so 13325 
  def __init__(self, bannerName=None, bannerType=None,):
8579 kshitij.so 13326 
    self.bannerName = bannerName
9155 kshitij.so 13327 
    self.bannerType = bannerType
8579 kshitij.so 13328 
 
13329 
  def read(self, iprot):
13330 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13331 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13332 
      return
13333 
    iprot.readStructBegin()
13334 
    while True:
13335 
      (fname, ftype, fid) = iprot.readFieldBegin()
13336 
      if ftype == TType.STOP:
13337 
        break
13338 
      if fid == 1:
13339 
        if ftype == TType.STRING:
13340 
          self.bannerName = iprot.readString();
13341 
        else:
13342 
          iprot.skip(ftype)
9155 kshitij.so 13343 
      elif fid == 2:
13344 
        if ftype == TType.I32:
13345 
          self.bannerType = iprot.readI32();
13346 
        else:
13347 
          iprot.skip(ftype)
8579 kshitij.so 13348 
      else:
13349 
        iprot.skip(ftype)
13350 
      iprot.readFieldEnd()
13351 
    iprot.readStructEnd()
13352 
 
13353 
  def write(self, oprot):
13354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13356 
      return
13357 
    oprot.writeStructBegin('getUriMapping_args')
13358 
    if self.bannerName is not None:
13359 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
13360 
      oprot.writeString(self.bannerName)
13361 
      oprot.writeFieldEnd()
9155 kshitij.so 13362 
    if self.bannerType is not None:
13363 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
13364 
      oprot.writeI32(self.bannerType)
13365 
      oprot.writeFieldEnd()
8579 kshitij.so 13366 
    oprot.writeFieldStop()
13367 
    oprot.writeStructEnd()
13368 
 
13369 
  def validate(self):
13370 
    return
13371 
 
13372 
 
13373 
  def __repr__(self):
13374 
    L = ['%s=%r' % (key, value)
13375 
      for key, value in self.__dict__.iteritems()]
13376 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13377 
 
13378 
  def __eq__(self, other):
13379 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13380 
 
13381 
  def __ne__(self, other):
13382 
    return not (self == other)
13383 
 
13384 
class getUriMapping_result:
13385 
  """
13386 
  Attributes:
13387 
   - success
13388 
  """
13389 
 
13390 
  thrift_spec = (
13391 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 0
13392 
  )
13393 
 
13394 
  def __init__(self, success=None,):
13395 
    self.success = success
13396 
 
13397 
  def read(self, iprot):
13398 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13399 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13400 
      return
13401 
    iprot.readStructBegin()
13402 
    while True:
13403 
      (fname, ftype, fid) = iprot.readFieldBegin()
13404 
      if ftype == TType.STOP:
13405 
        break
13406 
      if fid == 0:
13407 
        if ftype == TType.LIST:
13408 
          self.success = []
8590 kshitij.so 13409 
          (_etype242, _size239) = iprot.readListBegin()
13410 
          for _i243 in xrange(_size239):
13411 
            _elem244 = BannerUriMapping()
13412 
            _elem244.read(iprot)
13413 
            self.success.append(_elem244)
8579 kshitij.so 13414 
          iprot.readListEnd()
13415 
        else:
13416 
          iprot.skip(ftype)
13417 
      else:
13418 
        iprot.skip(ftype)
13419 
      iprot.readFieldEnd()
13420 
    iprot.readStructEnd()
13421 
 
13422 
  def write(self, oprot):
13423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13425 
      return
13426 
    oprot.writeStructBegin('getUriMapping_result')
13427 
    if self.success is not None:
13428 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13429 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 13430 
      for iter245 in self.success:
13431 
        iter245.write(oprot)
8579 kshitij.so 13432 
      oprot.writeListEnd()
13433 
      oprot.writeFieldEnd()
13434 
    oprot.writeFieldStop()
13435 
    oprot.writeStructEnd()
13436 
 
13437 
  def validate(self):
13438 
    return
13439 
 
13440 
 
13441 
  def __repr__(self):
13442 
    L = ['%s=%r' % (key, value)
13443 
      for key, value in self.__dict__.iteritems()]
13444 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13445 
 
13446 
  def __eq__(self, other):
13447 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13448 
 
13449 
  def __ne__(self, other):
13450 
    return not (self == other)
13451 
 
13452 
class addCampaign_args:
13453 
  """
13454 
  Attributes:
13455 
   - campaign
13456 
  """
13457 
 
13458 
  thrift_spec = (
13459 
    None, # 0
13460 
    (1, TType.STRUCT, 'campaign', (Campaign, Campaign.thrift_spec), None, ), # 1
13461 
  )
13462 
 
13463 
  def __init__(self, campaign=None,):
13464 
    self.campaign = campaign
13465 
 
13466 
  def read(self, iprot):
13467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13469 
      return
13470 
    iprot.readStructBegin()
13471 
    while True:
13472 
      (fname, ftype, fid) = iprot.readFieldBegin()
13473 
      if ftype == TType.STOP:
13474 
        break
13475 
      if fid == 1:
13476 
        if ftype == TType.STRUCT:
13477 
          self.campaign = Campaign()
13478 
          self.campaign.read(iprot)
13479 
        else:
13480 
          iprot.skip(ftype)
13481 
      else:
13482 
        iprot.skip(ftype)
13483 
      iprot.readFieldEnd()
13484 
    iprot.readStructEnd()
13485 
 
13486 
  def write(self, oprot):
13487 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13488 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13489 
      return
13490 
    oprot.writeStructBegin('addCampaign_args')
13491 
    if self.campaign is not None:
13492 
      oprot.writeFieldBegin('campaign', TType.STRUCT, 1)
13493 
      self.campaign.write(oprot)
13494 
      oprot.writeFieldEnd()
13495 
    oprot.writeFieldStop()
13496 
    oprot.writeStructEnd()
13497 
 
13498 
  def validate(self):
13499 
    return
13500 
 
13501 
 
13502 
  def __repr__(self):
13503 
    L = ['%s=%r' % (key, value)
13504 
      for key, value in self.__dict__.iteritems()]
13505 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13506 
 
13507 
  def __eq__(self, other):
13508 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13509 
 
13510 
  def __ne__(self, other):
13511 
    return not (self == other)
13512 
 
13513 
class addCampaign_result:
13514 
 
13515 
  thrift_spec = (
13516 
  )
13517 
 
13518 
  def read(self, iprot):
13519 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13520 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13521 
      return
13522 
    iprot.readStructBegin()
13523 
    while True:
13524 
      (fname, ftype, fid) = iprot.readFieldBegin()
13525 
      if ftype == TType.STOP:
13526 
        break
13527 
      else:
13528 
        iprot.skip(ftype)
13529 
      iprot.readFieldEnd()
13530 
    iprot.readStructEnd()
13531 
 
13532 
  def write(self, oprot):
13533 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13534 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13535 
      return
13536 
    oprot.writeStructBegin('addCampaign_result')
13537 
    oprot.writeFieldStop()
13538 
    oprot.writeStructEnd()
13539 
 
13540 
  def validate(self):
13541 
    return
13542 
 
13543 
 
13544 
  def __repr__(self):
13545 
    L = ['%s=%r' % (key, value)
13546 
      for key, value in self.__dict__.iteritems()]
13547 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13548 
 
13549 
  def __eq__(self, other):
13550 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13551 
 
13552 
  def __ne__(self, other):
13553 
    return not (self == other)
13554 
 
13555 
class getCampaigns_args:
13556 
  """
13557 
  Attributes:
13558 
   - campaignName
13559 
  """
13560 
 
13561 
  thrift_spec = (
13562 
    None, # 0
13563 
    (1, TType.STRING, 'campaignName', None, None, ), # 1
13564 
  )
13565 
 
13566 
  def __init__(self, campaignName=None,):
13567 
    self.campaignName = campaignName
13568 
 
13569 
  def read(self, iprot):
13570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13572 
      return
13573 
    iprot.readStructBegin()
13574 
    while True:
13575 
      (fname, ftype, fid) = iprot.readFieldBegin()
13576 
      if ftype == TType.STOP:
13577 
        break
13578 
      if fid == 1:
13579 
        if ftype == TType.STRING:
13580 
          self.campaignName = iprot.readString();
13581 
        else:
13582 
          iprot.skip(ftype)
13583 
      else:
13584 
        iprot.skip(ftype)
13585 
      iprot.readFieldEnd()
13586 
    iprot.readStructEnd()
13587 
 
13588 
  def write(self, oprot):
13589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13591 
      return
13592 
    oprot.writeStructBegin('getCampaigns_args')
13593 
    if self.campaignName is not None:
13594 
      oprot.writeFieldBegin('campaignName', TType.STRING, 1)
13595 
      oprot.writeString(self.campaignName)
13596 
      oprot.writeFieldEnd()
13597 
    oprot.writeFieldStop()
13598 
    oprot.writeStructEnd()
13599 
 
13600 
  def validate(self):
13601 
    return
13602 
 
13603 
 
13604 
  def __repr__(self):
13605 
    L = ['%s=%r' % (key, value)
13606 
      for key, value in self.__dict__.iteritems()]
13607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13608 
 
13609 
  def __eq__(self, other):
13610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13611 
 
13612 
  def __ne__(self, other):
13613 
    return not (self == other)
13614 
 
13615 
class getCampaigns_result:
13616 
  """
13617 
  Attributes:
13618 
   - success
13619 
  """
13620 
 
13621 
  thrift_spec = (
13622 
    (0, TType.LIST, 'success', (TType.STRUCT,(Campaign, Campaign.thrift_spec)), None, ), # 0
13623 
  )
13624 
 
13625 
  def __init__(self, success=None,):
13626 
    self.success = success
13627 
 
13628 
  def read(self, iprot):
13629 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13630 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13631 
      return
13632 
    iprot.readStructBegin()
13633 
    while True:
13634 
      (fname, ftype, fid) = iprot.readFieldBegin()
13635 
      if ftype == TType.STOP:
13636 
        break
13637 
      if fid == 0:
13638 
        if ftype == TType.LIST:
13639 
          self.success = []
8590 kshitij.so 13640 
          (_etype249, _size246) = iprot.readListBegin()
13641 
          for _i250 in xrange(_size246):
13642 
            _elem251 = Campaign()
13643 
            _elem251.read(iprot)
13644 
            self.success.append(_elem251)
8579 kshitij.so 13645 
          iprot.readListEnd()
13646 
        else:
13647 
          iprot.skip(ftype)
13648 
      else:
13649 
        iprot.skip(ftype)
13650 
      iprot.readFieldEnd()
13651 
    iprot.readStructEnd()
13652 
 
13653 
  def write(self, oprot):
13654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13656 
      return
13657 
    oprot.writeStructBegin('getCampaigns_result')
13658 
    if self.success is not None:
13659 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13660 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 13661 
      for iter252 in self.success:
13662 
        iter252.write(oprot)
8579 kshitij.so 13663 
      oprot.writeListEnd()
13664 
      oprot.writeFieldEnd()
13665 
    oprot.writeFieldStop()
13666 
    oprot.writeStructEnd()
13667 
 
13668 
  def validate(self):
13669 
    return
13670 
 
13671 
 
13672 
  def __repr__(self):
13673 
    L = ['%s=%r' % (key, value)
13674 
      for key, value in self.__dict__.iteritems()]
13675 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13676 
 
13677 
  def __eq__(self, other):
13678 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13679 
 
13680 
  def __ne__(self, other):
13681 
    return not (self == other)
13682 
 
13683 
class deleteCampaign_args:
13684 
  """
13685 
  Attributes:
13686 
   - campaignId
13687 
  """
13688 
 
13689 
  thrift_spec = (
13690 
    None, # 0
13691 
    (1, TType.I64, 'campaignId', None, None, ), # 1
13692 
  )
13693 
 
13694 
  def __init__(self, campaignId=None,):
13695 
    self.campaignId = campaignId
13696 
 
13697 
  def read(self, iprot):
13698 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13699 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13700 
      return
13701 
    iprot.readStructBegin()
13702 
    while True:
13703 
      (fname, ftype, fid) = iprot.readFieldBegin()
13704 
      if ftype == TType.STOP:
13705 
        break
13706 
      if fid == 1:
13707 
        if ftype == TType.I64:
13708 
          self.campaignId = iprot.readI64();
13709 
        else:
13710 
          iprot.skip(ftype)
13711 
      else:
13712 
        iprot.skip(ftype)
13713 
      iprot.readFieldEnd()
13714 
    iprot.readStructEnd()
13715 
 
13716 
  def write(self, oprot):
13717 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13718 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13719 
      return
13720 
    oprot.writeStructBegin('deleteCampaign_args')
13721 
    if self.campaignId is not None:
13722 
      oprot.writeFieldBegin('campaignId', TType.I64, 1)
13723 
      oprot.writeI64(self.campaignId)
13724 
      oprot.writeFieldEnd()
13725 
    oprot.writeFieldStop()
13726 
    oprot.writeStructEnd()
13727 
 
13728 
  def validate(self):
13729 
    return
13730 
 
13731 
 
13732 
  def __repr__(self):
13733 
    L = ['%s=%r' % (key, value)
13734 
      for key, value in self.__dict__.iteritems()]
13735 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13736 
 
13737 
  def __eq__(self, other):
13738 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13739 
 
13740 
  def __ne__(self, other):
13741 
    return not (self == other)
13742 
 
13743 
class deleteCampaign_result:
13744 
 
13745 
  thrift_spec = (
13746 
  )
13747 
 
13748 
  def read(self, iprot):
13749 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13750 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13751 
      return
13752 
    iprot.readStructBegin()
13753 
    while True:
13754 
      (fname, ftype, fid) = iprot.readFieldBegin()
13755 
      if ftype == TType.STOP:
13756 
        break
13757 
      else:
13758 
        iprot.skip(ftype)
13759 
      iprot.readFieldEnd()
13760 
    iprot.readStructEnd()
13761 
 
13762 
  def write(self, oprot):
13763 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13764 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13765 
      return
13766 
    oprot.writeStructBegin('deleteCampaign_result')
13767 
    oprot.writeFieldStop()
13768 
    oprot.writeStructEnd()
13769 
 
13770 
  def validate(self):
13771 
    return
13772 
 
13773 
 
13774 
  def __repr__(self):
13775 
    L = ['%s=%r' % (key, value)
13776 
      for key, value in self.__dict__.iteritems()]
13777 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13778 
 
13779 
  def __eq__(self, other):
13780 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13781 
 
13782 
  def __ne__(self, other):
13783 
    return not (self == other)
13784 
 
13785 
class getAllCampaigns_args:
13786 
 
13787 
  thrift_spec = (
13788 
  )
13789 
 
13790 
  def read(self, iprot):
13791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13793 
      return
13794 
    iprot.readStructBegin()
13795 
    while True:
13796 
      (fname, ftype, fid) = iprot.readFieldBegin()
13797 
      if ftype == TType.STOP:
13798 
        break
13799 
      else:
13800 
        iprot.skip(ftype)
13801 
      iprot.readFieldEnd()
13802 
    iprot.readStructEnd()
13803 
 
13804 
  def write(self, oprot):
13805 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13806 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13807 
      return
13808 
    oprot.writeStructBegin('getAllCampaigns_args')
13809 
    oprot.writeFieldStop()
13810 
    oprot.writeStructEnd()
13811 
 
13812 
  def validate(self):
13813 
    return
13814 
 
13815 
 
13816 
  def __repr__(self):
13817 
    L = ['%s=%r' % (key, value)
13818 
      for key, value in self.__dict__.iteritems()]
13819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13820 
 
13821 
  def __eq__(self, other):
13822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13823 
 
13824 
  def __ne__(self, other):
13825 
    return not (self == other)
13826 
 
13827 
class getAllCampaigns_result:
13828 
  """
13829 
  Attributes:
13830 
   - success
13831 
  """
13832 
 
13833 
  thrift_spec = (
13834 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
13835 
  )
13836 
 
13837 
  def __init__(self, success=None,):
13838 
    self.success = success
13839 
 
13840 
  def read(self, iprot):
13841 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13842 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13843 
      return
13844 
    iprot.readStructBegin()
13845 
    while True:
13846 
      (fname, ftype, fid) = iprot.readFieldBegin()
13847 
      if ftype == TType.STOP:
13848 
        break
13849 
      if fid == 0:
13850 
        if ftype == TType.LIST:
13851 
          self.success = []
8590 kshitij.so 13852 
          (_etype256, _size253) = iprot.readListBegin()
13853 
          for _i257 in xrange(_size253):
13854 
            _elem258 = iprot.readString();
13855 
            self.success.append(_elem258)
8579 kshitij.so 13856 
          iprot.readListEnd()
13857 
        else:
13858 
          iprot.skip(ftype)
13859 
      else:
13860 
        iprot.skip(ftype)
13861 
      iprot.readFieldEnd()
13862 
    iprot.readStructEnd()
13863 
 
13864 
  def write(self, oprot):
13865 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13866 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13867 
      return
13868 
    oprot.writeStructBegin('getAllCampaigns_result')
13869 
    if self.success is not None:
13870 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13871 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 13872 
      for iter259 in self.success:
13873 
        oprot.writeString(iter259)
8579 kshitij.so 13874 
      oprot.writeListEnd()
13875 
      oprot.writeFieldEnd()
13876 
    oprot.writeFieldStop()
13877 
    oprot.writeStructEnd()
13878 
 
13879 
  def validate(self):
13880 
    return
13881 
 
13882 
 
13883 
  def __repr__(self):
13884 
    L = ['%s=%r' % (key, value)
13885 
      for key, value in self.__dict__.iteritems()]
13886 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13887 
 
13888 
  def __eq__(self, other):
13889 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13890 
 
13891 
  def __ne__(self, other):
13892 
    return not (self == other)
13893 
 
9155 kshitij.so 13894 
class getActiveBannersForMobileSite_args:
13895 
 
13896 
  thrift_spec = (
13897 
  )
13898 
 
13899 
  def read(self, iprot):
13900 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13901 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13902 
      return
13903 
    iprot.readStructBegin()
13904 
    while True:
13905 
      (fname, ftype, fid) = iprot.readFieldBegin()
13906 
      if ftype == TType.STOP:
13907 
        break
13908 
      else:
13909 
        iprot.skip(ftype)
13910 
      iprot.readFieldEnd()
13911 
    iprot.readStructEnd()
13912 
 
13913 
  def write(self, oprot):
13914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13916 
      return
13917 
    oprot.writeStructBegin('getActiveBannersForMobileSite_args')
13918 
    oprot.writeFieldStop()
13919 
    oprot.writeStructEnd()
13920 
 
13921 
  def validate(self):
13922 
    return
13923 
 
13924 
 
13925 
  def __repr__(self):
13926 
    L = ['%s=%r' % (key, value)
13927 
      for key, value in self.__dict__.iteritems()]
13928 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13929 
 
13930 
  def __eq__(self, other):
13931 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13932 
 
13933 
  def __ne__(self, other):
13934 
    return not (self == other)
13935 
 
13936 
class getActiveBannersForMobileSite_result:
13937 
  """
13938 
  Attributes:
13939 
   - success
13940 
  """
13941 
 
13942 
  thrift_spec = (
13943 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
13944 
  )
13945 
 
13946 
  def __init__(self, success=None,):
13947 
    self.success = success
13948 
 
13949 
  def read(self, iprot):
13950 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13951 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13952 
      return
13953 
    iprot.readStructBegin()
13954 
    while True:
13955 
      (fname, ftype, fid) = iprot.readFieldBegin()
13956 
      if ftype == TType.STOP:
13957 
        break
13958 
      if fid == 0:
13959 
        if ftype == TType.MAP:
13960 
          self.success = {}
13961 
          (_ktype261, _vtype262, _size260 ) = iprot.readMapBegin()
13962 
          for _i264 in xrange(_size260):
13963 
            _key265 = iprot.readString();
13964 
            _val266 = []
13965 
            (_etype270, _size267) = iprot.readListBegin()
13966 
            for _i271 in xrange(_size267):
13967 
              _elem272 = Banner()
13968 
              _elem272.read(iprot)
13969 
              _val266.append(_elem272)
13970 
            iprot.readListEnd()
13971 
            self.success[_key265] = _val266
13972 
          iprot.readMapEnd()
13973 
        else:
13974 
          iprot.skip(ftype)
13975 
      else:
13976 
        iprot.skip(ftype)
13977 
      iprot.readFieldEnd()
13978 
    iprot.readStructEnd()
13979 
 
13980 
  def write(self, oprot):
13981 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13982 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13983 
      return
13984 
    oprot.writeStructBegin('getActiveBannersForMobileSite_result')
13985 
    if self.success is not None:
13986 
      oprot.writeFieldBegin('success', TType.MAP, 0)
13987 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
13988 
      for kiter273,viter274 in self.success.items():
13989 
        oprot.writeString(kiter273)
13990 
        oprot.writeListBegin(TType.STRUCT, len(viter274))
13991 
        for iter275 in viter274:
13992 
          iter275.write(oprot)
13993 
        oprot.writeListEnd()
13994 
      oprot.writeMapEnd()
13995 
      oprot.writeFieldEnd()
13996 
    oprot.writeFieldStop()
13997 
    oprot.writeStructEnd()
13998 
 
13999 
  def validate(self):
14000 
    return
14001 
 
14002 
 
14003 
  def __repr__(self):
14004 
    L = ['%s=%r' % (key, value)
14005 
      for key, value in self.__dict__.iteritems()]
14006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14007 
 
14008 
  def __eq__(self, other):
14009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14010 
 
14011 
  def __ne__(self, other):
14012 
    return not (self == other)
14013 
 
5944 mandeep.dh 14014 
class deleteSimilarItem_args:
14015 
  """
14016 
  Attributes:
14017 
   - itemId
14018 
   - catalogItemId
14019 
  """
14020 
 
14021 
  thrift_spec = (
14022 
    None, # 0
14023 
    (1, TType.I64, 'itemId', None, None, ), # 1
14024 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
14025 
  )
14026 
 
14027 
  def __init__(self, itemId=None, catalogItemId=None,):
14028 
    self.itemId = itemId
14029 
    self.catalogItemId = catalogItemId
14030 
 
14031 
  def read(self, iprot):
14032 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14033 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14034 
      return
14035 
    iprot.readStructBegin()
14036 
    while True:
14037 
      (fname, ftype, fid) = iprot.readFieldBegin()
14038 
      if ftype == TType.STOP:
14039 
        break
14040 
      if fid == 1:
14041 
        if ftype == TType.I64:
14042 
          self.itemId = iprot.readI64();
14043 
        else:
14044 
          iprot.skip(ftype)
14045 
      elif fid == 2:
14046 
        if ftype == TType.I64:
14047 
          self.catalogItemId = iprot.readI64();
14048 
        else:
14049 
          iprot.skip(ftype)
14050 
      else:
14051 
        iprot.skip(ftype)
14052 
      iprot.readFieldEnd()
14053 
    iprot.readStructEnd()
14054 
 
14055 
  def write(self, oprot):
14056 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14057 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14058 
      return
14059 
    oprot.writeStructBegin('deleteSimilarItem_args')
14060 
    if self.itemId is not None:
14061 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14062 
      oprot.writeI64(self.itemId)
14063 
      oprot.writeFieldEnd()
14064 
    if self.catalogItemId is not None:
14065 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
14066 
      oprot.writeI64(self.catalogItemId)
14067 
      oprot.writeFieldEnd()
14068 
    oprot.writeFieldStop()
14069 
    oprot.writeStructEnd()
14070 
 
14071 
  def validate(self):
14072 
    return
14073 
 
14074 
 
14075 
  def __repr__(self):
14076 
    L = ['%s=%r' % (key, value)
14077 
      for key, value in self.__dict__.iteritems()]
14078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14079 
 
14080 
  def __eq__(self, other):
14081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14082 
 
14083 
  def __ne__(self, other):
14084 
    return not (self == other)
14085 
 
14086 
class deleteSimilarItem_result:
14087 
  """
14088 
  Attributes:
14089 
   - success
14090 
   - cex
14091 
  """
14092 
 
14093 
  thrift_spec = (
14094 
    (0, TType.BOOL, 'success', None, None, ), # 0
14095 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14096 
  )
14097 
 
14098 
  def __init__(self, success=None, cex=None,):
14099 
    self.success = success
14100 
    self.cex = cex
14101 
 
14102 
  def read(self, iprot):
14103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14105 
      return
14106 
    iprot.readStructBegin()
14107 
    while True:
14108 
      (fname, ftype, fid) = iprot.readFieldBegin()
14109 
      if ftype == TType.STOP:
14110 
        break
14111 
      if fid == 0:
14112 
        if ftype == TType.BOOL:
14113 
          self.success = iprot.readBool();
14114 
        else:
14115 
          iprot.skip(ftype)
14116 
      elif fid == 1:
14117 
        if ftype == TType.STRUCT:
14118 
          self.cex = CatalogServiceException()
14119 
          self.cex.read(iprot)
14120 
        else:
14121 
          iprot.skip(ftype)
14122 
      else:
14123 
        iprot.skip(ftype)
14124 
      iprot.readFieldEnd()
14125 
    iprot.readStructEnd()
14126 
 
14127 
  def write(self, oprot):
14128 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14129 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14130 
      return
14131 
    oprot.writeStructBegin('deleteSimilarItem_result')
14132 
    if self.success is not None:
14133 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14134 
      oprot.writeBool(self.success)
14135 
      oprot.writeFieldEnd()
14136 
    if self.cex is not None:
14137 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14138 
      self.cex.write(oprot)
14139 
      oprot.writeFieldEnd()
14140 
    oprot.writeFieldStop()
14141 
    oprot.writeStructEnd()
14142 
 
14143 
  def validate(self):
14144 
    return
14145 
 
14146 
 
14147 
  def __repr__(self):
14148 
    L = ['%s=%r' % (key, value)
14149 
      for key, value in self.__dict__.iteritems()]
14150 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14151 
 
14152 
  def __eq__(self, other):
14153 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14154 
 
14155 
  def __ne__(self, other):
14156 
    return not (self == other)
14157 
 
14158 
class checkSimilarItem_args:
14159 
  """
14160 
  Attributes:
14161 
   - brand
14162 
   - modelNumber
14163 
   - modelName
14164 
   - color
14165 
  """
14166 
 
14167 
  thrift_spec = (
14168 
    None, # 0
14169 
    (1, TType.STRING, 'brand', None, None, ), # 1
14170 
    (2, TType.STRING, 'modelNumber', None, None, ), # 2
14171 
    (3, TType.STRING, 'modelName', None, None, ), # 3
14172 
    (4, TType.STRING, 'color', None, None, ), # 4
14173 
  )
14174 
 
14175 
  def __init__(self, brand=None, modelNumber=None, modelName=None, color=None,):
14176 
    self.brand = brand
14177 
    self.modelNumber = modelNumber
14178 
    self.modelName = modelName
14179 
    self.color = color
14180 
 
14181 
  def read(self, iprot):
14182 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14183 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14184 
      return
14185 
    iprot.readStructBegin()
14186 
    while True:
14187 
      (fname, ftype, fid) = iprot.readFieldBegin()
14188 
      if ftype == TType.STOP:
14189 
        break
14190 
      if fid == 1:
14191 
        if ftype == TType.STRING:
14192 
          self.brand = iprot.readString();
14193 
        else:
14194 
          iprot.skip(ftype)
14195 
      elif fid == 2:
14196 
        if ftype == TType.STRING:
14197 
          self.modelNumber = iprot.readString();
14198 
        else:
14199 
          iprot.skip(ftype)
14200 
      elif fid == 3:
14201 
        if ftype == TType.STRING:
14202 
          self.modelName = iprot.readString();
14203 
        else:
14204 
          iprot.skip(ftype)
14205 
      elif fid == 4:
14206 
        if ftype == TType.STRING:
14207 
          self.color = iprot.readString();
14208 
        else:
14209 
          iprot.skip(ftype)
14210 
      else:
14211 
        iprot.skip(ftype)
14212 
      iprot.readFieldEnd()
14213 
    iprot.readStructEnd()
14214 
 
14215 
  def write(self, oprot):
14216 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14217 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14218 
      return
14219 
    oprot.writeStructBegin('checkSimilarItem_args')
14220 
    if self.brand is not None:
14221 
      oprot.writeFieldBegin('brand', TType.STRING, 1)
14222 
      oprot.writeString(self.brand)
14223 
      oprot.writeFieldEnd()
14224 
    if self.modelNumber is not None:
14225 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 2)
14226 
      oprot.writeString(self.modelNumber)
14227 
      oprot.writeFieldEnd()
14228 
    if self.modelName is not None:
14229 
      oprot.writeFieldBegin('modelName', TType.STRING, 3)
14230 
      oprot.writeString(self.modelName)
14231 
      oprot.writeFieldEnd()
14232 
    if self.color is not None:
14233 
      oprot.writeFieldBegin('color', TType.STRING, 4)
14234 
      oprot.writeString(self.color)
14235 
      oprot.writeFieldEnd()
14236 
    oprot.writeFieldStop()
14237 
    oprot.writeStructEnd()
14238 
 
14239 
  def validate(self):
14240 
    return
14241 
 
14242 
 
14243 
  def __repr__(self):
14244 
    L = ['%s=%r' % (key, value)
14245 
      for key, value in self.__dict__.iteritems()]
14246 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14247 
 
14248 
  def __eq__(self, other):
14249 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14250 
 
14251 
  def __ne__(self, other):
14252 
    return not (self == other)
14253 
 
14254 
class checkSimilarItem_result:
14255 
  """
14256 
  Attributes:
14257 
   - success
14258 
  """
14259 
 
14260 
  thrift_spec = (
14261 
    (0, TType.I64, 'success', None, None, ), # 0
14262 
  )
14263 
 
14264 
  def __init__(self, success=None,):
14265 
    self.success = success
14266 
 
14267 
  def read(self, iprot):
14268 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14269 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14270 
      return
14271 
    iprot.readStructBegin()
14272 
    while True:
14273 
      (fname, ftype, fid) = iprot.readFieldBegin()
14274 
      if ftype == TType.STOP:
14275 
        break
14276 
      if fid == 0:
14277 
        if ftype == TType.I64:
14278 
          self.success = iprot.readI64();
14279 
        else:
14280 
          iprot.skip(ftype)
14281 
      else:
14282 
        iprot.skip(ftype)
14283 
      iprot.readFieldEnd()
14284 
    iprot.readStructEnd()
14285 
 
14286 
  def write(self, oprot):
14287 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14288 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14289 
      return
14290 
    oprot.writeStructBegin('checkSimilarItem_result')
14291 
    if self.success is not None:
14292 
      oprot.writeFieldBegin('success', TType.I64, 0)
14293 
      oprot.writeI64(self.success)
14294 
      oprot.writeFieldEnd()
14295 
    oprot.writeFieldStop()
14296 
    oprot.writeStructEnd()
14297 
 
14298 
  def validate(self):
14299 
    return
14300 
 
14301 
 
14302 
  def __repr__(self):
14303 
    L = ['%s=%r' % (key, value)
14304 
      for key, value in self.__dict__.iteritems()]
14305 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14306 
 
14307 
  def __eq__(self, other):
14308 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14309 
 
14310 
  def __ne__(self, other):
14311 
    return not (self == other)
14312 
 
14313 
class validateRiskyStatus_args:
14314 
  """
14315 
  Attributes:
14316 
   - itemId
14317 
  """
14318 
 
14319 
  thrift_spec = (
14320 
    None, # 0
14321 
    (1, TType.I64, 'itemId', None, None, ), # 1
14322 
  )
14323 
 
14324 
  def __init__(self, itemId=None,):
14325 
    self.itemId = itemId
14326 
 
14327 
  def read(self, iprot):
14328 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14329 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14330 
      return
14331 
    iprot.readStructBegin()
14332 
    while True:
14333 
      (fname, ftype, fid) = iprot.readFieldBegin()
14334 
      if ftype == TType.STOP:
14335 
        break
14336 
      if fid == 1:
14337 
        if ftype == TType.I64:
14338 
          self.itemId = iprot.readI64();
14339 
        else:
14340 
          iprot.skip(ftype)
14341 
      else:
14342 
        iprot.skip(ftype)
14343 
      iprot.readFieldEnd()
14344 
    iprot.readStructEnd()
14345 
 
14346 
  def write(self, oprot):
14347 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14348 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14349 
      return
14350 
    oprot.writeStructBegin('validateRiskyStatus_args')
14351 
    if self.itemId is not None:
14352 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14353 
      oprot.writeI64(self.itemId)
14354 
      oprot.writeFieldEnd()
14355 
    oprot.writeFieldStop()
14356 
    oprot.writeStructEnd()
14357 
 
14358 
  def validate(self):
14359 
    return
14360 
 
14361 
 
14362 
  def __repr__(self):
14363 
    L = ['%s=%r' % (key, value)
14364 
      for key, value in self.__dict__.iteritems()]
14365 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14366 
 
14367 
  def __eq__(self, other):
14368 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14369 
 
14370 
  def __ne__(self, other):
14371 
    return not (self == other)
14372 
 
14373 
class validateRiskyStatus_result:
14374 
 
14375 
  thrift_spec = (
14376 
  )
14377 
 
14378 
  def read(self, iprot):
14379 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14380 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14381 
      return
14382 
    iprot.readStructBegin()
14383 
    while True:
14384 
      (fname, ftype, fid) = iprot.readFieldBegin()
14385 
      if ftype == TType.STOP:
14386 
        break
14387 
      else:
14388 
        iprot.skip(ftype)
14389 
      iprot.readFieldEnd()
14390 
    iprot.readStructEnd()
14391 
 
14392 
  def write(self, oprot):
14393 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14394 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14395 
      return
14396 
    oprot.writeStructBegin('validateRiskyStatus_result')
14397 
    oprot.writeFieldStop()
14398 
    oprot.writeStructEnd()
14399 
 
14400 
  def validate(self):
14401 
    return
14402 
 
14403 
 
14404 
  def __repr__(self):
14405 
    L = ['%s=%r' % (key, value)
14406 
      for key, value in self.__dict__.iteritems()]
14407 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14408 
 
14409 
  def __eq__(self, other):
14410 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14411 
 
14412 
  def __ne__(self, other):
14413 
    return not (self == other)
14414 
 
14415 
class changeItemRiskyFlag_args:
14416 
  """
14417 
  Attributes:
14418 
   - itemId
14419 
   - risky
14420 
  """
14421 
 
14422 
  thrift_spec = (
14423 
    None, # 0
14424 
    (1, TType.I64, 'itemId', None, None, ), # 1
14425 
    (2, TType.BOOL, 'risky', None, None, ), # 2
14426 
  )
14427 
 
14428 
  def __init__(self, itemId=None, risky=None,):
14429 
    self.itemId = itemId
14430 
    self.risky = risky
14431 
 
14432 
  def read(self, iprot):
14433 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14434 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14435 
      return
14436 
    iprot.readStructBegin()
14437 
    while True:
14438 
      (fname, ftype, fid) = iprot.readFieldBegin()
14439 
      if ftype == TType.STOP:
14440 
        break
14441 
      if fid == 1:
14442 
        if ftype == TType.I64:
14443 
          self.itemId = iprot.readI64();
14444 
        else:
14445 
          iprot.skip(ftype)
14446 
      elif fid == 2:
14447 
        if ftype == TType.BOOL:
14448 
          self.risky = iprot.readBool();
14449 
        else:
14450 
          iprot.skip(ftype)
14451 
      else:
14452 
        iprot.skip(ftype)
14453 
      iprot.readFieldEnd()
14454 
    iprot.readStructEnd()
14455 
 
14456 
  def write(self, oprot):
14457 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14458 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14459 
      return
14460 
    oprot.writeStructBegin('changeItemRiskyFlag_args')
14461 
    if self.itemId is not None:
14462 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14463 
      oprot.writeI64(self.itemId)
14464 
      oprot.writeFieldEnd()
14465 
    if self.risky is not None:
14466 
      oprot.writeFieldBegin('risky', TType.BOOL, 2)
14467 
      oprot.writeBool(self.risky)
14468 
      oprot.writeFieldEnd()
14469 
    oprot.writeFieldStop()
14470 
    oprot.writeStructEnd()
14471 
 
14472 
  def validate(self):
14473 
    return
14474 
 
14475 
 
14476 
  def __repr__(self):
14477 
    L = ['%s=%r' % (key, value)
14478 
      for key, value in self.__dict__.iteritems()]
14479 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14480 
 
14481 
  def __eq__(self, other):
14482 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14483 
 
14484 
  def __ne__(self, other):
14485 
    return not (self == other)
14486 
 
14487 
class changeItemRiskyFlag_result:
14488 
 
14489 
  thrift_spec = (
14490 
  )
14491 
 
14492 
  def read(self, iprot):
14493 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14494 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14495 
      return
14496 
    iprot.readStructBegin()
14497 
    while True:
14498 
      (fname, ftype, fid) = iprot.readFieldBegin()
14499 
      if ftype == TType.STOP:
14500 
        break
14501 
      else:
14502 
        iprot.skip(ftype)
14503 
      iprot.readFieldEnd()
14504 
    iprot.readStructEnd()
14505 
 
14506 
  def write(self, oprot):
14507 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14508 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14509 
      return
14510 
    oprot.writeStructBegin('changeItemRiskyFlag_result')
14511 
    oprot.writeFieldStop()
14512 
    oprot.writeStructEnd()
14513 
 
14514 
  def validate(self):
14515 
    return
14516 
 
14517 
 
14518 
  def __repr__(self):
14519 
    L = ['%s=%r' % (key, value)
14520 
      for key, value in self.__dict__.iteritems()]
14521 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14522 
 
14523 
  def __eq__(self, other):
14524 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14525 
 
14526 
  def __ne__(self, other):
14527 
    return not (self == other)
14528 
 
14529 
class getItemsByRiskyFlag_args:
14530 
 
14531 
  thrift_spec = (
14532 
  )
14533 
 
14534 
  def read(self, iprot):
14535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14537 
      return
14538 
    iprot.readStructBegin()
14539 
    while True:
14540 
      (fname, ftype, fid) = iprot.readFieldBegin()
14541 
      if ftype == TType.STOP:
14542 
        break
14543 
      else:
14544 
        iprot.skip(ftype)
14545 
      iprot.readFieldEnd()
14546 
    iprot.readStructEnd()
14547 
 
14548 
  def write(self, oprot):
14549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14551 
      return
14552 
    oprot.writeStructBegin('getItemsByRiskyFlag_args')
14553 
    oprot.writeFieldStop()
14554 
    oprot.writeStructEnd()
14555 
 
14556 
  def validate(self):
14557 
    return
14558 
 
14559 
 
14560 
  def __repr__(self):
14561 
    L = ['%s=%r' % (key, value)
14562 
      for key, value in self.__dict__.iteritems()]
14563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14564 
 
14565 
  def __eq__(self, other):
14566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14567 
 
14568 
  def __ne__(self, other):
14569 
    return not (self == other)
14570 
 
14571 
class getItemsByRiskyFlag_result:
14572 
  """
14573 
  Attributes:
14574 
   - success
14575 
  """
14576 
 
14577 
  thrift_spec = (
14578 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
14579 
  )
14580 
 
14581 
  def __init__(self, success=None,):
14582 
    self.success = success
14583 
 
14584 
  def read(self, iprot):
14585 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14586 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14587 
      return
14588 
    iprot.readStructBegin()
14589 
    while True:
14590 
      (fname, ftype, fid) = iprot.readFieldBegin()
14591 
      if ftype == TType.STOP:
14592 
        break
14593 
      if fid == 0:
14594 
        if ftype == TType.LIST:
14595 
          self.success = []
9155 kshitij.so 14596 
          (_etype279, _size276) = iprot.readListBegin()
14597 
          for _i280 in xrange(_size276):
14598 
            _elem281 = Item()
14599 
            _elem281.read(iprot)
14600 
            self.success.append(_elem281)
5944 mandeep.dh 14601 
          iprot.readListEnd()
14602 
        else:
14603 
          iprot.skip(ftype)
14604 
      else:
14605 
        iprot.skip(ftype)
14606 
      iprot.readFieldEnd()
14607 
    iprot.readStructEnd()
14608 
 
14609 
  def write(self, oprot):
14610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14612 
      return
14613 
    oprot.writeStructBegin('getItemsByRiskyFlag_result')
14614 
    if self.success is not None:
14615 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14616 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 14617 
      for iter282 in self.success:
14618 
        iter282.write(oprot)
5944 mandeep.dh 14619 
      oprot.writeListEnd()
14620 
      oprot.writeFieldEnd()
14621 
    oprot.writeFieldStop()
14622 
    oprot.writeStructEnd()
14623 
 
14624 
  def validate(self):
14625 
    return
14626 
 
14627 
 
14628 
  def __repr__(self):
14629 
    L = ['%s=%r' % (key, value)
14630 
      for key, value in self.__dict__.iteritems()]
14631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14632 
 
14633 
  def __eq__(self, other):
14634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14635 
 
14636 
  def __ne__(self, other):
14637 
    return not (self == other)
14638 
 
14639 
class getItemsForMasterSheet_args:
14640 
  """
14641 
  Attributes:
14642 
   - category
14643 
   - brand
14644 
  """
14645 
 
14646 
  thrift_spec = (
14647 
    None, # 0
14648 
    (1, TType.STRING, 'category', None, None, ), # 1
14649 
    (2, TType.STRING, 'brand', None, None, ), # 2
14650 
  )
14651 
 
14652 
  def __init__(self, category=None, brand=None,):
14653 
    self.category = category
14654 
    self.brand = brand
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 == 1:
14666 
        if ftype == TType.STRING:
14667 
          self.category = iprot.readString();
14668 
        else:
14669 
          iprot.skip(ftype)
14670 
      elif fid == 2:
14671 
        if ftype == TType.STRING:
14672 
          self.brand = iprot.readString();
14673 
        else:
14674 
          iprot.skip(ftype)
14675 
      else:
14676 
        iprot.skip(ftype)
14677 
      iprot.readFieldEnd()
14678 
    iprot.readStructEnd()
14679 
 
14680 
  def write(self, oprot):
14681 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14682 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14683 
      return
14684 
    oprot.writeStructBegin('getItemsForMasterSheet_args')
14685 
    if self.category is not None:
14686 
      oprot.writeFieldBegin('category', TType.STRING, 1)
14687 
      oprot.writeString(self.category)
14688 
      oprot.writeFieldEnd()
14689 
    if self.brand is not None:
14690 
      oprot.writeFieldBegin('brand', TType.STRING, 2)
14691 
      oprot.writeString(self.brand)
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 getItemsForMasterSheet_result:
14712 
  """
14713 
  Attributes:
14714 
   - success
14715 
  """
14716 
 
14717 
  thrift_spec = (
14718 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
14719 
  )
14720 
 
14721 
  def __init__(self, success=None,):
14722 
    self.success = success
14723 
 
14724 
  def read(self, iprot):
14725 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14726 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14727 
      return
14728 
    iprot.readStructBegin()
14729 
    while True:
14730 
      (fname, ftype, fid) = iprot.readFieldBegin()
14731 
      if ftype == TType.STOP:
14732 
        break
14733 
      if fid == 0:
14734 
        if ftype == TType.LIST:
14735 
          self.success = []
9155 kshitij.so 14736 
          (_etype286, _size283) = iprot.readListBegin()
14737 
          for _i287 in xrange(_size283):
14738 
            _elem288 = Item()
14739 
            _elem288.read(iprot)
14740 
            self.success.append(_elem288)
5944 mandeep.dh 14741 
          iprot.readListEnd()
14742 
        else:
14743 
          iprot.skip(ftype)
14744 
      else:
14745 
        iprot.skip(ftype)
14746 
      iprot.readFieldEnd()
14747 
    iprot.readStructEnd()
14748 
 
14749 
  def write(self, oprot):
14750 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14751 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14752 
      return
14753 
    oprot.writeStructBegin('getItemsForMasterSheet_result')
14754 
    if self.success is not None:
14755 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14756 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 14757 
      for iter289 in self.success:
14758 
        iter289.write(oprot)
5944 mandeep.dh 14759 
      oprot.writeListEnd()
14760 
      oprot.writeFieldEnd()
14761 
    oprot.writeFieldStop()
14762 
    oprot.writeStructEnd()
14763 
 
14764 
  def validate(self):
14765 
    return
14766 
 
14767 
 
14768 
  def __repr__(self):
14769 
    L = ['%s=%r' % (key, value)
14770 
      for key, value in self.__dict__.iteritems()]
14771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14772 
 
14773 
  def __eq__(self, other):
14774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14775 
 
14776 
  def __ne__(self, other):
14777 
    return not (self == other)
14778 
 
14779 
class getSimilarItemsCatalogIds_args:
14780 
  """
14781 
  Attributes:
14782 
   - beginIndex
14783 
   - totalItems
14784 
   - itemId
14785 
  """
14786 
 
14787 
  thrift_spec = (
14788 
    None, # 0
14789 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
14790 
    (2, TType.I64, 'totalItems', None, None, ), # 2
14791 
    (3, TType.I64, 'itemId', None, None, ), # 3
14792 
  )
14793 
 
14794 
  def __init__(self, beginIndex=None, totalItems=None, itemId=None,):
14795 
    self.beginIndex = beginIndex
14796 
    self.totalItems = totalItems
14797 
    self.itemId = itemId
14798 
 
14799 
  def read(self, iprot):
14800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14802 
      return
14803 
    iprot.readStructBegin()
14804 
    while True:
14805 
      (fname, ftype, fid) = iprot.readFieldBegin()
14806 
      if ftype == TType.STOP:
14807 
        break
14808 
      if fid == 1:
14809 
        if ftype == TType.I64:
14810 
          self.beginIndex = iprot.readI64();
14811 
        else:
14812 
          iprot.skip(ftype)
14813 
      elif fid == 2:
14814 
        if ftype == TType.I64:
14815 
          self.totalItems = iprot.readI64();
14816 
        else:
14817 
          iprot.skip(ftype)
14818 
      elif fid == 3:
14819 
        if ftype == TType.I64:
14820 
          self.itemId = iprot.readI64();
14821 
        else:
14822 
          iprot.skip(ftype)
14823 
      else:
14824 
        iprot.skip(ftype)
14825 
      iprot.readFieldEnd()
14826 
    iprot.readStructEnd()
14827 
 
14828 
  def write(self, oprot):
14829 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14830 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14831 
      return
14832 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_args')
14833 
    if self.beginIndex is not None:
14834 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
14835 
      oprot.writeI64(self.beginIndex)
14836 
      oprot.writeFieldEnd()
14837 
    if self.totalItems is not None:
14838 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
14839 
      oprot.writeI64(self.totalItems)
14840 
      oprot.writeFieldEnd()
14841 
    if self.itemId is not None:
14842 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
14843 
      oprot.writeI64(self.itemId)
14844 
      oprot.writeFieldEnd()
14845 
    oprot.writeFieldStop()
14846 
    oprot.writeStructEnd()
14847 
 
14848 
  def validate(self):
14849 
    return
14850 
 
14851 
 
14852 
  def __repr__(self):
14853 
    L = ['%s=%r' % (key, value)
14854 
      for key, value in self.__dict__.iteritems()]
14855 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14856 
 
14857 
  def __eq__(self, other):
14858 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14859 
 
14860 
  def __ne__(self, other):
14861 
    return not (self == other)
14862 
 
14863 
class getSimilarItemsCatalogIds_result:
14864 
  """
14865 
  Attributes:
14866 
   - success
14867 
  """
14868 
 
14869 
  thrift_spec = (
14870 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
14871 
  )
14872 
 
14873 
  def __init__(self, success=None,):
14874 
    self.success = success
14875 
 
14876 
  def read(self, iprot):
14877 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14878 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14879 
      return
14880 
    iprot.readStructBegin()
14881 
    while True:
14882 
      (fname, ftype, fid) = iprot.readFieldBegin()
14883 
      if ftype == TType.STOP:
14884 
        break
14885 
      if fid == 0:
14886 
        if ftype == TType.LIST:
14887 
          self.success = []
9155 kshitij.so 14888 
          (_etype293, _size290) = iprot.readListBegin()
14889 
          for _i294 in xrange(_size290):
14890 
            _elem295 = iprot.readI64();
14891 
            self.success.append(_elem295)
5944 mandeep.dh 14892 
          iprot.readListEnd()
14893 
        else:
14894 
          iprot.skip(ftype)
14895 
      else:
14896 
        iprot.skip(ftype)
14897 
      iprot.readFieldEnd()
14898 
    iprot.readStructEnd()
14899 
 
14900 
  def write(self, oprot):
14901 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14902 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14903 
      return
14904 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_result')
14905 
    if self.success is not None:
14906 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14907 
      oprot.writeListBegin(TType.I64, len(self.success))
9155 kshitij.so 14908 
      for iter296 in self.success:
14909 
        oprot.writeI64(iter296)
5944 mandeep.dh 14910 
      oprot.writeListEnd()
14911 
      oprot.writeFieldEnd()
14912 
    oprot.writeFieldStop()
14913 
    oprot.writeStructEnd()
14914 
 
14915 
  def validate(self):
14916 
    return
14917 
 
14918 
 
14919 
  def __repr__(self):
14920 
    L = ['%s=%r' % (key, value)
14921 
      for key, value in self.__dict__.iteritems()]
14922 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14923 
 
14924 
  def __eq__(self, other):
14925 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14926 
 
14927 
  def __ne__(self, other):
14928 
    return not (self == other)
14929 
 
14930 
class addProductNotification_args:
14931 
  """
14932 
  Attributes:
14933 
   - itemId
14934 
   - email
14935 
  """
14936 
 
14937 
  thrift_spec = None
14938 
  def __init__(self, itemId=None, email=None,):
14939 
    self.itemId = itemId
14940 
    self.email = email
14941 
 
14942 
  def read(self, iprot):
14943 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14944 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14945 
      return
14946 
    iprot.readStructBegin()
14947 
    while True:
14948 
      (fname, ftype, fid) = iprot.readFieldBegin()
14949 
      if ftype == TType.STOP:
14950 
        break
14951 
      if fid == -1:
14952 
        if ftype == TType.I64:
14953 
          self.itemId = iprot.readI64();
14954 
        else:
14955 
          iprot.skip(ftype)
14956 
      elif fid == -2:
14957 
        if ftype == TType.STRING:
14958 
          self.email = iprot.readString();
14959 
        else:
14960 
          iprot.skip(ftype)
14961 
      else:
14962 
        iprot.skip(ftype)
14963 
      iprot.readFieldEnd()
14964 
    iprot.readStructEnd()
14965 
 
14966 
  def write(self, oprot):
14967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14969 
      return
14970 
    oprot.writeStructBegin('addProductNotification_args')
14971 
    if self.email is not None:
14972 
      oprot.writeFieldBegin('email', TType.STRING, -2)
14973 
      oprot.writeString(self.email)
14974 
      oprot.writeFieldEnd()
14975 
    if self.itemId is not None:
14976 
      oprot.writeFieldBegin('itemId', TType.I64, -1)
14977 
      oprot.writeI64(self.itemId)
14978 
      oprot.writeFieldEnd()
14979 
    oprot.writeFieldStop()
14980 
    oprot.writeStructEnd()
14981 
 
14982 
  def validate(self):
14983 
    return
14984 
 
14985 
 
14986 
  def __repr__(self):
14987 
    L = ['%s=%r' % (key, value)
14988 
      for key, value in self.__dict__.iteritems()]
14989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14990 
 
14991 
  def __eq__(self, other):
14992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14993 
 
14994 
  def __ne__(self, other):
14995 
    return not (self == other)
14996 
 
14997 
class addProductNotification_result:
14998 
  """
14999 
  Attributes:
15000 
   - success
15001 
  """
15002 
 
15003 
  thrift_spec = (
15004 
    (0, TType.BOOL, 'success', None, None, ), # 0
15005 
  )
15006 
 
15007 
  def __init__(self, success=None,):
15008 
    self.success = success
15009 
 
15010 
  def read(self, iprot):
15011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15013 
      return
15014 
    iprot.readStructBegin()
15015 
    while True:
15016 
      (fname, ftype, fid) = iprot.readFieldBegin()
15017 
      if ftype == TType.STOP:
15018 
        break
15019 
      if fid == 0:
15020 
        if ftype == TType.BOOL:
15021 
          self.success = iprot.readBool();
15022 
        else:
15023 
          iprot.skip(ftype)
15024 
      else:
15025 
        iprot.skip(ftype)
15026 
      iprot.readFieldEnd()
15027 
    iprot.readStructEnd()
15028 
 
15029 
  def write(self, oprot):
15030 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15031 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15032 
      return
15033 
    oprot.writeStructBegin('addProductNotification_result')
15034 
    if self.success is not None:
15035 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15036 
      oprot.writeBool(self.success)
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 sendProductNotifications_args:
15057 
 
15058 
  thrift_spec = (
15059 
  )
15060 
 
15061 
  def read(self, iprot):
15062 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15063 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15064 
      return
15065 
    iprot.readStructBegin()
15066 
    while True:
15067 
      (fname, ftype, fid) = iprot.readFieldBegin()
15068 
      if ftype == TType.STOP:
15069 
        break
15070 
      else:
15071 
        iprot.skip(ftype)
15072 
      iprot.readFieldEnd()
15073 
    iprot.readStructEnd()
15074 
 
15075 
  def write(self, oprot):
15076 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15077 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15078 
      return
15079 
    oprot.writeStructBegin('sendProductNotifications_args')
15080 
    oprot.writeFieldStop()
15081 
    oprot.writeStructEnd()
15082 
 
15083 
  def validate(self):
15084 
    return
15085 
 
15086 
 
15087 
  def __repr__(self):
15088 
    L = ['%s=%r' % (key, value)
15089 
      for key, value in self.__dict__.iteritems()]
15090 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15091 
 
15092 
  def __eq__(self, other):
15093 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15094 
 
15095 
  def __ne__(self, other):
15096 
    return not (self == other)
15097 
 
15098 
class sendProductNotifications_result:
15099 
  """
15100 
  Attributes:
15101 
   - success
15102 
  """
15103 
 
15104 
  thrift_spec = (
15105 
    (0, TType.BOOL, 'success', None, None, ), # 0
15106 
  )
15107 
 
15108 
  def __init__(self, success=None,):
15109 
    self.success = success
15110 
 
15111 
  def read(self, iprot):
15112 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15113 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15114 
      return
15115 
    iprot.readStructBegin()
15116 
    while True:
15117 
      (fname, ftype, fid) = iprot.readFieldBegin()
15118 
      if ftype == TType.STOP:
15119 
        break
15120 
      if fid == 0:
15121 
        if ftype == TType.BOOL:
15122 
          self.success = iprot.readBool();
15123 
        else:
15124 
          iprot.skip(ftype)
15125 
      else:
15126 
        iprot.skip(ftype)
15127 
      iprot.readFieldEnd()
15128 
    iprot.readStructEnd()
15129 
 
15130 
  def write(self, oprot):
15131 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15132 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15133 
      return
15134 
    oprot.writeStructBegin('sendProductNotifications_result')
15135 
    if self.success is not None:
15136 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15137 
      oprot.writeBool(self.success)
15138 
      oprot.writeFieldEnd()
15139 
    oprot.writeFieldStop()
15140 
    oprot.writeStructEnd()
15141 
 
15142 
  def validate(self):
15143 
    return
15144 
 
15145 
 
15146 
  def __repr__(self):
15147 
    L = ['%s=%r' % (key, value)
15148 
      for key, value in self.__dict__.iteritems()]
15149 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15150 
 
15151 
  def __eq__(self, other):
15152 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15153 
 
15154 
  def __ne__(self, other):
15155 
    return not (self == other)
15156 
 
15157 
class getAllBrandsByCategory_args:
15158 
  """
15159 
  Attributes:
15160 
   - categoryId
15161 
  """
15162 
 
15163 
  thrift_spec = (
15164 
    None, # 0
15165 
    (1, TType.I64, 'categoryId', None, None, ), # 1
15166 
  )
15167 
 
15168 
  def __init__(self, categoryId=None,):
15169 
    self.categoryId = categoryId
15170 
 
15171 
  def read(self, iprot):
15172 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15173 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15174 
      return
15175 
    iprot.readStructBegin()
15176 
    while True:
15177 
      (fname, ftype, fid) = iprot.readFieldBegin()
15178 
      if ftype == TType.STOP:
15179 
        break
15180 
      if fid == 1:
15181 
        if ftype == TType.I64:
15182 
          self.categoryId = iprot.readI64();
15183 
        else:
15184 
          iprot.skip(ftype)
15185 
      else:
15186 
        iprot.skip(ftype)
15187 
      iprot.readFieldEnd()
15188 
    iprot.readStructEnd()
15189 
 
15190 
  def write(self, oprot):
15191 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15192 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15193 
      return
15194 
    oprot.writeStructBegin('getAllBrandsByCategory_args')
15195 
    if self.categoryId is not None:
15196 
      oprot.writeFieldBegin('categoryId', TType.I64, 1)
15197 
      oprot.writeI64(self.categoryId)
15198 
      oprot.writeFieldEnd()
15199 
    oprot.writeFieldStop()
15200 
    oprot.writeStructEnd()
15201 
 
15202 
  def validate(self):
15203 
    return
15204 
 
15205 
 
15206 
  def __repr__(self):
15207 
    L = ['%s=%r' % (key, value)
15208 
      for key, value in self.__dict__.iteritems()]
15209 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15210 
 
15211 
  def __eq__(self, other):
15212 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15213 
 
15214 
  def __ne__(self, other):
15215 
    return not (self == other)
15216 
 
15217 
class getAllBrandsByCategory_result:
15218 
  """
15219 
  Attributes:
15220 
   - success
15221 
  """
15222 
 
15223 
  thrift_spec = (
15224 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
15225 
  )
15226 
 
15227 
  def __init__(self, success=None,):
15228 
    self.success = success
15229 
 
15230 
  def read(self, iprot):
15231 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15232 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15233 
      return
15234 
    iprot.readStructBegin()
15235 
    while True:
15236 
      (fname, ftype, fid) = iprot.readFieldBegin()
15237 
      if ftype == TType.STOP:
15238 
        break
15239 
      if fid == 0:
15240 
        if ftype == TType.LIST:
15241 
          self.success = []
9155 kshitij.so 15242 
          (_etype300, _size297) = iprot.readListBegin()
15243 
          for _i301 in xrange(_size297):
15244 
            _elem302 = iprot.readString();
15245 
            self.success.append(_elem302)
5944 mandeep.dh 15246 
          iprot.readListEnd()
15247 
        else:
15248 
          iprot.skip(ftype)
15249 
      else:
15250 
        iprot.skip(ftype)
15251 
      iprot.readFieldEnd()
15252 
    iprot.readStructEnd()
15253 
 
15254 
  def write(self, oprot):
15255 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15256 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15257 
      return
15258 
    oprot.writeStructBegin('getAllBrandsByCategory_result')
15259 
    if self.success is not None:
15260 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15261 
      oprot.writeListBegin(TType.STRING, len(self.success))
9155 kshitij.so 15262 
      for iter303 in self.success:
15263 
        oprot.writeString(iter303)
5944 mandeep.dh 15264 
      oprot.writeListEnd()
15265 
      oprot.writeFieldEnd()
15266 
    oprot.writeFieldStop()
15267 
    oprot.writeStructEnd()
15268 
 
15269 
  def validate(self):
15270 
    return
15271 
 
15272 
 
15273 
  def __repr__(self):
15274 
    L = ['%s=%r' % (key, value)
15275 
      for key, value in self.__dict__.iteritems()]
15276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15277 
 
15278 
  def __eq__(self, other):
15279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15280 
 
15281 
  def __ne__(self, other):
15282 
    return not (self == other)
15283 
 
15284 
class getAllBrands_args:
15285 
 
15286 
  thrift_spec = (
15287 
  )
15288 
 
15289 
  def read(self, iprot):
15290 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15291 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15292 
      return
15293 
    iprot.readStructBegin()
15294 
    while True:
15295 
      (fname, ftype, fid) = iprot.readFieldBegin()
15296 
      if ftype == TType.STOP:
15297 
        break
15298 
      else:
15299 
        iprot.skip(ftype)
15300 
      iprot.readFieldEnd()
15301 
    iprot.readStructEnd()
15302 
 
15303 
  def write(self, oprot):
15304 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15305 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15306 
      return
15307 
    oprot.writeStructBegin('getAllBrands_args')
15308 
    oprot.writeFieldStop()
15309 
    oprot.writeStructEnd()
15310 
 
15311 
  def validate(self):
15312 
    return
15313 
 
15314 
 
15315 
  def __repr__(self):
15316 
    L = ['%s=%r' % (key, value)
15317 
      for key, value in self.__dict__.iteritems()]
15318 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15319 
 
15320 
  def __eq__(self, other):
15321 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15322 
 
15323 
  def __ne__(self, other):
15324 
    return not (self == other)
15325 
 
15326 
class getAllBrands_result:
15327 
  """
15328 
  Attributes:
15329 
   - success
15330 
  """
15331 
 
15332 
  thrift_spec = (
15333 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
15334 
  )
15335 
 
15336 
  def __init__(self, success=None,):
15337 
    self.success = success
15338 
 
15339 
  def read(self, iprot):
15340 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15341 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15342 
      return
15343 
    iprot.readStructBegin()
15344 
    while True:
15345 
      (fname, ftype, fid) = iprot.readFieldBegin()
15346 
      if ftype == TType.STOP:
15347 
        break
15348 
      if fid == 0:
15349 
        if ftype == TType.LIST:
15350 
          self.success = []
9155 kshitij.so 15351 
          (_etype307, _size304) = iprot.readListBegin()
15352 
          for _i308 in xrange(_size304):
15353 
            _elem309 = iprot.readString();
15354 
            self.success.append(_elem309)
5944 mandeep.dh 15355 
          iprot.readListEnd()
15356 
        else:
15357 
          iprot.skip(ftype)
15358 
      else:
15359 
        iprot.skip(ftype)
15360 
      iprot.readFieldEnd()
15361 
    iprot.readStructEnd()
15362 
 
15363 
  def write(self, oprot):
15364 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15365 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15366 
      return
15367 
    oprot.writeStructBegin('getAllBrands_result')
15368 
    if self.success is not None:
15369 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15370 
      oprot.writeListBegin(TType.STRING, len(self.success))
9155 kshitij.so 15371 
      for iter310 in self.success:
15372 
        oprot.writeString(iter310)
5944 mandeep.dh 15373 
      oprot.writeListEnd()
15374 
      oprot.writeFieldEnd()
15375 
    oprot.writeFieldStop()
15376 
    oprot.writeStructEnd()
15377 
 
15378 
  def validate(self):
15379 
    return
15380 
 
15381 
 
15382 
  def __repr__(self):
15383 
    L = ['%s=%r' % (key, value)
15384 
      for key, value in self.__dict__.iteritems()]
15385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15386 
 
15387 
  def __eq__(self, other):
15388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15389 
 
15390 
  def __ne__(self, other):
15391 
    return not (self == other)
15392 
 
15393 
class getAllSources_args:
15394 
 
15395 
  thrift_spec = (
15396 
  )
15397 
 
15398 
  def read(self, iprot):
15399 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15400 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15401 
      return
15402 
    iprot.readStructBegin()
15403 
    while True:
15404 
      (fname, ftype, fid) = iprot.readFieldBegin()
15405 
      if ftype == TType.STOP:
15406 
        break
15407 
      else:
15408 
        iprot.skip(ftype)
15409 
      iprot.readFieldEnd()
15410 
    iprot.readStructEnd()
15411 
 
15412 
  def write(self, oprot):
15413 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15414 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15415 
      return
15416 
    oprot.writeStructBegin('getAllSources_args')
15417 
    oprot.writeFieldStop()
15418 
    oprot.writeStructEnd()
15419 
 
15420 
  def validate(self):
15421 
    return
15422 
 
15423 
 
15424 
  def __repr__(self):
15425 
    L = ['%s=%r' % (key, value)
15426 
      for key, value in self.__dict__.iteritems()]
15427 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15428 
 
15429 
  def __eq__(self, other):
15430 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15431 
 
15432 
  def __ne__(self, other):
15433 
    return not (self == other)
15434 
 
15435 
class getAllSources_result:
15436 
  """
15437 
  Attributes:
15438 
   - success
15439 
  """
15440 
 
15441 
  thrift_spec = (
15442 
    (0, TType.LIST, 'success', (TType.STRUCT,(Source, Source.thrift_spec)), None, ), # 0
15443 
  )
15444 
 
15445 
  def __init__(self, success=None,):
15446 
    self.success = success
15447 
 
15448 
  def read(self, iprot):
15449 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15450 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15451 
      return
15452 
    iprot.readStructBegin()
15453 
    while True:
15454 
      (fname, ftype, fid) = iprot.readFieldBegin()
15455 
      if ftype == TType.STOP:
15456 
        break
15457 
      if fid == 0:
15458 
        if ftype == TType.LIST:
15459 
          self.success = []
9155 kshitij.so 15460 
          (_etype314, _size311) = iprot.readListBegin()
15461 
          for _i315 in xrange(_size311):
15462 
            _elem316 = Source()
15463 
            _elem316.read(iprot)
15464 
            self.success.append(_elem316)
5944 mandeep.dh 15465 
          iprot.readListEnd()
15466 
        else:
15467 
          iprot.skip(ftype)
15468 
      else:
15469 
        iprot.skip(ftype)
15470 
      iprot.readFieldEnd()
15471 
    iprot.readStructEnd()
15472 
 
15473 
  def write(self, oprot):
15474 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15475 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15476 
      return
15477 
    oprot.writeStructBegin('getAllSources_result')
15478 
    if self.success is not None:
15479 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15480 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 15481 
      for iter317 in self.success:
15482 
        iter317.write(oprot)
5944 mandeep.dh 15483 
      oprot.writeListEnd()
15484 
      oprot.writeFieldEnd()
15485 
    oprot.writeFieldStop()
15486 
    oprot.writeStructEnd()
15487 
 
15488 
  def validate(self):
15489 
    return
15490 
 
15491 
 
15492 
  def __repr__(self):
15493 
    L = ['%s=%r' % (key, value)
15494 
      for key, value in self.__dict__.iteritems()]
15495 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15496 
 
15497 
  def __eq__(self, other):
15498 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15499 
 
15500 
  def __ne__(self, other):
15501 
    return not (self == other)
15502 
 
15503 
class getItemPricingBySource_args:
15504 
  """
15505 
  Attributes:
15506 
   - itemId
15507 
   - sourceId
15508 
  """
15509 
 
15510 
  thrift_spec = (
15511 
    None, # 0
15512 
    (1, TType.I64, 'itemId', None, None, ), # 1
15513 
    (2, TType.I64, 'sourceId', None, None, ), # 2
15514 
  )
15515 
 
15516 
  def __init__(self, itemId=None, sourceId=None,):
15517 
    self.itemId = itemId
15518 
    self.sourceId = sourceId
15519 
 
15520 
  def read(self, iprot):
15521 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15522 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15523 
      return
15524 
    iprot.readStructBegin()
15525 
    while True:
15526 
      (fname, ftype, fid) = iprot.readFieldBegin()
15527 
      if ftype == TType.STOP:
15528 
        break
15529 
      if fid == 1:
15530 
        if ftype == TType.I64:
15531 
          self.itemId = iprot.readI64();
15532 
        else:
15533 
          iprot.skip(ftype)
15534 
      elif fid == 2:
15535 
        if ftype == TType.I64:
15536 
          self.sourceId = iprot.readI64();
15537 
        else:
15538 
          iprot.skip(ftype)
15539 
      else:
15540 
        iprot.skip(ftype)
15541 
      iprot.readFieldEnd()
15542 
    iprot.readStructEnd()
15543 
 
15544 
  def write(self, oprot):
15545 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15546 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15547 
      return
15548 
    oprot.writeStructBegin('getItemPricingBySource_args')
15549 
    if self.itemId is not None:
15550 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15551 
      oprot.writeI64(self.itemId)
15552 
      oprot.writeFieldEnd()
15553 
    if self.sourceId is not None:
15554 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
15555 
      oprot.writeI64(self.sourceId)
15556 
      oprot.writeFieldEnd()
15557 
    oprot.writeFieldStop()
15558 
    oprot.writeStructEnd()
15559 
 
15560 
  def validate(self):
15561 
    return
15562 
 
15563 
 
15564 
  def __repr__(self):
15565 
    L = ['%s=%r' % (key, value)
15566 
      for key, value in self.__dict__.iteritems()]
15567 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15568 
 
15569 
  def __eq__(self, other):
15570 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15571 
 
15572 
  def __ne__(self, other):
15573 
    return not (self == other)
15574 
 
15575 
class getItemPricingBySource_result:
15576 
  """
15577 
  Attributes:
15578 
   - success
15579 
   - cex
15580 
  """
15581 
 
15582 
  thrift_spec = (
15583 
    (0, TType.STRUCT, 'success', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 0
15584 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
15585 
  )
15586 
 
15587 
  def __init__(self, success=None, cex=None,):
15588 
    self.success = success
15589 
    self.cex = cex
15590 
 
15591 
  def read(self, iprot):
15592 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15593 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15594 
      return
15595 
    iprot.readStructBegin()
15596 
    while True:
15597 
      (fname, ftype, fid) = iprot.readFieldBegin()
15598 
      if ftype == TType.STOP:
15599 
        break
15600 
      if fid == 0:
15601 
        if ftype == TType.STRUCT:
15602 
          self.success = SourceItemPricing()
15603 
          self.success.read(iprot)
15604 
        else:
15605 
          iprot.skip(ftype)
15606 
      elif fid == 1:
15607 
        if ftype == TType.STRUCT:
15608 
          self.cex = CatalogServiceException()
15609 
          self.cex.read(iprot)
15610 
        else:
15611 
          iprot.skip(ftype)
15612 
      else:
15613 
        iprot.skip(ftype)
15614 
      iprot.readFieldEnd()
15615 
    iprot.readStructEnd()
15616 
 
15617 
  def write(self, oprot):
15618 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15619 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15620 
      return
15621 
    oprot.writeStructBegin('getItemPricingBySource_result')
15622 
    if self.success is not None:
15623 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15624 
      self.success.write(oprot)
15625 
      oprot.writeFieldEnd()
15626 
    if self.cex is not None:
15627 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15628 
      self.cex.write(oprot)
15629 
      oprot.writeFieldEnd()
15630 
    oprot.writeFieldStop()
15631 
    oprot.writeStructEnd()
15632 
 
15633 
  def validate(self):
15634 
    return
15635 
 
15636 
 
15637 
  def __repr__(self):
15638 
    L = ['%s=%r' % (key, value)
15639 
      for key, value in self.__dict__.iteritems()]
15640 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15641 
 
15642 
  def __eq__(self, other):
15643 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15644 
 
15645 
  def __ne__(self, other):
15646 
    return not (self == other)
15647 
 
15648 
class addSourceItemPricing_args:
15649 
  """
15650 
  Attributes:
15651 
   - sourceItemPricing
15652 
  """
15653 
 
15654 
  thrift_spec = (
15655 
    None, # 0
15656 
    (1, TType.STRUCT, 'sourceItemPricing', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 1
15657 
  )
15658 
 
15659 
  def __init__(self, sourceItemPricing=None,):
15660 
    self.sourceItemPricing = sourceItemPricing
15661 
 
15662 
  def read(self, iprot):
15663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15665 
      return
15666 
    iprot.readStructBegin()
15667 
    while True:
15668 
      (fname, ftype, fid) = iprot.readFieldBegin()
15669 
      if ftype == TType.STOP:
15670 
        break
15671 
      if fid == 1:
15672 
        if ftype == TType.STRUCT:
15673 
          self.sourceItemPricing = SourceItemPricing()
15674 
          self.sourceItemPricing.read(iprot)
15675 
        else:
15676 
          iprot.skip(ftype)
15677 
      else:
15678 
        iprot.skip(ftype)
15679 
      iprot.readFieldEnd()
15680 
    iprot.readStructEnd()
15681 
 
15682 
  def write(self, oprot):
15683 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15684 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15685 
      return
15686 
    oprot.writeStructBegin('addSourceItemPricing_args')
15687 
    if self.sourceItemPricing is not None:
15688 
      oprot.writeFieldBegin('sourceItemPricing', TType.STRUCT, 1)
15689 
      self.sourceItemPricing.write(oprot)
15690 
      oprot.writeFieldEnd()
15691 
    oprot.writeFieldStop()
15692 
    oprot.writeStructEnd()
15693 
 
15694 
  def validate(self):
15695 
    return
15696 
 
15697 
 
15698 
  def __repr__(self):
15699 
    L = ['%s=%r' % (key, value)
15700 
      for key, value in self.__dict__.iteritems()]
15701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15702 
 
15703 
  def __eq__(self, other):
15704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15705 
 
15706 
  def __ne__(self, other):
15707 
    return not (self == other)
15708 
 
15709 
class addSourceItemPricing_result:
15710 
  """
15711 
  Attributes:
15712 
   - cex
15713 
  """
15714 
 
15715 
  thrift_spec = (
15716 
    None, # 0
15717 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
15718 
  )
15719 
 
15720 
  def __init__(self, cex=None,):
15721 
    self.cex = cex
15722 
 
15723 
  def read(self, iprot):
15724 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15725 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15726 
      return
15727 
    iprot.readStructBegin()
15728 
    while True:
15729 
      (fname, ftype, fid) = iprot.readFieldBegin()
15730 
      if ftype == TType.STOP:
15731 
        break
15732 
      if fid == 1:
15733 
        if ftype == TType.STRUCT:
15734 
          self.cex = CatalogServiceException()
15735 
          self.cex.read(iprot)
15736 
        else:
15737 
          iprot.skip(ftype)
15738 
      else:
15739 
        iprot.skip(ftype)
15740 
      iprot.readFieldEnd()
15741 
    iprot.readStructEnd()
15742 
 
15743 
  def write(self, oprot):
15744 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15745 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15746 
      return
15747 
    oprot.writeStructBegin('addSourceItemPricing_result')
15748 
    if self.cex is not None:
15749 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15750 
      self.cex.write(oprot)
15751 
      oprot.writeFieldEnd()
15752 
    oprot.writeFieldStop()
15753 
    oprot.writeStructEnd()
15754 
 
15755 
  def validate(self):
15756 
    return
15757 
 
15758 
 
15759 
  def __repr__(self):
15760 
    L = ['%s=%r' % (key, value)
15761 
      for key, value in self.__dict__.iteritems()]
15762 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15763 
 
15764 
  def __eq__(self, other):
15765 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15766 
 
15767 
  def __ne__(self, other):
15768 
    return not (self == other)
15769 
 
15770 
class getAllSourcePricing_args:
15771 
  """
15772 
  Attributes:
15773 
   - itemId
15774 
  """
15775 
 
15776 
  thrift_spec = (
15777 
    None, # 0
15778 
    (1, TType.I64, 'itemId', None, None, ), # 1
15779 
  )
15780 
 
15781 
  def __init__(self, itemId=None,):
15782 
    self.itemId = itemId
15783 
 
15784 
  def read(self, iprot):
15785 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15786 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15787 
      return
15788 
    iprot.readStructBegin()
15789 
    while True:
15790 
      (fname, ftype, fid) = iprot.readFieldBegin()
15791 
      if ftype == TType.STOP:
15792 
        break
15793 
      if fid == 1:
15794 
        if ftype == TType.I64:
15795 
          self.itemId = iprot.readI64();
15796 
        else:
15797 
          iprot.skip(ftype)
15798 
      else:
15799 
        iprot.skip(ftype)
15800 
      iprot.readFieldEnd()
15801 
    iprot.readStructEnd()
15802 
 
15803 
  def write(self, oprot):
15804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15806 
      return
15807 
    oprot.writeStructBegin('getAllSourcePricing_args')
15808 
    if self.itemId is not None:
15809 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15810 
      oprot.writeI64(self.itemId)
15811 
      oprot.writeFieldEnd()
15812 
    oprot.writeFieldStop()
15813 
    oprot.writeStructEnd()
15814 
 
15815 
  def validate(self):
15816 
    return
15817 
 
15818 
 
15819 
  def __repr__(self):
15820 
    L = ['%s=%r' % (key, value)
15821 
      for key, value in self.__dict__.iteritems()]
15822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15823 
 
15824 
  def __eq__(self, other):
15825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15826 
 
15827 
  def __ne__(self, other):
15828 
    return not (self == other)
15829 
 
15830 
class getAllSourcePricing_result:
15831 
  """
15832 
  Attributes:
15833 
   - success
15834 
   - cex
15835 
  """
15836 
 
15837 
  thrift_spec = (
15838 
    (0, TType.LIST, 'success', (TType.STRUCT,(SourceItemPricing, SourceItemPricing.thrift_spec)), None, ), # 0
15839 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
15840 
  )
15841 
 
15842 
  def __init__(self, success=None, cex=None,):
15843 
    self.success = success
15844 
    self.cex = cex
15845 
 
15846 
  def read(self, iprot):
15847 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15848 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15849 
      return
15850 
    iprot.readStructBegin()
15851 
    while True:
15852 
      (fname, ftype, fid) = iprot.readFieldBegin()
15853 
      if ftype == TType.STOP:
15854 
        break
15855 
      if fid == 0:
15856 
        if ftype == TType.LIST:
15857 
          self.success = []
9155 kshitij.so 15858 
          (_etype321, _size318) = iprot.readListBegin()
15859 
          for _i322 in xrange(_size318):
15860 
            _elem323 = SourceItemPricing()
15861 
            _elem323.read(iprot)
15862 
            self.success.append(_elem323)
5944 mandeep.dh 15863 
          iprot.readListEnd()
15864 
        else:
15865 
          iprot.skip(ftype)
15866 
      elif fid == 1:
15867 
        if ftype == TType.STRUCT:
15868 
          self.cex = CatalogServiceException()
15869 
          self.cex.read(iprot)
15870 
        else:
15871 
          iprot.skip(ftype)
15872 
      else:
15873 
        iprot.skip(ftype)
15874 
      iprot.readFieldEnd()
15875 
    iprot.readStructEnd()
15876 
 
15877 
  def write(self, oprot):
15878 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15879 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15880 
      return
15881 
    oprot.writeStructBegin('getAllSourcePricing_result')
15882 
    if self.success is not None:
15883 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15884 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 15885 
      for iter324 in self.success:
15886 
        iter324.write(oprot)
5944 mandeep.dh 15887 
      oprot.writeListEnd()
15888 
      oprot.writeFieldEnd()
15889 
    if self.cex is not None:
15890 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15891 
      self.cex.write(oprot)
15892 
      oprot.writeFieldEnd()
15893 
    oprot.writeFieldStop()
15894 
    oprot.writeStructEnd()
15895 
 
15896 
  def validate(self):
15897 
    return
15898 
 
15899 
 
15900 
  def __repr__(self):
15901 
    L = ['%s=%r' % (key, value)
15902 
      for key, value in self.__dict__.iteritems()]
15903 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15904 
 
15905 
  def __eq__(self, other):
15906 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15907 
 
15908 
  def __ne__(self, other):
15909 
    return not (self == other)
15910 
 
15911 
class getItemForSource_args:
15912 
  """
15913 
  Attributes:
15914 
   - item_id
15915 
   - sourceId
15916 
  """
15917 
 
15918 
  thrift_spec = (
15919 
    None, # 0
15920 
    (1, TType.I64, 'item_id', None, None, ), # 1
15921 
    (2, TType.I64, 'sourceId', None, None, ), # 2
15922 
  )
15923 
 
15924 
  def __init__(self, item_id=None, sourceId=None,):
15925 
    self.item_id = item_id
15926 
    self.sourceId = sourceId
15927 
 
15928 
  def read(self, iprot):
15929 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15930 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15931 
      return
15932 
    iprot.readStructBegin()
15933 
    while True:
15934 
      (fname, ftype, fid) = iprot.readFieldBegin()
15935 
      if ftype == TType.STOP:
15936 
        break
15937 
      if fid == 1:
15938 
        if ftype == TType.I64:
15939 
          self.item_id = iprot.readI64();
15940 
        else:
15941 
          iprot.skip(ftype)
15942 
      elif fid == 2:
15943 
        if ftype == TType.I64:
15944 
          self.sourceId = iprot.readI64();
15945 
        else:
15946 
          iprot.skip(ftype)
15947 
      else:
15948 
        iprot.skip(ftype)
15949 
      iprot.readFieldEnd()
15950 
    iprot.readStructEnd()
15951 
 
15952 
  def write(self, oprot):
15953 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15954 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15955 
      return
15956 
    oprot.writeStructBegin('getItemForSource_args')
15957 
    if self.item_id is not None:
15958 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
15959 
      oprot.writeI64(self.item_id)
15960 
      oprot.writeFieldEnd()
15961 
    if self.sourceId is not None:
15962 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
15963 
      oprot.writeI64(self.sourceId)
15964 
      oprot.writeFieldEnd()
15965 
    oprot.writeFieldStop()
15966 
    oprot.writeStructEnd()
15967 
 
15968 
  def validate(self):
15969 
    return
15970 
 
15971 
 
15972 
  def __repr__(self):
15973 
    L = ['%s=%r' % (key, value)
15974 
      for key, value in self.__dict__.iteritems()]
15975 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15976 
 
15977 
  def __eq__(self, other):
15978 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15979 
 
15980 
  def __ne__(self, other):
15981 
    return not (self == other)
15982 
 
15983 
class getItemForSource_result:
15984 
  """
15985 
  Attributes:
15986 
   - success
15987 
   - cex
15988 
  """
15989 
 
15990 
  thrift_spec = (
15991 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
15992 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
15993 
  )
15994 
 
15995 
  def __init__(self, success=None, cex=None,):
15996 
    self.success = success
15997 
    self.cex = cex
15998 
 
15999 
  def read(self, iprot):
16000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16002 
      return
16003 
    iprot.readStructBegin()
16004 
    while True:
16005 
      (fname, ftype, fid) = iprot.readFieldBegin()
16006 
      if ftype == TType.STOP:
16007 
        break
16008 
      if fid == 0:
16009 
        if ftype == TType.STRUCT:
16010 
          self.success = Item()
16011 
          self.success.read(iprot)
16012 
        else:
16013 
          iprot.skip(ftype)
16014 
      elif fid == 1:
16015 
        if ftype == TType.STRUCT:
16016 
          self.cex = CatalogServiceException()
16017 
          self.cex.read(iprot)
16018 
        else:
16019 
          iprot.skip(ftype)
16020 
      else:
16021 
        iprot.skip(ftype)
16022 
      iprot.readFieldEnd()
16023 
    iprot.readStructEnd()
16024 
 
16025 
  def write(self, oprot):
16026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16028 
      return
16029 
    oprot.writeStructBegin('getItemForSource_result')
16030 
    if self.success is not None:
16031 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16032 
      self.success.write(oprot)
16033 
      oprot.writeFieldEnd()
16034 
    if self.cex is not None:
16035 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16036 
      self.cex.write(oprot)
16037 
      oprot.writeFieldEnd()
16038 
    oprot.writeFieldStop()
16039 
    oprot.writeStructEnd()
16040 
 
16041 
  def validate(self):
16042 
    return
16043 
 
16044 
 
16045 
  def __repr__(self):
16046 
    L = ['%s=%r' % (key, value)
16047 
      for key, value in self.__dict__.iteritems()]
16048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16049 
 
16050 
  def __eq__(self, other):
16051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16052 
 
16053 
  def __ne__(self, other):
16054 
    return not (self == other)
16055 
 
16056 
class searchItemsInRange_args:
16057 
  """
16058 
  Attributes:
16059 
   - searchTerms
16060 
   - offset
16061 
   - limit
16062 
  """
16063 
 
16064 
  thrift_spec = (
16065 
    None, # 0
16066 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
16067 
    (2, TType.I64, 'offset', None, None, ), # 2
16068 
    (3, TType.I64, 'limit', None, None, ), # 3
16069 
  )
16070 
 
16071 
  def __init__(self, searchTerms=None, offset=None, limit=None,):
16072 
    self.searchTerms = searchTerms
16073 
    self.offset = offset
16074 
    self.limit = limit
16075 
 
16076 
  def read(self, iprot):
16077 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16078 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16079 
      return
16080 
    iprot.readStructBegin()
16081 
    while True:
16082 
      (fname, ftype, fid) = iprot.readFieldBegin()
16083 
      if ftype == TType.STOP:
16084 
        break
16085 
      if fid == 1:
16086 
        if ftype == TType.LIST:
16087 
          self.searchTerms = []
9155 kshitij.so 16088 
          (_etype328, _size325) = iprot.readListBegin()
16089 
          for _i329 in xrange(_size325):
16090 
            _elem330 = iprot.readString();
16091 
            self.searchTerms.append(_elem330)
5944 mandeep.dh 16092 
          iprot.readListEnd()
16093 
        else:
16094 
          iprot.skip(ftype)
16095 
      elif fid == 2:
16096 
        if ftype == TType.I64:
16097 
          self.offset = iprot.readI64();
16098 
        else:
16099 
          iprot.skip(ftype)
16100 
      elif fid == 3:
16101 
        if ftype == TType.I64:
16102 
          self.limit = iprot.readI64();
16103 
        else:
16104 
          iprot.skip(ftype)
16105 
      else:
16106 
        iprot.skip(ftype)
16107 
      iprot.readFieldEnd()
16108 
    iprot.readStructEnd()
16109 
 
16110 
  def write(self, oprot):
16111 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16112 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16113 
      return
16114 
    oprot.writeStructBegin('searchItemsInRange_args')
16115 
    if self.searchTerms is not None:
16116 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
16117 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
9155 kshitij.so 16118 
      for iter331 in self.searchTerms:
16119 
        oprot.writeString(iter331)
5944 mandeep.dh 16120 
      oprot.writeListEnd()
16121 
      oprot.writeFieldEnd()
16122 
    if self.offset is not None:
16123 
      oprot.writeFieldBegin('offset', TType.I64, 2)
16124 
      oprot.writeI64(self.offset)
16125 
      oprot.writeFieldEnd()
16126 
    if self.limit is not None:
16127 
      oprot.writeFieldBegin('limit', TType.I64, 3)
16128 
      oprot.writeI64(self.limit)
16129 
      oprot.writeFieldEnd()
16130 
    oprot.writeFieldStop()
16131 
    oprot.writeStructEnd()
16132 
 
16133 
  def validate(self):
16134 
    return
16135 
 
16136 
 
16137 
  def __repr__(self):
16138 
    L = ['%s=%r' % (key, value)
16139 
      for key, value in self.__dict__.iteritems()]
16140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16141 
 
16142 
  def __eq__(self, other):
16143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16144 
 
16145 
  def __ne__(self, other):
16146 
    return not (self == other)
16147 
 
16148 
class searchItemsInRange_result:
16149 
  """
16150 
  Attributes:
16151 
   - success
16152 
  """
16153 
 
16154 
  thrift_spec = (
16155 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
16156 
  )
16157 
 
16158 
  def __init__(self, success=None,):
16159 
    self.success = success
16160 
 
16161 
  def read(self, iprot):
16162 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16163 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16164 
      return
16165 
    iprot.readStructBegin()
16166 
    while True:
16167 
      (fname, ftype, fid) = iprot.readFieldBegin()
16168 
      if ftype == TType.STOP:
16169 
        break
16170 
      if fid == 0:
16171 
        if ftype == TType.LIST:
16172 
          self.success = []
9155 kshitij.so 16173 
          (_etype335, _size332) = iprot.readListBegin()
16174 
          for _i336 in xrange(_size332):
16175 
            _elem337 = Item()
16176 
            _elem337.read(iprot)
16177 
            self.success.append(_elem337)
5944 mandeep.dh 16178 
          iprot.readListEnd()
16179 
        else:
16180 
          iprot.skip(ftype)
16181 
      else:
16182 
        iprot.skip(ftype)
16183 
      iprot.readFieldEnd()
16184 
    iprot.readStructEnd()
16185 
 
16186 
  def write(self, oprot):
16187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16189 
      return
16190 
    oprot.writeStructBegin('searchItemsInRange_result')
16191 
    if self.success is not None:
16192 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16193 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16194 
      for iter338 in self.success:
16195 
        iter338.write(oprot)
5944 mandeep.dh 16196 
      oprot.writeListEnd()
16197 
      oprot.writeFieldEnd()
16198 
    oprot.writeFieldStop()
16199 
    oprot.writeStructEnd()
16200 
 
16201 
  def validate(self):
16202 
    return
16203 
 
16204 
 
16205 
  def __repr__(self):
16206 
    L = ['%s=%r' % (key, value)
16207 
      for key, value in self.__dict__.iteritems()]
16208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16209 
 
16210 
  def __eq__(self, other):
16211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16212 
 
16213 
  def __ne__(self, other):
16214 
    return not (self == other)
16215 
 
16216 
class getSearchResultCount_args:
16217 
  """
16218 
  Attributes:
16219 
   - searchTerms
16220 
  """
16221 
 
16222 
  thrift_spec = (
16223 
    None, # 0
16224 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
16225 
  )
16226 
 
16227 
  def __init__(self, searchTerms=None,):
16228 
    self.searchTerms = searchTerms
16229 
 
16230 
  def read(self, iprot):
16231 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16232 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16233 
      return
16234 
    iprot.readStructBegin()
16235 
    while True:
16236 
      (fname, ftype, fid) = iprot.readFieldBegin()
16237 
      if ftype == TType.STOP:
16238 
        break
16239 
      if fid == 1:
16240 
        if ftype == TType.LIST:
16241 
          self.searchTerms = []
9155 kshitij.so 16242 
          (_etype342, _size339) = iprot.readListBegin()
16243 
          for _i343 in xrange(_size339):
16244 
            _elem344 = iprot.readString();
16245 
            self.searchTerms.append(_elem344)
5944 mandeep.dh 16246 
          iprot.readListEnd()
16247 
        else:
16248 
          iprot.skip(ftype)
16249 
      else:
16250 
        iprot.skip(ftype)
16251 
      iprot.readFieldEnd()
16252 
    iprot.readStructEnd()
16253 
 
16254 
  def write(self, oprot):
16255 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16256 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16257 
      return
16258 
    oprot.writeStructBegin('getSearchResultCount_args')
16259 
    if self.searchTerms is not None:
16260 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
16261 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
9155 kshitij.so 16262 
      for iter345 in self.searchTerms:
16263 
        oprot.writeString(iter345)
5944 mandeep.dh 16264 
      oprot.writeListEnd()
16265 
      oprot.writeFieldEnd()
16266 
    oprot.writeFieldStop()
16267 
    oprot.writeStructEnd()
16268 
 
16269 
  def validate(self):
16270 
    return
16271 
 
16272 
 
16273 
  def __repr__(self):
16274 
    L = ['%s=%r' % (key, value)
16275 
      for key, value in self.__dict__.iteritems()]
16276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16277 
 
16278 
  def __eq__(self, other):
16279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16280 
 
16281 
  def __ne__(self, other):
16282 
    return not (self == other)
16283 
 
16284 
class getSearchResultCount_result:
16285 
  """
16286 
  Attributes:
16287 
   - success
16288 
  """
16289 
 
16290 
  thrift_spec = (
16291 
    (0, TType.I32, 'success', None, None, ), # 0
16292 
  )
16293 
 
16294 
  def __init__(self, success=None,):
16295 
    self.success = success
16296 
 
16297 
  def read(self, iprot):
16298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16300 
      return
16301 
    iprot.readStructBegin()
16302 
    while True:
16303 
      (fname, ftype, fid) = iprot.readFieldBegin()
16304 
      if ftype == TType.STOP:
16305 
        break
16306 
      if fid == 0:
16307 
        if ftype == TType.I32:
16308 
          self.success = iprot.readI32();
16309 
        else:
16310 
          iprot.skip(ftype)
16311 
      else:
16312 
        iprot.skip(ftype)
16313 
      iprot.readFieldEnd()
16314 
    iprot.readStructEnd()
16315 
 
16316 
  def write(self, oprot):
16317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16319 
      return
16320 
    oprot.writeStructBegin('getSearchResultCount_result')
16321 
    if self.success is not None:
16322 
      oprot.writeFieldBegin('success', TType.I32, 0)
16323 
      oprot.writeI32(self.success)
16324 
      oprot.writeFieldEnd()
16325 
    oprot.writeFieldStop()
16326 
    oprot.writeStructEnd()
16327 
 
16328 
  def validate(self):
16329 
    return
16330 
 
16331 
 
16332 
  def __repr__(self):
16333 
    L = ['%s=%r' % (key, value)
16334 
      for key, value in self.__dict__.iteritems()]
16335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16336 
 
16337 
  def __eq__(self, other):
16338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16339 
 
16340 
  def __ne__(self, other):
16341 
    return not (self == other)
16342 
 
16343 
class getProductNotifications_args:
16344 
  """
16345 
  Attributes:
16346 
   - startDateTime
16347 
  """
16348 
 
16349 
  thrift_spec = (
16350 
    None, # 0
16351 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
16352 
  )
16353 
 
16354 
  def __init__(self, startDateTime=None,):
16355 
    self.startDateTime = startDateTime
16356 
 
16357 
  def read(self, iprot):
16358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16360 
      return
16361 
    iprot.readStructBegin()
16362 
    while True:
16363 
      (fname, ftype, fid) = iprot.readFieldBegin()
16364 
      if ftype == TType.STOP:
16365 
        break
16366 
      if fid == 1:
16367 
        if ftype == TType.I64:
16368 
          self.startDateTime = iprot.readI64();
16369 
        else:
16370 
          iprot.skip(ftype)
16371 
      else:
16372 
        iprot.skip(ftype)
16373 
      iprot.readFieldEnd()
16374 
    iprot.readStructEnd()
16375 
 
16376 
  def write(self, oprot):
16377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16379 
      return
16380 
    oprot.writeStructBegin('getProductNotifications_args')
16381 
    if self.startDateTime is not None:
16382 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
16383 
      oprot.writeI64(self.startDateTime)
16384 
      oprot.writeFieldEnd()
16385 
    oprot.writeFieldStop()
16386 
    oprot.writeStructEnd()
16387 
 
16388 
  def validate(self):
16389 
    return
16390 
 
16391 
 
16392 
  def __repr__(self):
16393 
    L = ['%s=%r' % (key, value)
16394 
      for key, value in self.__dict__.iteritems()]
16395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16396 
 
16397 
  def __eq__(self, other):
16398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16399 
 
16400 
  def __ne__(self, other):
16401 
    return not (self == other)
16402 
 
16403 
class getProductNotifications_result:
16404 
  """
16405 
  Attributes:
16406 
   - success
16407 
  """
16408 
 
16409 
  thrift_spec = (
16410 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequest, ProductNotificationRequest.thrift_spec)), None, ), # 0
16411 
  )
16412 
 
16413 
  def __init__(self, success=None,):
16414 
    self.success = success
16415 
 
16416 
  def read(self, iprot):
16417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16419 
      return
16420 
    iprot.readStructBegin()
16421 
    while True:
16422 
      (fname, ftype, fid) = iprot.readFieldBegin()
16423 
      if ftype == TType.STOP:
16424 
        break
16425 
      if fid == 0:
16426 
        if ftype == TType.LIST:
16427 
          self.success = []
9155 kshitij.so 16428 
          (_etype349, _size346) = iprot.readListBegin()
16429 
          for _i350 in xrange(_size346):
16430 
            _elem351 = ProductNotificationRequest()
16431 
            _elem351.read(iprot)
16432 
            self.success.append(_elem351)
5944 mandeep.dh 16433 
          iprot.readListEnd()
16434 
        else:
16435 
          iprot.skip(ftype)
16436 
      else:
16437 
        iprot.skip(ftype)
16438 
      iprot.readFieldEnd()
16439 
    iprot.readStructEnd()
16440 
 
16441 
  def write(self, oprot):
16442 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16443 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16444 
      return
16445 
    oprot.writeStructBegin('getProductNotifications_result')
16446 
    if self.success is not None:
16447 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16448 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16449 
      for iter352 in self.success:
16450 
        iter352.write(oprot)
5944 mandeep.dh 16451 
      oprot.writeListEnd()
16452 
      oprot.writeFieldEnd()
16453 
    oprot.writeFieldStop()
16454 
    oprot.writeStructEnd()
16455 
 
16456 
  def validate(self):
16457 
    return
16458 
 
16459 
 
16460 
  def __repr__(self):
16461 
    L = ['%s=%r' % (key, value)
16462 
      for key, value in self.__dict__.iteritems()]
16463 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16464 
 
16465 
  def __eq__(self, other):
16466 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16467 
 
16468 
  def __ne__(self, other):
16469 
    return not (self == other)
16470 
 
16471 
class getProductNotificationRequestCount_args:
16472 
  """
16473 
  Attributes:
16474 
   - startDateTime
7897 amar.kumar 16475 
   - categoryId
5944 mandeep.dh 16476 
  """
16477 
 
16478 
  thrift_spec = (
16479 
    None, # 0
16480 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
7897 amar.kumar 16481 
    (2, TType.I64, 'categoryId', None, None, ), # 2
5944 mandeep.dh 16482 
  )
16483 
 
7897 amar.kumar 16484 
  def __init__(self, startDateTime=None, categoryId=None,):
5944 mandeep.dh 16485 
    self.startDateTime = startDateTime
7897 amar.kumar 16486 
    self.categoryId = categoryId
5944 mandeep.dh 16487 
 
16488 
  def read(self, iprot):
16489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16491 
      return
16492 
    iprot.readStructBegin()
16493 
    while True:
16494 
      (fname, ftype, fid) = iprot.readFieldBegin()
16495 
      if ftype == TType.STOP:
16496 
        break
16497 
      if fid == 1:
16498 
        if ftype == TType.I64:
16499 
          self.startDateTime = iprot.readI64();
16500 
        else:
16501 
          iprot.skip(ftype)
7897 amar.kumar 16502 
      elif fid == 2:
16503 
        if ftype == TType.I64:
16504 
          self.categoryId = iprot.readI64();
16505 
        else:
16506 
          iprot.skip(ftype)
5944 mandeep.dh 16507 
      else:
16508 
        iprot.skip(ftype)
16509 
      iprot.readFieldEnd()
16510 
    iprot.readStructEnd()
16511 
 
16512 
  def write(self, oprot):
16513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16515 
      return
16516 
    oprot.writeStructBegin('getProductNotificationRequestCount_args')
16517 
    if self.startDateTime is not None:
16518 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
16519 
      oprot.writeI64(self.startDateTime)
16520 
      oprot.writeFieldEnd()
7897 amar.kumar 16521 
    if self.categoryId is not None:
16522 
      oprot.writeFieldBegin('categoryId', TType.I64, 2)
16523 
      oprot.writeI64(self.categoryId)
16524 
      oprot.writeFieldEnd()
5944 mandeep.dh 16525 
    oprot.writeFieldStop()
16526 
    oprot.writeStructEnd()
16527 
 
16528 
  def validate(self):
16529 
    return
16530 
 
16531 
 
16532 
  def __repr__(self):
16533 
    L = ['%s=%r' % (key, value)
16534 
      for key, value in self.__dict__.iteritems()]
16535 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16536 
 
16537 
  def __eq__(self, other):
16538 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16539 
 
16540 
  def __ne__(self, other):
16541 
    return not (self == other)
16542 
 
16543 
class getProductNotificationRequestCount_result:
16544 
  """
16545 
  Attributes:
16546 
   - success
16547 
  """
16548 
 
16549 
  thrift_spec = (
16550 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequestCount, ProductNotificationRequestCount.thrift_spec)), None, ), # 0
16551 
  )
16552 
 
16553 
  def __init__(self, success=None,):
16554 
    self.success = success
16555 
 
16556 
  def read(self, iprot):
16557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16559 
      return
16560 
    iprot.readStructBegin()
16561 
    while True:
16562 
      (fname, ftype, fid) = iprot.readFieldBegin()
16563 
      if ftype == TType.STOP:
16564 
        break
16565 
      if fid == 0:
16566 
        if ftype == TType.LIST:
16567 
          self.success = []
9155 kshitij.so 16568 
          (_etype356, _size353) = iprot.readListBegin()
16569 
          for _i357 in xrange(_size353):
16570 
            _elem358 = ProductNotificationRequestCount()
16571 
            _elem358.read(iprot)
16572 
            self.success.append(_elem358)
5944 mandeep.dh 16573 
          iprot.readListEnd()
16574 
        else:
16575 
          iprot.skip(ftype)
16576 
      else:
16577 
        iprot.skip(ftype)
16578 
      iprot.readFieldEnd()
16579 
    iprot.readStructEnd()
16580 
 
16581 
  def write(self, oprot):
16582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16584 
      return
16585 
    oprot.writeStructBegin('getProductNotificationRequestCount_result')
16586 
    if self.success is not None:
16587 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16588 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16589 
      for iter359 in self.success:
16590 
        iter359.write(oprot)
5944 mandeep.dh 16591 
      oprot.writeListEnd()
16592 
      oprot.writeFieldEnd()
16593 
    oprot.writeFieldStop()
16594 
    oprot.writeStructEnd()
16595 
 
16596 
  def validate(self):
16597 
    return
16598 
 
16599 
 
16600 
  def __repr__(self):
16601 
    L = ['%s=%r' % (key, value)
16602 
      for key, value in self.__dict__.iteritems()]
16603 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16604 
 
16605 
  def __eq__(self, other):
16606 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16607 
 
16608 
  def __ne__(self, other):
16609 
    return not (self == other)
16610 
 
16611 
class addAuthorizationLog_args:
16612 
  """
16613 
  Attributes:
16614 
   - itemId
16615 
   - username
16616 
   - reason
16617 
  """
16618 
 
16619 
  thrift_spec = (
16620 
    None, # 0
16621 
    (1, TType.I64, 'itemId', None, None, ), # 1
16622 
    (2, TType.STRING, 'username', None, None, ), # 2
16623 
    (3, TType.STRING, 'reason', None, None, ), # 3
16624 
  )
16625 
 
16626 
  def __init__(self, itemId=None, username=None, reason=None,):
16627 
    self.itemId = itemId
16628 
    self.username = username
16629 
    self.reason = reason
16630 
 
16631 
  def read(self, iprot):
16632 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16633 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16634 
      return
16635 
    iprot.readStructBegin()
16636 
    while True:
16637 
      (fname, ftype, fid) = iprot.readFieldBegin()
16638 
      if ftype == TType.STOP:
16639 
        break
16640 
      if fid == 1:
16641 
        if ftype == TType.I64:
16642 
          self.itemId = iprot.readI64();
16643 
        else:
16644 
          iprot.skip(ftype)
16645 
      elif fid == 2:
16646 
        if ftype == TType.STRING:
16647 
          self.username = iprot.readString();
16648 
        else:
16649 
          iprot.skip(ftype)
16650 
      elif fid == 3:
16651 
        if ftype == TType.STRING:
16652 
          self.reason = iprot.readString();
16653 
        else:
16654 
          iprot.skip(ftype)
16655 
      else:
16656 
        iprot.skip(ftype)
16657 
      iprot.readFieldEnd()
16658 
    iprot.readStructEnd()
16659 
 
16660 
  def write(self, oprot):
16661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16663 
      return
16664 
    oprot.writeStructBegin('addAuthorizationLog_args')
16665 
    if self.itemId is not None:
16666 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16667 
      oprot.writeI64(self.itemId)
16668 
      oprot.writeFieldEnd()
16669 
    if self.username is not None:
16670 
      oprot.writeFieldBegin('username', TType.STRING, 2)
16671 
      oprot.writeString(self.username)
16672 
      oprot.writeFieldEnd()
16673 
    if self.reason is not None:
16674 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
16675 
      oprot.writeString(self.reason)
16676 
      oprot.writeFieldEnd()
16677 
    oprot.writeFieldStop()
16678 
    oprot.writeStructEnd()
16679 
 
16680 
  def validate(self):
16681 
    return
16682 
 
16683 
 
16684 
  def __repr__(self):
16685 
    L = ['%s=%r' % (key, value)
16686 
      for key, value in self.__dict__.iteritems()]
16687 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16688 
 
16689 
  def __eq__(self, other):
16690 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16691 
 
16692 
  def __ne__(self, other):
16693 
    return not (self == other)
16694 
 
16695 
class addAuthorizationLog_result:
16696 
  """
16697 
  Attributes:
16698 
   - success
16699 
   - cex
16700 
  """
16701 
 
16702 
  thrift_spec = (
16703 
    (0, TType.BOOL, 'success', None, None, ), # 0
16704 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16705 
  )
16706 
 
16707 
  def __init__(self, success=None, cex=None,):
16708 
    self.success = success
16709 
    self.cex = cex
16710 
 
16711 
  def read(self, iprot):
16712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16714 
      return
16715 
    iprot.readStructBegin()
16716 
    while True:
16717 
      (fname, ftype, fid) = iprot.readFieldBegin()
16718 
      if ftype == TType.STOP:
16719 
        break
16720 
      if fid == 0:
16721 
        if ftype == TType.BOOL:
16722 
          self.success = iprot.readBool();
16723 
        else:
16724 
          iprot.skip(ftype)
16725 
      elif fid == 1:
16726 
        if ftype == TType.STRUCT:
16727 
          self.cex = CatalogServiceException()
16728 
          self.cex.read(iprot)
16729 
        else:
16730 
          iprot.skip(ftype)
16731 
      else:
16732 
        iprot.skip(ftype)
16733 
      iprot.readFieldEnd()
16734 
    iprot.readStructEnd()
16735 
 
16736 
  def write(self, oprot):
16737 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16738 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16739 
      return
16740 
    oprot.writeStructBegin('addAuthorizationLog_result')
16741 
    if self.success is not None:
16742 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16743 
      oprot.writeBool(self.success)
16744 
      oprot.writeFieldEnd()
16745 
    if self.cex is not None:
16746 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16747 
      self.cex.write(oprot)
16748 
      oprot.writeFieldEnd()
16749 
    oprot.writeFieldStop()
16750 
    oprot.writeStructEnd()
16751 
 
16752 
  def validate(self):
16753 
    return
16754 
 
16755 
 
16756 
  def __repr__(self):
16757 
    L = ['%s=%r' % (key, value)
16758 
      for key, value in self.__dict__.iteritems()]
16759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16760 
 
16761 
  def __eq__(self, other):
16762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16763 
 
16764 
  def __ne__(self, other):
16765 
    return not (self == other)
16766 
 
16767 
class addupdateVoucherForItem_args:
16768 
  """
16769 
  Attributes:
16770 
   - catalog_item_id
16771 
   - voucherType
16772 
   - voucherAmount
16773 
  """
16774 
 
16775 
  thrift_spec = (
16776 
    None, # 0
16777 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
16778 
    (2, TType.I64, 'voucherType', None, None, ), # 2
16779 
    (3, TType.I64, 'voucherAmount', None, None, ), # 3
16780 
  )
16781 
 
16782 
  def __init__(self, catalog_item_id=None, voucherType=None, voucherAmount=None,):
16783 
    self.catalog_item_id = catalog_item_id
16784 
    self.voucherType = voucherType
16785 
    self.voucherAmount = voucherAmount
16786 
 
16787 
  def read(self, iprot):
16788 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16789 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16790 
      return
16791 
    iprot.readStructBegin()
16792 
    while True:
16793 
      (fname, ftype, fid) = iprot.readFieldBegin()
16794 
      if ftype == TType.STOP:
16795 
        break
16796 
      if fid == 1:
16797 
        if ftype == TType.I64:
16798 
          self.catalog_item_id = iprot.readI64();
16799 
        else:
16800 
          iprot.skip(ftype)
16801 
      elif fid == 2:
16802 
        if ftype == TType.I64:
16803 
          self.voucherType = iprot.readI64();
16804 
        else:
16805 
          iprot.skip(ftype)
16806 
      elif fid == 3:
16807 
        if ftype == TType.I64:
16808 
          self.voucherAmount = iprot.readI64();
16809 
        else:
16810 
          iprot.skip(ftype)
16811 
      else:
16812 
        iprot.skip(ftype)
16813 
      iprot.readFieldEnd()
16814 
    iprot.readStructEnd()
16815 
 
16816 
  def write(self, oprot):
16817 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16818 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16819 
      return
16820 
    oprot.writeStructBegin('addupdateVoucherForItem_args')
16821 
    if self.catalog_item_id is not None:
16822 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
16823 
      oprot.writeI64(self.catalog_item_id)
16824 
      oprot.writeFieldEnd()
16825 
    if self.voucherType is not None:
16826 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
16827 
      oprot.writeI64(self.voucherType)
16828 
      oprot.writeFieldEnd()
16829 
    if self.voucherAmount is not None:
16830 
      oprot.writeFieldBegin('voucherAmount', TType.I64, 3)
16831 
      oprot.writeI64(self.voucherAmount)
16832 
      oprot.writeFieldEnd()
16833 
    oprot.writeFieldStop()
16834 
    oprot.writeStructEnd()
16835 
 
16836 
  def validate(self):
16837 
    return
16838 
 
16839 
 
16840 
  def __repr__(self):
16841 
    L = ['%s=%r' % (key, value)
16842 
      for key, value in self.__dict__.iteritems()]
16843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16844 
 
16845 
  def __eq__(self, other):
16846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16847 
 
16848 
  def __ne__(self, other):
16849 
    return not (self == other)
16850 
 
16851 
class addupdateVoucherForItem_result:
16852 
  """
16853 
  Attributes:
16854 
   - success
16855 
   - cex
16856 
  """
16857 
 
16858 
  thrift_spec = (
16859 
    (0, TType.BOOL, 'success', None, None, ), # 0
16860 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16861 
  )
16862 
 
16863 
  def __init__(self, success=None, cex=None,):
16864 
    self.success = success
16865 
    self.cex = cex
16866 
 
16867 
  def read(self, iprot):
16868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16870 
      return
16871 
    iprot.readStructBegin()
16872 
    while True:
16873 
      (fname, ftype, fid) = iprot.readFieldBegin()
16874 
      if ftype == TType.STOP:
16875 
        break
16876 
      if fid == 0:
16877 
        if ftype == TType.BOOL:
16878 
          self.success = iprot.readBool();
16879 
        else:
16880 
          iprot.skip(ftype)
16881 
      elif fid == 1:
16882 
        if ftype == TType.STRUCT:
16883 
          self.cex = CatalogServiceException()
16884 
          self.cex.read(iprot)
16885 
        else:
16886 
          iprot.skip(ftype)
16887 
      else:
16888 
        iprot.skip(ftype)
16889 
      iprot.readFieldEnd()
16890 
    iprot.readStructEnd()
16891 
 
16892 
  def write(self, oprot):
16893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16895 
      return
16896 
    oprot.writeStructBegin('addupdateVoucherForItem_result')
16897 
    if self.success is not None:
16898 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16899 
      oprot.writeBool(self.success)
16900 
      oprot.writeFieldEnd()
16901 
    if self.cex is not None:
16902 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16903 
      self.cex.write(oprot)
16904 
      oprot.writeFieldEnd()
16905 
    oprot.writeFieldStop()
16906 
    oprot.writeStructEnd()
16907 
 
16908 
  def validate(self):
16909 
    return
16910 
 
16911 
 
16912 
  def __repr__(self):
16913 
    L = ['%s=%r' % (key, value)
16914 
      for key, value in self.__dict__.iteritems()]
16915 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16916 
 
16917 
  def __eq__(self, other):
16918 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16919 
 
16920 
  def __ne__(self, other):
16921 
    return not (self == other)
16922 
 
16923 
class deleteVoucherForItem_args:
16924 
  """
16925 
  Attributes:
16926 
   - catalog_item_id
16927 
   - voucherType
16928 
  """
16929 
 
16930 
  thrift_spec = (
16931 
    None, # 0
16932 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
16933 
    (2, TType.I64, 'voucherType', None, None, ), # 2
16934 
  )
16935 
 
16936 
  def __init__(self, catalog_item_id=None, voucherType=None,):
16937 
    self.catalog_item_id = catalog_item_id
16938 
    self.voucherType = voucherType
16939 
 
16940 
  def read(self, iprot):
16941 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16942 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16943 
      return
16944 
    iprot.readStructBegin()
16945 
    while True:
16946 
      (fname, ftype, fid) = iprot.readFieldBegin()
16947 
      if ftype == TType.STOP:
16948 
        break
16949 
      if fid == 1:
16950 
        if ftype == TType.I64:
16951 
          self.catalog_item_id = iprot.readI64();
16952 
        else:
16953 
          iprot.skip(ftype)
16954 
      elif fid == 2:
16955 
        if ftype == TType.I64:
16956 
          self.voucherType = iprot.readI64();
16957 
        else:
16958 
          iprot.skip(ftype)
16959 
      else:
16960 
        iprot.skip(ftype)
16961 
      iprot.readFieldEnd()
16962 
    iprot.readStructEnd()
16963 
 
16964 
  def write(self, oprot):
16965 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16966 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16967 
      return
16968 
    oprot.writeStructBegin('deleteVoucherForItem_args')
16969 
    if self.catalog_item_id is not None:
16970 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
16971 
      oprot.writeI64(self.catalog_item_id)
16972 
      oprot.writeFieldEnd()
16973 
    if self.voucherType is not None:
16974 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
16975 
      oprot.writeI64(self.voucherType)
16976 
      oprot.writeFieldEnd()
16977 
    oprot.writeFieldStop()
16978 
    oprot.writeStructEnd()
16979 
 
16980 
  def validate(self):
16981 
    return
16982 
 
16983 
 
16984 
  def __repr__(self):
16985 
    L = ['%s=%r' % (key, value)
16986 
      for key, value in self.__dict__.iteritems()]
16987 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16988 
 
16989 
  def __eq__(self, other):
16990 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16991 
 
16992 
  def __ne__(self, other):
16993 
    return not (self == other)
16994 
 
16995 
class deleteVoucherForItem_result:
16996 
  """
16997 
  Attributes:
16998 
   - success
16999 
   - cex
17000 
  """
17001 
 
17002 
  thrift_spec = (
17003 
    (0, TType.BOOL, 'success', None, None, ), # 0
17004 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17005 
  )
17006 
 
17007 
  def __init__(self, success=None, cex=None,):
17008 
    self.success = success
17009 
    self.cex = cex
17010 
 
17011 
  def read(self, iprot):
17012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17014 
      return
17015 
    iprot.readStructBegin()
17016 
    while True:
17017 
      (fname, ftype, fid) = iprot.readFieldBegin()
17018 
      if ftype == TType.STOP:
17019 
        break
17020 
      if fid == 0:
17021 
        if ftype == TType.BOOL:
17022 
          self.success = iprot.readBool();
17023 
        else:
17024 
          iprot.skip(ftype)
17025 
      elif fid == 1:
17026 
        if ftype == TType.STRUCT:
17027 
          self.cex = CatalogServiceException()
17028 
          self.cex.read(iprot)
17029 
        else:
17030 
          iprot.skip(ftype)
17031 
      else:
17032 
        iprot.skip(ftype)
17033 
      iprot.readFieldEnd()
17034 
    iprot.readStructEnd()
17035 
 
17036 
  def write(self, oprot):
17037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17039 
      return
17040 
    oprot.writeStructBegin('deleteVoucherForItem_result')
17041 
    if self.success is not None:
17042 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17043 
      oprot.writeBool(self.success)
17044 
      oprot.writeFieldEnd()
17045 
    if self.cex is not None:
17046 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17047 
      self.cex.write(oprot)
17048 
      oprot.writeFieldEnd()
17049 
    oprot.writeFieldStop()
17050 
    oprot.writeStructEnd()
17051 
 
17052 
  def validate(self):
17053 
    return
17054 
 
17055 
 
17056 
  def __repr__(self):
17057 
    L = ['%s=%r' % (key, value)
17058 
      for key, value in self.__dict__.iteritems()]
17059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17060 
 
17061 
  def __eq__(self, other):
17062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17063 
 
17064 
  def __ne__(self, other):
17065 
    return not (self == other)
17066 
 
17067 
class getVoucherAmount_args:
17068 
  """
17069 
  Attributes:
17070 
   - itemId
17071 
   - voucherType
17072 
  """
17073 
 
17074 
  thrift_spec = (
17075 
    None, # 0
17076 
    (1, TType.I64, 'itemId', None, None, ), # 1
17077 
    (2, TType.I64, 'voucherType', None, None, ), # 2
17078 
  )
17079 
 
17080 
  def __init__(self, itemId=None, voucherType=None,):
17081 
    self.itemId = itemId
17082 
    self.voucherType = voucherType
17083 
 
17084 
  def read(self, iprot):
17085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17087 
      return
17088 
    iprot.readStructBegin()
17089 
    while True:
17090 
      (fname, ftype, fid) = iprot.readFieldBegin()
17091 
      if ftype == TType.STOP:
17092 
        break
17093 
      if fid == 1:
17094 
        if ftype == TType.I64:
17095 
          self.itemId = iprot.readI64();
17096 
        else:
17097 
          iprot.skip(ftype)
17098 
      elif fid == 2:
17099 
        if ftype == TType.I64:
17100 
          self.voucherType = iprot.readI64();
17101 
        else:
17102 
          iprot.skip(ftype)
17103 
      else:
17104 
        iprot.skip(ftype)
17105 
      iprot.readFieldEnd()
17106 
    iprot.readStructEnd()
17107 
 
17108 
  def write(self, oprot):
17109 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17110 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17111 
      return
17112 
    oprot.writeStructBegin('getVoucherAmount_args')
17113 
    if self.itemId is not None:
17114 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17115 
      oprot.writeI64(self.itemId)
17116 
      oprot.writeFieldEnd()
17117 
    if self.voucherType is not None:
17118 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
17119 
      oprot.writeI64(self.voucherType)
17120 
      oprot.writeFieldEnd()
17121 
    oprot.writeFieldStop()
17122 
    oprot.writeStructEnd()
17123 
 
17124 
  def validate(self):
17125 
    return
17126 
 
17127 
 
17128 
  def __repr__(self):
17129 
    L = ['%s=%r' % (key, value)
17130 
      for key, value in self.__dict__.iteritems()]
17131 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17132 
 
17133 
  def __eq__(self, other):
17134 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17135 
 
17136 
  def __ne__(self, other):
17137 
    return not (self == other)
17138 
 
17139 
class getVoucherAmount_result:
17140 
  """
17141 
  Attributes:
17142 
   - success
17143 
  """
17144 
 
17145 
  thrift_spec = (
17146 
    (0, TType.I64, 'success', None, None, ), # 0
17147 
  )
17148 
 
17149 
  def __init__(self, success=None,):
17150 
    self.success = success
17151 
 
17152 
  def read(self, iprot):
17153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17155 
      return
17156 
    iprot.readStructBegin()
17157 
    while True:
17158 
      (fname, ftype, fid) = iprot.readFieldBegin()
17159 
      if ftype == TType.STOP:
17160 
        break
17161 
      if fid == 0:
17162 
        if ftype == TType.I64:
17163 
          self.success = iprot.readI64();
17164 
        else:
17165 
          iprot.skip(ftype)
17166 
      else:
17167 
        iprot.skip(ftype)
17168 
      iprot.readFieldEnd()
17169 
    iprot.readStructEnd()
17170 
 
17171 
  def write(self, oprot):
17172 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17173 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17174 
      return
17175 
    oprot.writeStructBegin('getVoucherAmount_result')
17176 
    if self.success is not None:
17177 
      oprot.writeFieldBegin('success', TType.I64, 0)
17178 
      oprot.writeI64(self.success)
17179 
      oprot.writeFieldEnd()
17180 
    oprot.writeFieldStop()
17181 
    oprot.writeStructEnd()
17182 
 
17183 
  def validate(self):
17184 
    return
17185 
 
17186 
 
17187 
  def __repr__(self):
17188 
    L = ['%s=%r' % (key, value)
17189 
      for key, value in self.__dict__.iteritems()]
17190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17191 
 
17192 
  def __eq__(self, other):
17193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17194 
 
17195 
  def __ne__(self, other):
17196 
    return not (self == other)
17197 
 
17198 
class getAllItemVouchers_args:
17199 
  """
17200 
  Attributes:
17201 
   - itemId
17202 
  """
17203 
 
17204 
  thrift_spec = (
17205 
    None, # 0
17206 
    (1, TType.I64, 'itemId', None, None, ), # 1
17207 
  )
17208 
 
17209 
  def __init__(self, itemId=None,):
17210 
    self.itemId = itemId
17211 
 
17212 
  def read(self, iprot):
17213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17215 
      return
17216 
    iprot.readStructBegin()
17217 
    while True:
17218 
      (fname, ftype, fid) = iprot.readFieldBegin()
17219 
      if ftype == TType.STOP:
17220 
        break
17221 
      if fid == 1:
17222 
        if ftype == TType.I64:
17223 
          self.itemId = iprot.readI64();
17224 
        else:
17225 
          iprot.skip(ftype)
17226 
      else:
17227 
        iprot.skip(ftype)
17228 
      iprot.readFieldEnd()
17229 
    iprot.readStructEnd()
17230 
 
17231 
  def write(self, oprot):
17232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17234 
      return
17235 
    oprot.writeStructBegin('getAllItemVouchers_args')
17236 
    if self.itemId is not None:
17237 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17238 
      oprot.writeI64(self.itemId)
17239 
      oprot.writeFieldEnd()
17240 
    oprot.writeFieldStop()
17241 
    oprot.writeStructEnd()
17242 
 
17243 
  def validate(self):
17244 
    return
17245 
 
17246 
 
17247 
  def __repr__(self):
17248 
    L = ['%s=%r' % (key, value)
17249 
      for key, value in self.__dict__.iteritems()]
17250 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17251 
 
17252 
  def __eq__(self, other):
17253 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17254 
 
17255 
  def __ne__(self, other):
17256 
    return not (self == other)
17257 
 
17258 
class getAllItemVouchers_result:
17259 
  """
17260 
  Attributes:
17261 
   - success
17262 
  """
17263 
 
17264 
  thrift_spec = (
17265 
    (0, TType.LIST, 'success', (TType.STRUCT,(VoucherItemMapping, VoucherItemMapping.thrift_spec)), None, ), # 0
17266 
  )
17267 
 
17268 
  def __init__(self, success=None,):
17269 
    self.success = success
17270 
 
17271 
  def read(self, iprot):
17272 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17273 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17274 
      return
17275 
    iprot.readStructBegin()
17276 
    while True:
17277 
      (fname, ftype, fid) = iprot.readFieldBegin()
17278 
      if ftype == TType.STOP:
17279 
        break
17280 
      if fid == 0:
17281 
        if ftype == TType.LIST:
17282 
          self.success = []
9155 kshitij.so 17283 
          (_etype363, _size360) = iprot.readListBegin()
17284 
          for _i364 in xrange(_size360):
17285 
            _elem365 = VoucherItemMapping()
17286 
            _elem365.read(iprot)
17287 
            self.success.append(_elem365)
5944 mandeep.dh 17288 
          iprot.readListEnd()
17289 
        else:
17290 
          iprot.skip(ftype)
17291 
      else:
17292 
        iprot.skip(ftype)
17293 
      iprot.readFieldEnd()
17294 
    iprot.readStructEnd()
17295 
 
17296 
  def write(self, oprot):
17297 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17298 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17299 
      return
17300 
    oprot.writeStructBegin('getAllItemVouchers_result')
17301 
    if self.success is not None:
17302 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17303 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 17304 
      for iter366 in self.success:
17305 
        iter366.write(oprot)
5944 mandeep.dh 17306 
      oprot.writeListEnd()
17307 
      oprot.writeFieldEnd()
17308 
    oprot.writeFieldStop()
17309 
    oprot.writeStructEnd()
17310 
 
17311 
  def validate(self):
17312 
    return
17313 
 
17314 
 
17315 
  def __repr__(self):
17316 
    L = ['%s=%r' % (key, value)
17317 
      for key, value in self.__dict__.iteritems()]
17318 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17319 
 
17320 
  def __eq__(self, other):
17321 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17322 
 
17323 
  def __ne__(self, other):
17324 
    return not (self == other)
17325 
 
17326 
class isValidCatalogItemId_args:
17327 
  """
17328 
  Attributes:
17329 
   - catalog_item_id
17330 
  """
17331 
 
17332 
  thrift_spec = (
17333 
    None, # 0
17334 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
17335 
  )
17336 
 
17337 
  def __init__(self, catalog_item_id=None,):
17338 
    self.catalog_item_id = catalog_item_id
17339 
 
17340 
  def read(self, iprot):
17341 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17342 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17343 
      return
17344 
    iprot.readStructBegin()
17345 
    while True:
17346 
      (fname, ftype, fid) = iprot.readFieldBegin()
17347 
      if ftype == TType.STOP:
17348 
        break
17349 
      if fid == 1:
17350 
        if ftype == TType.I64:
17351 
          self.catalog_item_id = iprot.readI64();
17352 
        else:
17353 
          iprot.skip(ftype)
17354 
      else:
17355 
        iprot.skip(ftype)
17356 
      iprot.readFieldEnd()
17357 
    iprot.readStructEnd()
17358 
 
17359 
  def write(self, oprot):
17360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17362 
      return
17363 
    oprot.writeStructBegin('isValidCatalogItemId_args')
17364 
    if self.catalog_item_id is not None:
17365 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
17366 
      oprot.writeI64(self.catalog_item_id)
17367 
      oprot.writeFieldEnd()
17368 
    oprot.writeFieldStop()
17369 
    oprot.writeStructEnd()
17370 
 
17371 
  def validate(self):
17372 
    return
17373 
 
17374 
 
17375 
  def __repr__(self):
17376 
    L = ['%s=%r' % (key, value)
17377 
      for key, value in self.__dict__.iteritems()]
17378 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17379 
 
17380 
  def __eq__(self, other):
17381 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17382 
 
17383 
  def __ne__(self, other):
17384 
    return not (self == other)
17385 
 
17386 
class isValidCatalogItemId_result:
17387 
  """
17388 
  Attributes:
17389 
   - success
17390 
  """
17391 
 
17392 
  thrift_spec = (
17393 
    (0, TType.BOOL, 'success', None, None, ), # 0
17394 
  )
17395 
 
17396 
  def __init__(self, success=None,):
17397 
    self.success = success
17398 
 
17399 
  def read(self, iprot):
17400 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17401 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17402 
      return
17403 
    iprot.readStructBegin()
17404 
    while True:
17405 
      (fname, ftype, fid) = iprot.readFieldBegin()
17406 
      if ftype == TType.STOP:
17407 
        break
17408 
      if fid == 0:
17409 
        if ftype == TType.BOOL:
17410 
          self.success = iprot.readBool();
17411 
        else:
17412 
          iprot.skip(ftype)
17413 
      else:
17414 
        iprot.skip(ftype)
17415 
      iprot.readFieldEnd()
17416 
    iprot.readStructEnd()
17417 
 
17418 
  def write(self, oprot):
17419 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17420 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17421 
      return
17422 
    oprot.writeStructBegin('isValidCatalogItemId_result')
17423 
    if self.success is not None:
17424 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17425 
      oprot.writeBool(self.success)
17426 
      oprot.writeFieldEnd()
17427 
    oprot.writeFieldStop()
17428 
    oprot.writeStructEnd()
17429 
 
17430 
  def validate(self):
17431 
    return
17432 
 
17433 
 
17434 
  def __repr__(self):
17435 
    L = ['%s=%r' % (key, value)
17436 
      for key, value in self.__dict__.iteritems()]
17437 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17438 
 
17439 
  def __eq__(self, other):
17440 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17441 
 
17442 
  def __ne__(self, other):
17443 
    return not (self == other)
6039 amit.gupta 17444 
 
17445 
class getVatPercentageForItem_args:
17446 
  """
17447 
  Attributes:
17448 
   - itemId
7330 amit.gupta 17449 
   - stateId
6039 amit.gupta 17450 
   - price
17451 
  """
17452 
 
17453 
  thrift_spec = (
17454 
    None, # 0
17455 
    (1, TType.I64, 'itemId', None, None, ), # 1
7330 amit.gupta 17456 
    (2, TType.I64, 'stateId', None, None, ), # 2
17457 
    (3, TType.DOUBLE, 'price', None, None, ), # 3
6039 amit.gupta 17458 
  )
17459 
 
7330 amit.gupta 17460 
  def __init__(self, itemId=None, stateId=None, price=None,):
6039 amit.gupta 17461 
    self.itemId = itemId
7330 amit.gupta 17462 
    self.stateId = stateId
6039 amit.gupta 17463 
    self.price = price
17464 
 
17465 
  def read(self, iprot):
17466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17468 
      return
17469 
    iprot.readStructBegin()
17470 
    while True:
17471 
      (fname, ftype, fid) = iprot.readFieldBegin()
17472 
      if ftype == TType.STOP:
17473 
        break
17474 
      if fid == 1:
17475 
        if ftype == TType.I64:
17476 
          self.itemId = iprot.readI64();
17477 
        else:
17478 
          iprot.skip(ftype)
17479 
      elif fid == 2:
7330 amit.gupta 17480 
        if ftype == TType.I64:
17481 
          self.stateId = iprot.readI64();
17482 
        else:
17483 
          iprot.skip(ftype)
17484 
      elif fid == 3:
6039 amit.gupta 17485 
        if ftype == TType.DOUBLE:
17486 
          self.price = iprot.readDouble();
17487 
        else:
17488 
          iprot.skip(ftype)
17489 
      else:
17490 
        iprot.skip(ftype)
17491 
      iprot.readFieldEnd()
17492 
    iprot.readStructEnd()
17493 
 
17494 
  def write(self, oprot):
17495 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17496 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17497 
      return
17498 
    oprot.writeStructBegin('getVatPercentageForItem_args')
17499 
    if self.itemId is not None:
17500 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17501 
      oprot.writeI64(self.itemId)
17502 
      oprot.writeFieldEnd()
7330 amit.gupta 17503 
    if self.stateId is not None:
17504 
      oprot.writeFieldBegin('stateId', TType.I64, 2)
17505 
      oprot.writeI64(self.stateId)
17506 
      oprot.writeFieldEnd()
6039 amit.gupta 17507 
    if self.price is not None:
7330 amit.gupta 17508 
      oprot.writeFieldBegin('price', TType.DOUBLE, 3)
6039 amit.gupta 17509 
      oprot.writeDouble(self.price)
17510 
      oprot.writeFieldEnd()
17511 
    oprot.writeFieldStop()
17512 
    oprot.writeStructEnd()
17513 
 
17514 
  def validate(self):
17515 
    return
17516 
 
17517 
 
17518 
  def __repr__(self):
17519 
    L = ['%s=%r' % (key, value)
17520 
      for key, value in self.__dict__.iteritems()]
17521 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17522 
 
17523 
  def __eq__(self, other):
17524 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17525 
 
17526 
  def __ne__(self, other):
17527 
    return not (self == other)
17528 
 
17529 
class getVatPercentageForItem_result:
17530 
  """
17531 
  Attributes:
17532 
   - success
7340 amit.gupta 17533 
   - cex
6039 amit.gupta 17534 
  """
17535 
 
17536 
  thrift_spec = (
17537 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
7340 amit.gupta 17538 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6039 amit.gupta 17539 
  )
17540 
 
7340 amit.gupta 17541 
  def __init__(self, success=None, cex=None,):
6039 amit.gupta 17542 
    self.success = success
7340 amit.gupta 17543 
    self.cex = cex
6039 amit.gupta 17544 
 
17545 
  def read(self, iprot):
17546 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17547 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17548 
      return
17549 
    iprot.readStructBegin()
17550 
    while True:
17551 
      (fname, ftype, fid) = iprot.readFieldBegin()
17552 
      if ftype == TType.STOP:
17553 
        break
17554 
      if fid == 0:
17555 
        if ftype == TType.DOUBLE:
17556 
          self.success = iprot.readDouble();
17557 
        else:
17558 
          iprot.skip(ftype)
7340 amit.gupta 17559 
      elif fid == 1:
17560 
        if ftype == TType.STRUCT:
17561 
          self.cex = CatalogServiceException()
17562 
          self.cex.read(iprot)
17563 
        else:
17564 
          iprot.skip(ftype)
6039 amit.gupta 17565 
      else:
17566 
        iprot.skip(ftype)
17567 
      iprot.readFieldEnd()
17568 
    iprot.readStructEnd()
17569 
 
17570 
  def write(self, oprot):
17571 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17572 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17573 
      return
17574 
    oprot.writeStructBegin('getVatPercentageForItem_result')
17575 
    if self.success is not None:
17576 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
17577 
      oprot.writeDouble(self.success)
17578 
      oprot.writeFieldEnd()
7340 amit.gupta 17579 
    if self.cex is not None:
17580 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17581 
      self.cex.write(oprot)
17582 
      oprot.writeFieldEnd()
6039 amit.gupta 17583 
    oprot.writeFieldStop()
17584 
    oprot.writeStructEnd()
17585 
 
17586 
  def validate(self):
17587 
    return
17588 
 
17589 
 
17590 
  def __repr__(self):
17591 
    L = ['%s=%r' % (key, value)
17592 
      for key, value in self.__dict__.iteritems()]
17593 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17594 
 
17595 
  def __eq__(self, other):
17596 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17597 
 
17598 
  def __ne__(self, other):
17599 
    return not (self == other)
17600 
 
17601 
class getVatAmountForItem_args:
17602 
  """
17603 
  Attributes:
17604 
   - itemId
17605 
   - price
17606 
  """
17607 
 
17608 
  thrift_spec = (
17609 
    None, # 0
17610 
    (1, TType.I64, 'itemId', None, None, ), # 1
17611 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
17612 
  )
17613 
 
17614 
  def __init__(self, itemId=None, price=None,):
17615 
    self.itemId = itemId
17616 
    self.price = price
17617 
 
17618 
  def read(self, iprot):
17619 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17620 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17621 
      return
17622 
    iprot.readStructBegin()
17623 
    while True:
17624 
      (fname, ftype, fid) = iprot.readFieldBegin()
17625 
      if ftype == TType.STOP:
17626 
        break
17627 
      if fid == 1:
17628 
        if ftype == TType.I64:
17629 
          self.itemId = iprot.readI64();
17630 
        else:
17631 
          iprot.skip(ftype)
17632 
      elif fid == 2:
17633 
        if ftype == TType.DOUBLE:
17634 
          self.price = iprot.readDouble();
17635 
        else:
17636 
          iprot.skip(ftype)
17637 
      else:
17638 
        iprot.skip(ftype)
17639 
      iprot.readFieldEnd()
17640 
    iprot.readStructEnd()
17641 
 
17642 
  def write(self, oprot):
17643 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17644 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17645 
      return
17646 
    oprot.writeStructBegin('getVatAmountForItem_args')
17647 
    if self.itemId is not None:
17648 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17649 
      oprot.writeI64(self.itemId)
17650 
      oprot.writeFieldEnd()
17651 
    if self.price is not None:
17652 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
17653 
      oprot.writeDouble(self.price)
17654 
      oprot.writeFieldEnd()
17655 
    oprot.writeFieldStop()
17656 
    oprot.writeStructEnd()
17657 
 
17658 
  def validate(self):
17659 
    return
17660 
 
17661 
 
17662 
  def __repr__(self):
17663 
    L = ['%s=%r' % (key, value)
17664 
      for key, value in self.__dict__.iteritems()]
17665 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17666 
 
17667 
  def __eq__(self, other):
17668 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17669 
 
17670 
  def __ne__(self, other):
17671 
    return not (self == other)
17672 
 
17673 
class getVatAmountForItem_result:
17674 
  """
17675 
  Attributes:
17676 
   - success
17677 
  """
17678 
 
17679 
  thrift_spec = (
17680 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
17681 
  )
17682 
 
17683 
  def __init__(self, success=None,):
17684 
    self.success = success
17685 
 
17686 
  def read(self, iprot):
17687 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17688 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17689 
      return
17690 
    iprot.readStructBegin()
17691 
    while True:
17692 
      (fname, ftype, fid) = iprot.readFieldBegin()
17693 
      if ftype == TType.STOP:
17694 
        break
17695 
      if fid == 0:
17696 
        if ftype == TType.DOUBLE:
17697 
          self.success = iprot.readDouble();
17698 
        else:
17699 
          iprot.skip(ftype)
17700 
      else:
17701 
        iprot.skip(ftype)
17702 
      iprot.readFieldEnd()
17703 
    iprot.readStructEnd()
17704 
 
17705 
  def write(self, oprot):
17706 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17707 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17708 
      return
17709 
    oprot.writeStructBegin('getVatAmountForItem_result')
17710 
    if self.success is not None:
17711 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
17712 
      oprot.writeDouble(self.success)
17713 
      oprot.writeFieldEnd()
17714 
    oprot.writeFieldStop()
17715 
    oprot.writeStructEnd()
17716 
 
17717 
  def validate(self):
17718 
    return
17719 
 
17720 
 
17721 
  def __repr__(self):
17722 
    L = ['%s=%r' % (key, value)
17723 
      for key, value in self.__dict__.iteritems()]
17724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17725 
 
17726 
  def __eq__(self, other):
17727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17728 
 
17729 
  def __ne__(self, other):
17730 
    return not (self == other)
6531 vikram.rag 17731 
 
17732 
class getAllIgnoredInventoryUpdateItemsList_args:
17733 
  """
17734 
  Attributes:
17735 
   - offset
17736 
   - limit
17737 
  """
17738 
 
17739 
  thrift_spec = (
17740 
    None, # 0
17741 
    (1, TType.I32, 'offset', None, None, ), # 1
17742 
    (2, TType.I32, 'limit', None, None, ), # 2
17743 
  )
17744 
 
17745 
  def __init__(self, offset=None, limit=None,):
17746 
    self.offset = offset
17747 
    self.limit = limit
17748 
 
17749 
  def read(self, iprot):
17750 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17751 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17752 
      return
17753 
    iprot.readStructBegin()
17754 
    while True:
17755 
      (fname, ftype, fid) = iprot.readFieldBegin()
17756 
      if ftype == TType.STOP:
17757 
        break
17758 
      if fid == 1:
17759 
        if ftype == TType.I32:
17760 
          self.offset = iprot.readI32();
17761 
        else:
17762 
          iprot.skip(ftype)
17763 
      elif fid == 2:
17764 
        if ftype == TType.I32:
17765 
          self.limit = iprot.readI32();
17766 
        else:
17767 
          iprot.skip(ftype)
17768 
      else:
17769 
        iprot.skip(ftype)
17770 
      iprot.readFieldEnd()
17771 
    iprot.readStructEnd()
17772 
 
17773 
  def write(self, oprot):
17774 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17775 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17776 
      return
17777 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_args')
17778 
    if self.offset is not None:
17779 
      oprot.writeFieldBegin('offset', TType.I32, 1)
17780 
      oprot.writeI32(self.offset)
17781 
      oprot.writeFieldEnd()
17782 
    if self.limit is not None:
17783 
      oprot.writeFieldBegin('limit', TType.I32, 2)
17784 
      oprot.writeI32(self.limit)
17785 
      oprot.writeFieldEnd()
17786 
    oprot.writeFieldStop()
17787 
    oprot.writeStructEnd()
17788 
 
17789 
  def validate(self):
17790 
    return
17791 
 
17792 
 
17793 
  def __repr__(self):
17794 
    L = ['%s=%r' % (key, value)
17795 
      for key, value in self.__dict__.iteritems()]
17796 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17797 
 
17798 
  def __eq__(self, other):
17799 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17800 
 
17801 
  def __ne__(self, other):
17802 
    return not (self == other)
17803 
 
17804 
class getAllIgnoredInventoryUpdateItemsList_result:
17805 
  """
17806 
  Attributes:
17807 
   - success
17808 
  """
17809 
 
17810 
  thrift_spec = (
17811 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
17812 
  )
17813 
 
17814 
  def __init__(self, success=None,):
17815 
    self.success = success
17816 
 
17817 
  def read(self, iprot):
17818 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17819 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17820 
      return
17821 
    iprot.readStructBegin()
17822 
    while True:
17823 
      (fname, ftype, fid) = iprot.readFieldBegin()
17824 
      if ftype == TType.STOP:
17825 
        break
17826 
      if fid == 0:
17827 
        if ftype == TType.LIST:
17828 
          self.success = []
9155 kshitij.so 17829 
          (_etype370, _size367) = iprot.readListBegin()
17830 
          for _i371 in xrange(_size367):
17831 
            _elem372 = Item()
17832 
            _elem372.read(iprot)
17833 
            self.success.append(_elem372)
6531 vikram.rag 17834 
          iprot.readListEnd()
17835 
        else:
17836 
          iprot.skip(ftype)
17837 
      else:
17838 
        iprot.skip(ftype)
17839 
      iprot.readFieldEnd()
17840 
    iprot.readStructEnd()
17841 
 
17842 
  def write(self, oprot):
17843 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17844 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17845 
      return
17846 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_result')
17847 
    if self.success is not None:
17848 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17849 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 17850 
      for iter373 in self.success:
17851 
        iter373.write(oprot)
6531 vikram.rag 17852 
      oprot.writeListEnd()
17853 
      oprot.writeFieldEnd()
17854 
    oprot.writeFieldStop()
17855 
    oprot.writeStructEnd()
17856 
 
17857 
  def validate(self):
17858 
    return
17859 
 
17860 
 
17861 
  def __repr__(self):
17862 
    L = ['%s=%r' % (key, value)
17863 
      for key, value in self.__dict__.iteritems()]
17864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17865 
 
17866 
  def __eq__(self, other):
17867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17868 
 
17869 
  def __ne__(self, other):
17870 
    return not (self == other)
6805 anupam.sin 17871 
 
6821 amar.kumar 17872 
class getAllAliveItems_args:
17873 
 
17874 
  thrift_spec = (
17875 
  )
17876 
 
17877 
  def read(self, iprot):
17878 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17879 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17880 
      return
17881 
    iprot.readStructBegin()
17882 
    while True:
17883 
      (fname, ftype, fid) = iprot.readFieldBegin()
17884 
      if ftype == TType.STOP:
17885 
        break
17886 
      else:
17887 
        iprot.skip(ftype)
17888 
      iprot.readFieldEnd()
17889 
    iprot.readStructEnd()
17890 
 
17891 
  def write(self, oprot):
17892 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17893 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17894 
      return
17895 
    oprot.writeStructBegin('getAllAliveItems_args')
17896 
    oprot.writeFieldStop()
17897 
    oprot.writeStructEnd()
17898 
 
17899 
  def validate(self):
17900 
    return
17901 
 
17902 
 
17903 
  def __repr__(self):
17904 
    L = ['%s=%r' % (key, value)
17905 
      for key, value in self.__dict__.iteritems()]
17906 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17907 
 
17908 
  def __eq__(self, other):
17909 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17910 
 
17911 
  def __ne__(self, other):
17912 
    return not (self == other)
17913 
 
17914 
class getAllAliveItems_result:
17915 
  """
17916 
  Attributes:
17917 
   - success
17918 
  """
17919 
 
17920 
  thrift_spec = (
17921 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
17922 
  )
17923 
 
17924 
  def __init__(self, success=None,):
17925 
    self.success = success
17926 
 
17927 
  def read(self, iprot):
17928 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17929 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17930 
      return
17931 
    iprot.readStructBegin()
17932 
    while True:
17933 
      (fname, ftype, fid) = iprot.readFieldBegin()
17934 
      if ftype == TType.STOP:
17935 
        break
17936 
      if fid == 0:
17937 
        if ftype == TType.LIST:
17938 
          self.success = []
9155 kshitij.so 17939 
          (_etype377, _size374) = iprot.readListBegin()
17940 
          for _i378 in xrange(_size374):
17941 
            _elem379 = Item()
17942 
            _elem379.read(iprot)
17943 
            self.success.append(_elem379)
6821 amar.kumar 17944 
          iprot.readListEnd()
17945 
        else:
17946 
          iprot.skip(ftype)
17947 
      else:
17948 
        iprot.skip(ftype)
17949 
      iprot.readFieldEnd()
17950 
    iprot.readStructEnd()
17951 
 
17952 
  def write(self, oprot):
17953 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17954 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17955 
      return
17956 
    oprot.writeStructBegin('getAllAliveItems_result')
17957 
    if self.success is not None:
17958 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17959 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 17960 
      for iter380 in self.success:
17961 
        iter380.write(oprot)
6821 amar.kumar 17962 
      oprot.writeListEnd()
17963 
      oprot.writeFieldEnd()
17964 
    oprot.writeFieldStop()
17965 
    oprot.writeStructEnd()
17966 
 
17967 
  def validate(self):
17968 
    return
17969 
 
17970 
 
17971 
  def __repr__(self):
17972 
    L = ['%s=%r' % (key, value)
17973 
      for key, value in self.__dict__.iteritems()]
17974 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17975 
 
17976 
  def __eq__(self, other):
17977 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17978 
 
17979 
  def __ne__(self, other):
17980 
    return not (self == other)
17981 
 
6805 anupam.sin 17982 
class getInsuranceAmount_args:
17983 
  """
17984 
  Attributes:
17985 
   - itemId
6921 anupam.sin 17986 
   - price
6805 anupam.sin 17987 
   - insurerId
17988 
   - quantity
17989 
  """
17990 
 
17991 
  thrift_spec = (
17992 
    None, # 0
17993 
    (1, TType.I64, 'itemId', None, None, ), # 1
6921 anupam.sin 17994 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
17995 
    (3, TType.I64, 'insurerId', None, None, ), # 3
17996 
    (4, TType.I64, 'quantity', None, None, ), # 4
6805 anupam.sin 17997 
  )
17998 
 
6921 anupam.sin 17999 
  def __init__(self, itemId=None, price=None, insurerId=None, quantity=None,):
6805 anupam.sin 18000 
    self.itemId = itemId
6921 anupam.sin 18001 
    self.price = price
6805 anupam.sin 18002 
    self.insurerId = insurerId
18003 
    self.quantity = quantity
18004 
 
18005 
  def read(self, iprot):
18006 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18007 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18008 
      return
18009 
    iprot.readStructBegin()
18010 
    while True:
18011 
      (fname, ftype, fid) = iprot.readFieldBegin()
18012 
      if ftype == TType.STOP:
18013 
        break
18014 
      if fid == 1:
18015 
        if ftype == TType.I64:
18016 
          self.itemId = iprot.readI64();
18017 
        else:
18018 
          iprot.skip(ftype)
18019 
      elif fid == 2:
6921 anupam.sin 18020 
        if ftype == TType.DOUBLE:
18021 
          self.price = iprot.readDouble();
18022 
        else:
18023 
          iprot.skip(ftype)
18024 
      elif fid == 3:
6805 anupam.sin 18025 
        if ftype == TType.I64:
18026 
          self.insurerId = iprot.readI64();
18027 
        else:
18028 
          iprot.skip(ftype)
6921 anupam.sin 18029 
      elif fid == 4:
6805 anupam.sin 18030 
        if ftype == TType.I64:
18031 
          self.quantity = iprot.readI64();
18032 
        else:
18033 
          iprot.skip(ftype)
18034 
      else:
18035 
        iprot.skip(ftype)
18036 
      iprot.readFieldEnd()
18037 
    iprot.readStructEnd()
18038 
 
18039 
  def write(self, oprot):
18040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18042 
      return
18043 
    oprot.writeStructBegin('getInsuranceAmount_args')
18044 
    if self.itemId is not None:
18045 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18046 
      oprot.writeI64(self.itemId)
18047 
      oprot.writeFieldEnd()
6921 anupam.sin 18048 
    if self.price is not None:
18049 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
18050 
      oprot.writeDouble(self.price)
18051 
      oprot.writeFieldEnd()
6805 anupam.sin 18052 
    if self.insurerId is not None:
6921 anupam.sin 18053 
      oprot.writeFieldBegin('insurerId', TType.I64, 3)
6805 anupam.sin 18054 
      oprot.writeI64(self.insurerId)
18055 
      oprot.writeFieldEnd()
18056 
    if self.quantity is not None:
6921 anupam.sin 18057 
      oprot.writeFieldBegin('quantity', TType.I64, 4)
6805 anupam.sin 18058 
      oprot.writeI64(self.quantity)
18059 
      oprot.writeFieldEnd()
18060 
    oprot.writeFieldStop()
18061 
    oprot.writeStructEnd()
18062 
 
18063 
  def validate(self):
18064 
    return
18065 
 
18066 
 
18067 
  def __repr__(self):
18068 
    L = ['%s=%r' % (key, value)
18069 
      for key, value in self.__dict__.iteritems()]
18070 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18071 
 
18072 
  def __eq__(self, other):
18073 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18074 
 
18075 
  def __ne__(self, other):
18076 
    return not (self == other)
18077 
 
18078 
class getInsuranceAmount_result:
18079 
  """
18080 
  Attributes:
18081 
   - success
18082 
  """
18083 
 
18084 
  thrift_spec = (
18085 
    (0, TType.I64, 'success', None, None, ), # 0
18086 
  )
18087 
 
18088 
  def __init__(self, success=None,):
18089 
    self.success = success
18090 
 
18091 
  def read(self, iprot):
18092 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18093 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18094 
      return
18095 
    iprot.readStructBegin()
18096 
    while True:
18097 
      (fname, ftype, fid) = iprot.readFieldBegin()
18098 
      if ftype == TType.STOP:
18099 
        break
18100 
      if fid == 0:
18101 
        if ftype == TType.I64:
18102 
          self.success = iprot.readI64();
18103 
        else:
18104 
          iprot.skip(ftype)
18105 
      else:
18106 
        iprot.skip(ftype)
18107 
      iprot.readFieldEnd()
18108 
    iprot.readStructEnd()
18109 
 
18110 
  def write(self, oprot):
18111 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18112 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18113 
      return
18114 
    oprot.writeStructBegin('getInsuranceAmount_result')
18115 
    if self.success is not None:
18116 
      oprot.writeFieldBegin('success', TType.I64, 0)
18117 
      oprot.writeI64(self.success)
18118 
      oprot.writeFieldEnd()
18119 
    oprot.writeFieldStop()
18120 
    oprot.writeStructEnd()
18121 
 
18122 
  def validate(self):
18123 
    return
18124 
 
18125 
 
18126 
  def __repr__(self):
18127 
    L = ['%s=%r' % (key, value)
18128 
      for key, value in self.__dict__.iteritems()]
18129 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18130 
 
18131 
  def __eq__(self, other):
18132 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18133 
 
18134 
  def __ne__(self, other):
18135 
    return not (self == other)
18136 
 
18137 
class getInsurer_args:
18138 
  """
18139 
  Attributes:
18140 
   - insurerId
18141 
  """
18142 
 
18143 
  thrift_spec = (
18144 
    None, # 0
18145 
    (1, TType.I64, 'insurerId', None, None, ), # 1
18146 
  )
18147 
 
18148 
  def __init__(self, insurerId=None,):
18149 
    self.insurerId = insurerId
18150 
 
18151 
  def read(self, iprot):
18152 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18153 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18154 
      return
18155 
    iprot.readStructBegin()
18156 
    while True:
18157 
      (fname, ftype, fid) = iprot.readFieldBegin()
18158 
      if ftype == TType.STOP:
18159 
        break
18160 
      if fid == 1:
18161 
        if ftype == TType.I64:
18162 
          self.insurerId = iprot.readI64();
18163 
        else:
18164 
          iprot.skip(ftype)
18165 
      else:
18166 
        iprot.skip(ftype)
18167 
      iprot.readFieldEnd()
18168 
    iprot.readStructEnd()
18169 
 
18170 
  def write(self, oprot):
18171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18173 
      return
18174 
    oprot.writeStructBegin('getInsurer_args')
18175 
    if self.insurerId is not None:
18176 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
18177 
      oprot.writeI64(self.insurerId)
18178 
      oprot.writeFieldEnd()
18179 
    oprot.writeFieldStop()
18180 
    oprot.writeStructEnd()
18181 
 
18182 
  def validate(self):
18183 
    return
18184 
 
18185 
 
18186 
  def __repr__(self):
18187 
    L = ['%s=%r' % (key, value)
18188 
      for key, value in self.__dict__.iteritems()]
18189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18190 
 
18191 
  def __eq__(self, other):
18192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18193 
 
18194 
  def __ne__(self, other):
18195 
    return not (self == other)
18196 
 
18197 
class getInsurer_result:
18198 
  """
18199 
  Attributes:
18200 
   - success
18201 
  """
18202 
 
18203 
  thrift_spec = (
18204 
    (0, TType.STRUCT, 'success', (Insurer, Insurer.thrift_spec), None, ), # 0
18205 
  )
18206 
 
18207 
  def __init__(self, success=None,):
18208 
    self.success = success
18209 
 
18210 
  def read(self, iprot):
18211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18213 
      return
18214 
    iprot.readStructBegin()
18215 
    while True:
18216 
      (fname, ftype, fid) = iprot.readFieldBegin()
18217 
      if ftype == TType.STOP:
18218 
        break
18219 
      if fid == 0:
18220 
        if ftype == TType.STRUCT:
18221 
          self.success = Insurer()
18222 
          self.success.read(iprot)
18223 
        else:
18224 
          iprot.skip(ftype)
18225 
      else:
18226 
        iprot.skip(ftype)
18227 
      iprot.readFieldEnd()
18228 
    iprot.readStructEnd()
18229 
 
18230 
  def write(self, oprot):
18231 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18232 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18233 
      return
18234 
    oprot.writeStructBegin('getInsurer_result')
18235 
    if self.success is not None:
18236 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18237 
      self.success.write(oprot)
18238 
      oprot.writeFieldEnd()
18239 
    oprot.writeFieldStop()
18240 
    oprot.writeStructEnd()
18241 
 
18242 
  def validate(self):
18243 
    return
18244 
 
18245 
 
18246 
  def __repr__(self):
18247 
    L = ['%s=%r' % (key, value)
18248 
      for key, value in self.__dict__.iteritems()]
18249 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18250 
 
18251 
  def __eq__(self, other):
18252 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18253 
 
18254 
  def __ne__(self, other):
18255 
    return not (self == other)
6838 vikram.rag 18256 
 
18257 
class getAllInsurers_args:
18258 
 
18259 
  thrift_spec = (
18260 
  )
18261 
 
18262 
  def read(self, iprot):
18263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18265 
      return
18266 
    iprot.readStructBegin()
18267 
    while True:
18268 
      (fname, ftype, fid) = iprot.readFieldBegin()
18269 
      if ftype == TType.STOP:
18270 
        break
18271 
      else:
18272 
        iprot.skip(ftype)
18273 
      iprot.readFieldEnd()
18274 
    iprot.readStructEnd()
18275 
 
18276 
  def write(self, oprot):
18277 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18278 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18279 
      return
18280 
    oprot.writeStructBegin('getAllInsurers_args')
18281 
    oprot.writeFieldStop()
18282 
    oprot.writeStructEnd()
18283 
 
18284 
  def validate(self):
18285 
    return
18286 
 
18287 
 
18288 
  def __repr__(self):
18289 
    L = ['%s=%r' % (key, value)
18290 
      for key, value in self.__dict__.iteritems()]
18291 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18292 
 
18293 
  def __eq__(self, other):
18294 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18295 
 
18296 
  def __ne__(self, other):
18297 
    return not (self == other)
18298 
 
18299 
class getAllInsurers_result:
18300 
  """
18301 
  Attributes:
18302 
   - success
18303 
  """
18304 
 
18305 
  thrift_spec = (
18306 
    (0, TType.LIST, 'success', (TType.STRUCT,(Insurer, Insurer.thrift_spec)), None, ), # 0
18307 
  )
18308 
 
18309 
  def __init__(self, success=None,):
18310 
    self.success = success
18311 
 
18312 
  def read(self, iprot):
18313 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18314 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18315 
      return
18316 
    iprot.readStructBegin()
18317 
    while True:
18318 
      (fname, ftype, fid) = iprot.readFieldBegin()
18319 
      if ftype == TType.STOP:
18320 
        break
18321 
      if fid == 0:
18322 
        if ftype == TType.LIST:
18323 
          self.success = []
9155 kshitij.so 18324 
          (_etype384, _size381) = iprot.readListBegin()
18325 
          for _i385 in xrange(_size381):
18326 
            _elem386 = Insurer()
18327 
            _elem386.read(iprot)
18328 
            self.success.append(_elem386)
6838 vikram.rag 18329 
          iprot.readListEnd()
18330 
        else:
18331 
          iprot.skip(ftype)
18332 
      else:
18333 
        iprot.skip(ftype)
18334 
      iprot.readFieldEnd()
18335 
    iprot.readStructEnd()
18336 
 
18337 
  def write(self, oprot):
18338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18340 
      return
18341 
    oprot.writeStructBegin('getAllInsurers_result')
18342 
    if self.success is not None:
18343 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18344 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18345 
      for iter387 in self.success:
18346 
        iter387.write(oprot)
6838 vikram.rag 18347 
      oprot.writeListEnd()
18348 
      oprot.writeFieldEnd()
18349 
    oprot.writeFieldStop()
18350 
    oprot.writeStructEnd()
18351 
 
18352 
  def validate(self):
18353 
    return
18354 
 
18355 
 
18356 
  def __repr__(self):
18357 
    L = ['%s=%r' % (key, value)
18358 
      for key, value in self.__dict__.iteritems()]
18359 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18360 
 
18361 
  def __eq__(self, other):
18362 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18363 
 
18364 
  def __ne__(self, other):
18365 
    return not (self == other)
6962 rajveer 18366 
 
18367 
class updateInsuranceDeclaredAmount_args:
18368 
  """
18369 
  Attributes:
18370 
   - insurerId
18371 
   - amount
18372 
  """
18373 
 
18374 
  thrift_spec = (
18375 
    None, # 0
18376 
    (1, TType.I64, 'insurerId', None, None, ), # 1
18377 
    (2, TType.DOUBLE, 'amount', None, None, ), # 2
18378 
  )
18379 
 
18380 
  def __init__(self, insurerId=None, amount=None,):
18381 
    self.insurerId = insurerId
18382 
    self.amount = amount
18383 
 
18384 
  def read(self, iprot):
18385 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18386 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18387 
      return
18388 
    iprot.readStructBegin()
18389 
    while True:
18390 
      (fname, ftype, fid) = iprot.readFieldBegin()
18391 
      if ftype == TType.STOP:
18392 
        break
18393 
      if fid == 1:
18394 
        if ftype == TType.I64:
18395 
          self.insurerId = iprot.readI64();
18396 
        else:
18397 
          iprot.skip(ftype)
18398 
      elif fid == 2:
18399 
        if ftype == TType.DOUBLE:
18400 
          self.amount = iprot.readDouble();
18401 
        else:
18402 
          iprot.skip(ftype)
18403 
      else:
18404 
        iprot.skip(ftype)
18405 
      iprot.readFieldEnd()
18406 
    iprot.readStructEnd()
18407 
 
18408 
  def write(self, oprot):
18409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18411 
      return
18412 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_args')
18413 
    if self.insurerId is not None:
18414 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
18415 
      oprot.writeI64(self.insurerId)
18416 
      oprot.writeFieldEnd()
18417 
    if self.amount is not None:
18418 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 2)
18419 
      oprot.writeDouble(self.amount)
18420 
      oprot.writeFieldEnd()
18421 
    oprot.writeFieldStop()
18422 
    oprot.writeStructEnd()
18423 
 
18424 
  def validate(self):
18425 
    return
18426 
 
18427 
 
18428 
  def __repr__(self):
18429 
    L = ['%s=%r' % (key, value)
18430 
      for key, value in self.__dict__.iteritems()]
18431 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18432 
 
18433 
  def __eq__(self, other):
18434 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18435 
 
18436 
  def __ne__(self, other):
18437 
    return not (self == other)
18438 
 
18439 
class updateInsuranceDeclaredAmount_result:
18440 
 
18441 
  thrift_spec = (
18442 
  )
18443 
 
18444 
  def read(self, iprot):
18445 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18446 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18447 
      return
18448 
    iprot.readStructBegin()
18449 
    while True:
18450 
      (fname, ftype, fid) = iprot.readFieldBegin()
18451 
      if ftype == TType.STOP:
18452 
        break
18453 
      else:
18454 
        iprot.skip(ftype)
18455 
      iprot.readFieldEnd()
18456 
    iprot.readStructEnd()
18457 
 
18458 
  def write(self, oprot):
18459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18461 
      return
18462 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_result')
18463 
    oprot.writeFieldStop()
18464 
    oprot.writeStructEnd()
18465 
 
18466 
  def validate(self):
18467 
    return
18468 
 
18469 
 
18470 
  def __repr__(self):
18471 
    L = ['%s=%r' % (key, value)
18472 
      for key, value in self.__dict__.iteritems()]
18473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18474 
 
18475 
  def __eq__(self, other):
18476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18477 
 
18478 
  def __ne__(self, other):
18479 
    return not (self == other)
7190 amar.kumar 18480 
 
18481 
class getFreebieForItem_args:
18482 
  """
18483 
  Attributes:
18484 
   - itemId
18485 
  """
18486 
 
18487 
  thrift_spec = (
18488 
    None, # 0
18489 
    (1, TType.I64, 'itemId', None, None, ), # 1
18490 
  )
18491 
 
18492 
  def __init__(self, itemId=None,):
18493 
    self.itemId = itemId
18494 
 
18495 
  def read(self, iprot):
18496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18498 
      return
18499 
    iprot.readStructBegin()
18500 
    while True:
18501 
      (fname, ftype, fid) = iprot.readFieldBegin()
18502 
      if ftype == TType.STOP:
18503 
        break
18504 
      if fid == 1:
18505 
        if ftype == TType.I64:
18506 
          self.itemId = iprot.readI64();
18507 
        else:
18508 
          iprot.skip(ftype)
18509 
      else:
18510 
        iprot.skip(ftype)
18511 
      iprot.readFieldEnd()
18512 
    iprot.readStructEnd()
18513 
 
18514 
  def write(self, oprot):
18515 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18516 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18517 
      return
18518 
    oprot.writeStructBegin('getFreebieForItem_args')
18519 
    if self.itemId is not None:
18520 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18521 
      oprot.writeI64(self.itemId)
18522 
      oprot.writeFieldEnd()
18523 
    oprot.writeFieldStop()
18524 
    oprot.writeStructEnd()
18525 
 
18526 
  def validate(self):
18527 
    return
18528 
 
18529 
 
18530 
  def __repr__(self):
18531 
    L = ['%s=%r' % (key, value)
18532 
      for key, value in self.__dict__.iteritems()]
18533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18534 
 
18535 
  def __eq__(self, other):
18536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18537 
 
18538 
  def __ne__(self, other):
18539 
    return not (self == other)
18540 
 
18541 
class getFreebieForItem_result:
18542 
  """
18543 
  Attributes:
18544 
   - success
18545 
  """
18546 
 
18547 
  thrift_spec = (
18548 
    (0, TType.I64, 'success', None, None, ), # 0
18549 
  )
18550 
 
18551 
  def __init__(self, success=None,):
18552 
    self.success = success
18553 
 
18554 
  def read(self, iprot):
18555 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18556 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18557 
      return
18558 
    iprot.readStructBegin()
18559 
    while True:
18560 
      (fname, ftype, fid) = iprot.readFieldBegin()
18561 
      if ftype == TType.STOP:
18562 
        break
18563 
      if fid == 0:
18564 
        if ftype == TType.I64:
18565 
          self.success = iprot.readI64();
18566 
        else:
18567 
          iprot.skip(ftype)
18568 
      else:
18569 
        iprot.skip(ftype)
18570 
      iprot.readFieldEnd()
18571 
    iprot.readStructEnd()
18572 
 
18573 
  def write(self, oprot):
18574 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18575 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18576 
      return
18577 
    oprot.writeStructBegin('getFreebieForItem_result')
18578 
    if self.success is not None:
18579 
      oprot.writeFieldBegin('success', TType.I64, 0)
18580 
      oprot.writeI64(self.success)
18581 
      oprot.writeFieldEnd()
18582 
    oprot.writeFieldStop()
18583 
    oprot.writeStructEnd()
18584 
 
18585 
  def validate(self):
18586 
    return
18587 
 
18588 
 
18589 
  def __repr__(self):
18590 
    L = ['%s=%r' % (key, value)
18591 
      for key, value in self.__dict__.iteritems()]
18592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18593 
 
18594 
  def __eq__(self, other):
18595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18596 
 
18597 
  def __ne__(self, other):
18598 
    return not (self == other)
18599 
 
18600 
class addOrUpdateFreebieForItem_args:
18601 
  """
18602 
  Attributes:
18603 
   - freebieItem
18604 
  """
18605 
 
18606 
  thrift_spec = (
18607 
    None, # 0
18608 
    (1, TType.STRUCT, 'freebieItem', (FreebieItem, FreebieItem.thrift_spec), None, ), # 1
18609 
  )
18610 
 
18611 
  def __init__(self, freebieItem=None,):
18612 
    self.freebieItem = freebieItem
18613 
 
18614 
  def read(self, iprot):
18615 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18616 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18617 
      return
18618 
    iprot.readStructBegin()
18619 
    while True:
18620 
      (fname, ftype, fid) = iprot.readFieldBegin()
18621 
      if ftype == TType.STOP:
18622 
        break
18623 
      if fid == 1:
18624 
        if ftype == TType.STRUCT:
18625 
          self.freebieItem = FreebieItem()
18626 
          self.freebieItem.read(iprot)
18627 
        else:
18628 
          iprot.skip(ftype)
18629 
      else:
18630 
        iprot.skip(ftype)
18631 
      iprot.readFieldEnd()
18632 
    iprot.readStructEnd()
18633 
 
18634 
  def write(self, oprot):
18635 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18636 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18637 
      return
18638 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_args')
18639 
    if self.freebieItem is not None:
18640 
      oprot.writeFieldBegin('freebieItem', TType.STRUCT, 1)
18641 
      self.freebieItem.write(oprot)
18642 
      oprot.writeFieldEnd()
18643 
    oprot.writeFieldStop()
18644 
    oprot.writeStructEnd()
18645 
 
18646 
  def validate(self):
18647 
    return
18648 
 
18649 
 
18650 
  def __repr__(self):
18651 
    L = ['%s=%r' % (key, value)
18652 
      for key, value in self.__dict__.iteritems()]
18653 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18654 
 
18655 
  def __eq__(self, other):
18656 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18657 
 
18658 
  def __ne__(self, other):
18659 
    return not (self == other)
18660 
 
18661 
class addOrUpdateFreebieForItem_result:
18662 
 
18663 
  thrift_spec = (
18664 
  )
18665 
 
18666 
  def read(self, iprot):
18667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18669 
      return
18670 
    iprot.readStructBegin()
18671 
    while True:
18672 
      (fname, ftype, fid) = iprot.readFieldBegin()
18673 
      if ftype == TType.STOP:
18674 
        break
18675 
      else:
18676 
        iprot.skip(ftype)
18677 
      iprot.readFieldEnd()
18678 
    iprot.readStructEnd()
18679 
 
18680 
  def write(self, oprot):
18681 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18682 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18683 
      return
18684 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_result')
18685 
    oprot.writeFieldStop()
18686 
    oprot.writeStructEnd()
18687 
 
18688 
  def validate(self):
18689 
    return
18690 
 
18691 
 
18692 
  def __repr__(self):
18693 
    L = ['%s=%r' % (key, value)
18694 
      for key, value in self.__dict__.iteritems()]
18695 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18696 
 
18697 
  def __eq__(self, other):
18698 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18699 
 
18700 
  def __ne__(self, other):
18701 
    return not (self == other)
7256 rajveer 18702 
 
7272 amit.gupta 18703 
class addOrUpdateBrandInfo_args:
18704 
  """
18705 
  Attributes:
18706 
   - brandInfo
18707 
  """
18708 
 
18709 
  thrift_spec = (
18710 
    None, # 0
18711 
    (1, TType.STRUCT, 'brandInfo', (BrandInfo, BrandInfo.thrift_spec), None, ), # 1
18712 
  )
18713 
 
18714 
  def __init__(self, brandInfo=None,):
18715 
    self.brandInfo = brandInfo
18716 
 
18717 
  def read(self, iprot):
18718 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18719 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18720 
      return
18721 
    iprot.readStructBegin()
18722 
    while True:
18723 
      (fname, ftype, fid) = iprot.readFieldBegin()
18724 
      if ftype == TType.STOP:
18725 
        break
18726 
      if fid == 1:
18727 
        if ftype == TType.STRUCT:
18728 
          self.brandInfo = BrandInfo()
18729 
          self.brandInfo.read(iprot)
18730 
        else:
18731 
          iprot.skip(ftype)
18732 
      else:
18733 
        iprot.skip(ftype)
18734 
      iprot.readFieldEnd()
18735 
    iprot.readStructEnd()
18736 
 
18737 
  def write(self, oprot):
18738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18740 
      return
18741 
    oprot.writeStructBegin('addOrUpdateBrandInfo_args')
18742 
    if self.brandInfo is not None:
18743 
      oprot.writeFieldBegin('brandInfo', TType.STRUCT, 1)
18744 
      self.brandInfo.write(oprot)
18745 
      oprot.writeFieldEnd()
18746 
    oprot.writeFieldStop()
18747 
    oprot.writeStructEnd()
18748 
 
18749 
  def validate(self):
18750 
    return
18751 
 
18752 
 
18753 
  def __repr__(self):
18754 
    L = ['%s=%r' % (key, value)
18755 
      for key, value in self.__dict__.iteritems()]
18756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18757 
 
18758 
  def __eq__(self, other):
18759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18760 
 
18761 
  def __ne__(self, other):
18762 
    return not (self == other)
18763 
 
18764 
class addOrUpdateBrandInfo_result:
18765 
 
18766 
  thrift_spec = (
18767 
  )
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 
      else:
18779 
        iprot.skip(ftype)
18780 
      iprot.readFieldEnd()
18781 
    iprot.readStructEnd()
18782 
 
18783 
  def write(self, oprot):
18784 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18785 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18786 
      return
18787 
    oprot.writeStructBegin('addOrUpdateBrandInfo_result')
18788 
    oprot.writeFieldStop()
18789 
    oprot.writeStructEnd()
18790 
 
18791 
  def validate(self):
18792 
    return
18793 
 
18794 
 
18795 
  def __repr__(self):
18796 
    L = ['%s=%r' % (key, value)
18797 
      for key, value in self.__dict__.iteritems()]
18798 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18799 
 
18800 
  def __eq__(self, other):
18801 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18802 
 
18803 
  def __ne__(self, other):
18804 
    return not (self == other)
18805 
 
18806 
class getBrandInfo_args:
18807 
 
18808 
  thrift_spec = (
18809 
  )
18810 
 
18811 
  def read(self, iprot):
18812 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18813 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18814 
      return
18815 
    iprot.readStructBegin()
18816 
    while True:
18817 
      (fname, ftype, fid) = iprot.readFieldBegin()
18818 
      if ftype == TType.STOP:
18819 
        break
18820 
      else:
18821 
        iprot.skip(ftype)
18822 
      iprot.readFieldEnd()
18823 
    iprot.readStructEnd()
18824 
 
18825 
  def write(self, oprot):
18826 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18827 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18828 
      return
18829 
    oprot.writeStructBegin('getBrandInfo_args')
18830 
    oprot.writeFieldStop()
18831 
    oprot.writeStructEnd()
18832 
 
18833 
  def validate(self):
18834 
    return
18835 
 
18836 
 
18837 
  def __repr__(self):
18838 
    L = ['%s=%r' % (key, value)
18839 
      for key, value in self.__dict__.iteritems()]
18840 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18841 
 
18842 
  def __eq__(self, other):
18843 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18844 
 
18845 
  def __ne__(self, other):
18846 
    return not (self == other)
18847 
 
18848 
class getBrandInfo_result:
18849 
  """
18850 
  Attributes:
18851 
   - success
18852 
  """
18853 
 
18854 
  thrift_spec = (
18855 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(BrandInfo, BrandInfo.thrift_spec)), None, ), # 0
18856 
  )
18857 
 
18858 
  def __init__(self, success=None,):
18859 
    self.success = success
18860 
 
18861 
  def read(self, iprot):
18862 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18863 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18864 
      return
18865 
    iprot.readStructBegin()
18866 
    while True:
18867 
      (fname, ftype, fid) = iprot.readFieldBegin()
18868 
      if ftype == TType.STOP:
18869 
        break
18870 
      if fid == 0:
18871 
        if ftype == TType.MAP:
18872 
          self.success = {}
9155 kshitij.so 18873 
          (_ktype389, _vtype390, _size388 ) = iprot.readMapBegin()
18874 
          for _i392 in xrange(_size388):
18875 
            _key393 = iprot.readString();
18876 
            _val394 = BrandInfo()
18877 
            _val394.read(iprot)
18878 
            self.success[_key393] = _val394
7272 amit.gupta 18879 
          iprot.readMapEnd()
18880 
        else:
18881 
          iprot.skip(ftype)
18882 
      else:
18883 
        iprot.skip(ftype)
18884 
      iprot.readFieldEnd()
18885 
    iprot.readStructEnd()
18886 
 
18887 
  def write(self, oprot):
18888 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18889 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18890 
      return
18891 
    oprot.writeStructBegin('getBrandInfo_result')
18892 
    if self.success is not None:
18893 
      oprot.writeFieldBegin('success', TType.MAP, 0)
18894 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
9155 kshitij.so 18895 
      for kiter395,viter396 in self.success.items():
18896 
        oprot.writeString(kiter395)
18897 
        viter396.write(oprot)
7272 amit.gupta 18898 
      oprot.writeMapEnd()
18899 
      oprot.writeFieldEnd()
18900 
    oprot.writeFieldStop()
18901 
    oprot.writeStructEnd()
18902 
 
18903 
  def validate(self):
18904 
    return
18905 
 
18906 
 
18907 
  def __repr__(self):
18908 
    L = ['%s=%r' % (key, value)
18909 
      for key, value in self.__dict__.iteritems()]
18910 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18911 
 
18912 
  def __eq__(self, other):
18913 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18914 
 
18915 
  def __ne__(self, other):
18916 
    return not (self == other)
18917 
 
7256 rajveer 18918 
class getStorePricing_args:
18919 
  """
18920 
  Attributes:
18921 
   - itemId
18922 
  """
18923 
 
18924 
  thrift_spec = (
18925 
    None, # 0
18926 
    (1, TType.I64, 'itemId', None, None, ), # 1
18927 
  )
18928 
 
18929 
  def __init__(self, itemId=None,):
18930 
    self.itemId = itemId
18931 
 
18932 
  def read(self, iprot):
18933 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18934 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18935 
      return
18936 
    iprot.readStructBegin()
18937 
    while True:
18938 
      (fname, ftype, fid) = iprot.readFieldBegin()
18939 
      if ftype == TType.STOP:
18940 
        break
18941 
      if fid == 1:
18942 
        if ftype == TType.I64:
18943 
          self.itemId = iprot.readI64();
18944 
        else:
18945 
          iprot.skip(ftype)
18946 
      else:
18947 
        iprot.skip(ftype)
18948 
      iprot.readFieldEnd()
18949 
    iprot.readStructEnd()
18950 
 
18951 
  def write(self, oprot):
18952 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18953 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18954 
      return
18955 
    oprot.writeStructBegin('getStorePricing_args')
18956 
    if self.itemId is not None:
18957 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18958 
      oprot.writeI64(self.itemId)
18959 
      oprot.writeFieldEnd()
18960 
    oprot.writeFieldStop()
18961 
    oprot.writeStructEnd()
18962 
 
18963 
  def validate(self):
18964 
    return
18965 
 
18966 
 
18967 
  def __repr__(self):
18968 
    L = ['%s=%r' % (key, value)
18969 
      for key, value in self.__dict__.iteritems()]
18970 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18971 
 
18972 
  def __eq__(self, other):
18973 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18974 
 
18975 
  def __ne__(self, other):
18976 
    return not (self == other)
18977 
 
18978 
class getStorePricing_result:
18979 
  """
18980 
  Attributes:
18981 
   - success
18982 
  """
18983 
 
18984 
  thrift_spec = (
18985 
    (0, TType.STRUCT, 'success', (StorePricing, StorePricing.thrift_spec), None, ), # 0
18986 
  )
18987 
 
18988 
  def __init__(self, success=None,):
18989 
    self.success = success
18990 
 
18991 
  def read(self, iprot):
18992 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18993 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18994 
      return
18995 
    iprot.readStructBegin()
18996 
    while True:
18997 
      (fname, ftype, fid) = iprot.readFieldBegin()
18998 
      if ftype == TType.STOP:
18999 
        break
19000 
      if fid == 0:
19001 
        if ftype == TType.STRUCT:
19002 
          self.success = StorePricing()
19003 
          self.success.read(iprot)
19004 
        else:
19005 
          iprot.skip(ftype)
19006 
      else:
19007 
        iprot.skip(ftype)
19008 
      iprot.readFieldEnd()
19009 
    iprot.readStructEnd()
19010 
 
19011 
  def write(self, oprot):
19012 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19013 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19014 
      return
19015 
    oprot.writeStructBegin('getStorePricing_result')
19016 
    if self.success is not None:
19017 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19018 
      self.success.write(oprot)
19019 
      oprot.writeFieldEnd()
19020 
    oprot.writeFieldStop()
19021 
    oprot.writeStructEnd()
19022 
 
19023 
  def validate(self):
19024 
    return
19025 
 
19026 
 
19027 
  def __repr__(self):
19028 
    L = ['%s=%r' % (key, value)
19029 
      for key, value in self.__dict__.iteritems()]
19030 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19031 
 
19032 
  def __eq__(self, other):
19033 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19034 
 
19035 
  def __ne__(self, other):
19036 
    return not (self == other)
7265 rajveer 19037 
 
7306 rajveer 19038 
class getStorePricings_args:
19039 
  """
19040 
  Attributes:
19041 
   - itemIds
19042 
  """
19043 
 
19044 
  thrift_spec = (
19045 
    None, # 0
19046 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
19047 
  )
19048 
 
19049 
  def __init__(self, itemIds=None,):
19050 
    self.itemIds = itemIds
19051 
 
19052 
  def read(self, iprot):
19053 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19054 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19055 
      return
19056 
    iprot.readStructBegin()
19057 
    while True:
19058 
      (fname, ftype, fid) = iprot.readFieldBegin()
19059 
      if ftype == TType.STOP:
19060 
        break
19061 
      if fid == 1:
19062 
        if ftype == TType.LIST:
19063 
          self.itemIds = []
9155 kshitij.so 19064 
          (_etype400, _size397) = iprot.readListBegin()
19065 
          for _i401 in xrange(_size397):
19066 
            _elem402 = iprot.readI64();
19067 
            self.itemIds.append(_elem402)
7306 rajveer 19068 
          iprot.readListEnd()
19069 
        else:
19070 
          iprot.skip(ftype)
19071 
      else:
19072 
        iprot.skip(ftype)
19073 
      iprot.readFieldEnd()
19074 
    iprot.readStructEnd()
19075 
 
19076 
  def write(self, oprot):
19077 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19078 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19079 
      return
19080 
    oprot.writeStructBegin('getStorePricings_args')
19081 
    if self.itemIds is not None:
19082 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
19083 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
9155 kshitij.so 19084 
      for iter403 in self.itemIds:
19085 
        oprot.writeI64(iter403)
7306 rajveer 19086 
      oprot.writeListEnd()
19087 
      oprot.writeFieldEnd()
19088 
    oprot.writeFieldStop()
19089 
    oprot.writeStructEnd()
19090 
 
19091 
  def validate(self):
19092 
    return
19093 
 
19094 
 
19095 
  def __repr__(self):
19096 
    L = ['%s=%r' % (key, value)
19097 
      for key, value in self.__dict__.iteritems()]
19098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19099 
 
19100 
  def __eq__(self, other):
19101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19102 
 
19103 
  def __ne__(self, other):
19104 
    return not (self == other)
19105 
 
19106 
class getStorePricings_result:
19107 
  """
19108 
  Attributes:
19109 
   - success
19110 
  """
19111 
 
19112 
  thrift_spec = (
19113 
    (0, TType.LIST, 'success', (TType.STRUCT,(StorePricing, StorePricing.thrift_spec)), None, ), # 0
19114 
  )
19115 
 
19116 
  def __init__(self, success=None,):
19117 
    self.success = success
19118 
 
19119 
  def read(self, iprot):
19120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19122 
      return
19123 
    iprot.readStructBegin()
19124 
    while True:
19125 
      (fname, ftype, fid) = iprot.readFieldBegin()
19126 
      if ftype == TType.STOP:
19127 
        break
19128 
      if fid == 0:
19129 
        if ftype == TType.LIST:
19130 
          self.success = []
9155 kshitij.so 19131 
          (_etype407, _size404) = iprot.readListBegin()
19132 
          for _i408 in xrange(_size404):
19133 
            _elem409 = StorePricing()
19134 
            _elem409.read(iprot)
19135 
            self.success.append(_elem409)
7306 rajveer 19136 
          iprot.readListEnd()
19137 
        else:
19138 
          iprot.skip(ftype)
19139 
      else:
19140 
        iprot.skip(ftype)
19141 
      iprot.readFieldEnd()
19142 
    iprot.readStructEnd()
19143 
 
19144 
  def write(self, oprot):
19145 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19146 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19147 
      return
19148 
    oprot.writeStructBegin('getStorePricings_result')
19149 
    if self.success is not None:
19150 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19151 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 19152 
      for iter410 in self.success:
19153 
        iter410.write(oprot)
7306 rajveer 19154 
      oprot.writeListEnd()
19155 
      oprot.writeFieldEnd()
19156 
    oprot.writeFieldStop()
19157 
    oprot.writeStructEnd()
19158 
 
19159 
  def validate(self):
19160 
    return
19161 
 
19162 
 
19163 
  def __repr__(self):
19164 
    L = ['%s=%r' % (key, value)
19165 
      for key, value in self.__dict__.iteritems()]
19166 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19167 
 
19168 
  def __eq__(self, other):
19169 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19170 
 
19171 
  def __ne__(self, other):
19172 
    return not (self == other)
19173 
 
7265 rajveer 19174 
class updateStorePricing_args:
19175 
  """
19176 
  Attributes:
19177 
   - sp
7382 rajveer 19178 
   - allColors
7265 rajveer 19179 
  """
19180 
 
19181 
  thrift_spec = (
19182 
    None, # 0
19183 
    (1, TType.STRUCT, 'sp', (StorePricing, StorePricing.thrift_spec), None, ), # 1
7382 rajveer 19184 
    (2, TType.BOOL, 'allColors', None, None, ), # 2
7265 rajveer 19185 
  )
19186 
 
7382 rajveer 19187 
  def __init__(self, sp=None, allColors=None,):
7265 rajveer 19188 
    self.sp = sp
7382 rajveer 19189 
    self.allColors = allColors
7265 rajveer 19190 
 
19191 
  def read(self, iprot):
19192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19194 
      return
19195 
    iprot.readStructBegin()
19196 
    while True:
19197 
      (fname, ftype, fid) = iprot.readFieldBegin()
19198 
      if ftype == TType.STOP:
19199 
        break
19200 
      if fid == 1:
19201 
        if ftype == TType.STRUCT:
19202 
          self.sp = StorePricing()
19203 
          self.sp.read(iprot)
19204 
        else:
19205 
          iprot.skip(ftype)
7382 rajveer 19206 
      elif fid == 2:
19207 
        if ftype == TType.BOOL:
19208 
          self.allColors = iprot.readBool();
19209 
        else:
19210 
          iprot.skip(ftype)
7265 rajveer 19211 
      else:
19212 
        iprot.skip(ftype)
19213 
      iprot.readFieldEnd()
19214 
    iprot.readStructEnd()
19215 
 
19216 
  def write(self, oprot):
19217 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19218 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19219 
      return
19220 
    oprot.writeStructBegin('updateStorePricing_args')
19221 
    if self.sp is not None:
19222 
      oprot.writeFieldBegin('sp', TType.STRUCT, 1)
19223 
      self.sp.write(oprot)
19224 
      oprot.writeFieldEnd()
7382 rajveer 19225 
    if self.allColors is not None:
19226 
      oprot.writeFieldBegin('allColors', TType.BOOL, 2)
19227 
      oprot.writeBool(self.allColors)
19228 
      oprot.writeFieldEnd()
7265 rajveer 19229 
    oprot.writeFieldStop()
19230 
    oprot.writeStructEnd()
19231 
 
19232 
  def validate(self):
19233 
    return
19234 
 
19235 
 
19236 
  def __repr__(self):
19237 
    L = ['%s=%r' % (key, value)
19238 
      for key, value in self.__dict__.iteritems()]
19239 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19240 
 
19241 
  def __eq__(self, other):
19242 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19243 
 
19244 
  def __ne__(self, other):
19245 
    return not (self == other)
19246 
 
19247 
class updateStorePricing_result:
19248 
 
19249 
  thrift_spec = (
19250 
  )
19251 
 
19252 
  def read(self, iprot):
19253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19255 
      return
19256 
    iprot.readStructBegin()
19257 
    while True:
19258 
      (fname, ftype, fid) = iprot.readFieldBegin()
19259 
      if ftype == TType.STOP:
19260 
        break
19261 
      else:
19262 
        iprot.skip(ftype)
19263 
      iprot.readFieldEnd()
19264 
    iprot.readStructEnd()
19265 
 
19266 
  def write(self, oprot):
19267 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19268 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19269 
      return
19270 
    oprot.writeStructBegin('updateStorePricing_result')
19271 
    oprot.writeFieldStop()
19272 
    oprot.writeStructEnd()
19273 
 
19274 
  def validate(self):
19275 
    return
19276 
 
19277 
 
19278 
  def __repr__(self):
19279 
    L = ['%s=%r' % (key, value)
19280 
      for key, value in self.__dict__.iteritems()]
19281 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19282 
 
19283 
  def __eq__(self, other):
19284 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19285 
 
19286 
  def __ne__(self, other):
19287 
    return not (self == other)
7281 kshitij.so 19288 
 
19289 
class getAllAmazonListedItems_args:
19290 
 
19291 
  thrift_spec = (
19292 
  )
19293 
 
19294 
  def read(self, iprot):
19295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19297 
      return
19298 
    iprot.readStructBegin()
19299 
    while True:
19300 
      (fname, ftype, fid) = iprot.readFieldBegin()
19301 
      if ftype == TType.STOP:
19302 
        break
19303 
      else:
19304 
        iprot.skip(ftype)
19305 
      iprot.readFieldEnd()
19306 
    iprot.readStructEnd()
19307 
 
19308 
  def write(self, oprot):
19309 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19310 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19311 
      return
19312 
    oprot.writeStructBegin('getAllAmazonListedItems_args')
19313 
    oprot.writeFieldStop()
19314 
    oprot.writeStructEnd()
19315 
 
19316 
  def validate(self):
19317 
    return
19318 
 
19319 
 
19320 
  def __repr__(self):
19321 
    L = ['%s=%r' % (key, value)
19322 
      for key, value in self.__dict__.iteritems()]
19323 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19324 
 
19325 
  def __eq__(self, other):
19326 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19327 
 
19328 
  def __ne__(self, other):
19329 
    return not (self == other)
19330 
 
19331 
class getAllAmazonListedItems_result:
19332 
  """
19333 
  Attributes:
19334 
   - success
19335 
  """
19336 
 
19337 
  thrift_spec = (
19338 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
19339 
  )
19340 
 
19341 
  def __init__(self, success=None,):
19342 
    self.success = success
19343 
 
19344 
  def read(self, iprot):
19345 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19346 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19347 
      return
19348 
    iprot.readStructBegin()
19349 
    while True:
19350 
      (fname, ftype, fid) = iprot.readFieldBegin()
19351 
      if ftype == TType.STOP:
19352 
        break
19353 
      if fid == 0:
19354 
        if ftype == TType.LIST:
19355 
          self.success = []
9155 kshitij.so 19356 
          (_etype414, _size411) = iprot.readListBegin()
19357 
          for _i415 in xrange(_size411):
19358 
            _elem416 = Amazonlisted()
19359 
            _elem416.read(iprot)
19360 
            self.success.append(_elem416)
7281 kshitij.so 19361 
          iprot.readListEnd()
19362 
        else:
19363 
          iprot.skip(ftype)
19364 
      else:
19365 
        iprot.skip(ftype)
19366 
      iprot.readFieldEnd()
19367 
    iprot.readStructEnd()
19368 
 
19369 
  def write(self, oprot):
19370 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19371 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19372 
      return
19373 
    oprot.writeStructBegin('getAllAmazonListedItems_result')
19374 
    if self.success is not None:
19375 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19376 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 19377 
      for iter417 in self.success:
19378 
        iter417.write(oprot)
7281 kshitij.so 19379 
      oprot.writeListEnd()
19380 
      oprot.writeFieldEnd()
19381 
    oprot.writeFieldStop()
19382 
    oprot.writeStructEnd()
19383 
 
19384 
  def validate(self):
19385 
    return
19386 
 
19387 
 
19388 
  def __repr__(self):
19389 
    L = ['%s=%r' % (key, value)
19390 
      for key, value in self.__dict__.iteritems()]
19391 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19392 
 
19393 
  def __eq__(self, other):
19394 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19395 
 
19396 
  def __ne__(self, other):
19397 
    return not (self == other)
19398 
 
8619 kshitij.so 19399 
class searchAmazonItems_args:
19400 
  """
19401 
  Attributes:
19402 
   - searchTerm
19403 
   - offset
19404 
   - limit
19405 
  """
19406 
 
19407 
  thrift_spec = (
19408 
    None, # 0
19409 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
19410 
    (2, TType.I64, 'offset', None, None, ), # 2
19411 
    (3, TType.I64, 'limit', None, None, ), # 3
19412 
  )
19413 
 
19414 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
19415 
    self.searchTerm = searchTerm
19416 
    self.offset = offset
19417 
    self.limit = limit
19418 
 
19419 
  def read(self, iprot):
19420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19422 
      return
19423 
    iprot.readStructBegin()
19424 
    while True:
19425 
      (fname, ftype, fid) = iprot.readFieldBegin()
19426 
      if ftype == TType.STOP:
19427 
        break
19428 
      if fid == 1:
19429 
        if ftype == TType.LIST:
19430 
          self.searchTerm = []
9155 kshitij.so 19431 
          (_etype421, _size418) = iprot.readListBegin()
19432 
          for _i422 in xrange(_size418):
19433 
            _elem423 = iprot.readString();
19434 
            self.searchTerm.append(_elem423)
8619 kshitij.so 19435 
          iprot.readListEnd()
19436 
        else:
19437 
          iprot.skip(ftype)
19438 
      elif fid == 2:
19439 
        if ftype == TType.I64:
19440 
          self.offset = iprot.readI64();
19441 
        else:
19442 
          iprot.skip(ftype)
19443 
      elif fid == 3:
19444 
        if ftype == TType.I64:
19445 
          self.limit = iprot.readI64();
19446 
        else:
19447 
          iprot.skip(ftype)
19448 
      else:
19449 
        iprot.skip(ftype)
19450 
      iprot.readFieldEnd()
19451 
    iprot.readStructEnd()
19452 
 
19453 
  def write(self, oprot):
19454 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19455 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19456 
      return
19457 
    oprot.writeStructBegin('searchAmazonItems_args')
19458 
    if self.searchTerm is not None:
19459 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
19460 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
9155 kshitij.so 19461 
      for iter424 in self.searchTerm:
19462 
        oprot.writeString(iter424)
8619 kshitij.so 19463 
      oprot.writeListEnd()
19464 
      oprot.writeFieldEnd()
19465 
    if self.offset is not None:
19466 
      oprot.writeFieldBegin('offset', TType.I64, 2)
19467 
      oprot.writeI64(self.offset)
19468 
      oprot.writeFieldEnd()
19469 
    if self.limit is not None:
19470 
      oprot.writeFieldBegin('limit', TType.I64, 3)
19471 
      oprot.writeI64(self.limit)
19472 
      oprot.writeFieldEnd()
19473 
    oprot.writeFieldStop()
19474 
    oprot.writeStructEnd()
19475 
 
19476 
  def validate(self):
19477 
    return
19478 
 
19479 
 
19480 
  def __repr__(self):
19481 
    L = ['%s=%r' % (key, value)
19482 
      for key, value in self.__dict__.iteritems()]
19483 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19484 
 
19485 
  def __eq__(self, other):
19486 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19487 
 
19488 
  def __ne__(self, other):
19489 
    return not (self == other)
19490 
 
19491 
class searchAmazonItems_result:
19492 
  """
19493 
  Attributes:
19494 
   - success
19495 
  """
19496 
 
19497 
  thrift_spec = (
19498 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
19499 
  )
19500 
 
19501 
  def __init__(self, success=None,):
19502 
    self.success = success
19503 
 
19504 
  def read(self, iprot):
19505 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19506 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19507 
      return
19508 
    iprot.readStructBegin()
19509 
    while True:
19510 
      (fname, ftype, fid) = iprot.readFieldBegin()
19511 
      if ftype == TType.STOP:
19512 
        break
19513 
      if fid == 0:
19514 
        if ftype == TType.LIST:
19515 
          self.success = []
9155 kshitij.so 19516 
          (_etype428, _size425) = iprot.readListBegin()
19517 
          for _i429 in xrange(_size425):
19518 
            _elem430 = Amazonlisted()
19519 
            _elem430.read(iprot)
19520 
            self.success.append(_elem430)
8619 kshitij.so 19521 
          iprot.readListEnd()
19522 
        else:
19523 
          iprot.skip(ftype)
19524 
      else:
19525 
        iprot.skip(ftype)
19526 
      iprot.readFieldEnd()
19527 
    iprot.readStructEnd()
19528 
 
19529 
  def write(self, oprot):
19530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19532 
      return
19533 
    oprot.writeStructBegin('searchAmazonItems_result')
19534 
    if self.success is not None:
19535 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19536 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 19537 
      for iter431 in self.success:
19538 
        iter431.write(oprot)
8619 kshitij.so 19539 
      oprot.writeListEnd()
19540 
      oprot.writeFieldEnd()
19541 
    oprot.writeFieldStop()
19542 
    oprot.writeStructEnd()
19543 
 
19544 
  def validate(self):
19545 
    return
19546 
 
19547 
 
19548 
  def __repr__(self):
19549 
    L = ['%s=%r' % (key, value)
19550 
      for key, value in self.__dict__.iteritems()]
19551 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19552 
 
19553 
  def __eq__(self, other):
19554 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19555 
 
19556 
  def __ne__(self, other):
19557 
    return not (self == other)
19558 
 
19559 
class getAmazonSearchResultCount_args:
19560 
  """
19561 
  Attributes:
19562 
   - searchTerm
19563 
  """
19564 
 
19565 
  thrift_spec = (
19566 
    None, # 0
19567 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
19568 
  )
19569 
 
19570 
  def __init__(self, searchTerm=None,):
19571 
    self.searchTerm = searchTerm
19572 
 
19573 
  def read(self, iprot):
19574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19576 
      return
19577 
    iprot.readStructBegin()
19578 
    while True:
19579 
      (fname, ftype, fid) = iprot.readFieldBegin()
19580 
      if ftype == TType.STOP:
19581 
        break
19582 
      if fid == 1:
19583 
        if ftype == TType.LIST:
19584 
          self.searchTerm = []
9155 kshitij.so 19585 
          (_etype435, _size432) = iprot.readListBegin()
19586 
          for _i436 in xrange(_size432):
19587 
            _elem437 = iprot.readString();
19588 
            self.searchTerm.append(_elem437)
8619 kshitij.so 19589 
          iprot.readListEnd()
19590 
        else:
19591 
          iprot.skip(ftype)
19592 
      else:
19593 
        iprot.skip(ftype)
19594 
      iprot.readFieldEnd()
19595 
    iprot.readStructEnd()
19596 
 
19597 
  def write(self, oprot):
19598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19600 
      return
19601 
    oprot.writeStructBegin('getAmazonSearchResultCount_args')
19602 
    if self.searchTerm is not None:
19603 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
19604 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
9155 kshitij.so 19605 
      for iter438 in self.searchTerm:
19606 
        oprot.writeString(iter438)
8619 kshitij.so 19607 
      oprot.writeListEnd()
19608 
      oprot.writeFieldEnd()
19609 
    oprot.writeFieldStop()
19610 
    oprot.writeStructEnd()
19611 
 
19612 
  def validate(self):
19613 
    return
19614 
 
19615 
 
19616 
  def __repr__(self):
19617 
    L = ['%s=%r' % (key, value)
19618 
      for key, value in self.__dict__.iteritems()]
19619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19620 
 
19621 
  def __eq__(self, other):
19622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19623 
 
19624 
  def __ne__(self, other):
19625 
    return not (self == other)
19626 
 
19627 
class getAmazonSearchResultCount_result:
19628 
  """
19629 
  Attributes:
19630 
   - success
19631 
  """
19632 
 
19633 
  thrift_spec = (
19634 
    (0, TType.I64, 'success', None, None, ), # 0
19635 
  )
19636 
 
19637 
  def __init__(self, success=None,):
19638 
    self.success = success
19639 
 
19640 
  def read(self, iprot):
19641 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19642 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19643 
      return
19644 
    iprot.readStructBegin()
19645 
    while True:
19646 
      (fname, ftype, fid) = iprot.readFieldBegin()
19647 
      if ftype == TType.STOP:
19648 
        break
19649 
      if fid == 0:
19650 
        if ftype == TType.I64:
19651 
          self.success = iprot.readI64();
19652 
        else:
19653 
          iprot.skip(ftype)
19654 
      else:
19655 
        iprot.skip(ftype)
19656 
      iprot.readFieldEnd()
19657 
    iprot.readStructEnd()
19658 
 
19659 
  def write(self, oprot):
19660 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19661 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19662 
      return
19663 
    oprot.writeStructBegin('getAmazonSearchResultCount_result')
19664 
    if self.success is not None:
19665 
      oprot.writeFieldBegin('success', TType.I64, 0)
19666 
      oprot.writeI64(self.success)
19667 
      oprot.writeFieldEnd()
19668 
    oprot.writeFieldStop()
19669 
    oprot.writeStructEnd()
19670 
 
19671 
  def validate(self):
19672 
    return
19673 
 
19674 
 
19675 
  def __repr__(self):
19676 
    L = ['%s=%r' % (key, value)
19677 
      for key, value in self.__dict__.iteritems()]
19678 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19679 
 
19680 
  def __eq__(self, other):
19681 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19682 
 
19683 
  def __ne__(self, other):
19684 
    return not (self == other)
19685 
 
19686 
class getCountForAmazonlistedItems_args:
19687 
 
19688 
  thrift_spec = (
19689 
  )
19690 
 
19691 
  def read(self, iprot):
19692 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19693 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19694 
      return
19695 
    iprot.readStructBegin()
19696 
    while True:
19697 
      (fname, ftype, fid) = iprot.readFieldBegin()
19698 
      if ftype == TType.STOP:
19699 
        break
19700 
      else:
19701 
        iprot.skip(ftype)
19702 
      iprot.readFieldEnd()
19703 
    iprot.readStructEnd()
19704 
 
19705 
  def write(self, oprot):
19706 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19707 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19708 
      return
19709 
    oprot.writeStructBegin('getCountForAmazonlistedItems_args')
19710 
    oprot.writeFieldStop()
19711 
    oprot.writeStructEnd()
19712 
 
19713 
  def validate(self):
19714 
    return
19715 
 
19716 
 
19717 
  def __repr__(self):
19718 
    L = ['%s=%r' % (key, value)
19719 
      for key, value in self.__dict__.iteritems()]
19720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19721 
 
19722 
  def __eq__(self, other):
19723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19724 
 
19725 
  def __ne__(self, other):
19726 
    return not (self == other)
19727 
 
19728 
class getCountForAmazonlistedItems_result:
19729 
  """
19730 
  Attributes:
19731 
   - success
19732 
  """
19733 
 
19734 
  thrift_spec = (
19735 
    (0, TType.I64, 'success', None, None, ), # 0
19736 
  )
19737 
 
19738 
  def __init__(self, success=None,):
19739 
    self.success = success
19740 
 
19741 
  def read(self, iprot):
19742 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19743 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19744 
      return
19745 
    iprot.readStructBegin()
19746 
    while True:
19747 
      (fname, ftype, fid) = iprot.readFieldBegin()
19748 
      if ftype == TType.STOP:
19749 
        break
19750 
      if fid == 0:
19751 
        if ftype == TType.I64:
19752 
          self.success = iprot.readI64();
19753 
        else:
19754 
          iprot.skip(ftype)
19755 
      else:
19756 
        iprot.skip(ftype)
19757 
      iprot.readFieldEnd()
19758 
    iprot.readStructEnd()
19759 
 
19760 
  def write(self, oprot):
19761 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19762 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19763 
      return
19764 
    oprot.writeStructBegin('getCountForAmazonlistedItems_result')
19765 
    if self.success is not None:
19766 
      oprot.writeFieldBegin('success', TType.I64, 0)
19767 
      oprot.writeI64(self.success)
19768 
      oprot.writeFieldEnd()
19769 
    oprot.writeFieldStop()
19770 
    oprot.writeStructEnd()
19771 
 
19772 
  def validate(self):
19773 
    return
19774 
 
19775 
 
19776 
  def __repr__(self):
19777 
    L = ['%s=%r' % (key, value)
19778 
      for key, value in self.__dict__.iteritems()]
19779 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19780 
 
19781 
  def __eq__(self, other):
19782 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19783 
 
19784 
  def __ne__(self, other):
19785 
    return not (self == other)
19786 
 
7281 kshitij.so 19787 
class getAmazonItemDetails_args:
19788 
  """
19789 
  Attributes:
19790 
   - itemId
19791 
  """
19792 
 
19793 
  thrift_spec = (
19794 
    None, # 0
19795 
    (1, TType.I64, 'itemId', None, None, ), # 1
19796 
  )
19797 
 
19798 
  def __init__(self, itemId=None,):
19799 
    self.itemId = itemId
19800 
 
19801 
  def read(self, iprot):
19802 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19803 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19804 
      return
19805 
    iprot.readStructBegin()
19806 
    while True:
19807 
      (fname, ftype, fid) = iprot.readFieldBegin()
19808 
      if ftype == TType.STOP:
19809 
        break
19810 
      if fid == 1:
19811 
        if ftype == TType.I64:
19812 
          self.itemId = iprot.readI64();
19813 
        else:
19814 
          iprot.skip(ftype)
19815 
      else:
19816 
        iprot.skip(ftype)
19817 
      iprot.readFieldEnd()
19818 
    iprot.readStructEnd()
19819 
 
19820 
  def write(self, oprot):
19821 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19822 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19823 
      return
19824 
    oprot.writeStructBegin('getAmazonItemDetails_args')
19825 
    if self.itemId is not None:
19826 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19827 
      oprot.writeI64(self.itemId)
19828 
      oprot.writeFieldEnd()
19829 
    oprot.writeFieldStop()
19830 
    oprot.writeStructEnd()
19831 
 
19832 
  def validate(self):
19833 
    return
19834 
 
19835 
 
19836 
  def __repr__(self):
19837 
    L = ['%s=%r' % (key, value)
19838 
      for key, value in self.__dict__.iteritems()]
19839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19840 
 
19841 
  def __eq__(self, other):
19842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19843 
 
19844 
  def __ne__(self, other):
19845 
    return not (self == other)
19846 
 
19847 
class getAmazonItemDetails_result:
19848 
  """
19849 
  Attributes:
19850 
   - success
19851 
  """
19852 
 
19853 
  thrift_spec = (
19854 
    (0, TType.STRUCT, 'success', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 0
19855 
  )
19856 
 
19857 
  def __init__(self, success=None,):
19858 
    self.success = success
19859 
 
19860 
  def read(self, iprot):
19861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19863 
      return
19864 
    iprot.readStructBegin()
19865 
    while True:
19866 
      (fname, ftype, fid) = iprot.readFieldBegin()
19867 
      if ftype == TType.STOP:
19868 
        break
19869 
      if fid == 0:
19870 
        if ftype == TType.STRUCT:
19871 
          self.success = Amazonlisted()
19872 
          self.success.read(iprot)
19873 
        else:
19874 
          iprot.skip(ftype)
19875 
      else:
19876 
        iprot.skip(ftype)
19877 
      iprot.readFieldEnd()
19878 
    iprot.readStructEnd()
19879 
 
19880 
  def write(self, oprot):
19881 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19882 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19883 
      return
19884 
    oprot.writeStructBegin('getAmazonItemDetails_result')
19885 
    if self.success is not None:
19886 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19887 
      self.success.write(oprot)
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 updateAmazonItemDetails_args:
19908 
  """
19909 
  Attributes:
8168 kshitij.so 19910 
   - amazonlisted
7281 kshitij.so 19911 
  """
19912 
 
19913 
  thrift_spec = (
19914 
    None, # 0
8168 kshitij.so 19915 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
7281 kshitij.so 19916 
  )
19917 
 
8168 kshitij.so 19918 
  def __init__(self, amazonlisted=None,):
19919 
    self.amazonlisted = amazonlisted
7281 kshitij.so 19920 
 
19921 
  def read(self, iprot):
19922 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19923 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19924 
      return
19925 
    iprot.readStructBegin()
19926 
    while True:
19927 
      (fname, ftype, fid) = iprot.readFieldBegin()
19928 
      if ftype == TType.STOP:
19929 
        break
19930 
      if fid == 1:
8168 kshitij.so 19931 
        if ftype == TType.STRUCT:
19932 
          self.amazonlisted = Amazonlisted()
19933 
          self.amazonlisted.read(iprot)
7281 kshitij.so 19934 
        else:
19935 
          iprot.skip(ftype)
19936 
      else:
19937 
        iprot.skip(ftype)
19938 
      iprot.readFieldEnd()
19939 
    iprot.readStructEnd()
19940 
 
19941 
  def write(self, oprot):
19942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19944 
      return
19945 
    oprot.writeStructBegin('updateAmazonItemDetails_args')
8168 kshitij.so 19946 
    if self.amazonlisted is not None:
19947 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
19948 
      self.amazonlisted.write(oprot)
7281 kshitij.so 19949 
      oprot.writeFieldEnd()
19950 
    oprot.writeFieldStop()
19951 
    oprot.writeStructEnd()
19952 
 
19953 
  def validate(self):
19954 
    return
19955 
 
19956 
 
19957 
  def __repr__(self):
19958 
    L = ['%s=%r' % (key, value)
19959 
      for key, value in self.__dict__.iteritems()]
19960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19961 
 
19962 
  def __eq__(self, other):
19963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19964 
 
19965 
  def __ne__(self, other):
19966 
    return not (self == other)
19967 
 
19968 
class updateAmazonItemDetails_result:
19969 
 
19970 
  thrift_spec = (
19971 
  )
19972 
 
19973 
  def read(self, iprot):
19974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19976 
      return
19977 
    iprot.readStructBegin()
19978 
    while True:
19979 
      (fname, ftype, fid) = iprot.readFieldBegin()
19980 
      if ftype == TType.STOP:
19981 
        break
19982 
      else:
19983 
        iprot.skip(ftype)
19984 
      iprot.readFieldEnd()
19985 
    iprot.readStructEnd()
19986 
 
19987 
  def write(self, oprot):
19988 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19989 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19990 
      return
19991 
    oprot.writeStructBegin('updateAmazonItemDetails_result')
19992 
    oprot.writeFieldStop()
19993 
    oprot.writeStructEnd()
19994 
 
19995 
  def validate(self):
19996 
    return
19997 
 
19998 
 
19999 
  def __repr__(self):
20000 
    L = ['%s=%r' % (key, value)
20001 
      for key, value in self.__dict__.iteritems()]
20002 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20003 
 
20004 
  def __eq__(self, other):
20005 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20006 
 
20007 
  def __ne__(self, other):
20008 
    return not (self == other)
20009 
 
20010 
class addAmazonItem_args:
20011 
  """
20012 
  Attributes:
20013 
   - amazonlisted
20014 
  """
20015 
 
20016 
  thrift_spec = (
20017 
    None, # 0
20018 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
20019 
  )
20020 
 
20021 
  def __init__(self, amazonlisted=None,):
20022 
    self.amazonlisted = amazonlisted
20023 
 
20024 
  def read(self, iprot):
20025 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20026 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20027 
      return
20028 
    iprot.readStructBegin()
20029 
    while True:
20030 
      (fname, ftype, fid) = iprot.readFieldBegin()
20031 
      if ftype == TType.STOP:
20032 
        break
20033 
      if fid == 1:
20034 
        if ftype == TType.STRUCT:
20035 
          self.amazonlisted = Amazonlisted()
20036 
          self.amazonlisted.read(iprot)
20037 
        else:
20038 
          iprot.skip(ftype)
20039 
      else:
20040 
        iprot.skip(ftype)
20041 
      iprot.readFieldEnd()
20042 
    iprot.readStructEnd()
20043 
 
20044 
  def write(self, oprot):
20045 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20046 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20047 
      return
20048 
    oprot.writeStructBegin('addAmazonItem_args')
20049 
    if self.amazonlisted is not None:
20050 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
20051 
      self.amazonlisted.write(oprot)
20052 
      oprot.writeFieldEnd()
20053 
    oprot.writeFieldStop()
20054 
    oprot.writeStructEnd()
20055 
 
20056 
  def validate(self):
20057 
    return
20058 
 
20059 
 
20060 
  def __repr__(self):
20061 
    L = ['%s=%r' % (key, value)
20062 
      for key, value in self.__dict__.iteritems()]
20063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20064 
 
20065 
  def __eq__(self, other):
20066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20067 
 
20068 
  def __ne__(self, other):
20069 
    return not (self == other)
20070 
 
20071 
class addAmazonItem_result:
20072 
 
20073 
  thrift_spec = (
20074 
  )
20075 
 
20076 
  def read(self, iprot):
20077 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20078 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20079 
      return
20080 
    iprot.readStructBegin()
20081 
    while True:
20082 
      (fname, ftype, fid) = iprot.readFieldBegin()
20083 
      if ftype == TType.STOP:
20084 
        break
20085 
      else:
20086 
        iprot.skip(ftype)
20087 
      iprot.readFieldEnd()
20088 
    iprot.readStructEnd()
20089 
 
20090 
  def write(self, oprot):
20091 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20092 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20093 
      return
20094 
    oprot.writeStructBegin('addAmazonItem_result')
20095 
    oprot.writeFieldStop()
20096 
    oprot.writeStructEnd()
20097 
 
20098 
  def validate(self):
20099 
    return
20100 
 
20101 
 
20102 
  def __repr__(self):
20103 
    L = ['%s=%r' % (key, value)
20104 
      for key, value in self.__dict__.iteritems()]
20105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20106 
 
20107 
  def __eq__(self, other):
20108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20109 
 
20110 
  def __ne__(self, other):
20111 
    return not (self == other)
7291 vikram.rag 20112 
 
20113 
class getAsinItems_args:
20114 
 
20115 
  thrift_spec = (
20116 
  )
20117 
 
20118 
  def read(self, iprot):
20119 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20120 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20121 
      return
20122 
    iprot.readStructBegin()
20123 
    while True:
20124 
      (fname, ftype, fid) = iprot.readFieldBegin()
20125 
      if ftype == TType.STOP:
20126 
        break
20127 
      else:
20128 
        iprot.skip(ftype)
20129 
      iprot.readFieldEnd()
20130 
    iprot.readStructEnd()
20131 
 
20132 
  def write(self, oprot):
20133 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20134 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20135 
      return
20136 
    oprot.writeStructBegin('getAsinItems_args')
20137 
    oprot.writeFieldStop()
20138 
    oprot.writeStructEnd()
20139 
 
20140 
  def validate(self):
20141 
    return
20142 
 
20143 
 
20144 
  def __repr__(self):
20145 
    L = ['%s=%r' % (key, value)
20146 
      for key, value in self.__dict__.iteritems()]
20147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20148 
 
20149 
  def __eq__(self, other):
20150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20151 
 
20152 
  def __ne__(self, other):
20153 
    return not (self == other)
20154 
 
20155 
class getAsinItems_result:
20156 
  """
20157 
  Attributes:
20158 
   - success
20159 
  """
20160 
 
20161 
  thrift_spec = (
20162 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
20163 
  )
20164 
 
20165 
  def __init__(self, success=None,):
20166 
    self.success = success
20167 
 
20168 
  def read(self, iprot):
20169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20171 
      return
20172 
    iprot.readStructBegin()
20173 
    while True:
20174 
      (fname, ftype, fid) = iprot.readFieldBegin()
20175 
      if ftype == TType.STOP:
20176 
        break
20177 
      if fid == 0:
20178 
        if ftype == TType.LIST:
20179 
          self.success = []
9155 kshitij.so 20180 
          (_etype442, _size439) = iprot.readListBegin()
20181 
          for _i443 in xrange(_size439):
20182 
            _elem444 = Item()
20183 
            _elem444.read(iprot)
20184 
            self.success.append(_elem444)
7291 vikram.rag 20185 
          iprot.readListEnd()
20186 
        else:
20187 
          iprot.skip(ftype)
20188 
      else:
20189 
        iprot.skip(ftype)
20190 
      iprot.readFieldEnd()
20191 
    iprot.readStructEnd()
20192 
 
20193 
  def write(self, oprot):
20194 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20195 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20196 
      return
20197 
    oprot.writeStructBegin('getAsinItems_result')
20198 
    if self.success is not None:
20199 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20200 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 20201 
      for iter445 in self.success:
20202 
        iter445.write(oprot)
7291 vikram.rag 20203 
      oprot.writeListEnd()
20204 
      oprot.writeFieldEnd()
20205 
    oprot.writeFieldStop()
20206 
    oprot.writeStructEnd()
20207 
 
20208 
  def validate(self):
20209 
    return
20210 
 
20211 
 
20212 
  def __repr__(self):
20213 
    L = ['%s=%r' % (key, value)
20214 
      for key, value in self.__dict__.iteritems()]
20215 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20216 
 
20217 
  def __eq__(self, other):
20218 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20219 
 
20220 
  def __ne__(self, other):
20221 
    return not (self == other)
20222 
 
20223 
class getAllFbaListedItems_args:
20224 
 
20225 
  thrift_spec = (
20226 
  )
20227 
 
20228 
  def read(self, iprot):
20229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20231 
      return
20232 
    iprot.readStructBegin()
20233 
    while True:
20234 
      (fname, ftype, fid) = iprot.readFieldBegin()
20235 
      if ftype == TType.STOP:
20236 
        break
20237 
      else:
20238 
        iprot.skip(ftype)
20239 
      iprot.readFieldEnd()
20240 
    iprot.readStructEnd()
20241 
 
20242 
  def write(self, oprot):
20243 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20244 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20245 
      return
20246 
    oprot.writeStructBegin('getAllFbaListedItems_args')
20247 
    oprot.writeFieldStop()
20248 
    oprot.writeStructEnd()
20249 
 
20250 
  def validate(self):
20251 
    return
20252 
 
20253 
 
20254 
  def __repr__(self):
20255 
    L = ['%s=%r' % (key, value)
20256 
      for key, value in self.__dict__.iteritems()]
20257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20258 
 
20259 
  def __eq__(self, other):
20260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20261 
 
20262 
  def __ne__(self, other):
20263 
    return not (self == other)
20264 
 
20265 
class getAllFbaListedItems_result:
20266 
  """
20267 
  Attributes:
20268 
   - success
20269 
  """
20270 
 
20271 
  thrift_spec = (
20272 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
20273 
  )
20274 
 
20275 
  def __init__(self, success=None,):
20276 
    self.success = success
20277 
 
20278 
  def read(self, iprot):
20279 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20280 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20281 
      return
20282 
    iprot.readStructBegin()
20283 
    while True:
20284 
      (fname, ftype, fid) = iprot.readFieldBegin()
20285 
      if ftype == TType.STOP:
20286 
        break
20287 
      if fid == 0:
20288 
        if ftype == TType.LIST:
20289 
          self.success = []
9155 kshitij.so 20290 
          (_etype449, _size446) = iprot.readListBegin()
20291 
          for _i450 in xrange(_size446):
20292 
            _elem451 = Amazonlisted()
20293 
            _elem451.read(iprot)
20294 
            self.success.append(_elem451)
7291 vikram.rag 20295 
          iprot.readListEnd()
20296 
        else:
20297 
          iprot.skip(ftype)
20298 
      else:
20299 
        iprot.skip(ftype)
20300 
      iprot.readFieldEnd()
20301 
    iprot.readStructEnd()
20302 
 
20303 
  def write(self, oprot):
20304 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20305 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20306 
      return
20307 
    oprot.writeStructBegin('getAllFbaListedItems_result')
20308 
    if self.success is not None:
20309 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20310 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 20311 
      for iter452 in self.success:
20312 
        iter452.write(oprot)
7291 vikram.rag 20313 
      oprot.writeListEnd()
20314 
      oprot.writeFieldEnd()
20315 
    oprot.writeFieldStop()
20316 
    oprot.writeStructEnd()
20317 
 
20318 
  def validate(self):
20319 
    return
20320 
 
20321 
 
20322 
  def __repr__(self):
20323 
    L = ['%s=%r' % (key, value)
20324 
      for key, value in self.__dict__.iteritems()]
20325 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20326 
 
20327 
  def __eq__(self, other):
20328 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20329 
 
20330 
  def __ne__(self, other):
20331 
    return not (self == other)
20332 
 
20333 
class getAllNonFbaListedItems_args:
20334 
 
20335 
  thrift_spec = (
20336 
  )
20337 
 
20338 
  def read(self, iprot):
20339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20341 
      return
20342 
    iprot.readStructBegin()
20343 
    while True:
20344 
      (fname, ftype, fid) = iprot.readFieldBegin()
20345 
      if ftype == TType.STOP:
20346 
        break
20347 
      else:
20348 
        iprot.skip(ftype)
20349 
      iprot.readFieldEnd()
20350 
    iprot.readStructEnd()
20351 
 
20352 
  def write(self, oprot):
20353 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20354 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20355 
      return
20356 
    oprot.writeStructBegin('getAllNonFbaListedItems_args')
20357 
    oprot.writeFieldStop()
20358 
    oprot.writeStructEnd()
20359 
 
20360 
  def validate(self):
20361 
    return
20362 
 
20363 
 
20364 
  def __repr__(self):
20365 
    L = ['%s=%r' % (key, value)
20366 
      for key, value in self.__dict__.iteritems()]
20367 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20368 
 
20369 
  def __eq__(self, other):
20370 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20371 
 
20372 
  def __ne__(self, other):
20373 
    return not (self == other)
20374 
 
20375 
class getAllNonFbaListedItems_result:
20376 
  """
20377 
  Attributes:
20378 
   - success
20379 
  """
20380 
 
20381 
  thrift_spec = (
20382 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
20383 
  )
20384 
 
20385 
  def __init__(self, success=None,):
20386 
    self.success = success
20387 
 
20388 
  def read(self, iprot):
20389 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20390 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20391 
      return
20392 
    iprot.readStructBegin()
20393 
    while True:
20394 
      (fname, ftype, fid) = iprot.readFieldBegin()
20395 
      if ftype == TType.STOP:
20396 
        break
20397 
      if fid == 0:
20398 
        if ftype == TType.LIST:
20399 
          self.success = []
9155 kshitij.so 20400 
          (_etype456, _size453) = iprot.readListBegin()
20401 
          for _i457 in xrange(_size453):
20402 
            _elem458 = Amazonlisted()
20403 
            _elem458.read(iprot)
20404 
            self.success.append(_elem458)
7291 vikram.rag 20405 
          iprot.readListEnd()
20406 
        else:
20407 
          iprot.skip(ftype)
20408 
      else:
20409 
        iprot.skip(ftype)
20410 
      iprot.readFieldEnd()
20411 
    iprot.readStructEnd()
20412 
 
20413 
  def write(self, oprot):
20414 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20415 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20416 
      return
20417 
    oprot.writeStructBegin('getAllNonFbaListedItems_result')
20418 
    if self.success is not None:
20419 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20420 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 20421 
      for iter459 in self.success:
20422 
        iter459.write(oprot)
7291 vikram.rag 20423 
      oprot.writeListEnd()
20424 
      oprot.writeFieldEnd()
20425 
    oprot.writeFieldStop()
20426 
    oprot.writeStructEnd()
20427 
 
20428 
  def validate(self):
20429 
    return
20430 
 
20431 
 
20432 
  def __repr__(self):
20433 
    L = ['%s=%r' % (key, value)
20434 
      for key, value in self.__dict__.iteritems()]
20435 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20436 
 
20437 
  def __eq__(self, other):
20438 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20439 
 
20440 
  def __ne__(self, other):
20441 
    return not (self == other)
7460 kshitij.so 20442 
 
20443 
class updateItemInventory_args:
20444 
  """
20445 
  Attributes:
20446 
   - itemId
20447 
   - holdInventory
20448 
   - defaultInventory
20449 
  """
20450 
 
20451 
  thrift_spec = (
20452 
    None, # 0
20453 
    (1, TType.I64, 'itemId', None, None, ), # 1
20454 
    (2, TType.I64, 'holdInventory', None, None, ), # 2
20455 
    (3, TType.I64, 'defaultInventory', None, None, ), # 3
20456 
  )
20457 
 
20458 
  def __init__(self, itemId=None, holdInventory=None, defaultInventory=None,):
20459 
    self.itemId = itemId
20460 
    self.holdInventory = holdInventory
20461 
    self.defaultInventory = defaultInventory
20462 
 
20463 
  def read(self, iprot):
20464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20466 
      return
20467 
    iprot.readStructBegin()
20468 
    while True:
20469 
      (fname, ftype, fid) = iprot.readFieldBegin()
20470 
      if ftype == TType.STOP:
20471 
        break
20472 
      if fid == 1:
20473 
        if ftype == TType.I64:
20474 
          self.itemId = iprot.readI64();
20475 
        else:
20476 
          iprot.skip(ftype)
20477 
      elif fid == 2:
20478 
        if ftype == TType.I64:
20479 
          self.holdInventory = iprot.readI64();
20480 
        else:
20481 
          iprot.skip(ftype)
20482 
      elif fid == 3:
20483 
        if ftype == TType.I64:
20484 
          self.defaultInventory = iprot.readI64();
20485 
        else:
20486 
          iprot.skip(ftype)
20487 
      else:
20488 
        iprot.skip(ftype)
20489 
      iprot.readFieldEnd()
20490 
    iprot.readStructEnd()
20491 
 
20492 
  def write(self, oprot):
20493 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20494 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20495 
      return
20496 
    oprot.writeStructBegin('updateItemInventory_args')
20497 
    if self.itemId is not None:
20498 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20499 
      oprot.writeI64(self.itemId)
20500 
      oprot.writeFieldEnd()
20501 
    if self.holdInventory is not None:
20502 
      oprot.writeFieldBegin('holdInventory', TType.I64, 2)
20503 
      oprot.writeI64(self.holdInventory)
20504 
      oprot.writeFieldEnd()
20505 
    if self.defaultInventory is not None:
20506 
      oprot.writeFieldBegin('defaultInventory', TType.I64, 3)
20507 
      oprot.writeI64(self.defaultInventory)
20508 
      oprot.writeFieldEnd()
20509 
    oprot.writeFieldStop()
20510 
    oprot.writeStructEnd()
20511 
 
20512 
  def validate(self):
20513 
    return
20514 
 
20515 
 
20516 
  def __repr__(self):
20517 
    L = ['%s=%r' % (key, value)
20518 
      for key, value in self.__dict__.iteritems()]
20519 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20520 
 
20521 
  def __eq__(self, other):
20522 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20523 
 
20524 
  def __ne__(self, other):
20525 
    return not (self == other)
20526 
 
20527 
class updateItemInventory_result:
20528 
  """
20529 
  Attributes:
20530 
   - success
20531 
  """
20532 
 
20533 
  thrift_spec = (
20534 
    (0, TType.BOOL, 'success', None, None, ), # 0
20535 
  )
20536 
 
20537 
  def __init__(self, success=None,):
20538 
    self.success = success
20539 
 
20540 
  def read(self, iprot):
20541 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20542 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20543 
      return
20544 
    iprot.readStructBegin()
20545 
    while True:
20546 
      (fname, ftype, fid) = iprot.readFieldBegin()
20547 
      if ftype == TType.STOP:
20548 
        break
20549 
      if fid == 0:
20550 
        if ftype == TType.BOOL:
20551 
          self.success = iprot.readBool();
20552 
        else:
20553 
          iprot.skip(ftype)
20554 
      else:
20555 
        iprot.skip(ftype)
20556 
      iprot.readFieldEnd()
20557 
    iprot.readStructEnd()
20558 
 
20559 
  def write(self, oprot):
20560 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20561 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20562 
      return
20563 
    oprot.writeStructBegin('updateItemInventory_result')
20564 
    if self.success is not None:
20565 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20566 
      oprot.writeBool(self.success)
20567 
      oprot.writeFieldEnd()
20568 
    oprot.writeFieldStop()
20569 
    oprot.writeStructEnd()
20570 
 
20571 
  def validate(self):
20572 
    return
20573 
 
20574 
 
20575 
  def __repr__(self):
20576 
    L = ['%s=%r' % (key, value)
20577 
      for key, value in self.__dict__.iteritems()]
20578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20579 
 
20580 
  def __eq__(self, other):
20581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20582 
 
20583 
  def __ne__(self, other):
20584 
    return not (self == other)
7770 kshitij.so 20585 
 
20586 
class updateTimestampForAmazonFeeds_args:
20587 
  """
20588 
  Attributes:
20589 
   - type
20590 
   - sku
20591 
   - timestamp
20592 
  """
20593 
 
20594 
  thrift_spec = (
20595 
    None, # 0
20596 
    (1, TType.STRING, 'type', None, None, ), # 1
20597 
    (2, TType.LIST, 'sku', (TType.I64,None), None, ), # 2
20598 
    (3, TType.I64, 'timestamp', None, None, ), # 3
20599 
  )
20600 
 
20601 
  def __init__(self, type=None, sku=None, timestamp=None,):
20602 
    self.type = type
20603 
    self.sku = sku
20604 
    self.timestamp = timestamp
20605 
 
20606 
  def read(self, iprot):
20607 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20608 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20609 
      return
20610 
    iprot.readStructBegin()
20611 
    while True:
20612 
      (fname, ftype, fid) = iprot.readFieldBegin()
20613 
      if ftype == TType.STOP:
20614 
        break
20615 
      if fid == 1:
20616 
        if ftype == TType.STRING:
20617 
          self.type = iprot.readString();
20618 
        else:
20619 
          iprot.skip(ftype)
20620 
      elif fid == 2:
20621 
        if ftype == TType.LIST:
20622 
          self.sku = []
9155 kshitij.so 20623 
          (_etype463, _size460) = iprot.readListBegin()
20624 
          for _i464 in xrange(_size460):
20625 
            _elem465 = iprot.readI64();
20626 
            self.sku.append(_elem465)
7770 kshitij.so 20627 
          iprot.readListEnd()
20628 
        else:
20629 
          iprot.skip(ftype)
20630 
      elif fid == 3:
20631 
        if ftype == TType.I64:
20632 
          self.timestamp = iprot.readI64();
20633 
        else:
20634 
          iprot.skip(ftype)
20635 
      else:
20636 
        iprot.skip(ftype)
20637 
      iprot.readFieldEnd()
20638 
    iprot.readStructEnd()
20639 
 
20640 
  def write(self, oprot):
20641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20643 
      return
20644 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_args')
20645 
    if self.type is not None:
20646 
      oprot.writeFieldBegin('type', TType.STRING, 1)
20647 
      oprot.writeString(self.type)
20648 
      oprot.writeFieldEnd()
20649 
    if self.sku is not None:
20650 
      oprot.writeFieldBegin('sku', TType.LIST, 2)
20651 
      oprot.writeListBegin(TType.I64, len(self.sku))
9155 kshitij.so 20652 
      for iter466 in self.sku:
20653 
        oprot.writeI64(iter466)
7770 kshitij.so 20654 
      oprot.writeListEnd()
20655 
      oprot.writeFieldEnd()
20656 
    if self.timestamp is not None:
20657 
      oprot.writeFieldBegin('timestamp', TType.I64, 3)
20658 
      oprot.writeI64(self.timestamp)
20659 
      oprot.writeFieldEnd()
20660 
    oprot.writeFieldStop()
20661 
    oprot.writeStructEnd()
20662 
 
20663 
  def validate(self):
20664 
    return
20665 
 
20666 
 
20667 
  def __repr__(self):
20668 
    L = ['%s=%r' % (key, value)
20669 
      for key, value in self.__dict__.iteritems()]
20670 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20671 
 
20672 
  def __eq__(self, other):
20673 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20674 
 
20675 
  def __ne__(self, other):
20676 
    return not (self == other)
20677 
 
20678 
class updateTimestampForAmazonFeeds_result:
20679 
  """
20680 
  Attributes:
20681 
   - success
20682 
  """
20683 
 
20684 
  thrift_spec = (
20685 
    (0, TType.BOOL, 'success', None, None, ), # 0
20686 
  )
20687 
 
20688 
  def __init__(self, success=None,):
20689 
    self.success = success
20690 
 
20691 
  def read(self, iprot):
20692 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20693 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20694 
      return
20695 
    iprot.readStructBegin()
20696 
    while True:
20697 
      (fname, ftype, fid) = iprot.readFieldBegin()
20698 
      if ftype == TType.STOP:
20699 
        break
20700 
      if fid == 0:
20701 
        if ftype == TType.BOOL:
20702 
          self.success = iprot.readBool();
20703 
        else:
20704 
          iprot.skip(ftype)
20705 
      else:
20706 
        iprot.skip(ftype)
20707 
      iprot.readFieldEnd()
20708 
    iprot.readStructEnd()
20709 
 
20710 
  def write(self, oprot):
20711 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20712 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20713 
      return
20714 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_result')
20715 
    if self.success is not None:
20716 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20717 
      oprot.writeBool(self.success)
20718 
      oprot.writeFieldEnd()
20719 
    oprot.writeFieldStop()
20720 
    oprot.writeStructEnd()
20721 
 
20722 
  def validate(self):
20723 
    return
20724 
 
20725 
 
20726 
  def __repr__(self):
20727 
    L = ['%s=%r' % (key, value)
20728 
      for key, value in self.__dict__.iteritems()]
20729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20730 
 
20731 
  def __eq__(self, other):
20732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20733 
 
20734 
  def __ne__(self, other):
20735 
    return not (self == other)
7897 amar.kumar 20736 
 
20737 
class getAllParentCategories_args:
20738 
 
20739 
  thrift_spec = (
20740 
  )
20741 
 
20742 
  def read(self, iprot):
20743 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20744 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20745 
      return
20746 
    iprot.readStructBegin()
20747 
    while True:
20748 
      (fname, ftype, fid) = iprot.readFieldBegin()
20749 
      if ftype == TType.STOP:
20750 
        break
20751 
      else:
20752 
        iprot.skip(ftype)
20753 
      iprot.readFieldEnd()
20754 
    iprot.readStructEnd()
20755 
 
20756 
  def write(self, oprot):
20757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20759 
      return
20760 
    oprot.writeStructBegin('getAllParentCategories_args')
20761 
    oprot.writeFieldStop()
20762 
    oprot.writeStructEnd()
20763 
 
20764 
  def validate(self):
20765 
    return
20766 
 
20767 
 
20768 
  def __repr__(self):
20769 
    L = ['%s=%r' % (key, value)
20770 
      for key, value in self.__dict__.iteritems()]
20771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20772 
 
20773 
  def __eq__(self, other):
20774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20775 
 
20776 
  def __ne__(self, other):
20777 
    return not (self == other)
20778 
 
20779 
class getAllParentCategories_result:
20780 
  """
20781 
  Attributes:
20782 
   - success
20783 
  """
20784 
 
20785 
  thrift_spec = (
20786 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
20787 
  )
20788 
 
20789 
  def __init__(self, success=None,):
20790 
    self.success = success
20791 
 
20792 
  def read(self, iprot):
20793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20795 
      return
20796 
    iprot.readStructBegin()
20797 
    while True:
20798 
      (fname, ftype, fid) = iprot.readFieldBegin()
20799 
      if ftype == TType.STOP:
20800 
        break
20801 
      if fid == 0:
20802 
        if ftype == TType.LIST:
20803 
          self.success = []
9155 kshitij.so 20804 
          (_etype470, _size467) = iprot.readListBegin()
20805 
          for _i471 in xrange(_size467):
20806 
            _elem472 = Category()
20807 
            _elem472.read(iprot)
20808 
            self.success.append(_elem472)
7897 amar.kumar 20809 
          iprot.readListEnd()
20810 
        else:
20811 
          iprot.skip(ftype)
20812 
      else:
20813 
        iprot.skip(ftype)
20814 
      iprot.readFieldEnd()
20815 
    iprot.readStructEnd()
20816 
 
20817 
  def write(self, oprot):
20818 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20819 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20820 
      return
20821 
    oprot.writeStructBegin('getAllParentCategories_result')
20822 
    if self.success is not None:
20823 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20824 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 20825 
      for iter473 in self.success:
20826 
        iter473.write(oprot)
7897 amar.kumar 20827 
      oprot.writeListEnd()
20828 
      oprot.writeFieldEnd()
20829 
    oprot.writeFieldStop()
20830 
    oprot.writeStructEnd()
20831 
 
20832 
  def validate(self):
20833 
    return
20834 
 
20835 
 
20836 
  def __repr__(self):
20837 
    L = ['%s=%r' % (key, value)
20838 
      for key, value in self.__dict__.iteritems()]
20839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20840 
 
20841 
  def __eq__(self, other):
20842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20843 
 
20844 
  def __ne__(self, other):
20845 
    return not (self == other)
7977 kshitij.so 20846 
 
20847 
class addPageViewEvent_args:
20848 
  """
20849 
  Attributes:
20850 
   - pageViewEvents
20851 
  """
20852 
 
20853 
  thrift_spec = (
20854 
    None, # 0
20855 
    (1, TType.STRUCT, 'pageViewEvents', (PageViewEvents, PageViewEvents.thrift_spec), None, ), # 1
20856 
  )
20857 
 
20858 
  def __init__(self, pageViewEvents=None,):
20859 
    self.pageViewEvents = pageViewEvents
20860 
 
20861 
  def read(self, iprot):
20862 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20863 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20864 
      return
20865 
    iprot.readStructBegin()
20866 
    while True:
20867 
      (fname, ftype, fid) = iprot.readFieldBegin()
20868 
      if ftype == TType.STOP:
20869 
        break
20870 
      if fid == 1:
20871 
        if ftype == TType.STRUCT:
20872 
          self.pageViewEvents = PageViewEvents()
20873 
          self.pageViewEvents.read(iprot)
20874 
        else:
20875 
          iprot.skip(ftype)
20876 
      else:
20877 
        iprot.skip(ftype)
20878 
      iprot.readFieldEnd()
20879 
    iprot.readStructEnd()
20880 
 
20881 
  def write(self, oprot):
20882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20884 
      return
20885 
    oprot.writeStructBegin('addPageViewEvent_args')
20886 
    if self.pageViewEvents is not None:
20887 
      oprot.writeFieldBegin('pageViewEvents', TType.STRUCT, 1)
20888 
      self.pageViewEvents.write(oprot)
20889 
      oprot.writeFieldEnd()
20890 
    oprot.writeFieldStop()
20891 
    oprot.writeStructEnd()
20892 
 
20893 
  def validate(self):
20894 
    return
20895 
 
20896 
 
20897 
  def __repr__(self):
20898 
    L = ['%s=%r' % (key, value)
20899 
      for key, value in self.__dict__.iteritems()]
20900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20901 
 
20902 
  def __eq__(self, other):
20903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20904 
 
20905 
  def __ne__(self, other):
20906 
    return not (self == other)
20907 
 
20908 
class addPageViewEvent_result:
20909 
 
20910 
  thrift_spec = (
20911 
  )
20912 
 
20913 
  def read(self, iprot):
20914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20916 
      return
20917 
    iprot.readStructBegin()
20918 
    while True:
20919 
      (fname, ftype, fid) = iprot.readFieldBegin()
20920 
      if ftype == TType.STOP:
20921 
        break
20922 
      else:
20923 
        iprot.skip(ftype)
20924 
      iprot.readFieldEnd()
20925 
    iprot.readStructEnd()
20926 
 
20927 
  def write(self, oprot):
20928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20930 
      return
20931 
    oprot.writeStructBegin('addPageViewEvent_result')
20932 
    oprot.writeFieldStop()
20933 
    oprot.writeStructEnd()
20934 
 
20935 
  def validate(self):
20936 
    return
20937 
 
20938 
 
20939 
  def __repr__(self):
20940 
    L = ['%s=%r' % (key, value)
20941 
      for key, value in self.__dict__.iteritems()]
20942 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20943 
 
20944 
  def __eq__(self, other):
20945 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20946 
 
20947 
  def __ne__(self, other):
20948 
    return not (self == other)
20949 
 
20950 
class addCartEvent_args:
20951 
  """
20952 
  Attributes:
20953 
   - cartEvents
20954 
  """
20955 
 
20956 
  thrift_spec = (
20957 
    None, # 0
20958 
    (1, TType.STRUCT, 'cartEvents', (CartEvents, CartEvents.thrift_spec), None, ), # 1
20959 
  )
20960 
 
20961 
  def __init__(self, cartEvents=None,):
20962 
    self.cartEvents = cartEvents
20963 
 
20964 
  def read(self, iprot):
20965 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20966 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20967 
      return
20968 
    iprot.readStructBegin()
20969 
    while True:
20970 
      (fname, ftype, fid) = iprot.readFieldBegin()
20971 
      if ftype == TType.STOP:
20972 
        break
20973 
      if fid == 1:
20974 
        if ftype == TType.STRUCT:
20975 
          self.cartEvents = CartEvents()
20976 
          self.cartEvents.read(iprot)
20977 
        else:
20978 
          iprot.skip(ftype)
20979 
      else:
20980 
        iprot.skip(ftype)
20981 
      iprot.readFieldEnd()
20982 
    iprot.readStructEnd()
20983 
 
20984 
  def write(self, oprot):
20985 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20986 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20987 
      return
20988 
    oprot.writeStructBegin('addCartEvent_args')
20989 
    if self.cartEvents is not None:
20990 
      oprot.writeFieldBegin('cartEvents', TType.STRUCT, 1)
20991 
      self.cartEvents.write(oprot)
20992 
      oprot.writeFieldEnd()
20993 
    oprot.writeFieldStop()
20994 
    oprot.writeStructEnd()
20995 
 
20996 
  def validate(self):
20997 
    return
20998 
 
20999 
 
21000 
  def __repr__(self):
21001 
    L = ['%s=%r' % (key, value)
21002 
      for key, value in self.__dict__.iteritems()]
21003 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21004 
 
21005 
  def __eq__(self, other):
21006 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21007 
 
21008 
  def __ne__(self, other):
21009 
    return not (self == other)
21010 
 
21011 
class addCartEvent_result:
21012 
 
21013 
  thrift_spec = (
21014 
  )
21015 
 
21016 
  def read(self, iprot):
21017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21019 
      return
21020 
    iprot.readStructBegin()
21021 
    while True:
21022 
      (fname, ftype, fid) = iprot.readFieldBegin()
21023 
      if ftype == TType.STOP:
21024 
        break
21025 
      else:
21026 
        iprot.skip(ftype)
21027 
      iprot.readFieldEnd()
21028 
    iprot.readStructEnd()
21029 
 
21030 
  def write(self, oprot):
21031 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21032 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21033 
      return
21034 
    oprot.writeStructBegin('addCartEvent_result')
21035 
    oprot.writeFieldStop()
21036 
    oprot.writeStructEnd()
21037 
 
21038 
  def validate(self):
21039 
    return
21040 
 
21041 
 
21042 
  def __repr__(self):
21043 
    L = ['%s=%r' % (key, value)
21044 
      for key, value in self.__dict__.iteritems()]
21045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21046 
 
21047 
  def __eq__(self, other):
21048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21049 
 
21050 
  def __ne__(self, other):
21051 
    return not (self == other)
8139 kshitij.so 21052 
 
8182 amar.kumar 21053 
class addEbayItem_args:
21054 
  """
21055 
  Attributes:
21056 
   - ebayItem
21057 
  """
21058 
 
21059 
  thrift_spec = (
21060 
    None, # 0
21061 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
21062 
  )
21063 
 
21064 
  def __init__(self, ebayItem=None,):
21065 
    self.ebayItem = ebayItem
21066 
 
21067 
  def read(self, iprot):
21068 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21069 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21070 
      return
21071 
    iprot.readStructBegin()
21072 
    while True:
21073 
      (fname, ftype, fid) = iprot.readFieldBegin()
21074 
      if ftype == TType.STOP:
21075 
        break
21076 
      if fid == 1:
21077 
        if ftype == TType.STRUCT:
21078 
          self.ebayItem = EbayItem()
21079 
          self.ebayItem.read(iprot)
21080 
        else:
21081 
          iprot.skip(ftype)
21082 
      else:
21083 
        iprot.skip(ftype)
21084 
      iprot.readFieldEnd()
21085 
    iprot.readStructEnd()
21086 
 
21087 
  def write(self, oprot):
21088 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21089 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21090 
      return
21091 
    oprot.writeStructBegin('addEbayItem_args')
21092 
    if self.ebayItem is not None:
21093 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
21094 
      self.ebayItem.write(oprot)
21095 
      oprot.writeFieldEnd()
21096 
    oprot.writeFieldStop()
21097 
    oprot.writeStructEnd()
21098 
 
21099 
  def validate(self):
21100 
    return
21101 
 
21102 
 
21103 
  def __repr__(self):
21104 
    L = ['%s=%r' % (key, value)
21105 
      for key, value in self.__dict__.iteritems()]
21106 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21107 
 
21108 
  def __eq__(self, other):
21109 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21110 
 
21111 
  def __ne__(self, other):
21112 
    return not (self == other)
21113 
 
21114 
class addEbayItem_result:
21115 
 
21116 
  thrift_spec = (
21117 
  )
21118 
 
21119 
  def read(self, iprot):
21120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21122 
      return
21123 
    iprot.readStructBegin()
21124 
    while True:
21125 
      (fname, ftype, fid) = iprot.readFieldBegin()
21126 
      if ftype == TType.STOP:
21127 
        break
21128 
      else:
21129 
        iprot.skip(ftype)
21130 
      iprot.readFieldEnd()
21131 
    iprot.readStructEnd()
21132 
 
21133 
  def write(self, oprot):
21134 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21135 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21136 
      return
21137 
    oprot.writeStructBegin('addEbayItem_result')
21138 
    oprot.writeFieldStop()
21139 
    oprot.writeStructEnd()
21140 
 
21141 
  def validate(self):
21142 
    return
21143 
 
21144 
 
21145 
  def __repr__(self):
21146 
    L = ['%s=%r' % (key, value)
21147 
      for key, value in self.__dict__.iteritems()]
21148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21149 
 
21150 
  def __eq__(self, other):
21151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21152 
 
21153 
  def __ne__(self, other):
21154 
    return not (self == other)
21155 
 
21156 
class getEbayItem_args:
21157 
  """
21158 
  Attributes:
21159 
   - listingId
21160 
  """
21161 
 
21162 
  thrift_spec = (
21163 
    None, # 0
21164 
    (1, TType.STRING, 'listingId', None, None, ), # 1
21165 
  )
21166 
 
21167 
  def __init__(self, listingId=None,):
21168 
    self.listingId = listingId
21169 
 
21170 
  def read(self, iprot):
21171 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21172 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21173 
      return
21174 
    iprot.readStructBegin()
21175 
    while True:
21176 
      (fname, ftype, fid) = iprot.readFieldBegin()
21177 
      if ftype == TType.STOP:
21178 
        break
21179 
      if fid == 1:
21180 
        if ftype == TType.STRING:
21181 
          self.listingId = iprot.readString();
21182 
        else:
21183 
          iprot.skip(ftype)
21184 
      else:
21185 
        iprot.skip(ftype)
21186 
      iprot.readFieldEnd()
21187 
    iprot.readStructEnd()
21188 
 
21189 
  def write(self, oprot):
21190 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21191 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21192 
      return
21193 
    oprot.writeStructBegin('getEbayItem_args')
21194 
    if self.listingId is not None:
21195 
      oprot.writeFieldBegin('listingId', TType.STRING, 1)
21196 
      oprot.writeString(self.listingId)
21197 
      oprot.writeFieldEnd()
21198 
    oprot.writeFieldStop()
21199 
    oprot.writeStructEnd()
21200 
 
21201 
  def validate(self):
21202 
    return
21203 
 
21204 
 
21205 
  def __repr__(self):
21206 
    L = ['%s=%r' % (key, value)
21207 
      for key, value in self.__dict__.iteritems()]
21208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21209 
 
21210 
  def __eq__(self, other):
21211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21212 
 
21213 
  def __ne__(self, other):
21214 
    return not (self == other)
21215 
 
21216 
class getEbayItem_result:
21217 
  """
21218 
  Attributes:
21219 
   - success
21220 
  """
21221 
 
21222 
  thrift_spec = (
21223 
    (0, TType.STRUCT, 'success', (EbayItem, EbayItem.thrift_spec), None, ), # 0
21224 
  )
21225 
 
21226 
  def __init__(self, success=None,):
21227 
    self.success = success
21228 
 
21229 
  def read(self, iprot):
21230 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21231 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21232 
      return
21233 
    iprot.readStructBegin()
21234 
    while True:
21235 
      (fname, ftype, fid) = iprot.readFieldBegin()
21236 
      if ftype == TType.STOP:
21237 
        break
21238 
      if fid == 0:
21239 
        if ftype == TType.STRUCT:
21240 
          self.success = EbayItem()
21241 
          self.success.read(iprot)
21242 
        else:
21243 
          iprot.skip(ftype)
21244 
      else:
21245 
        iprot.skip(ftype)
21246 
      iprot.readFieldEnd()
21247 
    iprot.readStructEnd()
21248 
 
21249 
  def write(self, oprot):
21250 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21251 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21252 
      return
21253 
    oprot.writeStructBegin('getEbayItem_result')
21254 
    if self.success is not None:
21255 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21256 
      self.success.write(oprot)
21257 
      oprot.writeFieldEnd()
21258 
    oprot.writeFieldStop()
21259 
    oprot.writeStructEnd()
21260 
 
21261 
  def validate(self):
21262 
    return
21263 
 
21264 
 
21265 
  def __repr__(self):
21266 
    L = ['%s=%r' % (key, value)
21267 
      for key, value in self.__dict__.iteritems()]
21268 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21269 
 
21270 
  def __eq__(self, other):
21271 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21272 
 
21273 
  def __ne__(self, other):
21274 
    return not (self == other)
21275 
 
21276 
class updateEbayItem_args:
21277 
  """
21278 
  Attributes:
21279 
   - ebayItem
21280 
  """
21281 
 
21282 
  thrift_spec = (
21283 
    None, # 0
21284 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
21285 
  )
21286 
 
21287 
  def __init__(self, ebayItem=None,):
21288 
    self.ebayItem = ebayItem
21289 
 
21290 
  def read(self, iprot):
21291 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21292 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21293 
      return
21294 
    iprot.readStructBegin()
21295 
    while True:
21296 
      (fname, ftype, fid) = iprot.readFieldBegin()
21297 
      if ftype == TType.STOP:
21298 
        break
21299 
      if fid == 1:
21300 
        if ftype == TType.STRUCT:
21301 
          self.ebayItem = EbayItem()
21302 
          self.ebayItem.read(iprot)
21303 
        else:
21304 
          iprot.skip(ftype)
21305 
      else:
21306 
        iprot.skip(ftype)
21307 
      iprot.readFieldEnd()
21308 
    iprot.readStructEnd()
21309 
 
21310 
  def write(self, oprot):
21311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21313 
      return
21314 
    oprot.writeStructBegin('updateEbayItem_args')
21315 
    if self.ebayItem is not None:
21316 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
21317 
      self.ebayItem.write(oprot)
21318 
      oprot.writeFieldEnd()
21319 
    oprot.writeFieldStop()
21320 
    oprot.writeStructEnd()
21321 
 
21322 
  def validate(self):
21323 
    return
21324 
 
21325 
 
21326 
  def __repr__(self):
21327 
    L = ['%s=%r' % (key, value)
21328 
      for key, value in self.__dict__.iteritems()]
21329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21330 
 
21331 
  def __eq__(self, other):
21332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21333 
 
21334 
  def __ne__(self, other):
21335 
    return not (self == other)
21336 
 
21337 
class updateEbayItem_result:
21338 
 
21339 
  thrift_spec = (
21340 
  )
21341 
 
21342 
  def read(self, iprot):
21343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21345 
      return
21346 
    iprot.readStructBegin()
21347 
    while True:
21348 
      (fname, ftype, fid) = iprot.readFieldBegin()
21349 
      if ftype == TType.STOP:
21350 
        break
21351 
      else:
21352 
        iprot.skip(ftype)
21353 
      iprot.readFieldEnd()
21354 
    iprot.readStructEnd()
21355 
 
21356 
  def write(self, oprot):
21357 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21358 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21359 
      return
21360 
    oprot.writeStructBegin('updateEbayItem_result')
21361 
    oprot.writeFieldStop()
21362 
    oprot.writeStructEnd()
21363 
 
21364 
  def validate(self):
21365 
    return
21366 
 
21367 
 
21368 
  def __repr__(self):
21369 
    L = ['%s=%r' % (key, value)
21370 
      for key, value in self.__dict__.iteritems()]
21371 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21372 
 
21373 
  def __eq__(self, other):
21374 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21375 
 
21376 
  def __ne__(self, other):
21377 
    return not (self == other)
21378 
 
8139 kshitij.so 21379 
class getAmazonListedItems_args:
21380 
  """
21381 
  Attributes:
21382 
   - offset
21383 
   - limit
21384 
  """
21385 
 
21386 
  thrift_spec = (
21387 
    None, # 0
21388 
    (1, TType.I64, 'offset', None, None, ), # 1
21389 
    (2, TType.I64, 'limit', None, None, ), # 2
21390 
  )
21391 
 
21392 
  def __init__(self, offset=None, limit=None,):
21393 
    self.offset = offset
21394 
    self.limit = limit
21395 
 
21396 
  def read(self, iprot):
21397 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21398 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21399 
      return
21400 
    iprot.readStructBegin()
21401 
    while True:
21402 
      (fname, ftype, fid) = iprot.readFieldBegin()
21403 
      if ftype == TType.STOP:
21404 
        break
21405 
      if fid == 1:
21406 
        if ftype == TType.I64:
21407 
          self.offset = iprot.readI64();
21408 
        else:
21409 
          iprot.skip(ftype)
21410 
      elif fid == 2:
21411 
        if ftype == TType.I64:
21412 
          self.limit = iprot.readI64();
21413 
        else:
21414 
          iprot.skip(ftype)
21415 
      else:
21416 
        iprot.skip(ftype)
21417 
      iprot.readFieldEnd()
21418 
    iprot.readStructEnd()
21419 
 
21420 
  def write(self, oprot):
21421 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21422 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21423 
      return
21424 
    oprot.writeStructBegin('getAmazonListedItems_args')
21425 
    if self.offset is not None:
21426 
      oprot.writeFieldBegin('offset', TType.I64, 1)
21427 
      oprot.writeI64(self.offset)
21428 
      oprot.writeFieldEnd()
21429 
    if self.limit is not None:
21430 
      oprot.writeFieldBegin('limit', TType.I64, 2)
21431 
      oprot.writeI64(self.limit)
21432 
      oprot.writeFieldEnd()
21433 
    oprot.writeFieldStop()
21434 
    oprot.writeStructEnd()
21435 
 
21436 
  def validate(self):
21437 
    return
21438 
 
21439 
 
21440 
  def __repr__(self):
21441 
    L = ['%s=%r' % (key, value)
21442 
      for key, value in self.__dict__.iteritems()]
21443 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21444 
 
21445 
  def __eq__(self, other):
21446 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21447 
 
21448 
  def __ne__(self, other):
21449 
    return not (self == other)
21450 
 
21451 
class getAmazonListedItems_result:
21452 
  """
21453 
  Attributes:
21454 
   - success
21455 
  """
21456 
 
21457 
  thrift_spec = (
21458 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
21459 
  )
21460 
 
21461 
  def __init__(self, success=None,):
21462 
    self.success = success
21463 
 
21464 
  def read(self, iprot):
21465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21467 
      return
21468 
    iprot.readStructBegin()
21469 
    while True:
21470 
      (fname, ftype, fid) = iprot.readFieldBegin()
21471 
      if ftype == TType.STOP:
21472 
        break
21473 
      if fid == 0:
21474 
        if ftype == TType.LIST:
21475 
          self.success = []
9155 kshitij.so 21476 
          (_etype477, _size474) = iprot.readListBegin()
21477 
          for _i478 in xrange(_size474):
21478 
            _elem479 = Amazonlisted()
21479 
            _elem479.read(iprot)
21480 
            self.success.append(_elem479)
8139 kshitij.so 21481 
          iprot.readListEnd()
21482 
        else:
21483 
          iprot.skip(ftype)
21484 
      else:
21485 
        iprot.skip(ftype)
21486 
      iprot.readFieldEnd()
21487 
    iprot.readStructEnd()
21488 
 
21489 
  def write(self, oprot):
21490 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21491 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21492 
      return
21493 
    oprot.writeStructBegin('getAmazonListedItems_result')
21494 
    if self.success is not None:
21495 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21496 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21497 
      for iter480 in self.success:
21498 
        iter480.write(oprot)
8139 kshitij.so 21499 
      oprot.writeListEnd()
21500 
      oprot.writeFieldEnd()
21501 
    oprot.writeFieldStop()
21502 
    oprot.writeStructEnd()
21503 
 
21504 
  def validate(self):
21505 
    return
21506 
 
21507 
 
21508 
  def __repr__(self):
21509 
    L = ['%s=%r' % (key, value)
21510 
      for key, value in self.__dict__.iteritems()]
21511 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21512 
 
21513 
  def __eq__(self, other):
21514 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21515 
 
21516 
  def __ne__(self, other):
21517 
    return not (self == other)
8168 kshitij.so 21518 
 
21519 
class updateAmazonAttributesInBulk_args:
21520 
  """
21521 
  Attributes:
21522 
   - amazonlisted
21523 
  """
21524 
 
21525 
  thrift_spec = (
21526 
    None, # 0
21527 
    (1, TType.MAP, 'amazonlisted', (TType.I64,None,TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 1
21528 
  )
21529 
 
21530 
  def __init__(self, amazonlisted=None,):
21531 
    self.amazonlisted = amazonlisted
21532 
 
21533 
  def read(self, iprot):
21534 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21535 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21536 
      return
21537 
    iprot.readStructBegin()
21538 
    while True:
21539 
      (fname, ftype, fid) = iprot.readFieldBegin()
21540 
      if ftype == TType.STOP:
21541 
        break
21542 
      if fid == 1:
21543 
        if ftype == TType.MAP:
21544 
          self.amazonlisted = {}
9155 kshitij.so 21545 
          (_ktype482, _vtype483, _size481 ) = iprot.readMapBegin()
21546 
          for _i485 in xrange(_size481):
21547 
            _key486 = iprot.readI64();
21548 
            _val487 = Amazonlisted()
21549 
            _val487.read(iprot)
21550 
            self.amazonlisted[_key486] = _val487
8168 kshitij.so 21551 
          iprot.readMapEnd()
21552 
        else:
21553 
          iprot.skip(ftype)
21554 
      else:
21555 
        iprot.skip(ftype)
21556 
      iprot.readFieldEnd()
21557 
    iprot.readStructEnd()
21558 
 
21559 
  def write(self, oprot):
21560 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21561 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21562 
      return
21563 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_args')
21564 
    if self.amazonlisted is not None:
21565 
      oprot.writeFieldBegin('amazonlisted', TType.MAP, 1)
21566 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.amazonlisted))
9155 kshitij.so 21567 
      for kiter488,viter489 in self.amazonlisted.items():
21568 
        oprot.writeI64(kiter488)
21569 
        viter489.write(oprot)
8168 kshitij.so 21570 
      oprot.writeMapEnd()
21571 
      oprot.writeFieldEnd()
21572 
    oprot.writeFieldStop()
21573 
    oprot.writeStructEnd()
21574 
 
21575 
  def validate(self):
21576 
    return
21577 
 
21578 
 
21579 
  def __repr__(self):
21580 
    L = ['%s=%r' % (key, value)
21581 
      for key, value in self.__dict__.iteritems()]
21582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21583 
 
21584 
  def __eq__(self, other):
21585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21586 
 
21587 
  def __ne__(self, other):
21588 
    return not (self == other)
21589 
 
21590 
class updateAmazonAttributesInBulk_result:
21591 
  """
21592 
  Attributes:
21593 
   - success
21594 
  """
21595 
 
21596 
  thrift_spec = (
21597 
    (0, TType.BOOL, 'success', None, None, ), # 0
21598 
  )
21599 
 
21600 
  def __init__(self, success=None,):
21601 
    self.success = success
21602 
 
21603 
  def read(self, iprot):
21604 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21605 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21606 
      return
21607 
    iprot.readStructBegin()
21608 
    while True:
21609 
      (fname, ftype, fid) = iprot.readFieldBegin()
21610 
      if ftype == TType.STOP:
21611 
        break
21612 
      if fid == 0:
21613 
        if ftype == TType.BOOL:
21614 
          self.success = iprot.readBool();
21615 
        else:
21616 
          iprot.skip(ftype)
21617 
      else:
21618 
        iprot.skip(ftype)
21619 
      iprot.readFieldEnd()
21620 
    iprot.readStructEnd()
21621 
 
21622 
  def write(self, oprot):
21623 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21624 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21625 
      return
21626 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_result')
21627 
    if self.success is not None:
21628 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21629 
      oprot.writeBool(self.success)
21630 
      oprot.writeFieldEnd()
21631 
    oprot.writeFieldStop()
21632 
    oprot.writeStructEnd()
21633 
 
21634 
  def validate(self):
21635 
    return
21636 
 
21637 
 
21638 
  def __repr__(self):
21639 
    L = ['%s=%r' % (key, value)
21640 
      for key, value in self.__dict__.iteritems()]
21641 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21642 
 
21643 
  def __eq__(self, other):
21644 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21645 
 
21646 
  def __ne__(self, other):
21647 
    return not (self == other)
8379 vikram.rag 21648 
 
21649 
class getAllItemstoListOnFba_args:
21650 
 
21651 
  thrift_spec = (
21652 
  )
21653 
 
21654 
  def read(self, iprot):
21655 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21656 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21657 
      return
21658 
    iprot.readStructBegin()
21659 
    while True:
21660 
      (fname, ftype, fid) = iprot.readFieldBegin()
21661 
      if ftype == TType.STOP:
21662 
        break
21663 
      else:
21664 
        iprot.skip(ftype)
21665 
      iprot.readFieldEnd()
21666 
    iprot.readStructEnd()
21667 
 
21668 
  def write(self, oprot):
21669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21671 
      return
21672 
    oprot.writeStructBegin('getAllItemstoListOnFba_args')
21673 
    oprot.writeFieldStop()
21674 
    oprot.writeStructEnd()
21675 
 
21676 
  def validate(self):
21677 
    return
21678 
 
21679 
 
21680 
  def __repr__(self):
21681 
    L = ['%s=%r' % (key, value)
21682 
      for key, value in self.__dict__.iteritems()]
21683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21684 
 
21685 
  def __eq__(self, other):
21686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21687 
 
21688 
  def __ne__(self, other):
21689 
    return not (self == other)
21690 
 
21691 
class getAllItemstoListOnFba_result:
21692 
  """
21693 
  Attributes:
21694 
   - success
21695 
  """
21696 
 
21697 
  thrift_spec = (
21698 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
21699 
  )
21700 
 
21701 
  def __init__(self, success=None,):
21702 
    self.success = success
21703 
 
21704 
  def read(self, iprot):
21705 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21706 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21707 
      return
21708 
    iprot.readStructBegin()
21709 
    while True:
21710 
      (fname, ftype, fid) = iprot.readFieldBegin()
21711 
      if ftype == TType.STOP:
21712 
        break
21713 
      if fid == 0:
21714 
        if ftype == TType.LIST:
21715 
          self.success = []
9155 kshitij.so 21716 
          (_etype493, _size490) = iprot.readListBegin()
21717 
          for _i494 in xrange(_size490):
21718 
            _elem495 = Amazonlisted()
21719 
            _elem495.read(iprot)
21720 
            self.success.append(_elem495)
8379 vikram.rag 21721 
          iprot.readListEnd()
21722 
        else:
21723 
          iprot.skip(ftype)
21724 
      else:
21725 
        iprot.skip(ftype)
21726 
      iprot.readFieldEnd()
21727 
    iprot.readStructEnd()
21728 
 
21729 
  def write(self, oprot):
21730 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21731 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21732 
      return
21733 
    oprot.writeStructBegin('getAllItemstoListOnFba_result')
21734 
    if self.success is not None:
21735 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21736 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21737 
      for iter496 in self.success:
21738 
        iter496.write(oprot)
8379 vikram.rag 21739 
      oprot.writeListEnd()
21740 
      oprot.writeFieldEnd()
21741 
    oprot.writeFieldStop()
21742 
    oprot.writeStructEnd()
21743 
 
21744 
  def validate(self):
21745 
    return
21746 
 
21747 
 
21748 
  def __repr__(self):
21749 
    L = ['%s=%r' % (key, value)
21750 
      for key, value in self.__dict__.iteritems()]
21751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21752 
 
21753 
  def __eq__(self, other):
21754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21755 
 
21756 
  def __ne__(self, other):
21757 
    return not (self == other)
21758 
 
21759 
class getAllItemstoListOnNonFba_args:
21760 
 
21761 
  thrift_spec = (
21762 
  )
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 
      else:
21774 
        iprot.skip(ftype)
21775 
      iprot.readFieldEnd()
21776 
    iprot.readStructEnd()
21777 
 
21778 
  def write(self, oprot):
21779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21781 
      return
21782 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_args')
21783 
    oprot.writeFieldStop()
21784 
    oprot.writeStructEnd()
21785 
 
21786 
  def validate(self):
21787 
    return
21788 
 
21789 
 
21790 
  def __repr__(self):
21791 
    L = ['%s=%r' % (key, value)
21792 
      for key, value in self.__dict__.iteritems()]
21793 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21794 
 
21795 
  def __eq__(self, other):
21796 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21797 
 
21798 
  def __ne__(self, other):
21799 
    return not (self == other)
21800 
 
21801 
class getAllItemstoListOnNonFba_result:
21802 
  """
21803 
  Attributes:
21804 
   - success
21805 
  """
21806 
 
21807 
  thrift_spec = (
21808 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
21809 
  )
21810 
 
21811 
  def __init__(self, success=None,):
21812 
    self.success = success
21813 
 
21814 
  def read(self, iprot):
21815 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21816 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21817 
      return
21818 
    iprot.readStructBegin()
21819 
    while True:
21820 
      (fname, ftype, fid) = iprot.readFieldBegin()
21821 
      if ftype == TType.STOP:
21822 
        break
21823 
      if fid == 0:
21824 
        if ftype == TType.LIST:
21825 
          self.success = []
9155 kshitij.so 21826 
          (_etype500, _size497) = iprot.readListBegin()
21827 
          for _i501 in xrange(_size497):
21828 
            _elem502 = Amazonlisted()
21829 
            _elem502.read(iprot)
21830 
            self.success.append(_elem502)
8379 vikram.rag 21831 
          iprot.readListEnd()
21832 
        else:
21833 
          iprot.skip(ftype)
21834 
      else:
21835 
        iprot.skip(ftype)
21836 
      iprot.readFieldEnd()
21837 
    iprot.readStructEnd()
21838 
 
21839 
  def write(self, oprot):
21840 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21841 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21842 
      return
21843 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_result')
21844 
    if self.success is not None:
21845 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21846 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21847 
      for iter503 in self.success:
21848 
        iter503.write(oprot)
8379 vikram.rag 21849 
      oprot.writeListEnd()
21850 
      oprot.writeFieldEnd()
21851 
    oprot.writeFieldStop()
21852 
    oprot.writeStructEnd()
21853 
 
21854 
  def validate(self):
21855 
    return
21856 
 
21857 
 
21858 
  def __repr__(self):
21859 
    L = ['%s=%r' % (key, value)
21860 
      for key, value in self.__dict__.iteritems()]
21861 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21862 
 
21863 
  def __eq__(self, other):
21864 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21865 
 
21866 
  def __ne__(self, other):
21867 
    return not (self == other)
8616 vikram.rag 21868 
 
21869 
class getAllSnapdealListedActiveItems_args:
21870 
 
21871 
  thrift_spec = (
21872 
  )
21873 
 
21874 
  def read(self, iprot):
21875 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21876 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21877 
      return
21878 
    iprot.readStructBegin()
21879 
    while True:
21880 
      (fname, ftype, fid) = iprot.readFieldBegin()
21881 
      if ftype == TType.STOP:
21882 
        break
21883 
      else:
21884 
        iprot.skip(ftype)
21885 
      iprot.readFieldEnd()
21886 
    iprot.readStructEnd()
21887 
 
21888 
  def write(self, oprot):
21889 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21890 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21891 
      return
21892 
    oprot.writeStructBegin('getAllSnapdealListedActiveItems_args')
21893 
    oprot.writeFieldStop()
21894 
    oprot.writeStructEnd()
21895 
 
21896 
  def validate(self):
21897 
    return
21898 
 
21899 
 
21900 
  def __repr__(self):
21901 
    L = ['%s=%r' % (key, value)
21902 
      for key, value in self.__dict__.iteritems()]
21903 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21904 
 
21905 
  def __eq__(self, other):
21906 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21907 
 
21908 
  def __ne__(self, other):
21909 
    return not (self == other)
21910 
 
21911 
class getAllSnapdealListedActiveItems_result:
21912 
  """
21913 
  Attributes:
21914 
   - success
21915 
  """
21916 
 
21917 
  thrift_spec = (
21918 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
21919 
  )
21920 
 
21921 
  def __init__(self, success=None,):
21922 
    self.success = success
21923 
 
21924 
  def read(self, iprot):
21925 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21926 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21927 
      return
21928 
    iprot.readStructBegin()
21929 
    while True:
21930 
      (fname, ftype, fid) = iprot.readFieldBegin()
21931 
      if ftype == TType.STOP:
21932 
        break
21933 
      if fid == 0:
21934 
        if ftype == TType.LIST:
21935 
          self.success = []
9155 kshitij.so 21936 
          (_etype507, _size504) = iprot.readListBegin()
21937 
          for _i508 in xrange(_size504):
21938 
            _elem509 = Item()
21939 
            _elem509.read(iprot)
21940 
            self.success.append(_elem509)
8616 vikram.rag 21941 
          iprot.readListEnd()
21942 
        else:
21943 
          iprot.skip(ftype)
21944 
      else:
21945 
        iprot.skip(ftype)
21946 
      iprot.readFieldEnd()
21947 
    iprot.readStructEnd()
21948 
 
21949 
  def write(self, oprot):
21950 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21951 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21952 
      return
21953 
    oprot.writeStructBegin('getAllSnapdealListedActiveItems_result')
21954 
    if self.success is not None:
21955 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21956 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21957 
      for iter510 in self.success:
21958 
        iter510.write(oprot)
8616 vikram.rag 21959 
      oprot.writeListEnd()
21960 
      oprot.writeFieldEnd()
21961 
    oprot.writeFieldStop()
21962 
    oprot.writeStructEnd()
21963 
 
21964 
  def validate(self):
21965 
    return
21966 
 
21967 
 
21968 
  def __repr__(self):
21969 
    L = ['%s=%r' % (key, value)
21970 
      for key, value in self.__dict__.iteritems()]
21971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21972 
 
21973 
  def __eq__(self, other):
21974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21975 
 
21976 
  def __ne__(self, other):
21977 
    return not (self == other)
8619 kshitij.so 21978 
 
21979 
class updateAsin_args:
21980 
  """
21981 
  Attributes:
21982 
   - item
21983 
  """
21984 
 
21985 
  thrift_spec = (
21986 
    None, # 0
21987 
    (1, TType.MAP, 'item', (TType.I64,None,TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 1
21988 
  )
21989 
 
21990 
  def __init__(self, item=None,):
21991 
    self.item = item
21992 
 
21993 
  def read(self, iprot):
21994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21996 
      return
21997 
    iprot.readStructBegin()
21998 
    while True:
21999 
      (fname, ftype, fid) = iprot.readFieldBegin()
22000 
      if ftype == TType.STOP:
22001 
        break
22002 
      if fid == 1:
22003 
        if ftype == TType.MAP:
22004 
          self.item = {}
9155 kshitij.so 22005 
          (_ktype512, _vtype513, _size511 ) = iprot.readMapBegin()
22006 
          for _i515 in xrange(_size511):
22007 
            _key516 = iprot.readI64();
22008 
            _val517 = Item()
22009 
            _val517.read(iprot)
22010 
            self.item[_key516] = _val517
8619 kshitij.so 22011 
          iprot.readMapEnd()
22012 
        else:
22013 
          iprot.skip(ftype)
22014 
      else:
22015 
        iprot.skip(ftype)
22016 
      iprot.readFieldEnd()
22017 
    iprot.readStructEnd()
22018 
 
22019 
  def write(self, oprot):
22020 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22021 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22022 
      return
22023 
    oprot.writeStructBegin('updateAsin_args')
22024 
    if self.item is not None:
22025 
      oprot.writeFieldBegin('item', TType.MAP, 1)
22026 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.item))
9155 kshitij.so 22027 
      for kiter518,viter519 in self.item.items():
22028 
        oprot.writeI64(kiter518)
22029 
        viter519.write(oprot)
8619 kshitij.so 22030 
      oprot.writeMapEnd()
22031 
      oprot.writeFieldEnd()
22032 
    oprot.writeFieldStop()
22033 
    oprot.writeStructEnd()
22034 
 
22035 
  def validate(self):
22036 
    return
22037 
 
22038 
 
22039 
  def __repr__(self):
22040 
    L = ['%s=%r' % (key, value)
22041 
      for key, value in self.__dict__.iteritems()]
22042 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22043 
 
22044 
  def __eq__(self, other):
22045 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22046 
 
22047 
  def __ne__(self, other):
22048 
    return not (self == other)
22049 
 
22050 
class updateAsin_result:
22051 
 
22052 
  thrift_spec = (
22053 
  )
22054 
 
22055 
  def read(self, iprot):
22056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22058 
      return
22059 
    iprot.readStructBegin()
22060 
    while True:
22061 
      (fname, ftype, fid) = iprot.readFieldBegin()
22062 
      if ftype == TType.STOP:
22063 
        break
22064 
      else:
22065 
        iprot.skip(ftype)
22066 
      iprot.readFieldEnd()
22067 
    iprot.readStructEnd()
22068 
 
22069 
  def write(self, oprot):
22070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22072 
      return
22073 
    oprot.writeStructBegin('updateAsin_result')
22074 
    oprot.writeFieldStop()
22075 
    oprot.writeStructEnd()
22076 
 
22077 
  def validate(self):
22078 
    return
22079 
 
22080 
 
22081 
  def __repr__(self):
22082 
    L = ['%s=%r' % (key, value)
22083 
      for key, value in self.__dict__.iteritems()]
22084 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22085 
 
22086 
  def __eq__(self, other):
22087 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22088 
 
22089 
  def __ne__(self, other):
22090 
    return not (self == other)
8739 vikram.rag 22091 
 
22092 
class addOrUpdateSnapdealItem_args:
22093 
  """
22094 
  Attributes:
22095 
   - snapdealitem
22096 
  """
22097 
 
22098 
  thrift_spec = None
22099 
  def __init__(self, snapdealitem=None,):
22100 
    self.snapdealitem = snapdealitem
22101 
 
22102 
  def read(self, iprot):
22103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22105 
      return
22106 
    iprot.readStructBegin()
22107 
    while True:
22108 
      (fname, ftype, fid) = iprot.readFieldBegin()
22109 
      if ftype == TType.STOP:
22110 
        break
22111 
      if fid == -1:
22112 
        if ftype == TType.STRUCT:
22113 
          self.snapdealitem = SnapdealItem()
22114 
          self.snapdealitem.read(iprot)
22115 
        else:
22116 
          iprot.skip(ftype)
22117 
      else:
22118 
        iprot.skip(ftype)
22119 
      iprot.readFieldEnd()
22120 
    iprot.readStructEnd()
22121 
 
22122 
  def write(self, oprot):
22123 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22124 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22125 
      return
22126 
    oprot.writeStructBegin('addOrUpdateSnapdealItem_args')
22127 
    if self.snapdealitem is not None:
22128 
      oprot.writeFieldBegin('snapdealitem', TType.STRUCT, -1)
22129 
      self.snapdealitem.write(oprot)
22130 
      oprot.writeFieldEnd()
22131 
    oprot.writeFieldStop()
22132 
    oprot.writeStructEnd()
22133 
 
22134 
  def validate(self):
22135 
    return
22136 
 
22137 
 
22138 
  def __repr__(self):
22139 
    L = ['%s=%r' % (key, value)
22140 
      for key, value in self.__dict__.iteritems()]
22141 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22142 
 
22143 
  def __eq__(self, other):
22144 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22145 
 
22146 
  def __ne__(self, other):
22147 
    return not (self == other)
22148 
 
22149 
class addOrUpdateSnapdealItem_result:
22150 
  """
22151 
  Attributes:
22152 
   - success
22153 
  """
22154 
 
22155 
  thrift_spec = (
22156 
    (0, TType.BOOL, 'success', None, None, ), # 0
22157 
  )
22158 
 
22159 
  def __init__(self, success=None,):
22160 
    self.success = success
22161 
 
22162 
  def read(self, iprot):
22163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22165 
      return
22166 
    iprot.readStructBegin()
22167 
    while True:
22168 
      (fname, ftype, fid) = iprot.readFieldBegin()
22169 
      if ftype == TType.STOP:
22170 
        break
22171 
      if fid == 0:
22172 
        if ftype == TType.BOOL:
22173 
          self.success = iprot.readBool();
22174 
        else:
22175 
          iprot.skip(ftype)
22176 
      else:
22177 
        iprot.skip(ftype)
22178 
      iprot.readFieldEnd()
22179 
    iprot.readStructEnd()
22180 
 
22181 
  def write(self, oprot):
22182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22184 
      return
22185 
    oprot.writeStructBegin('addOrUpdateSnapdealItem_result')
22186 
    if self.success is not None:
22187 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22188 
      oprot.writeBool(self.success)
22189 
      oprot.writeFieldEnd()
22190 
    oprot.writeFieldStop()
22191 
    oprot.writeStructEnd()
22192 
 
22193 
  def validate(self):
22194 
    return
22195 
 
22196 
 
22197 
  def __repr__(self):
22198 
    L = ['%s=%r' % (key, value)
22199 
      for key, value in self.__dict__.iteritems()]
22200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22201 
 
22202 
  def __eq__(self, other):
22203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22204 
 
22205 
  def __ne__(self, other):
22206 
    return not (self == other)
22207 
 
22208 
class getSnapdealItem_args:
22209 
  """
22210 
  Attributes:
22211 
   - item_id
22212 
  """
22213 
 
22214 
  thrift_spec = (
22215 
    None, # 0
22216 
    (1, TType.I64, 'item_id', None, None, ), # 1
22217 
  )
22218 
 
22219 
  def __init__(self, item_id=None,):
22220 
    self.item_id = item_id
22221 
 
22222 
  def read(self, iprot):
22223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22225 
      return
22226 
    iprot.readStructBegin()
22227 
    while True:
22228 
      (fname, ftype, fid) = iprot.readFieldBegin()
22229 
      if ftype == TType.STOP:
22230 
        break
22231 
      if fid == 1:
22232 
        if ftype == TType.I64:
22233 
          self.item_id = iprot.readI64();
22234 
        else:
22235 
          iprot.skip(ftype)
22236 
      else:
22237 
        iprot.skip(ftype)
22238 
      iprot.readFieldEnd()
22239 
    iprot.readStructEnd()
22240 
 
22241 
  def write(self, oprot):
22242 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22243 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22244 
      return
22245 
    oprot.writeStructBegin('getSnapdealItem_args')
22246 
    if self.item_id is not None:
22247 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
22248 
      oprot.writeI64(self.item_id)
22249 
      oprot.writeFieldEnd()
22250 
    oprot.writeFieldStop()
22251 
    oprot.writeStructEnd()
22252 
 
22253 
  def validate(self):
22254 
    return
22255 
 
22256 
 
22257 
  def __repr__(self):
22258 
    L = ['%s=%r' % (key, value)
22259 
      for key, value in self.__dict__.iteritems()]
22260 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22261 
 
22262 
  def __eq__(self, other):
22263 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22264 
 
22265 
  def __ne__(self, other):
22266 
    return not (self == other)
22267 
 
22268 
class getSnapdealItem_result:
22269 
  """
22270 
  Attributes:
22271 
   - success
22272 
  """
22273 
 
22274 
  thrift_spec = (
22275 
    (0, TType.STRUCT, 'success', (SnapdealItem, SnapdealItem.thrift_spec), None, ), # 0
22276 
  )
22277 
 
22278 
  def __init__(self, success=None,):
22279 
    self.success = success
22280 
 
22281 
  def read(self, iprot):
22282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22284 
      return
22285 
    iprot.readStructBegin()
22286 
    while True:
22287 
      (fname, ftype, fid) = iprot.readFieldBegin()
22288 
      if ftype == TType.STOP:
22289 
        break
22290 
      if fid == 0:
22291 
        if ftype == TType.STRUCT:
22292 
          self.success = SnapdealItem()
22293 
          self.success.read(iprot)
22294 
        else:
22295 
          iprot.skip(ftype)
22296 
      else:
22297 
        iprot.skip(ftype)
22298 
      iprot.readFieldEnd()
22299 
    iprot.readStructEnd()
22300 
 
22301 
  def write(self, oprot):
22302 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22303 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22304 
      return
22305 
    oprot.writeStructBegin('getSnapdealItem_result')
22306 
    if self.success is not None:
22307 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22308 
      self.success.write(oprot)
22309 
      oprot.writeFieldEnd()
22310 
    oprot.writeFieldStop()
22311 
    oprot.writeStructEnd()
22312 
 
22313 
  def validate(self):
22314 
    return
22315 
 
22316 
 
22317 
  def __repr__(self):
22318 
    L = ['%s=%r' % (key, value)
22319 
      for key, value in self.__dict__.iteritems()]
22320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22321 
 
22322 
  def __eq__(self, other):
22323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22324 
 
22325 
  def __ne__(self, other):
22326 
    return not (self == other)
22327 
 
22328 
class getAllSnapdealItems_args:
22329 
 
22330 
  thrift_spec = (
22331 
  )
22332 
 
22333 
  def read(self, iprot):
22334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22336 
      return
22337 
    iprot.readStructBegin()
22338 
    while True:
22339 
      (fname, ftype, fid) = iprot.readFieldBegin()
22340 
      if ftype == TType.STOP:
22341 
        break
22342 
      else:
22343 
        iprot.skip(ftype)
22344 
      iprot.readFieldEnd()
22345 
    iprot.readStructEnd()
22346 
 
22347 
  def write(self, oprot):
22348 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22349 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22350 
      return
22351 
    oprot.writeStructBegin('getAllSnapdealItems_args')
22352 
    oprot.writeFieldStop()
22353 
    oprot.writeStructEnd()
22354 
 
22355 
  def validate(self):
22356 
    return
22357 
 
22358 
 
22359 
  def __repr__(self):
22360 
    L = ['%s=%r' % (key, value)
22361 
      for key, value in self.__dict__.iteritems()]
22362 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22363 
 
22364 
  def __eq__(self, other):
22365 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22366 
 
22367 
  def __ne__(self, other):
22368 
    return not (self == other)
22369 
 
22370 
class getAllSnapdealItems_result:
22371 
  """
22372 
  Attributes:
22373 
   - success
22374 
  """
22375 
 
22376 
  thrift_spec = (
22377 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItem, SnapdealItem.thrift_spec)), None, ), # 0
22378 
  )
22379 
 
22380 
  def __init__(self, success=None,):
22381 
    self.success = success
22382 
 
22383 
  def read(self, iprot):
22384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22386 
      return
22387 
    iprot.readStructBegin()
22388 
    while True:
22389 
      (fname, ftype, fid) = iprot.readFieldBegin()
22390 
      if ftype == TType.STOP:
22391 
        break
22392 
      if fid == 0:
22393 
        if ftype == TType.LIST:
22394 
          self.success = []
9155 kshitij.so 22395 
          (_etype523, _size520) = iprot.readListBegin()
22396 
          for _i524 in xrange(_size520):
22397 
            _elem525 = SnapdealItem()
22398 
            _elem525.read(iprot)
22399 
            self.success.append(_elem525)
8739 vikram.rag 22400 
          iprot.readListEnd()
22401 
        else:
22402 
          iprot.skip(ftype)
22403 
      else:
22404 
        iprot.skip(ftype)
22405 
      iprot.readFieldEnd()
22406 
    iprot.readStructEnd()
22407 
 
22408 
  def write(self, oprot):
22409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22411 
      return
22412 
    oprot.writeStructBegin('getAllSnapdealItems_result')
22413 
    if self.success is not None:
22414 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22415 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22416 
      for iter526 in self.success:
22417 
        iter526.write(oprot)
8739 vikram.rag 22418 
      oprot.writeListEnd()
22419 
      oprot.writeFieldEnd()
22420 
    oprot.writeFieldStop()
22421 
    oprot.writeStructEnd()
22422 
 
22423 
  def validate(self):
22424 
    return
22425 
 
22426 
 
22427 
  def __repr__(self):
22428 
    L = ['%s=%r' % (key, value)
22429 
      for key, value in self.__dict__.iteritems()]
22430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22431 
 
22432 
  def __eq__(self, other):
22433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22434 
 
22435 
  def __ne__(self, other):
22436 
    return not (self == other)