Subversion Repositories SmartDukaan

Rev

Rev 9155 | Rev 9253 | 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 
 
8619 kshitij.so 893 
  def updateAsin(self, item):
894 
    """
895 
    Parameters:
896 
     - item
897 
    """
898 
    pass
8616 vikram.rag 899 
 
8739 vikram.rag 900 
  def addOrUpdateSnapdealItem(self, snapdealitem):
901 
    """
902 
    Parameters:
903 
     - snapdealitem
904 
    """
905 
    pass
8619 kshitij.so 906 
 
8739 vikram.rag 907 
  def getSnapdealItem(self, item_id):
908 
    """
909 
    Parameters:
910 
     - item_id
911 
    """
912 
    pass
913 
 
9242 kshitij.so 914 
  def getSnapdealItemDetails(self, item_id):
915 
    """
916 
    Parameters:
917 
     - item_id
918 
    """
919 
    pass
920 
 
8739 vikram.rag 921 
  def getAllSnapdealItems(self, ):
922 
    pass
923 
 
9242 kshitij.so 924 
  def getSnapdealItems(self, offset, limit):
925 
    """
926 
    Parameters:
927 
     - offset
928 
     - limit
929 
    """
930 
    pass
8739 vikram.rag 931 
 
9242 kshitij.so 932 
  def searchSnapdealItems(self, searchTerm, offset, limit):
933 
    """
934 
    Parameters:
935 
     - searchTerm
936 
     - offset
937 
     - limit
938 
    """
939 
    pass
940 
 
941 
  def getCountForSnapdealItems(self, ):
942 
    pass
943 
 
944 
  def getSnapdealSearchResultCount(self, searchTerm):
945 
    """
946 
    Parameters:
947 
     - searchTerm
948 
    """
949 
    pass
950 
 
951 
 
5944 mandeep.dh 952 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
953 
  def __init__(self, iprot, oprot=None):
954 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
955 
 
956 
  def addItem(self, item):
957 
    """
958 
    Availability and inventory attributes
959 
 
960 
    Parameters:
961 
     - item
962 
    """
963 
    self.send_addItem(item)
964 
    return self.recv_addItem()
965 
 
966 
  def send_addItem(self, item):
967 
    self._oprot.writeMessageBegin('addItem', TMessageType.CALL, self._seqid)
968 
    args = addItem_args()
969 
    args.item = item
970 
    args.write(self._oprot)
971 
    self._oprot.writeMessageEnd()
972 
    self._oprot.trans.flush()
973 
 
974 
  def recv_addItem(self, ):
975 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
976 
    if mtype == TMessageType.EXCEPTION:
977 
      x = TApplicationException()
978 
      x.read(self._iprot)
979 
      self._iprot.readMessageEnd()
980 
      raise x
981 
    result = addItem_result()
982 
    result.read(self._iprot)
983 
    self._iprot.readMessageEnd()
984 
    if result.success is not None:
985 
      return result.success
986 
    if result.cex is not None:
987 
      raise result.cex
988 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItem failed: unknown result");
989 
 
990 
  def updateItem(self, item):
991 
    """
992 
    Parameters:
993 
     - item
994 
    """
995 
    self.send_updateItem(item)
996 
    return self.recv_updateItem()
997 
 
998 
  def send_updateItem(self, item):
999 
    self._oprot.writeMessageBegin('updateItem', TMessageType.CALL, self._seqid)
1000 
    args = updateItem_args()
1001 
    args.item = item
1002 
    args.write(self._oprot)
1003 
    self._oprot.writeMessageEnd()
1004 
    self._oprot.trans.flush()
1005 
 
1006 
  def recv_updateItem(self, ):
1007 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1008 
    if mtype == TMessageType.EXCEPTION:
1009 
      x = TApplicationException()
1010 
      x.read(self._iprot)
1011 
      self._iprot.readMessageEnd()
1012 
      raise x
1013 
    result = updateItem_result()
1014 
    result.read(self._iprot)
1015 
    self._iprot.readMessageEnd()
1016 
    if result.success is not None:
1017 
      return result.success
1018 
    if result.cex is not None:
1019 
      raise result.cex
1020 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItem failed: unknown result");
1021 
 
1022 
  def isActive(self, itemId):
1023 
    """
1024 
    Checks if the item given to the corresponding itemId is active. If it's active,
1025 
    whether it's risky and if it's risky, its inventory position.
1026 
 
1027 
    Parameters:
1028 
     - itemId
1029 
    """
1030 
    self.send_isActive(itemId)
1031 
    return self.recv_isActive()
1032 
 
1033 
  def send_isActive(self, itemId):
1034 
    self._oprot.writeMessageBegin('isActive', TMessageType.CALL, self._seqid)
1035 
    args = isActive_args()
1036 
    args.itemId = itemId
1037 
    args.write(self._oprot)
1038 
    self._oprot.writeMessageEnd()
1039 
    self._oprot.trans.flush()
1040 
 
1041 
  def recv_isActive(self, ):
1042 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1043 
    if mtype == TMessageType.EXCEPTION:
1044 
      x = TApplicationException()
1045 
      x.read(self._iprot)
1046 
      self._iprot.readMessageEnd()
1047 
      raise x
1048 
    result = isActive_result()
1049 
    result.read(self._iprot)
1050 
    self._iprot.readMessageEnd()
1051 
    if result.success is not None:
1052 
      return result.success
1053 
    if result.isex is not None:
1054 
      raise result.isex
1055 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isActive failed: unknown result");
1056 
 
7438 amit.gupta 1057 
  def getItemsStatus(self, itemIds):
1058 
    """
1059 
    Parameters:
1060 
     - itemIds
1061 
    """
1062 
    self.send_getItemsStatus(itemIds)
1063 
    return self.recv_getItemsStatus()
1064 
 
1065 
  def send_getItemsStatus(self, itemIds):
1066 
    self._oprot.writeMessageBegin('getItemsStatus', TMessageType.CALL, self._seqid)
1067 
    args = getItemsStatus_args()
1068 
    args.itemIds = itemIds
1069 
    args.write(self._oprot)
1070 
    self._oprot.writeMessageEnd()
1071 
    self._oprot.trans.flush()
1072 
 
1073 
  def recv_getItemsStatus(self, ):
1074 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1075 
    if mtype == TMessageType.EXCEPTION:
1076 
      x = TApplicationException()
1077 
      x.read(self._iprot)
1078 
      self._iprot.readMessageEnd()
1079 
      raise x
1080 
    result = getItemsStatus_result()
1081 
    result.read(self._iprot)
1082 
    self._iprot.readMessageEnd()
1083 
    if result.success is not None:
1084 
      return result.success
1085 
    if result.isex is not None:
1086 
      raise result.isex
1087 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsStatus failed: unknown result");
1088 
 
5944 mandeep.dh 1089 
  def getItemStatusDescription(self, itemId):
1090 
    """
1091 
    Parameters:
1092 
     - itemId
1093 
    """
1094 
    self.send_getItemStatusDescription(itemId)
1095 
    return self.recv_getItemStatusDescription()
1096 
 
1097 
  def send_getItemStatusDescription(self, itemId):
1098 
    self._oprot.writeMessageBegin('getItemStatusDescription', TMessageType.CALL, self._seqid)
1099 
    args = getItemStatusDescription_args()
1100 
    args.itemId = itemId
1101 
    args.write(self._oprot)
1102 
    self._oprot.writeMessageEnd()
1103 
    self._oprot.trans.flush()
1104 
 
1105 
  def recv_getItemStatusDescription(self, ):
1106 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1107 
    if mtype == TMessageType.EXCEPTION:
1108 
      x = TApplicationException()
1109 
      x.read(self._iprot)
1110 
      self._iprot.readMessageEnd()
1111 
      raise x
1112 
    result = getItemStatusDescription_result()
1113 
    result.read(self._iprot)
1114 
    self._iprot.readMessageEnd()
1115 
    if result.success is not None:
1116 
      return result.success
1117 
    if result.isex is not None:
1118 
      raise result.isex
1119 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStatusDescription failed: unknown result");
1120 
 
1121 
  def startItemOn(self, item_id, timestamp):
1122 
    """
1123 
    Parameters:
1124 
     - item_id
1125 
     - timestamp
1126 
    """
1127 
    self.send_startItemOn(item_id, timestamp)
1128 
    self.recv_startItemOn()
1129 
 
1130 
  def send_startItemOn(self, item_id, timestamp):
1131 
    self._oprot.writeMessageBegin('startItemOn', TMessageType.CALL, self._seqid)
1132 
    args = startItemOn_args()
1133 
    args.item_id = item_id
1134 
    args.timestamp = timestamp
1135 
    args.write(self._oprot)
1136 
    self._oprot.writeMessageEnd()
1137 
    self._oprot.trans.flush()
1138 
 
1139 
  def recv_startItemOn(self, ):
1140 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1141 
    if mtype == TMessageType.EXCEPTION:
1142 
      x = TApplicationException()
1143 
      x.read(self._iprot)
1144 
      self._iprot.readMessageEnd()
1145 
      raise x
1146 
    result = startItemOn_result()
1147 
    result.read(self._iprot)
1148 
    self._iprot.readMessageEnd()
1149 
    if result.cex is not None:
1150 
      raise result.cex
1151 
    return
1152 
 
1153 
  def retireItemOn(self, item_id, timestamp):
1154 
    """
1155 
    Parameters:
1156 
     - item_id
1157 
     - timestamp
1158 
    """
1159 
    self.send_retireItemOn(item_id, timestamp)
1160 
    self.recv_retireItemOn()
1161 
 
1162 
  def send_retireItemOn(self, item_id, timestamp):
1163 
    self._oprot.writeMessageBegin('retireItemOn', TMessageType.CALL, self._seqid)
1164 
    args = retireItemOn_args()
1165 
    args.item_id = item_id
1166 
    args.timestamp = timestamp
1167 
    args.write(self._oprot)
1168 
    self._oprot.writeMessageEnd()
1169 
    self._oprot.trans.flush()
1170 
 
1171 
  def recv_retireItemOn(self, ):
1172 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1173 
    if mtype == TMessageType.EXCEPTION:
1174 
      x = TApplicationException()
1175 
      x.read(self._iprot)
1176 
      self._iprot.readMessageEnd()
1177 
      raise x
1178 
    result = retireItemOn_result()
1179 
    result.read(self._iprot)
1180 
    self._iprot.readMessageEnd()
1181 
    if result.cex is not None:
1182 
      raise result.cex
1183 
    return
1184 
 
1185 
  def changeItemStatus(self, item_id, timestamp, newstatus):
1186 
    """
1187 
    Parameters:
1188 
     - item_id
1189 
     - timestamp
1190 
     - newstatus
1191 
    """
1192 
    self.send_changeItemStatus(item_id, timestamp, newstatus)
1193 
    self.recv_changeItemStatus()
1194 
 
1195 
  def send_changeItemStatus(self, item_id, timestamp, newstatus):
1196 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
1197 
    args = changeItemStatus_args()
1198 
    args.item_id = item_id
1199 
    args.timestamp = timestamp
1200 
    args.newstatus = newstatus
1201 
    args.write(self._oprot)
1202 
    self._oprot.writeMessageEnd()
1203 
    self._oprot.trans.flush()
1204 
 
1205 
  def recv_changeItemStatus(self, ):
1206 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1207 
    if mtype == TMessageType.EXCEPTION:
1208 
      x = TApplicationException()
1209 
      x.read(self._iprot)
1210 
      self._iprot.readMessageEnd()
1211 
      raise x
1212 
    result = changeItemStatus_result()
1213 
    result.read(self._iprot)
1214 
    self._iprot.readMessageEnd()
1215 
    if result.cex is not None:
1216 
      raise result.cex
1217 
    return
1218 
 
1219 
  def getItem(self, item_id):
1220 
    """
1221 
    Parameters:
1222 
     - item_id
1223 
    """
1224 
    self.send_getItem(item_id)
1225 
    return self.recv_getItem()
1226 
 
1227 
  def send_getItem(self, item_id):
1228 
    self._oprot.writeMessageBegin('getItem', TMessageType.CALL, self._seqid)
1229 
    args = getItem_args()
1230 
    args.item_id = item_id
1231 
    args.write(self._oprot)
1232 
    self._oprot.writeMessageEnd()
1233 
    self._oprot.trans.flush()
1234 
 
1235 
  def recv_getItem(self, ):
1236 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1237 
    if mtype == TMessageType.EXCEPTION:
1238 
      x = TApplicationException()
1239 
      x.read(self._iprot)
1240 
      self._iprot.readMessageEnd()
1241 
      raise x
1242 
    result = getItem_result()
1243 
    result.read(self._iprot)
1244 
    self._iprot.readMessageEnd()
1245 
    if result.success is not None:
1246 
      return result.success
1247 
    if result.cex is not None:
1248 
      raise result.cex
1249 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItem failed: unknown result");
1250 
 
1251 
  def getItemsByCatalogId(self, catalog_item_id):
1252 
    """
1253 
    Parameters:
1254 
     - catalog_item_id
1255 
    """
1256 
    self.send_getItemsByCatalogId(catalog_item_id)
1257 
    return self.recv_getItemsByCatalogId()
1258 
 
1259 
  def send_getItemsByCatalogId(self, catalog_item_id):
1260 
    self._oprot.writeMessageBegin('getItemsByCatalogId', TMessageType.CALL, self._seqid)
1261 
    args = getItemsByCatalogId_args()
1262 
    args.catalog_item_id = catalog_item_id
1263 
    args.write(self._oprot)
1264 
    self._oprot.writeMessageEnd()
1265 
    self._oprot.trans.flush()
1266 
 
1267 
  def recv_getItemsByCatalogId(self, ):
1268 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1269 
    if mtype == TMessageType.EXCEPTION:
1270 
      x = TApplicationException()
1271 
      x.read(self._iprot)
1272 
      self._iprot.readMessageEnd()
1273 
      raise x
1274 
    result = getItemsByCatalogId_result()
1275 
    result.read(self._iprot)
1276 
    self._iprot.readMessageEnd()
1277 
    if result.success is not None:
1278 
      return result.success
1279 
    if result.cex is not None:
1280 
      raise result.cex
1281 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByCatalogId failed: unknown result");
1282 
 
1283 
  def getValidItemsByCatalogId(self, catalog_item_id):
1284 
    """
1285 
    Parameters:
1286 
     - catalog_item_id
1287 
    """
1288 
    self.send_getValidItemsByCatalogId(catalog_item_id)
1289 
    return self.recv_getValidItemsByCatalogId()
1290 
 
1291 
  def send_getValidItemsByCatalogId(self, catalog_item_id):
1292 
    self._oprot.writeMessageBegin('getValidItemsByCatalogId', TMessageType.CALL, self._seqid)
1293 
    args = getValidItemsByCatalogId_args()
1294 
    args.catalog_item_id = catalog_item_id
1295 
    args.write(self._oprot)
1296 
    self._oprot.writeMessageEnd()
1297 
    self._oprot.trans.flush()
1298 
 
1299 
  def recv_getValidItemsByCatalogId(self, ):
1300 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1301 
    if mtype == TMessageType.EXCEPTION:
1302 
      x = TApplicationException()
1303 
      x.read(self._iprot)
1304 
      self._iprot.readMessageEnd()
1305 
      raise x
1306 
    result = getValidItemsByCatalogId_result()
1307 
    result.read(self._iprot)
1308 
    self._iprot.readMessageEnd()
1309 
    if result.success is not None:
1310 
      return result.success
1311 
    if result.cex is not None:
1312 
      raise result.cex
1313 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidItemsByCatalogId failed: unknown result");
1314 
 
1315 
  def getAllItems(self, isActive):
1316 
    """
1317 
    Parameters:
1318 
     - isActive
1319 
    """
1320 
    self.send_getAllItems(isActive)
1321 
    return self.recv_getAllItems()
1322 
 
1323 
  def send_getAllItems(self, isActive):
1324 
    self._oprot.writeMessageBegin('getAllItems', TMessageType.CALL, self._seqid)
1325 
    args = getAllItems_args()
1326 
    args.isActive = isActive
1327 
    args.write(self._oprot)
1328 
    self._oprot.writeMessageEnd()
1329 
    self._oprot.trans.flush()
1330 
 
1331 
  def recv_getAllItems(self, ):
1332 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1333 
    if mtype == TMessageType.EXCEPTION:
1334 
      x = TApplicationException()
1335 
      x.read(self._iprot)
1336 
      self._iprot.readMessageEnd()
1337 
      raise x
1338 
    result = getAllItems_result()
1339 
    result.read(self._iprot)
1340 
    self._iprot.readMessageEnd()
1341 
    if result.success is not None:
1342 
      return result.success
1343 
    if result.cex is not None:
1344 
      raise result.cex
1345 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItems failed: unknown result");
1346 
 
1347 
  def getAllItemsByStatus(self, itemStatus):
1348 
    """
1349 
    Parameters:
1350 
     - itemStatus
1351 
    """
1352 
    self.send_getAllItemsByStatus(itemStatus)
1353 
    return self.recv_getAllItemsByStatus()
1354 
 
1355 
  def send_getAllItemsByStatus(self, itemStatus):
1356 
    self._oprot.writeMessageBegin('getAllItemsByStatus', TMessageType.CALL, self._seqid)
1357 
    args = getAllItemsByStatus_args()
1358 
    args.itemStatus = itemStatus
1359 
    args.write(self._oprot)
1360 
    self._oprot.writeMessageEnd()
1361 
    self._oprot.trans.flush()
1362 
 
1363 
  def recv_getAllItemsByStatus(self, ):
1364 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1365 
    if mtype == TMessageType.EXCEPTION:
1366 
      x = TApplicationException()
1367 
      x.read(self._iprot)
1368 
      self._iprot.readMessageEnd()
1369 
      raise x
1370 
    result = getAllItemsByStatus_result()
1371 
    result.read(self._iprot)
1372 
    self._iprot.readMessageEnd()
1373 
    if result.success is not None:
1374 
      return result.success
1375 
    if result.cex is not None:
1376 
      raise result.cex
1377 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatus failed: unknown result");
1378 
 
1379 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1380 
    """
1381 
    Parameters:
1382 
     - entityId
1383 
     - category
1384 
     - brand
1385 
     - modelName
1386 
     - modelNumber
1387 
    """
1388 
    self.send_markItemAsContentComplete(entityId, category, brand, modelName, modelNumber)
1389 
    return self.recv_markItemAsContentComplete()
1390 
 
1391 
  def send_markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1392 
    self._oprot.writeMessageBegin('markItemAsContentComplete', TMessageType.CALL, self._seqid)
1393 
    args = markItemAsContentComplete_args()
1394 
    args.entityId = entityId
1395 
    args.category = category
1396 
    args.brand = brand
1397 
    args.modelName = modelName
1398 
    args.modelNumber = modelNumber
1399 
    args.write(self._oprot)
1400 
    self._oprot.writeMessageEnd()
1401 
    self._oprot.trans.flush()
1402 
 
1403 
  def recv_markItemAsContentComplete(self, ):
1404 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1405 
    if mtype == TMessageType.EXCEPTION:
1406 
      x = TApplicationException()
1407 
      x.read(self._iprot)
1408 
      self._iprot.readMessageEnd()
1409 
      raise x
1410 
    result = markItemAsContentComplete_result()
1411 
    result.read(self._iprot)
1412 
    self._iprot.readMessageEnd()
1413 
    if result.success is not None:
1414 
      return result.success
1415 
    if result.cex is not None:
1416 
      raise result.cex
1417 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markItemAsContentComplete failed: unknown result");
1418 
 
1419 
  def getAllItemsInRange(self, offset, limit):
1420 
    """
1421 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
1422 
 
1423 
    Parameters:
1424 
     - offset
1425 
     - limit
1426 
    """
1427 
    self.send_getAllItemsInRange(offset, limit)
1428 
    return self.recv_getAllItemsInRange()
1429 
 
1430 
  def send_getAllItemsInRange(self, offset, limit):
1431 
    self._oprot.writeMessageBegin('getAllItemsInRange', TMessageType.CALL, self._seqid)
1432 
    args = getAllItemsInRange_args()
1433 
    args.offset = offset
1434 
    args.limit = limit
1435 
    args.write(self._oprot)
1436 
    self._oprot.writeMessageEnd()
1437 
    self._oprot.trans.flush()
1438 
 
1439 
  def recv_getAllItemsInRange(self, ):
1440 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1441 
    if mtype == TMessageType.EXCEPTION:
1442 
      x = TApplicationException()
1443 
      x.read(self._iprot)
1444 
      self._iprot.readMessageEnd()
1445 
      raise x
1446 
    result = getAllItemsInRange_result()
1447 
    result.read(self._iprot)
1448 
    self._iprot.readMessageEnd()
1449 
    if result.success is not None:
1450 
      return result.success
1451 
    if result.cex is not None:
1452 
      raise result.cex
1453 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsInRange failed: unknown result");
1454 
 
1455 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1456 
    """
1457 
    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.
1458 
 
1459 
    Parameters:
1460 
     - itemStatus
1461 
     - offset
1462 
     - limit
1463 
    """
1464 
    self.send_getAllItemsByStatusInRange(itemStatus, offset, limit)
1465 
    return self.recv_getAllItemsByStatusInRange()
1466 
 
1467 
  def send_getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1468 
    self._oprot.writeMessageBegin('getAllItemsByStatusInRange', TMessageType.CALL, self._seqid)
1469 
    args = getAllItemsByStatusInRange_args()
1470 
    args.itemStatus = itemStatus
1471 
    args.offset = offset
1472 
    args.limit = limit
1473 
    args.write(self._oprot)
1474 
    self._oprot.writeMessageEnd()
1475 
    self._oprot.trans.flush()
1476 
 
1477 
  def recv_getAllItemsByStatusInRange(self, ):
1478 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1479 
    if mtype == TMessageType.EXCEPTION:
1480 
      x = TApplicationException()
1481 
      x.read(self._iprot)
1482 
      self._iprot.readMessageEnd()
1483 
      raise x
1484 
    result = getAllItemsByStatusInRange_result()
1485 
    result.read(self._iprot)
1486 
    self._iprot.readMessageEnd()
1487 
    if result.success is not None:
1488 
      return result.success
1489 
    if result.cex is not None:
1490 
      raise result.cex
1491 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatusInRange failed: unknown result");
1492 
 
1493 
  def getItemCountByStatus(self, useStatus, itemStatus):
1494 
    """
1495 
    Gets a count of all items by status
1496 
 
1497 
    Parameters:
1498 
     - useStatus
1499 
     - itemStatus
1500 
    """
1501 
    self.send_getItemCountByStatus(useStatus, itemStatus)
1502 
    return self.recv_getItemCountByStatus()
1503 
 
1504 
  def send_getItemCountByStatus(self, useStatus, itemStatus):
1505 
    self._oprot.writeMessageBegin('getItemCountByStatus', TMessageType.CALL, self._seqid)
1506 
    args = getItemCountByStatus_args()
1507 
    args.useStatus = useStatus
1508 
    args.itemStatus = itemStatus
1509 
    args.write(self._oprot)
1510 
    self._oprot.writeMessageEnd()
1511 
    self._oprot.trans.flush()
1512 
 
1513 
  def recv_getItemCountByStatus(self, ):
1514 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1515 
    if mtype == TMessageType.EXCEPTION:
1516 
      x = TApplicationException()
1517 
      x.read(self._iprot)
1518 
      self._iprot.readMessageEnd()
1519 
      raise x
1520 
    result = getItemCountByStatus_result()
1521 
    result.read(self._iprot)
1522 
    self._iprot.readMessageEnd()
1523 
    if result.success is not None:
1524 
      return result.success
1525 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemCountByStatus failed: unknown result");
1526 
 
1527 
  def getBestSellers(self, ):
1528 
    self.send_getBestSellers()
1529 
    return self.recv_getBestSellers()
1530 
 
1531 
  def send_getBestSellers(self, ):
1532 
    self._oprot.writeMessageBegin('getBestSellers', TMessageType.CALL, self._seqid)
1533 
    args = getBestSellers_args()
1534 
    args.write(self._oprot)
1535 
    self._oprot.writeMessageEnd()
1536 
    self._oprot.trans.flush()
1537 
 
1538 
  def recv_getBestSellers(self, ):
1539 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1540 
    if mtype == TMessageType.EXCEPTION:
1541 
      x = TApplicationException()
1542 
      x.read(self._iprot)
1543 
      self._iprot.readMessageEnd()
1544 
      raise x
1545 
    result = getBestSellers_result()
1546 
    result.read(self._iprot)
1547 
    self._iprot.readMessageEnd()
1548 
    if result.success is not None:
1549 
      return result.success
1550 
    if result.isex is not None:
1551 
      raise result.isex
1552 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellers failed: unknown result");
1553 
 
1554 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1555 
    """
1556 
    Parameters:
1557 
     - beginIndex
1558 
     - totalItems
1559 
     - brand
1560 
     - category
1561 
    """
1562 
    self.send_getBestSellersCatalogIds(beginIndex, totalItems, brand, category)
1563 
    return self.recv_getBestSellersCatalogIds()
1564 
 
1565 
  def send_getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1566 
    self._oprot.writeMessageBegin('getBestSellersCatalogIds', TMessageType.CALL, self._seqid)
1567 
    args = getBestSellersCatalogIds_args()
1568 
    args.beginIndex = beginIndex
1569 
    args.totalItems = totalItems
1570 
    args.brand = brand
1571 
    args.category = category
1572 
    args.write(self._oprot)
1573 
    self._oprot.writeMessageEnd()
1574 
    self._oprot.trans.flush()
1575 
 
1576 
  def recv_getBestSellersCatalogIds(self, ):
1577 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1578 
    if mtype == TMessageType.EXCEPTION:
1579 
      x = TApplicationException()
1580 
      x.read(self._iprot)
1581 
      self._iprot.readMessageEnd()
1582 
      raise x
1583 
    result = getBestSellersCatalogIds_result()
1584 
    result.read(self._iprot)
1585 
    self._iprot.readMessageEnd()
1586 
    if result.success is not None:
1587 
      return result.success
1588 
    if result.cex is not None:
1589 
      raise result.cex
1590 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCatalogIds failed: unknown result");
1591 
 
1592 
  def getBestSellersCount(self, ):
1593 
    self.send_getBestSellersCount()
1594 
    return self.recv_getBestSellersCount()
1595 
 
1596 
  def send_getBestSellersCount(self, ):
1597 
    self._oprot.writeMessageBegin('getBestSellersCount', TMessageType.CALL, self._seqid)
1598 
    args = getBestSellersCount_args()
1599 
    args.write(self._oprot)
1600 
    self._oprot.writeMessageEnd()
1601 
    self._oprot.trans.flush()
1602 
 
1603 
  def recv_getBestSellersCount(self, ):
1604 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1605 
    if mtype == TMessageType.EXCEPTION:
1606 
      x = TApplicationException()
1607 
      x.read(self._iprot)
1608 
      self._iprot.readMessageEnd()
1609 
      raise x
1610 
    result = getBestSellersCount_result()
1611 
    result.read(self._iprot)
1612 
    self._iprot.readMessageEnd()
1613 
    if result.success is not None:
1614 
      return result.success
1615 
    if result.cex is not None:
1616 
      raise result.cex
1617 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCount failed: unknown result");
1618 
 
1619 
  def getBestDeals(self, ):
1620 
    self.send_getBestDeals()
1621 
    return self.recv_getBestDeals()
1622 
 
1623 
  def send_getBestDeals(self, ):
1624 
    self._oprot.writeMessageBegin('getBestDeals', TMessageType.CALL, self._seqid)
1625 
    args = getBestDeals_args()
1626 
    args.write(self._oprot)
1627 
    self._oprot.writeMessageEnd()
1628 
    self._oprot.trans.flush()
1629 
 
1630 
  def recv_getBestDeals(self, ):
1631 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1632 
    if mtype == TMessageType.EXCEPTION:
1633 
      x = TApplicationException()
1634 
      x.read(self._iprot)
1635 
      self._iprot.readMessageEnd()
1636 
      raise x
1637 
    result = getBestDeals_result()
1638 
    result.read(self._iprot)
1639 
    self._iprot.readMessageEnd()
1640 
    if result.success is not None:
1641 
      return result.success
1642 
    if result.isex is not None:
1643 
      raise result.isex
1644 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDeals failed: unknown result");
1645 
 
1646 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1647 
    """
1648 
    Parameters:
1649 
     - beginIndex
1650 
     - totalItems
1651 
     - brand
1652 
     - category
1653 
    """
1654 
    self.send_getBestDealsCatalogIds(beginIndex, totalItems, brand, category)
1655 
    return self.recv_getBestDealsCatalogIds()
1656 
 
1657 
  def send_getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1658 
    self._oprot.writeMessageBegin('getBestDealsCatalogIds', TMessageType.CALL, self._seqid)
1659 
    args = getBestDealsCatalogIds_args()
1660 
    args.beginIndex = beginIndex
1661 
    args.totalItems = totalItems
1662 
    args.brand = brand
1663 
    args.category = category
1664 
    args.write(self._oprot)
1665 
    self._oprot.writeMessageEnd()
1666 
    self._oprot.trans.flush()
1667 
 
1668 
  def recv_getBestDealsCatalogIds(self, ):
1669 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1670 
    if mtype == TMessageType.EXCEPTION:
1671 
      x = TApplicationException()
1672 
      x.read(self._iprot)
1673 
      self._iprot.readMessageEnd()
1674 
      raise x
1675 
    result = getBestDealsCatalogIds_result()
1676 
    result.read(self._iprot)
1677 
    self._iprot.readMessageEnd()
1678 
    if result.success is not None:
1679 
      return result.success
1680 
    if result.cex is not None:
1681 
      raise result.cex
1682 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCatalogIds failed: unknown result");
1683 
 
1684 
  def getBestDealsCount(self, ):
1685 
    self.send_getBestDealsCount()
1686 
    return self.recv_getBestDealsCount()
1687 
 
1688 
  def send_getBestDealsCount(self, ):
1689 
    self._oprot.writeMessageBegin('getBestDealsCount', TMessageType.CALL, self._seqid)
1690 
    args = getBestDealsCount_args()
1691 
    args.write(self._oprot)
1692 
    self._oprot.writeMessageEnd()
1693 
    self._oprot.trans.flush()
1694 
 
1695 
  def recv_getBestDealsCount(self, ):
1696 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1697 
    if mtype == TMessageType.EXCEPTION:
1698 
      x = TApplicationException()
1699 
      x.read(self._iprot)
1700 
      self._iprot.readMessageEnd()
1701 
      raise x
1702 
    result = getBestDealsCount_result()
1703 
    result.read(self._iprot)
1704 
    self._iprot.readMessageEnd()
1705 
    if result.success is not None:
1706 
      return result.success
1707 
    if result.cex is not None:
1708 
      raise result.cex
1709 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCount failed: unknown result");
1710 
 
1711 
  def getComingSoon(self, ):
1712 
    self.send_getComingSoon()
1713 
    return self.recv_getComingSoon()
1714 
 
1715 
  def send_getComingSoon(self, ):
1716 
    self._oprot.writeMessageBegin('getComingSoon', TMessageType.CALL, self._seqid)
1717 
    args = getComingSoon_args()
1718 
    args.write(self._oprot)
1719 
    self._oprot.writeMessageEnd()
1720 
    self._oprot.trans.flush()
1721 
 
1722 
  def recv_getComingSoon(self, ):
1723 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1724 
    if mtype == TMessageType.EXCEPTION:
1725 
      x = TApplicationException()
1726 
      x.read(self._iprot)
1727 
      self._iprot.readMessageEnd()
1728 
      raise x
1729 
    result = getComingSoon_result()
1730 
    result.read(self._iprot)
1731 
    self._iprot.readMessageEnd()
1732 
    if result.success is not None:
1733 
      return result.success
1734 
    if result.isex is not None:
1735 
      raise result.isex
1736 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoon failed: unknown result");
1737 
 
1738 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1739 
    """
1740 
    Parameters:
1741 
     - beginIndex
1742 
     - totalItems
1743 
     - brand
1744 
     - category
1745 
    """
1746 
    self.send_getComingSoonCatalogIds(beginIndex, totalItems, brand, category)
1747 
    return self.recv_getComingSoonCatalogIds()
1748 
 
1749 
  def send_getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1750 
    self._oprot.writeMessageBegin('getComingSoonCatalogIds', TMessageType.CALL, self._seqid)
1751 
    args = getComingSoonCatalogIds_args()
1752 
    args.beginIndex = beginIndex
1753 
    args.totalItems = totalItems
1754 
    args.brand = brand
1755 
    args.category = category
1756 
    args.write(self._oprot)
1757 
    self._oprot.writeMessageEnd()
1758 
    self._oprot.trans.flush()
1759 
 
1760 
  def recv_getComingSoonCatalogIds(self, ):
1761 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1762 
    if mtype == TMessageType.EXCEPTION:
1763 
      x = TApplicationException()
1764 
      x.read(self._iprot)
1765 
      self._iprot.readMessageEnd()
1766 
      raise x
1767 
    result = getComingSoonCatalogIds_result()
1768 
    result.read(self._iprot)
1769 
    self._iprot.readMessageEnd()
1770 
    if result.success is not None:
1771 
      return result.success
1772 
    if result.cex is not None:
1773 
      raise result.cex
1774 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCatalogIds failed: unknown result");
1775 
 
1776 
  def getComingSoonCount(self, ):
1777 
    self.send_getComingSoonCount()
1778 
    return self.recv_getComingSoonCount()
1779 
 
1780 
  def send_getComingSoonCount(self, ):
1781 
    self._oprot.writeMessageBegin('getComingSoonCount', TMessageType.CALL, self._seqid)
1782 
    args = getComingSoonCount_args()
1783 
    args.write(self._oprot)
1784 
    self._oprot.writeMessageEnd()
1785 
    self._oprot.trans.flush()
1786 
 
1787 
  def recv_getComingSoonCount(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 = getComingSoonCount_result()
1795 
    result.read(self._iprot)
1796 
    self._iprot.readMessageEnd()
1797 
    if result.success is not None:
1798 
      return result.success
1799 
    if result.cex is not None:
1800 
      raise result.cex
1801 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCount failed: unknown result");
1802 
 
1803 
  def getLatestArrivals(self, ):
1804 
    """
1805 
    Returns a list of items sorted in the descending order by start date.
1806 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
1807 
    """
1808 
    self.send_getLatestArrivals()
1809 
    return self.recv_getLatestArrivals()
1810 
 
1811 
  def send_getLatestArrivals(self, ):
1812 
    self._oprot.writeMessageBegin('getLatestArrivals', TMessageType.CALL, self._seqid)
1813 
    args = getLatestArrivals_args()
1814 
    args.write(self._oprot)
1815 
    self._oprot.writeMessageEnd()
1816 
    self._oprot.trans.flush()
1817 
 
1818 
  def recv_getLatestArrivals(self, ):
1819 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1820 
    if mtype == TMessageType.EXCEPTION:
1821 
      x = TApplicationException()
1822 
      x.read(self._iprot)
1823 
      self._iprot.readMessageEnd()
1824 
      raise x
1825 
    result = getLatestArrivals_result()
1826 
    result.read(self._iprot)
1827 
    self._iprot.readMessageEnd()
1828 
    if result.success is not None:
1829 
      return result.success
1830 
    if result.isex is not None:
1831 
      raise result.isex
1832 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivals failed: unknown result");
1833 
 
1834 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1835 
    """
1836 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
1837 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
1838 
 
1839 
    Parameters:
1840 
     - beginIndex
1841 
     - totalItems
1842 
     - brand
1843 
     - categories
1844 
    """
1845 
    self.send_getLatestArrivalsCatalogIds(beginIndex, totalItems, brand, categories)
1846 
    return self.recv_getLatestArrivalsCatalogIds()
1847 
 
1848 
  def send_getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1849 
    self._oprot.writeMessageBegin('getLatestArrivalsCatalogIds', TMessageType.CALL, self._seqid)
1850 
    args = getLatestArrivalsCatalogIds_args()
1851 
    args.beginIndex = beginIndex
1852 
    args.totalItems = totalItems
1853 
    args.brand = brand
1854 
    args.categories = categories
1855 
    args.write(self._oprot)
1856 
    self._oprot.writeMessageEnd()
1857 
    self._oprot.trans.flush()
1858 
 
1859 
  def recv_getLatestArrivalsCatalogIds(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 = getLatestArrivalsCatalogIds_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, "getLatestArrivalsCatalogIds failed: unknown result");
1874 
 
1875 
  def getLatestArrivalsCount(self, ):
1876 
    """
1877 
    Get the total number of latest arrivals we are willing to show.
1878 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
1879 
    """
1880 
    self.send_getLatestArrivalsCount()
1881 
    return self.recv_getLatestArrivalsCount()
1882 
 
1883 
  def send_getLatestArrivalsCount(self, ):
1884 
    self._oprot.writeMessageBegin('getLatestArrivalsCount', TMessageType.CALL, self._seqid)
1885 
    args = getLatestArrivalsCount_args()
1886 
    args.write(self._oprot)
1887 
    self._oprot.writeMessageEnd()
1888 
    self._oprot.trans.flush()
1889 
 
1890 
  def recv_getLatestArrivalsCount(self, ):
1891 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1892 
    if mtype == TMessageType.EXCEPTION:
1893 
      x = TApplicationException()
1894 
      x.read(self._iprot)
1895 
      self._iprot.readMessageEnd()
1896 
      raise x
1897 
    result = getLatestArrivalsCount_result()
1898 
    result.read(self._iprot)
1899 
    self._iprot.readMessageEnd()
1900 
    if result.success is not None:
1901 
      return result.success
1902 
    if result.cex is not None:
1903 
      raise result.cex
1904 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCount failed: unknown result");
1905 
 
1906 
  def generateNewEntityID(self, ):
1907 
    self.send_generateNewEntityID()
1908 
    return self.recv_generateNewEntityID()
1909 
 
1910 
  def send_generateNewEntityID(self, ):
1911 
    self._oprot.writeMessageBegin('generateNewEntityID', TMessageType.CALL, self._seqid)
1912 
    args = generateNewEntityID_args()
1913 
    args.write(self._oprot)
1914 
    self._oprot.writeMessageEnd()
1915 
    self._oprot.trans.flush()
1916 
 
1917 
  def recv_generateNewEntityID(self, ):
1918 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1919 
    if mtype == TMessageType.EXCEPTION:
1920 
      x = TApplicationException()
1921 
      x.read(self._iprot)
1922 
      self._iprot.readMessageEnd()
1923 
      raise x
1924 
    result = generateNewEntityID_result()
1925 
    result.read(self._iprot)
1926 
    self._iprot.readMessageEnd()
1927 
    if result.success is not None:
1928 
      return result.success
1929 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateNewEntityID failed: unknown result");
1930 
 
1931 
  def addCategory(self, category):
1932 
    """
1933 
    All category related functions
1934 
 
1935 
    Parameters:
1936 
     - category
1937 
    """
1938 
    self.send_addCategory(category)
1939 
    return self.recv_addCategory()
1940 
 
1941 
  def send_addCategory(self, category):
1942 
    self._oprot.writeMessageBegin('addCategory', TMessageType.CALL, self._seqid)
1943 
    args = addCategory_args()
1944 
    args.category = category
1945 
    args.write(self._oprot)
1946 
    self._oprot.writeMessageEnd()
1947 
    self._oprot.trans.flush()
1948 
 
1949 
  def recv_addCategory(self, ):
1950 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1951 
    if mtype == TMessageType.EXCEPTION:
1952 
      x = TApplicationException()
1953 
      x.read(self._iprot)
1954 
      self._iprot.readMessageEnd()
1955 
      raise x
1956 
    result = addCategory_result()
1957 
    result.read(self._iprot)
1958 
    self._iprot.readMessageEnd()
1959 
    if result.success is not None:
1960 
      return result.success
1961 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addCategory failed: unknown result");
1962 
 
1963 
  def getCategory(self, id):
1964 
    """
1965 
    Parameters:
1966 
     - id
1967 
    """
1968 
    self.send_getCategory(id)
1969 
    return self.recv_getCategory()
1970 
 
1971 
  def send_getCategory(self, id):
1972 
    self._oprot.writeMessageBegin('getCategory', TMessageType.CALL, self._seqid)
1973 
    args = getCategory_args()
1974 
    args.id = id
1975 
    args.write(self._oprot)
1976 
    self._oprot.writeMessageEnd()
1977 
    self._oprot.trans.flush()
1978 
 
1979 
  def recv_getCategory(self, ):
1980 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1981 
    if mtype == TMessageType.EXCEPTION:
1982 
      x = TApplicationException()
1983 
      x.read(self._iprot)
1984 
      self._iprot.readMessageEnd()
1985 
      raise x
1986 
    result = getCategory_result()
1987 
    result.read(self._iprot)
1988 
    self._iprot.readMessageEnd()
1989 
    if result.success is not None:
1990 
      return result.success
1991 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCategory failed: unknown result");
1992 
 
1993 
  def getAllCategories(self, ):
1994 
    self.send_getAllCategories()
1995 
    return self.recv_getAllCategories()
1996 
 
1997 
  def send_getAllCategories(self, ):
1998 
    self._oprot.writeMessageBegin('getAllCategories', TMessageType.CALL, self._seqid)
1999 
    args = getAllCategories_args()
2000 
    args.write(self._oprot)
2001 
    self._oprot.writeMessageEnd()
2002 
    self._oprot.trans.flush()
2003 
 
2004 
  def recv_getAllCategories(self, ):
2005 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2006 
    if mtype == TMessageType.EXCEPTION:
2007 
      x = TApplicationException()
2008 
      x.read(self._iprot)
2009 
      self._iprot.readMessageEnd()
2010 
      raise x
2011 
    result = getAllCategories_result()
2012 
    result.read(self._iprot)
2013 
    self._iprot.readMessageEnd()
2014 
    if result.success is not None:
2015 
      return result.success
2016 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCategories failed: unknown result");
2017 
 
2018 
  def getAllSimilarItems(self, itemId):
2019 
    """
2020 
    Returns the list of similar items.
2021 
 
2022 
    Parameters:
2023 
     - itemId
2024 
    """
2025 
    self.send_getAllSimilarItems(itemId)
2026 
    return self.recv_getAllSimilarItems()
2027 
 
2028 
  def send_getAllSimilarItems(self, itemId):
2029 
    self._oprot.writeMessageBegin('getAllSimilarItems', TMessageType.CALL, self._seqid)
2030 
    args = getAllSimilarItems_args()
2031 
    args.itemId = itemId
2032 
    args.write(self._oprot)
2033 
    self._oprot.writeMessageEnd()
2034 
    self._oprot.trans.flush()
2035 
 
2036 
  def recv_getAllSimilarItems(self, ):
2037 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2038 
    if mtype == TMessageType.EXCEPTION:
2039 
      x = TApplicationException()
2040 
      x.read(self._iprot)
2041 
      self._iprot.readMessageEnd()
2042 
      raise x
2043 
    result = getAllSimilarItems_result()
2044 
    result.read(self._iprot)
2045 
    self._iprot.readMessageEnd()
2046 
    if result.success is not None:
2047 
      return result.success
2048 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSimilarItems failed: unknown result");
2049 
 
2050 
  def addSimilarItem(self, itemId, catalogItemId):
2051 
    """
2052 
    Adds similar item.
2053 
 
2054 
    Parameters:
2055 
     - itemId
2056 
     - catalogItemId
2057 
    """
2058 
    self.send_addSimilarItem(itemId, catalogItemId)
2059 
    return self.recv_addSimilarItem()
2060 
 
2061 
  def send_addSimilarItem(self, itemId, catalogItemId):
2062 
    self._oprot.writeMessageBegin('addSimilarItem', TMessageType.CALL, self._seqid)
2063 
    args = addSimilarItem_args()
2064 
    args.itemId = itemId
2065 
    args.catalogItemId = catalogItemId
2066 
    args.write(self._oprot)
2067 
    self._oprot.writeMessageEnd()
2068 
    self._oprot.trans.flush()
2069 
 
2070 
  def recv_addSimilarItem(self, ):
2071 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2072 
    if mtype == TMessageType.EXCEPTION:
2073 
      x = TApplicationException()
2074 
      x.read(self._iprot)
2075 
      self._iprot.readMessageEnd()
2076 
      raise x
2077 
    result = addSimilarItem_result()
2078 
    result.read(self._iprot)
2079 
    self._iprot.readMessageEnd()
2080 
    if result.success is not None:
2081 
      return result.success
2082 
    if result.cex is not None:
2083 
      raise result.cex
2084 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSimilarItem failed: unknown result");
2085 
 
6512 kshitij.so 2086 
  def addTag(self, displayName, itemId):
2087 
    """
2088 
    Tag Related
2089 
 
2090 
    Parameters:
2091 
     - displayName
2092 
     - itemId
2093 
    """
2094 
    self.send_addTag(displayName, itemId)
2095 
    return self.recv_addTag()
2096 
 
2097 
  def send_addTag(self, displayName, itemId):
2098 
    self._oprot.writeMessageBegin('addTag', TMessageType.CALL, self._seqid)
2099 
    args = addTag_args()
2100 
    args.displayName = displayName
2101 
    args.itemId = itemId
2102 
    args.write(self._oprot)
2103 
    self._oprot.writeMessageEnd()
2104 
    self._oprot.trans.flush()
2105 
 
2106 
  def recv_addTag(self, ):
2107 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2108 
    if mtype == TMessageType.EXCEPTION:
2109 
      x = TApplicationException()
2110 
      x.read(self._iprot)
2111 
      self._iprot.readMessageEnd()
2112 
      raise x
2113 
    result = addTag_result()
2114 
    result.read(self._iprot)
2115 
    self._iprot.readMessageEnd()
2116 
    if result.success is not None:
2117 
      return result.success
2118 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTag failed: unknown result");
2119 
 
2120 
  def deleteEntityTag(self, displayName, itemId):
2121 
    """
2122 
    Parameters:
2123 
     - displayName
2124 
     - itemId
2125 
    """
2126 
    self.send_deleteEntityTag(displayName, itemId)
2127 
    return self.recv_deleteEntityTag()
2128 
 
2129 
  def send_deleteEntityTag(self, displayName, itemId):
2130 
    self._oprot.writeMessageBegin('deleteEntityTag', TMessageType.CALL, self._seqid)
2131 
    args = deleteEntityTag_args()
2132 
    args.displayName = displayName
2133 
    args.itemId = itemId
2134 
    args.write(self._oprot)
2135 
    self._oprot.writeMessageEnd()
2136 
    self._oprot.trans.flush()
2137 
 
2138 
  def recv_deleteEntityTag(self, ):
2139 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2140 
    if mtype == TMessageType.EXCEPTION:
2141 
      x = TApplicationException()
2142 
      x.read(self._iprot)
2143 
      self._iprot.readMessageEnd()
2144 
      raise x
2145 
    result = deleteEntityTag_result()
2146 
    result.read(self._iprot)
2147 
    self._iprot.readMessageEnd()
2148 
    if result.success is not None:
2149 
      return result.success
2150 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteEntityTag failed: unknown result");
2151 
 
2152 
  def deleteTag(self, displayName):
2153 
    """
2154 
    Parameters:
2155 
     - displayName
2156 
    """
2157 
    self.send_deleteTag(displayName)
2158 
    return self.recv_deleteTag()
2159 
 
2160 
  def send_deleteTag(self, displayName):
2161 
    self._oprot.writeMessageBegin('deleteTag', TMessageType.CALL, self._seqid)
2162 
    args = deleteTag_args()
2163 
    args.displayName = displayName
2164 
    args.write(self._oprot)
2165 
    self._oprot.writeMessageEnd()
2166 
    self._oprot.trans.flush()
2167 
 
2168 
  def recv_deleteTag(self, ):
2169 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2170 
    if mtype == TMessageType.EXCEPTION:
2171 
      x = TApplicationException()
2172 
      x.read(self._iprot)
2173 
      self._iprot.readMessageEnd()
2174 
      raise x
2175 
    result = deleteTag_result()
2176 
    result.read(self._iprot)
2177 
    self._iprot.readMessageEnd()
2178 
    if result.success is not None:
2179 
      return result.success
2180 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteTag failed: unknown result");
2181 
 
2182 
  def getAllTags(self, ):
2183 
    self.send_getAllTags()
2184 
    return self.recv_getAllTags()
2185 
 
2186 
  def send_getAllTags(self, ):
2187 
    self._oprot.writeMessageBegin('getAllTags', TMessageType.CALL, self._seqid)
2188 
    args = getAllTags_args()
2189 
    args.write(self._oprot)
2190 
    self._oprot.writeMessageEnd()
2191 
    self._oprot.trans.flush()
2192 
 
2193 
  def recv_getAllTags(self, ):
2194 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2195 
    if mtype == TMessageType.EXCEPTION:
2196 
      x = TApplicationException()
2197 
      x.read(self._iprot)
2198 
      self._iprot.readMessageEnd()
2199 
      raise x
2200 
    result = getAllTags_result()
2201 
    result.read(self._iprot)
2202 
    self._iprot.readMessageEnd()
2203 
    if result.success is not None:
2204 
      return result.success
2205 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllTags failed: unknown result");
2206 
 
2207 
  def getAllEntitiesByTagName(self, displayName):
2208 
    """
2209 
    Parameters:
2210 
     - displayName
2211 
    """
2212 
    self.send_getAllEntitiesByTagName(displayName)
2213 
    return self.recv_getAllEntitiesByTagName()
2214 
 
2215 
  def send_getAllEntitiesByTagName(self, displayName):
2216 
    self._oprot.writeMessageBegin('getAllEntitiesByTagName', TMessageType.CALL, self._seqid)
2217 
    args = getAllEntitiesByTagName_args()
2218 
    args.displayName = displayName
2219 
    args.write(self._oprot)
2220 
    self._oprot.writeMessageEnd()
2221 
    self._oprot.trans.flush()
2222 
 
2223 
  def recv_getAllEntitiesByTagName(self, ):
2224 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2225 
    if mtype == TMessageType.EXCEPTION:
2226 
      x = TApplicationException()
2227 
      x.read(self._iprot)
2228 
      self._iprot.readMessageEnd()
2229 
      raise x
2230 
    result = getAllEntitiesByTagName_result()
2231 
    result.read(self._iprot)
2232 
    self._iprot.readMessageEnd()
2233 
    if result.success is not None:
2234 
      return result.success
2235 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntitiesByTagName failed: unknown result");
2236 
 
6845 amit.gupta 2237 
  def getAllEntityTags(self, ):
2238 
    self.send_getAllEntityTags()
2239 
    return self.recv_getAllEntityTags()
2240 
 
2241 
  def send_getAllEntityTags(self, ):
2242 
    self._oprot.writeMessageBegin('getAllEntityTags', TMessageType.CALL, self._seqid)
2243 
    args = getAllEntityTags_args()
2244 
    args.write(self._oprot)
2245 
    self._oprot.writeMessageEnd()
2246 
    self._oprot.trans.flush()
2247 
 
2248 
  def recv_getAllEntityTags(self, ):
2249 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2250 
    if mtype == TMessageType.EXCEPTION:
2251 
      x = TApplicationException()
2252 
      x.read(self._iprot)
2253 
      self._iprot.readMessageEnd()
2254 
      raise x
2255 
    result = getAllEntityTags_result()
2256 
    result.read(self._iprot)
2257 
    self._iprot.readMessageEnd()
2258 
    if result.success is not None:
2259 
      return result.success
2260 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntityTags failed: unknown result");
2261 
 
8590 kshitij.so 2262 
  def addBanner(self, bannerCongregate):
6850 kshitij.so 2263 
    """
8579 kshitij.so 2264 
    Banner Related
2265 
 
6850 kshitij.so 2266 
    Parameters:
8590 kshitij.so 2267 
     - bannerCongregate
6850 kshitij.so 2268 
    """
8590 kshitij.so 2269 
    self.send_addBanner(bannerCongregate)
2270 
    self.recv_addBanner()
6850 kshitij.so 2271 
 
8590 kshitij.so 2272 
  def send_addBanner(self, bannerCongregate):
6850 kshitij.so 2273 
    self._oprot.writeMessageBegin('addBanner', TMessageType.CALL, self._seqid)
2274 
    args = addBanner_args()
8590 kshitij.so 2275 
    args.bannerCongregate = bannerCongregate
6850 kshitij.so 2276 
    args.write(self._oprot)
2277 
    self._oprot.writeMessageEnd()
2278 
    self._oprot.trans.flush()
2279 
 
2280 
  def recv_addBanner(self, ):
2281 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2282 
    if mtype == TMessageType.EXCEPTION:
2283 
      x = TApplicationException()
2284 
      x.read(self._iprot)
2285 
      self._iprot.readMessageEnd()
2286 
      raise x
2287 
    result = addBanner_result()
2288 
    result.read(self._iprot)
2289 
    self._iprot.readMessageEnd()
8590 kshitij.so 2290 
    return
6850 kshitij.so 2291 
 
8579 kshitij.so 2292 
  def updateBanner(self, banner):
2293 
    """
2294 
    Parameters:
2295 
     - banner
2296 
    """
2297 
    self.send_updateBanner(banner)
2298 
    return self.recv_updateBanner()
2299 
 
2300 
  def send_updateBanner(self, banner):
2301 
    self._oprot.writeMessageBegin('updateBanner', TMessageType.CALL, self._seqid)
2302 
    args = updateBanner_args()
2303 
    args.banner = banner
2304 
    args.write(self._oprot)
2305 
    self._oprot.writeMessageEnd()
2306 
    self._oprot.trans.flush()
2307 
 
2308 
  def recv_updateBanner(self, ):
2309 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2310 
    if mtype == TMessageType.EXCEPTION:
2311 
      x = TApplicationException()
2312 
      x.read(self._iprot)
2313 
      self._iprot.readMessageEnd()
2314 
      raise x
2315 
    result = updateBanner_result()
2316 
    result.read(self._iprot)
2317 
    self._iprot.readMessageEnd()
2318 
    if result.success is not None:
2319 
      return result.success
2320 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBanner failed: unknown result");
2321 
 
6850 kshitij.so 2322 
  def getAllBanners(self, ):
2323 
    self.send_getAllBanners()
2324 
    return self.recv_getAllBanners()
2325 
 
2326 
  def send_getAllBanners(self, ):
2327 
    self._oprot.writeMessageBegin('getAllBanners', TMessageType.CALL, self._seqid)
2328 
    args = getAllBanners_args()
2329 
    args.write(self._oprot)
2330 
    self._oprot.writeMessageEnd()
2331 
    self._oprot.trans.flush()
2332 
 
2333 
  def recv_getAllBanners(self, ):
2334 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2335 
    if mtype == TMessageType.EXCEPTION:
2336 
      x = TApplicationException()
2337 
      x.read(self._iprot)
2338 
      self._iprot.readMessageEnd()
2339 
      raise x
2340 
    result = getAllBanners_result()
2341 
    result.read(self._iprot)
2342 
    self._iprot.readMessageEnd()
2343 
    if result.success is not None:
2344 
      return result.success
2345 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBanners failed: unknown result");
2346 
 
9155 kshitij.so 2347 
  def deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 2348 
    """
2349 
    Parameters:
2350 
     - bannerName
9155 kshitij.so 2351 
     - bannerType
6850 kshitij.so 2352 
    """
9155 kshitij.so 2353 
    self.send_deleteBanner(bannerName, bannerType)
6850 kshitij.so 2354 
    return self.recv_deleteBanner()
2355 
 
9155 kshitij.so 2356 
  def send_deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 2357 
    self._oprot.writeMessageBegin('deleteBanner', TMessageType.CALL, self._seqid)
2358 
    args = deleteBanner_args()
2359 
    args.bannerName = bannerName
9155 kshitij.so 2360 
    args.bannerType = bannerType
6850 kshitij.so 2361 
    args.write(self._oprot)
2362 
    self._oprot.writeMessageEnd()
2363 
    self._oprot.trans.flush()
2364 
 
2365 
  def recv_deleteBanner(self, ):
2366 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2367 
    if mtype == TMessageType.EXCEPTION:
2368 
      x = TApplicationException()
2369 
      x.read(self._iprot)
2370 
      self._iprot.readMessageEnd()
2371 
      raise x
2372 
    result = deleteBanner_result()
2373 
    result.read(self._iprot)
2374 
    self._iprot.readMessageEnd()
2375 
    if result.success is not None:
2376 
      return result.success
2377 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBanner failed: unknown result");
2378 
 
9155 kshitij.so 2379 
  def getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 2380 
    """
2381 
    Parameters:
2382 
     - bannerName
9155 kshitij.so 2383 
     - bannerType
6850 kshitij.so 2384 
    """
9155 kshitij.so 2385 
    self.send_getBannerDetails(bannerName, bannerType)
6850 kshitij.so 2386 
    return self.recv_getBannerDetails()
2387 
 
9155 kshitij.so 2388 
  def send_getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 2389 
    self._oprot.writeMessageBegin('getBannerDetails', TMessageType.CALL, self._seqid)
2390 
    args = getBannerDetails_args()
2391 
    args.bannerName = bannerName
9155 kshitij.so 2392 
    args.bannerType = bannerType
6850 kshitij.so 2393 
    args.write(self._oprot)
2394 
    self._oprot.writeMessageEnd()
2395 
    self._oprot.trans.flush()
2396 
 
2397 
  def recv_getBannerDetails(self, ):
2398 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2399 
    if mtype == TMessageType.EXCEPTION:
2400 
      x = TApplicationException()
2401 
      x.read(self._iprot)
2402 
      self._iprot.readMessageEnd()
2403 
      raise x
2404 
    result = getBannerDetails_result()
2405 
    result.read(self._iprot)
2406 
    self._iprot.readMessageEnd()
2407 
    if result.success is not None:
2408 
      return result.success
2409 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerDetails failed: unknown result");
2410 
 
2411 
  def getActiveBanners(self, ):
2412 
    self.send_getActiveBanners()
2413 
    return self.recv_getActiveBanners()
2414 
 
2415 
  def send_getActiveBanners(self, ):
2416 
    self._oprot.writeMessageBegin('getActiveBanners', TMessageType.CALL, self._seqid)
2417 
    args = getActiveBanners_args()
2418 
    args.write(self._oprot)
2419 
    self._oprot.writeMessageEnd()
2420 
    self._oprot.trans.flush()
2421 
 
2422 
  def recv_getActiveBanners(self, ):
2423 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2424 
    if mtype == TMessageType.EXCEPTION:
2425 
      x = TApplicationException()
2426 
      x.read(self._iprot)
2427 
      self._iprot.readMessageEnd()
2428 
      raise x
2429 
    result = getActiveBanners_result()
2430 
    result.read(self._iprot)
2431 
    self._iprot.readMessageEnd()
2432 
    if result.success is not None:
2433 
      return result.success
2434 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBanners failed: unknown result");
2435 
 
8579 kshitij.so 2436 
  def addBannerMap(self, bannerMaps):
6849 kshitij.so 2437 
    """
2438 
    Parameters:
8579 kshitij.so 2439 
     - bannerMaps
6849 kshitij.so 2440 
    """
8579 kshitij.so 2441 
    self.send_addBannerMap(bannerMaps)
6849 kshitij.so 2442 
    return self.recv_addBannerMap()
2443 
 
8579 kshitij.so 2444 
  def send_addBannerMap(self, bannerMaps):
6849 kshitij.so 2445 
    self._oprot.writeMessageBegin('addBannerMap', TMessageType.CALL, self._seqid)
2446 
    args = addBannerMap_args()
8579 kshitij.so 2447 
    args.bannerMaps = bannerMaps
6849 kshitij.so 2448 
    args.write(self._oprot)
2449 
    self._oprot.writeMessageEnd()
2450 
    self._oprot.trans.flush()
2451 
 
2452 
  def recv_addBannerMap(self, ):
2453 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2454 
    if mtype == TMessageType.EXCEPTION:
2455 
      x = TApplicationException()
2456 
      x.read(self._iprot)
2457 
      self._iprot.readMessageEnd()
2458 
      raise x
2459 
    result = addBannerMap_result()
2460 
    result.read(self._iprot)
2461 
    self._iprot.readMessageEnd()
2462 
    if result.success is not None:
2463 
      return result.success
2464 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBannerMap failed: unknown result");
2465 
 
8579 kshitij.so 2466 
  def updateBannerMap(self, bannerMap):
2467 
    """
2468 
    Parameters:
2469 
     - bannerMap
2470 
    """
2471 
    self.send_updateBannerMap(bannerMap)
2472 
    return self.recv_updateBannerMap()
2473 
 
2474 
  def send_updateBannerMap(self, bannerMap):
2475 
    self._oprot.writeMessageBegin('updateBannerMap', TMessageType.CALL, self._seqid)
2476 
    args = updateBannerMap_args()
2477 
    args.bannerMap = bannerMap
2478 
    args.write(self._oprot)
2479 
    self._oprot.writeMessageEnd()
2480 
    self._oprot.trans.flush()
2481 
 
2482 
  def recv_updateBannerMap(self, ):
2483 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2484 
    if mtype == TMessageType.EXCEPTION:
2485 
      x = TApplicationException()
2486 
      x.read(self._iprot)
2487 
      self._iprot.readMessageEnd()
2488 
      raise x
2489 
    result = updateBannerMap_result()
2490 
    result.read(self._iprot)
2491 
    self._iprot.readMessageEnd()
2492 
    if result.success is not None:
2493 
      return result.success
2494 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBannerMap failed: unknown result");
2495 
 
6849 kshitij.so 2496 
  def deleteBannerMap(self, bannerName):
2497 
    """
2498 
    Parameters:
2499 
     - bannerName
2500 
    """
2501 
    self.send_deleteBannerMap(bannerName)
2502 
    return self.recv_deleteBannerMap()
2503 
 
2504 
  def send_deleteBannerMap(self, bannerName):
2505 
    self._oprot.writeMessageBegin('deleteBannerMap', TMessageType.CALL, self._seqid)
2506 
    args = deleteBannerMap_args()
2507 
    args.bannerName = bannerName
2508 
    args.write(self._oprot)
2509 
    self._oprot.writeMessageEnd()
2510 
    self._oprot.trans.flush()
2511 
 
2512 
  def recv_deleteBannerMap(self, ):
2513 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2514 
    if mtype == TMessageType.EXCEPTION:
2515 
      x = TApplicationException()
2516 
      x.read(self._iprot)
2517 
      self._iprot.readMessageEnd()
2518 
      raise x
2519 
    result = deleteBannerMap_result()
2520 
    result.read(self._iprot)
2521 
    self._iprot.readMessageEnd()
2522 
    if result.success is not None:
2523 
      return result.success
2524 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBannerMap failed: unknown result");
2525 
 
9155 kshitij.so 2526 
  def getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 2527 
    """
2528 
    Parameters:
2529 
     - bannerName
9155 kshitij.so 2530 
     - bannerType
6849 kshitij.so 2531 
    """
9155 kshitij.so 2532 
    self.send_getBannerMapDetails(bannerName, bannerType)
6849 kshitij.so 2533 
    return self.recv_getBannerMapDetails()
2534 
 
9155 kshitij.so 2535 
  def send_getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 2536 
    self._oprot.writeMessageBegin('getBannerMapDetails', TMessageType.CALL, self._seqid)
2537 
    args = getBannerMapDetails_args()
2538 
    args.bannerName = bannerName
9155 kshitij.so 2539 
    args.bannerType = bannerType
6849 kshitij.so 2540 
    args.write(self._oprot)
2541 
    self._oprot.writeMessageEnd()
2542 
    self._oprot.trans.flush()
2543 
 
2544 
  def recv_getBannerMapDetails(self, ):
2545 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2546 
    if mtype == TMessageType.EXCEPTION:
2547 
      x = TApplicationException()
2548 
      x.read(self._iprot)
2549 
      self._iprot.readMessageEnd()
2550 
      raise x
2551 
    result = getBannerMapDetails_result()
2552 
    result.read(self._iprot)
2553 
    self._iprot.readMessageEnd()
2554 
    if result.success is not None:
2555 
      return result.success
2556 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerMapDetails failed: unknown result");
2557 
 
8579 kshitij.so 2558 
  def addBannerUri(self, bannerUriMappings):
2559 
    """
2560 
    Parameters:
2561 
     - bannerUriMappings
2562 
    """
2563 
    self.send_addBannerUri(bannerUriMappings)
2564 
    self.recv_addBannerUri()
2565 
 
2566 
  def send_addBannerUri(self, bannerUriMappings):
2567 
    self._oprot.writeMessageBegin('addBannerUri', TMessageType.CALL, self._seqid)
2568 
    args = addBannerUri_args()
2569 
    args.bannerUriMappings = bannerUriMappings
2570 
    args.write(self._oprot)
2571 
    self._oprot.writeMessageEnd()
2572 
    self._oprot.trans.flush()
2573 
 
2574 
  def recv_addBannerUri(self, ):
2575 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2576 
    if mtype == TMessageType.EXCEPTION:
2577 
      x = TApplicationException()
2578 
      x.read(self._iprot)
2579 
      self._iprot.readMessageEnd()
2580 
      raise x
2581 
    result = addBannerUri_result()
2582 
    result.read(self._iprot)
2583 
    self._iprot.readMessageEnd()
2584 
    return
2585 
 
9155 kshitij.so 2586 
  def getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 2587 
    """
2588 
    Parameters:
2589 
     - bannerName
9155 kshitij.so 2590 
     - bannerType
8579 kshitij.so 2591 
    """
9155 kshitij.so 2592 
    self.send_getUriMapping(bannerName, bannerType)
8579 kshitij.so 2593 
    return self.recv_getUriMapping()
2594 
 
9155 kshitij.so 2595 
  def send_getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 2596 
    self._oprot.writeMessageBegin('getUriMapping', TMessageType.CALL, self._seqid)
2597 
    args = getUriMapping_args()
2598 
    args.bannerName = bannerName
9155 kshitij.so 2599 
    args.bannerType = bannerType
8579 kshitij.so 2600 
    args.write(self._oprot)
2601 
    self._oprot.writeMessageEnd()
2602 
    self._oprot.trans.flush()
2603 
 
2604 
  def recv_getUriMapping(self, ):
2605 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2606 
    if mtype == TMessageType.EXCEPTION:
2607 
      x = TApplicationException()
2608 
      x.read(self._iprot)
2609 
      self._iprot.readMessageEnd()
2610 
      raise x
2611 
    result = getUriMapping_result()
2612 
    result.read(self._iprot)
2613 
    self._iprot.readMessageEnd()
2614 
    if result.success is not None:
2615 
      return result.success
2616 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUriMapping failed: unknown result");
2617 
 
2618 
  def addCampaign(self, campaign):
2619 
    """
2620 
    Parameters:
2621 
     - campaign
2622 
    """
2623 
    self.send_addCampaign(campaign)
2624 
    self.recv_addCampaign()
2625 
 
2626 
  def send_addCampaign(self, campaign):
2627 
    self._oprot.writeMessageBegin('addCampaign', TMessageType.CALL, self._seqid)
2628 
    args = addCampaign_args()
2629 
    args.campaign = campaign
2630 
    args.write(self._oprot)
2631 
    self._oprot.writeMessageEnd()
2632 
    self._oprot.trans.flush()
2633 
 
2634 
  def recv_addCampaign(self, ):
2635 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2636 
    if mtype == TMessageType.EXCEPTION:
2637 
      x = TApplicationException()
2638 
      x.read(self._iprot)
2639 
      self._iprot.readMessageEnd()
2640 
      raise x
2641 
    result = addCampaign_result()
2642 
    result.read(self._iprot)
2643 
    self._iprot.readMessageEnd()
2644 
    return
2645 
 
2646 
  def getCampaigns(self, campaignName):
2647 
    """
2648 
    Parameters:
2649 
     - campaignName
2650 
    """
2651 
    self.send_getCampaigns(campaignName)
2652 
    return self.recv_getCampaigns()
2653 
 
2654 
  def send_getCampaigns(self, campaignName):
2655 
    self._oprot.writeMessageBegin('getCampaigns', TMessageType.CALL, self._seqid)
2656 
    args = getCampaigns_args()
2657 
    args.campaignName = campaignName
2658 
    args.write(self._oprot)
2659 
    self._oprot.writeMessageEnd()
2660 
    self._oprot.trans.flush()
2661 
 
2662 
  def recv_getCampaigns(self, ):
2663 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2664 
    if mtype == TMessageType.EXCEPTION:
2665 
      x = TApplicationException()
2666 
      x.read(self._iprot)
2667 
      self._iprot.readMessageEnd()
2668 
      raise x
2669 
    result = getCampaigns_result()
2670 
    result.read(self._iprot)
2671 
    self._iprot.readMessageEnd()
2672 
    if result.success is not None:
2673 
      return result.success
2674 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCampaigns failed: unknown result");
2675 
 
2676 
  def deleteCampaign(self, campaignId):
2677 
    """
2678 
    Parameters:
2679 
     - campaignId
2680 
    """
2681 
    self.send_deleteCampaign(campaignId)
2682 
    self.recv_deleteCampaign()
2683 
 
2684 
  def send_deleteCampaign(self, campaignId):
2685 
    self._oprot.writeMessageBegin('deleteCampaign', TMessageType.CALL, self._seqid)
2686 
    args = deleteCampaign_args()
2687 
    args.campaignId = campaignId
2688 
    args.write(self._oprot)
2689 
    self._oprot.writeMessageEnd()
2690 
    self._oprot.trans.flush()
2691 
 
2692 
  def recv_deleteCampaign(self, ):
2693 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2694 
    if mtype == TMessageType.EXCEPTION:
2695 
      x = TApplicationException()
2696 
      x.read(self._iprot)
2697 
      self._iprot.readMessageEnd()
2698 
      raise x
2699 
    result = deleteCampaign_result()
2700 
    result.read(self._iprot)
2701 
    self._iprot.readMessageEnd()
2702 
    return
2703 
 
2704 
  def getAllCampaigns(self, ):
2705 
    self.send_getAllCampaigns()
2706 
    return self.recv_getAllCampaigns()
2707 
 
2708 
  def send_getAllCampaigns(self, ):
2709 
    self._oprot.writeMessageBegin('getAllCampaigns', TMessageType.CALL, self._seqid)
2710 
    args = getAllCampaigns_args()
2711 
    args.write(self._oprot)
2712 
    self._oprot.writeMessageEnd()
2713 
    self._oprot.trans.flush()
2714 
 
2715 
  def recv_getAllCampaigns(self, ):
2716 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2717 
    if mtype == TMessageType.EXCEPTION:
2718 
      x = TApplicationException()
2719 
      x.read(self._iprot)
2720 
      self._iprot.readMessageEnd()
2721 
      raise x
2722 
    result = getAllCampaigns_result()
2723 
    result.read(self._iprot)
2724 
    self._iprot.readMessageEnd()
2725 
    if result.success is not None:
2726 
      return result.success
2727 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCampaigns failed: unknown result");
2728 
 
9155 kshitij.so 2729 
  def getActiveBannersForMobileSite(self, ):
2730 
    self.send_getActiveBannersForMobileSite()
2731 
    return self.recv_getActiveBannersForMobileSite()
2732 
 
2733 
  def send_getActiveBannersForMobileSite(self, ):
2734 
    self._oprot.writeMessageBegin('getActiveBannersForMobileSite', TMessageType.CALL, self._seqid)
2735 
    args = getActiveBannersForMobileSite_args()
2736 
    args.write(self._oprot)
2737 
    self._oprot.writeMessageEnd()
2738 
    self._oprot.trans.flush()
2739 
 
2740 
  def recv_getActiveBannersForMobileSite(self, ):
2741 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2742 
    if mtype == TMessageType.EXCEPTION:
2743 
      x = TApplicationException()
2744 
      x.read(self._iprot)
2745 
      self._iprot.readMessageEnd()
2746 
      raise x
2747 
    result = getActiveBannersForMobileSite_result()
2748 
    result.read(self._iprot)
2749 
    self._iprot.readMessageEnd()
2750 
    if result.success is not None:
2751 
      return result.success
2752 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBannersForMobileSite failed: unknown result");
2753 
 
5944 mandeep.dh 2754 
  def deleteSimilarItem(self, itemId, catalogItemId):
2755 
    """
2756 
    Delete similar item.
2757 
 
2758 
    Parameters:
2759 
     - itemId
2760 
     - catalogItemId
2761 
    """
2762 
    self.send_deleteSimilarItem(itemId, catalogItemId)
2763 
    return self.recv_deleteSimilarItem()
2764 
 
2765 
  def send_deleteSimilarItem(self, itemId, catalogItemId):
2766 
    self._oprot.writeMessageBegin('deleteSimilarItem', TMessageType.CALL, self._seqid)
2767 
    args = deleteSimilarItem_args()
2768 
    args.itemId = itemId
2769 
    args.catalogItemId = catalogItemId
2770 
    args.write(self._oprot)
2771 
    self._oprot.writeMessageEnd()
2772 
    self._oprot.trans.flush()
2773 
 
2774 
  def recv_deleteSimilarItem(self, ):
2775 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2776 
    if mtype == TMessageType.EXCEPTION:
2777 
      x = TApplicationException()
2778 
      x.read(self._iprot)
2779 
      self._iprot.readMessageEnd()
2780 
      raise x
2781 
    result = deleteSimilarItem_result()
2782 
    result.read(self._iprot)
2783 
    self._iprot.readMessageEnd()
2784 
    if result.success is not None:
2785 
      return result.success
2786 
    if result.cex is not None:
2787 
      raise result.cex
2788 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteSimilarItem failed: unknown result");
2789 
 
2790 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
2791 
    """
2792 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
2793 
    If yes, returns the itemId else returns 0
2794 
 
2795 
    Parameters:
2796 
     - brand
2797 
     - modelNumber
2798 
     - modelName
2799 
     - color
2800 
    """
2801 
    self.send_checkSimilarItem(brand, modelNumber, modelName, color)
2802 
    return self.recv_checkSimilarItem()
2803 
 
2804 
  def send_checkSimilarItem(self, brand, modelNumber, modelName, color):
2805 
    self._oprot.writeMessageBegin('checkSimilarItem', TMessageType.CALL, self._seqid)
2806 
    args = checkSimilarItem_args()
2807 
    args.brand = brand
2808 
    args.modelNumber = modelNumber
2809 
    args.modelName = modelName
2810 
    args.color = color
2811 
    args.write(self._oprot)
2812 
    self._oprot.writeMessageEnd()
2813 
    self._oprot.trans.flush()
2814 
 
2815 
  def recv_checkSimilarItem(self, ):
2816 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2817 
    if mtype == TMessageType.EXCEPTION:
2818 
      x = TApplicationException()
2819 
      x.read(self._iprot)
2820 
      self._iprot.readMessageEnd()
2821 
      raise x
2822 
    result = checkSimilarItem_result()
2823 
    result.read(self._iprot)
2824 
    self._iprot.readMessageEnd()
2825 
    if result.success is not None:
2826 
      return result.success
2827 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkSimilarItem failed: unknown result");
2828 
 
2829 
  def validateRiskyStatus(self, itemId):
2830 
    """
2831 
    Check wether item is risky and change status if inventory is not available for risky items
2832 
 
2833 
    Parameters:
2834 
     - itemId
2835 
    """
2836 
    self.send_validateRiskyStatus(itemId)
2837 
    self.recv_validateRiskyStatus()
2838 
 
2839 
  def send_validateRiskyStatus(self, itemId):
2840 
    self._oprot.writeMessageBegin('validateRiskyStatus', TMessageType.CALL, self._seqid)
2841 
    args = validateRiskyStatus_args()
2842 
    args.itemId = itemId
2843 
    args.write(self._oprot)
2844 
    self._oprot.writeMessageEnd()
2845 
    self._oprot.trans.flush()
2846 
 
2847 
  def recv_validateRiskyStatus(self, ):
2848 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2849 
    if mtype == TMessageType.EXCEPTION:
2850 
      x = TApplicationException()
2851 
      x.read(self._iprot)
2852 
      self._iprot.readMessageEnd()
2853 
      raise x
2854 
    result = validateRiskyStatus_result()
2855 
    result.read(self._iprot)
2856 
    self._iprot.readMessageEnd()
2857 
    return
2858 
 
2859 
  def changeItemRiskyFlag(self, itemId, risky):
2860 
    """
2861 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
2862 
 
2863 
    Parameters:
2864 
     - itemId
2865 
     - risky
2866 
    """
2867 
    self.send_changeItemRiskyFlag(itemId, risky)
2868 
    self.recv_changeItemRiskyFlag()
2869 
 
2870 
  def send_changeItemRiskyFlag(self, itemId, risky):
2871 
    self._oprot.writeMessageBegin('changeItemRiskyFlag', TMessageType.CALL, self._seqid)
2872 
    args = changeItemRiskyFlag_args()
2873 
    args.itemId = itemId
2874 
    args.risky = risky
2875 
    args.write(self._oprot)
2876 
    self._oprot.writeMessageEnd()
2877 
    self._oprot.trans.flush()
2878 
 
2879 
  def recv_changeItemRiskyFlag(self, ):
2880 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2881 
    if mtype == TMessageType.EXCEPTION:
2882 
      x = TApplicationException()
2883 
      x.read(self._iprot)
2884 
      self._iprot.readMessageEnd()
2885 
      raise x
2886 
    result = changeItemRiskyFlag_result()
2887 
    result.read(self._iprot)
2888 
    self._iprot.readMessageEnd()
2889 
    return
2890 
 
2891 
  def getItemsByRiskyFlag(self, ):
2892 
    """
2893 
    Returns list of items marked as risky.
2894 
    """
2895 
    self.send_getItemsByRiskyFlag()
2896 
    return self.recv_getItemsByRiskyFlag()
2897 
 
2898 
  def send_getItemsByRiskyFlag(self, ):
2899 
    self._oprot.writeMessageBegin('getItemsByRiskyFlag', TMessageType.CALL, self._seqid)
2900 
    args = getItemsByRiskyFlag_args()
2901 
    args.write(self._oprot)
2902 
    self._oprot.writeMessageEnd()
2903 
    self._oprot.trans.flush()
2904 
 
2905 
  def recv_getItemsByRiskyFlag(self, ):
2906 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2907 
    if mtype == TMessageType.EXCEPTION:
2908 
      x = TApplicationException()
2909 
      x.read(self._iprot)
2910 
      self._iprot.readMessageEnd()
2911 
      raise x
2912 
    result = getItemsByRiskyFlag_result()
2913 
    result.read(self._iprot)
2914 
    self._iprot.readMessageEnd()
2915 
    if result.success is not None:
2916 
      return result.success
2917 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByRiskyFlag failed: unknown result");
2918 
 
2919 
  def getItemsForMasterSheet(self, category, brand):
2920 
    """
2921 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
2922 
 
2923 
    Parameters:
2924 
     - category
2925 
     - brand
2926 
    """
2927 
    self.send_getItemsForMasterSheet(category, brand)
2928 
    return self.recv_getItemsForMasterSheet()
2929 
 
2930 
  def send_getItemsForMasterSheet(self, category, brand):
2931 
    self._oprot.writeMessageBegin('getItemsForMasterSheet', TMessageType.CALL, self._seqid)
2932 
    args = getItemsForMasterSheet_args()
2933 
    args.category = category
2934 
    args.brand = brand
2935 
    args.write(self._oprot)
2936 
    self._oprot.writeMessageEnd()
2937 
    self._oprot.trans.flush()
2938 
 
2939 
  def recv_getItemsForMasterSheet(self, ):
2940 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2941 
    if mtype == TMessageType.EXCEPTION:
2942 
      x = TApplicationException()
2943 
      x.read(self._iprot)
2944 
      self._iprot.readMessageEnd()
2945 
      raise x
2946 
    result = getItemsForMasterSheet_result()
2947 
    result.read(self._iprot)
2948 
    self._iprot.readMessageEnd()
2949 
    if result.success is not None:
2950 
      return result.success
2951 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsForMasterSheet failed: unknown result");
2952 
 
2953 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2954 
    """
2955 
    Returns list of catalog ids of items with same similarity index as of the given itemId
2956 
 
2957 
    Parameters:
2958 
     - beginIndex
2959 
     - totalItems
2960 
     - itemId
2961 
    """
2962 
    self.send_getSimilarItemsCatalogIds(beginIndex, totalItems, itemId)
2963 
    return self.recv_getSimilarItemsCatalogIds()
2964 
 
2965 
  def send_getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2966 
    self._oprot.writeMessageBegin('getSimilarItemsCatalogIds', TMessageType.CALL, self._seqid)
2967 
    args = getSimilarItemsCatalogIds_args()
2968 
    args.beginIndex = beginIndex
2969 
    args.totalItems = totalItems
2970 
    args.itemId = itemId
2971 
    args.write(self._oprot)
2972 
    self._oprot.writeMessageEnd()
2973 
    self._oprot.trans.flush()
2974 
 
2975 
  def recv_getSimilarItemsCatalogIds(self, ):
2976 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2977 
    if mtype == TMessageType.EXCEPTION:
2978 
      x = TApplicationException()
2979 
      x.read(self._iprot)
2980 
      self._iprot.readMessageEnd()
2981 
      raise x
2982 
    result = getSimilarItemsCatalogIds_result()
2983 
    result.read(self._iprot)
2984 
    self._iprot.readMessageEnd()
2985 
    if result.success is not None:
2986 
      return result.success
2987 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSimilarItemsCatalogIds failed: unknown result");
2988 
 
2989 
  def addProductNotification(self, itemId, email):
2990 
    """
2991 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
2992 
 
2993 
    Parameters:
2994 
     - itemId
2995 
     - email
2996 
    """
2997 
    self.send_addProductNotification(itemId, email)
2998 
    return self.recv_addProductNotification()
2999 
 
3000 
  def send_addProductNotification(self, itemId, email):
3001 
    self._oprot.writeMessageBegin('addProductNotification', TMessageType.CALL, self._seqid)
3002 
    args = addProductNotification_args()
3003 
    args.itemId = itemId
3004 
    args.email = email
3005 
    args.write(self._oprot)
3006 
    self._oprot.writeMessageEnd()
3007 
    self._oprot.trans.flush()
3008 
 
3009 
  def recv_addProductNotification(self, ):
3010 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3011 
    if mtype == TMessageType.EXCEPTION:
3012 
      x = TApplicationException()
3013 
      x.read(self._iprot)
3014 
      self._iprot.readMessageEnd()
3015 
      raise x
3016 
    result = addProductNotification_result()
3017 
    result.read(self._iprot)
3018 
    self._iprot.readMessageEnd()
3019 
    if result.success is not None:
3020 
      return result.success
3021 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductNotification failed: unknown result");
3022 
 
3023 
  def sendProductNotifications(self, ):
3024 
    """
3025 
    Send the product notifications to the users for items which has stock.
3026 
    """
3027 
    self.send_sendProductNotifications()
3028 
    return self.recv_sendProductNotifications()
3029 
 
3030 
  def send_sendProductNotifications(self, ):
3031 
    self._oprot.writeMessageBegin('sendProductNotifications', TMessageType.CALL, self._seqid)
3032 
    args = sendProductNotifications_args()
3033 
    args.write(self._oprot)
3034 
    self._oprot.writeMessageEnd()
3035 
    self._oprot.trans.flush()
3036 
 
3037 
  def recv_sendProductNotifications(self, ):
3038 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3039 
    if mtype == TMessageType.EXCEPTION:
3040 
      x = TApplicationException()
3041 
      x.read(self._iprot)
3042 
      self._iprot.readMessageEnd()
3043 
      raise x
3044 
    result = sendProductNotifications_result()
3045 
    result.read(self._iprot)
3046 
    self._iprot.readMessageEnd()
3047 
    if result.success is not None:
3048 
      return result.success
3049 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendProductNotifications failed: unknown result");
3050 
 
3051 
  def getAllBrandsByCategory(self, categoryId):
3052 
    """
3053 
    Returns list of brand names for a given category Id
3054 
 
3055 
    Parameters:
3056 
     - categoryId
3057 
    """
3058 
    self.send_getAllBrandsByCategory(categoryId)
3059 
    return self.recv_getAllBrandsByCategory()
3060 
 
3061 
  def send_getAllBrandsByCategory(self, categoryId):
3062 
    self._oprot.writeMessageBegin('getAllBrandsByCategory', TMessageType.CALL, self._seqid)
3063 
    args = getAllBrandsByCategory_args()
3064 
    args.categoryId = categoryId
3065 
    args.write(self._oprot)
3066 
    self._oprot.writeMessageEnd()
3067 
    self._oprot.trans.flush()
3068 
 
3069 
  def recv_getAllBrandsByCategory(self, ):
3070 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3071 
    if mtype == TMessageType.EXCEPTION:
3072 
      x = TApplicationException()
3073 
      x.read(self._iprot)
3074 
      self._iprot.readMessageEnd()
3075 
      raise x
3076 
    result = getAllBrandsByCategory_result()
3077 
    result.read(self._iprot)
3078 
    self._iprot.readMessageEnd()
3079 
    if result.success is not None:
3080 
      return result.success
3081 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrandsByCategory failed: unknown result");
3082 
 
3083 
  def getAllBrands(self, ):
3084 
    """
3085 
    Returns list of brand names
3086 
    """
3087 
    self.send_getAllBrands()
3088 
    return self.recv_getAllBrands()
3089 
 
3090 
  def send_getAllBrands(self, ):
3091 
    self._oprot.writeMessageBegin('getAllBrands', TMessageType.CALL, self._seqid)
3092 
    args = getAllBrands_args()
3093 
    args.write(self._oprot)
3094 
    self._oprot.writeMessageEnd()
3095 
    self._oprot.trans.flush()
3096 
 
3097 
  def recv_getAllBrands(self, ):
3098 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3099 
    if mtype == TMessageType.EXCEPTION:
3100 
      x = TApplicationException()
3101 
      x.read(self._iprot)
3102 
      self._iprot.readMessageEnd()
3103 
      raise x
3104 
    result = getAllBrands_result()
3105 
    result.read(self._iprot)
3106 
    self._iprot.readMessageEnd()
3107 
    if result.success is not None:
3108 
      return result.success
3109 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrands failed: unknown result");
3110 
 
3111 
  def getAllSources(self, ):
3112 
    """
3113 
    Return list of all sources
3114 
    """
3115 
    self.send_getAllSources()
3116 
    return self.recv_getAllSources()
3117 
 
3118 
  def send_getAllSources(self, ):
3119 
    self._oprot.writeMessageBegin('getAllSources', TMessageType.CALL, self._seqid)
3120 
    args = getAllSources_args()
3121 
    args.write(self._oprot)
3122 
    self._oprot.writeMessageEnd()
3123 
    self._oprot.trans.flush()
3124 
 
3125 
  def recv_getAllSources(self, ):
3126 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3127 
    if mtype == TMessageType.EXCEPTION:
3128 
      x = TApplicationException()
3129 
      x.read(self._iprot)
3130 
      self._iprot.readMessageEnd()
3131 
      raise x
3132 
    result = getAllSources_result()
3133 
    result.read(self._iprot)
3134 
    self._iprot.readMessageEnd()
3135 
    if result.success is not None:
3136 
      return result.success
3137 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSources failed: unknown result");
3138 
 
3139 
  def getItemPricingBySource(self, itemId, sourceId):
3140 
    """
3141 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
3142 
 
3143 
    Parameters:
3144 
     - itemId
3145 
     - sourceId
3146 
    """
3147 
    self.send_getItemPricingBySource(itemId, sourceId)
3148 
    return self.recv_getItemPricingBySource()
3149 
 
3150 
  def send_getItemPricingBySource(self, itemId, sourceId):
3151 
    self._oprot.writeMessageBegin('getItemPricingBySource', TMessageType.CALL, self._seqid)
3152 
    args = getItemPricingBySource_args()
3153 
    args.itemId = itemId
3154 
    args.sourceId = sourceId
3155 
    args.write(self._oprot)
3156 
    self._oprot.writeMessageEnd()
3157 
    self._oprot.trans.flush()
3158 
 
3159 
  def recv_getItemPricingBySource(self, ):
3160 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3161 
    if mtype == TMessageType.EXCEPTION:
3162 
      x = TApplicationException()
3163 
      x.read(self._iprot)
3164 
      self._iprot.readMessageEnd()
3165 
      raise x
3166 
    result = getItemPricingBySource_result()
3167 
    result.read(self._iprot)
3168 
    self._iprot.readMessageEnd()
3169 
    if result.success is not None:
3170 
      return result.success
3171 
    if result.cex is not None:
3172 
      raise result.cex
3173 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricingBySource failed: unknown result");
3174 
 
3175 
  def addSourceItemPricing(self, sourceItemPricing):
3176 
    """
3177 
    Adds prices to be displayed corresponding to the item if user comes from a source.
3178 
    If item is not found or source is not found, it will throw exception.
3179 
 
3180 
    Parameters:
3181 
     - sourceItemPricing
3182 
    """
3183 
    self.send_addSourceItemPricing(sourceItemPricing)
3184 
    self.recv_addSourceItemPricing()
3185 
 
3186 
  def send_addSourceItemPricing(self, sourceItemPricing):
3187 
    self._oprot.writeMessageBegin('addSourceItemPricing', TMessageType.CALL, self._seqid)
3188 
    args = addSourceItemPricing_args()
3189 
    args.sourceItemPricing = sourceItemPricing
3190 
    args.write(self._oprot)
3191 
    self._oprot.writeMessageEnd()
3192 
    self._oprot.trans.flush()
3193 
 
3194 
  def recv_addSourceItemPricing(self, ):
3195 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3196 
    if mtype == TMessageType.EXCEPTION:
3197 
      x = TApplicationException()
3198 
      x.read(self._iprot)
3199 
      self._iprot.readMessageEnd()
3200 
      raise x
3201 
    result = addSourceItemPricing_result()
3202 
    result.read(self._iprot)
3203 
    self._iprot.readMessageEnd()
3204 
    if result.cex is not None:
3205 
      raise result.cex
3206 
    return
3207 
 
3208 
  def getAllSourcePricing(self, itemId):
3209 
    """
3210 
    Returns the list of source pricing information of an item.
3211 
    Raises an exception if item not found corresponding to itemId
3212 
 
3213 
    Parameters:
3214 
     - itemId
3215 
    """
3216 
    self.send_getAllSourcePricing(itemId)
3217 
    return self.recv_getAllSourcePricing()
3218 
 
3219 
  def send_getAllSourcePricing(self, itemId):
3220 
    self._oprot.writeMessageBegin('getAllSourcePricing', TMessageType.CALL, self._seqid)
3221 
    args = getAllSourcePricing_args()
3222 
    args.itemId = itemId
3223 
    args.write(self._oprot)
3224 
    self._oprot.writeMessageEnd()
3225 
    self._oprot.trans.flush()
3226 
 
3227 
  def recv_getAllSourcePricing(self, ):
3228 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3229 
    if mtype == TMessageType.EXCEPTION:
3230 
      x = TApplicationException()
3231 
      x.read(self._iprot)
3232 
      self._iprot.readMessageEnd()
3233 
      raise x
3234 
    result = getAllSourcePricing_result()
3235 
    result.read(self._iprot)
3236 
    self._iprot.readMessageEnd()
3237 
    if result.success is not None:
3238 
      return result.success
3239 
    if result.cex is not None:
3240 
      raise result.cex
3241 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSourcePricing failed: unknown result");
3242 
 
3243 
  def getItemForSource(self, item_id, sourceId):
3244 
    """
3245 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
3246 
 
3247 
    Parameters:
3248 
     - item_id
3249 
     - sourceId
3250 
    """
3251 
    self.send_getItemForSource(item_id, sourceId)
3252 
    return self.recv_getItemForSource()
3253 
 
3254 
  def send_getItemForSource(self, item_id, sourceId):
3255 
    self._oprot.writeMessageBegin('getItemForSource', TMessageType.CALL, self._seqid)
3256 
    args = getItemForSource_args()
3257 
    args.item_id = item_id
3258 
    args.sourceId = sourceId
3259 
    args.write(self._oprot)
3260 
    self._oprot.writeMessageEnd()
3261 
    self._oprot.trans.flush()
3262 
 
3263 
  def recv_getItemForSource(self, ):
3264 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3265 
    if mtype == TMessageType.EXCEPTION:
3266 
      x = TApplicationException()
3267 
      x.read(self._iprot)
3268 
      self._iprot.readMessageEnd()
3269 
      raise x
3270 
    result = getItemForSource_result()
3271 
    result.read(self._iprot)
3272 
    self._iprot.readMessageEnd()
3273 
    if result.success is not None:
3274 
      return result.success
3275 
    if result.cex is not None:
3276 
      raise result.cex
3277 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemForSource failed: unknown result");
3278 
 
3279 
  def searchItemsInRange(self, searchTerms, offset, limit):
3280 
    """
3281 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
3282 
 
3283 
    Parameters:
3284 
     - searchTerms
3285 
     - offset
3286 
     - limit
3287 
    """
3288 
    self.send_searchItemsInRange(searchTerms, offset, limit)
3289 
    return self.recv_searchItemsInRange()
3290 
 
3291 
  def send_searchItemsInRange(self, searchTerms, offset, limit):
3292 
    self._oprot.writeMessageBegin('searchItemsInRange', TMessageType.CALL, self._seqid)
3293 
    args = searchItemsInRange_args()
3294 
    args.searchTerms = searchTerms
3295 
    args.offset = offset
3296 
    args.limit = limit
3297 
    args.write(self._oprot)
3298 
    self._oprot.writeMessageEnd()
3299 
    self._oprot.trans.flush()
3300 
 
3301 
  def recv_searchItemsInRange(self, ):
3302 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3303 
    if mtype == TMessageType.EXCEPTION:
3304 
      x = TApplicationException()
3305 
      x.read(self._iprot)
3306 
      self._iprot.readMessageEnd()
3307 
      raise x
3308 
    result = searchItemsInRange_result()
3309 
    result.read(self._iprot)
3310 
    self._iprot.readMessageEnd()
3311 
    if result.success is not None:
3312 
      return result.success
3313 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchItemsInRange failed: unknown result");
3314 
 
3315 
  def getSearchResultCount(self, searchTerms):
3316 
    """
3317 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
3318 
 
3319 
    Parameters:
3320 
     - searchTerms
3321 
    """
3322 
    self.send_getSearchResultCount(searchTerms)
3323 
    return self.recv_getSearchResultCount()
3324 
 
3325 
  def send_getSearchResultCount(self, searchTerms):
3326 
    self._oprot.writeMessageBegin('getSearchResultCount', TMessageType.CALL, self._seqid)
3327 
    args = getSearchResultCount_args()
3328 
    args.searchTerms = searchTerms
3329 
    args.write(self._oprot)
3330 
    self._oprot.writeMessageEnd()
3331 
    self._oprot.trans.flush()
3332 
 
3333 
  def recv_getSearchResultCount(self, ):
3334 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3335 
    if mtype == TMessageType.EXCEPTION:
3336 
      x = TApplicationException()
3337 
      x.read(self._iprot)
3338 
      self._iprot.readMessageEnd()
3339 
      raise x
3340 
    result = getSearchResultCount_result()
3341 
    result.read(self._iprot)
3342 
    self._iprot.readMessageEnd()
3343 
    if result.success is not None:
3344 
      return result.success
3345 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSearchResultCount failed: unknown result");
3346 
 
3347 
  def getProductNotifications(self, startDateTime):
3348 
    """
3349 
    Returns a list of product notifications added after a supplied datetime
3350 
 
3351 
    Parameters:
3352 
     - startDateTime
3353 
    """
3354 
    self.send_getProductNotifications(startDateTime)
3355 
    return self.recv_getProductNotifications()
3356 
 
3357 
  def send_getProductNotifications(self, startDateTime):
3358 
    self._oprot.writeMessageBegin('getProductNotifications', TMessageType.CALL, self._seqid)
3359 
    args = getProductNotifications_args()
3360 
    args.startDateTime = startDateTime
3361 
    args.write(self._oprot)
3362 
    self._oprot.writeMessageEnd()
3363 
    self._oprot.trans.flush()
3364 
 
3365 
  def recv_getProductNotifications(self, ):
3366 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3367 
    if mtype == TMessageType.EXCEPTION:
3368 
      x = TApplicationException()
3369 
      x.read(self._iprot)
3370 
      self._iprot.readMessageEnd()
3371 
      raise x
3372 
    result = getProductNotifications_result()
3373 
    result.read(self._iprot)
3374 
    self._iprot.readMessageEnd()
3375 
    if result.success is not None:
3376 
      return result.success
3377 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotifications failed: unknown result");
3378 
 
7897 amar.kumar 3379 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3380 
    """
3381 
    Returns a list of count of requests for product notification against each item
3382 
 
3383 
    Parameters:
3384 
     - startDateTime
7897 amar.kumar 3385 
     - categoryId
5944 mandeep.dh 3386 
    """
7897 amar.kumar 3387 
    self.send_getProductNotificationRequestCount(startDateTime, categoryId)
5944 mandeep.dh 3388 
    return self.recv_getProductNotificationRequestCount()
3389 
 
7897 amar.kumar 3390 
  def send_getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3391 
    self._oprot.writeMessageBegin('getProductNotificationRequestCount', TMessageType.CALL, self._seqid)
3392 
    args = getProductNotificationRequestCount_args()
3393 
    args.startDateTime = startDateTime
7897 amar.kumar 3394 
    args.categoryId = categoryId
5944 mandeep.dh 3395 
    args.write(self._oprot)
3396 
    self._oprot.writeMessageEnd()
3397 
    self._oprot.trans.flush()
3398 
 
3399 
  def recv_getProductNotificationRequestCount(self, ):
3400 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3401 
    if mtype == TMessageType.EXCEPTION:
3402 
      x = TApplicationException()
3403 
      x.read(self._iprot)
3404 
      self._iprot.readMessageEnd()
3405 
      raise x
3406 
    result = getProductNotificationRequestCount_result()
3407 
    result.read(self._iprot)
3408 
    self._iprot.readMessageEnd()
3409 
    if result.success is not None:
3410 
      return result.success
3411 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotificationRequestCount failed: unknown result");
3412 
 
3413 
  def addAuthorizationLog(self, itemId, username, reason):
3414 
    """
3415 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
3416 
 
3417 
    Parameters:
3418 
     - itemId
3419 
     - username
3420 
     - reason
3421 
    """
3422 
    self.send_addAuthorizationLog(itemId, username, reason)
3423 
    return self.recv_addAuthorizationLog()
3424 
 
3425 
  def send_addAuthorizationLog(self, itemId, username, reason):
3426 
    self._oprot.writeMessageBegin('addAuthorizationLog', TMessageType.CALL, self._seqid)
3427 
    args = addAuthorizationLog_args()
3428 
    args.itemId = itemId
3429 
    args.username = username
3430 
    args.reason = reason
3431 
    args.write(self._oprot)
3432 
    self._oprot.writeMessageEnd()
3433 
    self._oprot.trans.flush()
3434 
 
3435 
  def recv_addAuthorizationLog(self, ):
3436 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3437 
    if mtype == TMessageType.EXCEPTION:
3438 
      x = TApplicationException()
3439 
      x.read(self._iprot)
3440 
      self._iprot.readMessageEnd()
3441 
      raise x
3442 
    result = addAuthorizationLog_result()
3443 
    result.read(self._iprot)
3444 
    self._iprot.readMessageEnd()
3445 
    if result.success is not None:
3446 
      return result.success
3447 
    if result.cex is not None:
3448 
      raise result.cex
3449 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAuthorizationLog failed: unknown result");
3450 
 
3451 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3452 
    """
3453 
    Parameters:
3454 
     - catalog_item_id
3455 
     - voucherType
3456 
     - voucherAmount
3457 
    """
3458 
    self.send_addupdateVoucherForItem(catalog_item_id, voucherType, voucherAmount)
3459 
    return self.recv_addupdateVoucherForItem()
3460 
 
3461 
  def send_addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3462 
    self._oprot.writeMessageBegin('addupdateVoucherForItem', TMessageType.CALL, self._seqid)
3463 
    args = addupdateVoucherForItem_args()
3464 
    args.catalog_item_id = catalog_item_id
3465 
    args.voucherType = voucherType
3466 
    args.voucherAmount = voucherAmount
3467 
    args.write(self._oprot)
3468 
    self._oprot.writeMessageEnd()
3469 
    self._oprot.trans.flush()
3470 
 
3471 
  def recv_addupdateVoucherForItem(self, ):
3472 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3473 
    if mtype == TMessageType.EXCEPTION:
3474 
      x = TApplicationException()
3475 
      x.read(self._iprot)
3476 
      self._iprot.readMessageEnd()
3477 
      raise x
3478 
    result = addupdateVoucherForItem_result()
3479 
    result.read(self._iprot)
3480 
    self._iprot.readMessageEnd()
3481 
    if result.success is not None:
3482 
      return result.success
3483 
    if result.cex is not None:
3484 
      raise result.cex
3485 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addupdateVoucherForItem failed: unknown result");
3486 
 
3487 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
3488 
    """
3489 
    Parameters:
3490 
     - catalog_item_id
3491 
     - voucherType
3492 
    """
3493 
    self.send_deleteVoucherForItem(catalog_item_id, voucherType)
3494 
    return self.recv_deleteVoucherForItem()
3495 
 
3496 
  def send_deleteVoucherForItem(self, catalog_item_id, voucherType):
3497 
    self._oprot.writeMessageBegin('deleteVoucherForItem', TMessageType.CALL, self._seqid)
3498 
    args = deleteVoucherForItem_args()
3499 
    args.catalog_item_id = catalog_item_id
3500 
    args.voucherType = voucherType
3501 
    args.write(self._oprot)
3502 
    self._oprot.writeMessageEnd()
3503 
    self._oprot.trans.flush()
3504 
 
3505 
  def recv_deleteVoucherForItem(self, ):
3506 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3507 
    if mtype == TMessageType.EXCEPTION:
3508 
      x = TApplicationException()
3509 
      x.read(self._iprot)
3510 
      self._iprot.readMessageEnd()
3511 
      raise x
3512 
    result = deleteVoucherForItem_result()
3513 
    result.read(self._iprot)
3514 
    self._iprot.readMessageEnd()
3515 
    if result.success is not None:
3516 
      return result.success
3517 
    if result.cex is not None:
3518 
      raise result.cex
3519 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteVoucherForItem failed: unknown result");
3520 
 
3521 
  def getVoucherAmount(self, itemId, voucherType):
3522 
    """
3523 
    Parameters:
3524 
     - itemId
3525 
     - voucherType
3526 
    """
3527 
    self.send_getVoucherAmount(itemId, voucherType)
3528 
    return self.recv_getVoucherAmount()
3529 
 
3530 
  def send_getVoucherAmount(self, itemId, voucherType):
3531 
    self._oprot.writeMessageBegin('getVoucherAmount', TMessageType.CALL, self._seqid)
3532 
    args = getVoucherAmount_args()
3533 
    args.itemId = itemId
3534 
    args.voucherType = voucherType
3535 
    args.write(self._oprot)
3536 
    self._oprot.writeMessageEnd()
3537 
    self._oprot.trans.flush()
3538 
 
3539 
  def recv_getVoucherAmount(self, ):
3540 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3541 
    if mtype == TMessageType.EXCEPTION:
3542 
      x = TApplicationException()
3543 
      x.read(self._iprot)
3544 
      self._iprot.readMessageEnd()
3545 
      raise x
3546 
    result = getVoucherAmount_result()
3547 
    result.read(self._iprot)
3548 
    self._iprot.readMessageEnd()
3549 
    if result.success is not None:
3550 
      return result.success
3551 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVoucherAmount failed: unknown result");
3552 
 
3553 
  def getAllItemVouchers(self, itemId):
3554 
    """
3555 
    Parameters:
3556 
     - itemId
3557 
    """
3558 
    self.send_getAllItemVouchers(itemId)
3559 
    return self.recv_getAllItemVouchers()
3560 
 
3561 
  def send_getAllItemVouchers(self, itemId):
3562 
    self._oprot.writeMessageBegin('getAllItemVouchers', TMessageType.CALL, self._seqid)
3563 
    args = getAllItemVouchers_args()
3564 
    args.itemId = itemId
3565 
    args.write(self._oprot)
3566 
    self._oprot.writeMessageEnd()
3567 
    self._oprot.trans.flush()
3568 
 
3569 
  def recv_getAllItemVouchers(self, ):
3570 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3571 
    if mtype == TMessageType.EXCEPTION:
3572 
      x = TApplicationException()
3573 
      x.read(self._iprot)
3574 
      self._iprot.readMessageEnd()
3575 
      raise x
3576 
    result = getAllItemVouchers_result()
3577 
    result.read(self._iprot)
3578 
    self._iprot.readMessageEnd()
3579 
    if result.success is not None:
3580 
      return result.success
3581 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemVouchers failed: unknown result");
3582 
 
3583 
  def isValidCatalogItemId(self, catalog_item_id):
3584 
    """
3585 
    Parameters:
3586 
     - catalog_item_id
3587 
    """
3588 
    self.send_isValidCatalogItemId(catalog_item_id)
3589 
    return self.recv_isValidCatalogItemId()
3590 
 
3591 
  def send_isValidCatalogItemId(self, catalog_item_id):
3592 
    self._oprot.writeMessageBegin('isValidCatalogItemId', TMessageType.CALL, self._seqid)
3593 
    args = isValidCatalogItemId_args()
3594 
    args.catalog_item_id = catalog_item_id
3595 
    args.write(self._oprot)
3596 
    self._oprot.writeMessageEnd()
3597 
    self._oprot.trans.flush()
3598 
 
3599 
  def recv_isValidCatalogItemId(self, ):
3600 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3601 
    if mtype == TMessageType.EXCEPTION:
3602 
      x = TApplicationException()
3603 
      x.read(self._iprot)
3604 
      self._iprot.readMessageEnd()
3605 
      raise x
3606 
    result = isValidCatalogItemId_result()
3607 
    result.read(self._iprot)
3608 
    self._iprot.readMessageEnd()
3609 
    if result.success is not None:
3610 
      return result.success
3611 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isValidCatalogItemId failed: unknown result");
3612 
 
7330 amit.gupta 3613 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3614 
    """
3615 
    Parameters:
3616 
     - itemId
7330 amit.gupta 3617 
     - stateId
6039 amit.gupta 3618 
     - price
3619 
    """
7330 amit.gupta 3620 
    self.send_getVatPercentageForItem(itemId, stateId, price)
6039 amit.gupta 3621 
    return self.recv_getVatPercentageForItem()
5944 mandeep.dh 3622 
 
7330 amit.gupta 3623 
  def send_getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3624 
    self._oprot.writeMessageBegin('getVatPercentageForItem', TMessageType.CALL, self._seqid)
3625 
    args = getVatPercentageForItem_args()
3626 
    args.itemId = itemId
7330 amit.gupta 3627 
    args.stateId = stateId
6039 amit.gupta 3628 
    args.price = price
3629 
    args.write(self._oprot)
3630 
    self._oprot.writeMessageEnd()
3631 
    self._oprot.trans.flush()
3632 
 
3633 
  def recv_getVatPercentageForItem(self, ):
3634 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3635 
    if mtype == TMessageType.EXCEPTION:
3636 
      x = TApplicationException()
3637 
      x.read(self._iprot)
3638 
      self._iprot.readMessageEnd()
3639 
      raise x
3640 
    result = getVatPercentageForItem_result()
3641 
    result.read(self._iprot)
3642 
    self._iprot.readMessageEnd()
3643 
    if result.success is not None:
3644 
      return result.success
7340 amit.gupta 3645 
    if result.cex is not None:
3646 
      raise result.cex
6039 amit.gupta 3647 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatPercentageForItem failed: unknown result");
3648 
 
3649 
  def getVatAmountForItem(self, itemId, price):
3650 
    """
3651 
    Parameters:
3652 
     - itemId
3653 
     - price
3654 
    """
3655 
    self.send_getVatAmountForItem(itemId, price)
3656 
    return self.recv_getVatAmountForItem()
3657 
 
3658 
  def send_getVatAmountForItem(self, itemId, price):
3659 
    self._oprot.writeMessageBegin('getVatAmountForItem', TMessageType.CALL, self._seqid)
3660 
    args = getVatAmountForItem_args()
3661 
    args.itemId = itemId
3662 
    args.price = price
3663 
    args.write(self._oprot)
3664 
    self._oprot.writeMessageEnd()
3665 
    self._oprot.trans.flush()
3666 
 
3667 
  def recv_getVatAmountForItem(self, ):
3668 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3669 
    if mtype == TMessageType.EXCEPTION:
3670 
      x = TApplicationException()
3671 
      x.read(self._iprot)
3672 
      self._iprot.readMessageEnd()
3673 
      raise x
3674 
    result = getVatAmountForItem_result()
3675 
    result.read(self._iprot)
3676 
    self._iprot.readMessageEnd()
3677 
    if result.success is not None:
3678 
      return result.success
3679 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatAmountForItem failed: unknown result");
3680 
 
6531 vikram.rag 3681 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3682 
    """
3683 
    Parameters:
3684 
     - offset
3685 
     - limit
3686 
    """
3687 
    self.send_getAllIgnoredInventoryUpdateItemsList(offset, limit)
3688 
    return self.recv_getAllIgnoredInventoryUpdateItemsList()
6039 amit.gupta 3689 
 
6531 vikram.rag 3690 
  def send_getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3691 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryUpdateItemsList', TMessageType.CALL, self._seqid)
3692 
    args = getAllIgnoredInventoryUpdateItemsList_args()
3693 
    args.offset = offset
3694 
    args.limit = limit
3695 
    args.write(self._oprot)
3696 
    self._oprot.writeMessageEnd()
3697 
    self._oprot.trans.flush()
3698 
 
3699 
  def recv_getAllIgnoredInventoryUpdateItemsList(self, ):
3700 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3701 
    if mtype == TMessageType.EXCEPTION:
3702 
      x = TApplicationException()
3703 
      x.read(self._iprot)
3704 
      self._iprot.readMessageEnd()
3705 
      raise x
3706 
    result = getAllIgnoredInventoryUpdateItemsList_result()
3707 
    result.read(self._iprot)
3708 
    self._iprot.readMessageEnd()
3709 
    if result.success is not None:
3710 
      return result.success
3711 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryUpdateItemsList failed: unknown result");
3712 
 
6821 amar.kumar 3713 
  def getAllAliveItems(self, ):
3714 
    self.send_getAllAliveItems()
3715 
    return self.recv_getAllAliveItems()
3716 
 
3717 
  def send_getAllAliveItems(self, ):
3718 
    self._oprot.writeMessageBegin('getAllAliveItems', TMessageType.CALL, self._seqid)
3719 
    args = getAllAliveItems_args()
3720 
    args.write(self._oprot)
3721 
    self._oprot.writeMessageEnd()
3722 
    self._oprot.trans.flush()
3723 
 
3724 
  def recv_getAllAliveItems(self, ):
3725 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3726 
    if mtype == TMessageType.EXCEPTION:
3727 
      x = TApplicationException()
3728 
      x.read(self._iprot)
3729 
      self._iprot.readMessageEnd()
3730 
      raise x
3731 
    result = getAllAliveItems_result()
3732 
    result.read(self._iprot)
3733 
    self._iprot.readMessageEnd()
3734 
    if result.success is not None:
3735 
      return result.success
3736 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAliveItems failed: unknown result");
3737 
 
6921 anupam.sin 3738 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3739 
    """
3740 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 3741 
 
6805 anupam.sin 3742 
    Parameters:
3743 
     - itemId
6921 anupam.sin 3744 
     - price
6805 anupam.sin 3745 
     - insurerId
3746 
     - quantity
3747 
    """
6921 anupam.sin 3748 
    self.send_getInsuranceAmount(itemId, price, insurerId, quantity)
6805 anupam.sin 3749 
    return self.recv_getInsuranceAmount()
3750 
 
6921 anupam.sin 3751 
  def send_getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3752 
    self._oprot.writeMessageBegin('getInsuranceAmount', TMessageType.CALL, self._seqid)
3753 
    args = getInsuranceAmount_args()
3754 
    args.itemId = itemId
6921 anupam.sin 3755 
    args.price = price
6805 anupam.sin 3756 
    args.insurerId = insurerId
3757 
    args.quantity = quantity
3758 
    args.write(self._oprot)
3759 
    self._oprot.writeMessageEnd()
3760 
    self._oprot.trans.flush()
3761 
 
3762 
  def recv_getInsuranceAmount(self, ):
3763 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3764 
    if mtype == TMessageType.EXCEPTION:
3765 
      x = TApplicationException()
3766 
      x.read(self._iprot)
3767 
      self._iprot.readMessageEnd()
3768 
      raise x
3769 
    result = getInsuranceAmount_result()
3770 
    result.read(self._iprot)
3771 
    self._iprot.readMessageEnd()
3772 
    if result.success is not None:
3773 
      return result.success
3774 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsuranceAmount failed: unknown result");
3775 
 
3776 
  def getInsurer(self, insurerId):
3777 
    """
3778 
    Parameters:
3779 
     - insurerId
3780 
    """
3781 
    self.send_getInsurer(insurerId)
3782 
    return self.recv_getInsurer()
3783 
 
3784 
  def send_getInsurer(self, insurerId):
3785 
    self._oprot.writeMessageBegin('getInsurer', TMessageType.CALL, self._seqid)
3786 
    args = getInsurer_args()
3787 
    args.insurerId = insurerId
3788 
    args.write(self._oprot)
3789 
    self._oprot.writeMessageEnd()
3790 
    self._oprot.trans.flush()
3791 
 
3792 
  def recv_getInsurer(self, ):
3793 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3794 
    if mtype == TMessageType.EXCEPTION:
3795 
      x = TApplicationException()
3796 
      x.read(self._iprot)
3797 
      self._iprot.readMessageEnd()
3798 
      raise x
3799 
    result = getInsurer_result()
3800 
    result.read(self._iprot)
3801 
    self._iprot.readMessageEnd()
3802 
    if result.success is not None:
3803 
      return result.success
3804 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsurer failed: unknown result");
3805 
 
6838 vikram.rag 3806 
  def getAllInsurers(self, ):
3807 
    self.send_getAllInsurers()
3808 
    return self.recv_getAllInsurers()
6805 anupam.sin 3809 
 
6838 vikram.rag 3810 
  def send_getAllInsurers(self, ):
3811 
    self._oprot.writeMessageBegin('getAllInsurers', TMessageType.CALL, self._seqid)
3812 
    args = getAllInsurers_args()
3813 
    args.write(self._oprot)
3814 
    self._oprot.writeMessageEnd()
3815 
    self._oprot.trans.flush()
3816 
 
3817 
  def recv_getAllInsurers(self, ):
3818 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3819 
    if mtype == TMessageType.EXCEPTION:
3820 
      x = TApplicationException()
3821 
      x.read(self._iprot)
3822 
      self._iprot.readMessageEnd()
3823 
      raise x
3824 
    result = getAllInsurers_result()
3825 
    result.read(self._iprot)
3826 
    self._iprot.readMessageEnd()
3827 
    if result.success is not None:
3828 
      return result.success
3829 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllInsurers failed: unknown result");
3830 
 
6962 rajveer 3831 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
3832 
    """
3833 
    Parameters:
3834 
     - insurerId
3835 
     - amount
3836 
    """
3837 
    self.send_updateInsuranceDeclaredAmount(insurerId, amount)
3838 
    self.recv_updateInsuranceDeclaredAmount()
6838 vikram.rag 3839 
 
6962 rajveer 3840 
  def send_updateInsuranceDeclaredAmount(self, insurerId, amount):
3841 
    self._oprot.writeMessageBegin('updateInsuranceDeclaredAmount', TMessageType.CALL, self._seqid)
3842 
    args = updateInsuranceDeclaredAmount_args()
3843 
    args.insurerId = insurerId
3844 
    args.amount = amount
3845 
    args.write(self._oprot)
3846 
    self._oprot.writeMessageEnd()
3847 
    self._oprot.trans.flush()
3848 
 
3849 
  def recv_updateInsuranceDeclaredAmount(self, ):
3850 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3851 
    if mtype == TMessageType.EXCEPTION:
3852 
      x = TApplicationException()
3853 
      x.read(self._iprot)
3854 
      self._iprot.readMessageEnd()
3855 
      raise x
3856 
    result = updateInsuranceDeclaredAmount_result()
3857 
    result.read(self._iprot)
3858 
    self._iprot.readMessageEnd()
3859 
    return
3860 
 
7190 amar.kumar 3861 
  def getFreebieForItem(self, itemId):
3862 
    """
3863 
    Parameters:
3864 
     - itemId
3865 
    """
3866 
    self.send_getFreebieForItem(itemId)
3867 
    return self.recv_getFreebieForItem()
6962 rajveer 3868 
 
7190 amar.kumar 3869 
  def send_getFreebieForItem(self, itemId):
3870 
    self._oprot.writeMessageBegin('getFreebieForItem', TMessageType.CALL, self._seqid)
3871 
    args = getFreebieForItem_args()
3872 
    args.itemId = itemId
3873 
    args.write(self._oprot)
3874 
    self._oprot.writeMessageEnd()
3875 
    self._oprot.trans.flush()
3876 
 
3877 
  def recv_getFreebieForItem(self, ):
3878 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3879 
    if mtype == TMessageType.EXCEPTION:
3880 
      x = TApplicationException()
3881 
      x.read(self._iprot)
3882 
      self._iprot.readMessageEnd()
3883 
      raise x
3884 
    result = getFreebieForItem_result()
3885 
    result.read(self._iprot)
3886 
    self._iprot.readMessageEnd()
3887 
    if result.success is not None:
3888 
      return result.success
3889 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFreebieForItem failed: unknown result");
3890 
 
3891 
  def addOrUpdateFreebieForItem(self, freebieItem):
3892 
    """
3893 
    Parameters:
3894 
     - freebieItem
3895 
    """
3896 
    self.send_addOrUpdateFreebieForItem(freebieItem)
3897 
    self.recv_addOrUpdateFreebieForItem()
3898 
 
3899 
  def send_addOrUpdateFreebieForItem(self, freebieItem):
3900 
    self._oprot.writeMessageBegin('addOrUpdateFreebieForItem', TMessageType.CALL, self._seqid)
3901 
    args = addOrUpdateFreebieForItem_args()
3902 
    args.freebieItem = freebieItem
3903 
    args.write(self._oprot)
3904 
    self._oprot.writeMessageEnd()
3905 
    self._oprot.trans.flush()
3906 
 
3907 
  def recv_addOrUpdateFreebieForItem(self, ):
3908 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3909 
    if mtype == TMessageType.EXCEPTION:
3910 
      x = TApplicationException()
3911 
      x.read(self._iprot)
3912 
      self._iprot.readMessageEnd()
3913 
      raise x
3914 
    result = addOrUpdateFreebieForItem_result()
3915 
    result.read(self._iprot)
3916 
    self._iprot.readMessageEnd()
3917 
    return
3918 
 
7272 amit.gupta 3919 
  def addOrUpdateBrandInfo(self, brandInfo):
3920 
    """
3921 
    Parameters:
3922 
     - brandInfo
3923 
    """
3924 
    self.send_addOrUpdateBrandInfo(brandInfo)
3925 
    self.recv_addOrUpdateBrandInfo()
3926 
 
3927 
  def send_addOrUpdateBrandInfo(self, brandInfo):
3928 
    self._oprot.writeMessageBegin('addOrUpdateBrandInfo', TMessageType.CALL, self._seqid)
3929 
    args = addOrUpdateBrandInfo_args()
3930 
    args.brandInfo = brandInfo
3931 
    args.write(self._oprot)
3932 
    self._oprot.writeMessageEnd()
3933 
    self._oprot.trans.flush()
3934 
 
3935 
  def recv_addOrUpdateBrandInfo(self, ):
3936 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3937 
    if mtype == TMessageType.EXCEPTION:
3938 
      x = TApplicationException()
3939 
      x.read(self._iprot)
3940 
      self._iprot.readMessageEnd()
3941 
      raise x
3942 
    result = addOrUpdateBrandInfo_result()
3943 
    result.read(self._iprot)
3944 
    self._iprot.readMessageEnd()
3945 
    return
3946 
 
3947 
  def getBrandInfo(self, ):
3948 
    self.send_getBrandInfo()
3949 
    return self.recv_getBrandInfo()
3950 
 
3951 
  def send_getBrandInfo(self, ):
3952 
    self._oprot.writeMessageBegin('getBrandInfo', TMessageType.CALL, self._seqid)
3953 
    args = getBrandInfo_args()
3954 
    args.write(self._oprot)
3955 
    self._oprot.writeMessageEnd()
3956 
    self._oprot.trans.flush()
3957 
 
3958 
  def recv_getBrandInfo(self, ):
3959 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3960 
    if mtype == TMessageType.EXCEPTION:
3961 
      x = TApplicationException()
3962 
      x.read(self._iprot)
3963 
      self._iprot.readMessageEnd()
3964 
      raise x
3965 
    result = getBrandInfo_result()
3966 
    result.read(self._iprot)
3967 
    self._iprot.readMessageEnd()
3968 
    if result.success is not None:
3969 
      return result.success
3970 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrandInfo failed: unknown result");
3971 
 
7256 rajveer 3972 
  def getStorePricing(self, itemId):
3973 
    """
3974 
    Parameters:
3975 
     - itemId
3976 
    """
3977 
    self.send_getStorePricing(itemId)
3978 
    return self.recv_getStorePricing()
7190 amar.kumar 3979 
 
7256 rajveer 3980 
  def send_getStorePricing(self, itemId):
3981 
    self._oprot.writeMessageBegin('getStorePricing', TMessageType.CALL, self._seqid)
3982 
    args = getStorePricing_args()
3983 
    args.itemId = itemId
3984 
    args.write(self._oprot)
3985 
    self._oprot.writeMessageEnd()
3986 
    self._oprot.trans.flush()
3987 
 
3988 
  def recv_getStorePricing(self, ):
3989 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3990 
    if mtype == TMessageType.EXCEPTION:
3991 
      x = TApplicationException()
3992 
      x.read(self._iprot)
3993 
      self._iprot.readMessageEnd()
3994 
      raise x
3995 
    result = getStorePricing_result()
3996 
    result.read(self._iprot)
3997 
    self._iprot.readMessageEnd()
3998 
    if result.success is not None:
3999 
      return result.success
4000 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricing failed: unknown result");
4001 
 
7306 rajveer 4002 
  def getStorePricings(self, itemIds):
4003 
    """
4004 
    Parameters:
4005 
     - itemIds
4006 
    """
4007 
    self.send_getStorePricings(itemIds)
4008 
    return self.recv_getStorePricings()
4009 
 
4010 
  def send_getStorePricings(self, itemIds):
4011 
    self._oprot.writeMessageBegin('getStorePricings', TMessageType.CALL, self._seqid)
4012 
    args = getStorePricings_args()
4013 
    args.itemIds = itemIds
4014 
    args.write(self._oprot)
4015 
    self._oprot.writeMessageEnd()
4016 
    self._oprot.trans.flush()
4017 
 
4018 
  def recv_getStorePricings(self, ):
4019 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4020 
    if mtype == TMessageType.EXCEPTION:
4021 
      x = TApplicationException()
4022 
      x.read(self._iprot)
4023 
      self._iprot.readMessageEnd()
4024 
      raise x
4025 
    result = getStorePricings_result()
4026 
    result.read(self._iprot)
4027 
    self._iprot.readMessageEnd()
4028 
    if result.success is not None:
4029 
      return result.success
4030 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricings failed: unknown result");
4031 
 
7382 rajveer 4032 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 4033 
    """
4034 
    Parameters:
4035 
     - sp
7382 rajveer 4036 
     - allColors
7265 rajveer 4037 
    """
7382 rajveer 4038 
    self.send_updateStorePricing(sp, allColors)
7265 rajveer 4039 
    self.recv_updateStorePricing()
7256 rajveer 4040 
 
7382 rajveer 4041 
  def send_updateStorePricing(self, sp, allColors):
7265 rajveer 4042 
    self._oprot.writeMessageBegin('updateStorePricing', TMessageType.CALL, self._seqid)
4043 
    args = updateStorePricing_args()
4044 
    args.sp = sp
7382 rajveer 4045 
    args.allColors = allColors
7265 rajveer 4046 
    args.write(self._oprot)
4047 
    self._oprot.writeMessageEnd()
4048 
    self._oprot.trans.flush()
4049 
 
4050 
  def recv_updateStorePricing(self, ):
4051 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4052 
    if mtype == TMessageType.EXCEPTION:
4053 
      x = TApplicationException()
4054 
      x.read(self._iprot)
4055 
      self._iprot.readMessageEnd()
4056 
      raise x
4057 
    result = updateStorePricing_result()
4058 
    result.read(self._iprot)
4059 
    self._iprot.readMessageEnd()
4060 
    return
4061 
 
7281 kshitij.so 4062 
  def getAllAmazonListedItems(self, ):
4063 
    self.send_getAllAmazonListedItems()
4064 
    return self.recv_getAllAmazonListedItems()
7265 rajveer 4065 
 
7281 kshitij.so 4066 
  def send_getAllAmazonListedItems(self, ):
4067 
    self._oprot.writeMessageBegin('getAllAmazonListedItems', TMessageType.CALL, self._seqid)
4068 
    args = getAllAmazonListedItems_args()
4069 
    args.write(self._oprot)
4070 
    self._oprot.writeMessageEnd()
4071 
    self._oprot.trans.flush()
4072 
 
4073 
  def recv_getAllAmazonListedItems(self, ):
4074 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4075 
    if mtype == TMessageType.EXCEPTION:
4076 
      x = TApplicationException()
4077 
      x.read(self._iprot)
4078 
      self._iprot.readMessageEnd()
4079 
      raise x
4080 
    result = getAllAmazonListedItems_result()
4081 
    result.read(self._iprot)
4082 
    self._iprot.readMessageEnd()
4083 
    if result.success is not None:
4084 
      return result.success
4085 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonListedItems failed: unknown result");
4086 
 
8619 kshitij.so 4087 
  def searchAmazonItems(self, searchTerm, offset, limit):
4088 
    """
4089 
    Parameters:
4090 
     - searchTerm
4091 
     - offset
4092 
     - limit
4093 
    """
4094 
    self.send_searchAmazonItems(searchTerm, offset, limit)
4095 
    return self.recv_searchAmazonItems()
4096 
 
4097 
  def send_searchAmazonItems(self, searchTerm, offset, limit):
4098 
    self._oprot.writeMessageBegin('searchAmazonItems', TMessageType.CALL, self._seqid)
4099 
    args = searchAmazonItems_args()
4100 
    args.searchTerm = searchTerm
4101 
    args.offset = offset
4102 
    args.limit = limit
4103 
    args.write(self._oprot)
4104 
    self._oprot.writeMessageEnd()
4105 
    self._oprot.trans.flush()
4106 
 
4107 
  def recv_searchAmazonItems(self, ):
4108 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4109 
    if mtype == TMessageType.EXCEPTION:
4110 
      x = TApplicationException()
4111 
      x.read(self._iprot)
4112 
      self._iprot.readMessageEnd()
4113 
      raise x
4114 
    result = searchAmazonItems_result()
4115 
    result.read(self._iprot)
4116 
    self._iprot.readMessageEnd()
4117 
    if result.success is not None:
4118 
      return result.success
4119 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchAmazonItems failed: unknown result");
4120 
 
4121 
  def getAmazonSearchResultCount(self, searchTerm):
4122 
    """
4123 
    Parameters:
4124 
     - searchTerm
4125 
    """
4126 
    self.send_getAmazonSearchResultCount(searchTerm)
4127 
    return self.recv_getAmazonSearchResultCount()
4128 
 
4129 
  def send_getAmazonSearchResultCount(self, searchTerm):
4130 
    self._oprot.writeMessageBegin('getAmazonSearchResultCount', TMessageType.CALL, self._seqid)
4131 
    args = getAmazonSearchResultCount_args()
4132 
    args.searchTerm = searchTerm
4133 
    args.write(self._oprot)
4134 
    self._oprot.writeMessageEnd()
4135 
    self._oprot.trans.flush()
4136 
 
4137 
  def recv_getAmazonSearchResultCount(self, ):
4138 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4139 
    if mtype == TMessageType.EXCEPTION:
4140 
      x = TApplicationException()
4141 
      x.read(self._iprot)
4142 
      self._iprot.readMessageEnd()
4143 
      raise x
4144 
    result = getAmazonSearchResultCount_result()
4145 
    result.read(self._iprot)
4146 
    self._iprot.readMessageEnd()
4147 
    if result.success is not None:
4148 
      return result.success
4149 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonSearchResultCount failed: unknown result");
4150 
 
4151 
  def getCountForAmazonlistedItems(self, ):
4152 
    self.send_getCountForAmazonlistedItems()
4153 
    return self.recv_getCountForAmazonlistedItems()
4154 
 
4155 
  def send_getCountForAmazonlistedItems(self, ):
4156 
    self._oprot.writeMessageBegin('getCountForAmazonlistedItems', TMessageType.CALL, self._seqid)
4157 
    args = getCountForAmazonlistedItems_args()
4158 
    args.write(self._oprot)
4159 
    self._oprot.writeMessageEnd()
4160 
    self._oprot.trans.flush()
4161 
 
4162 
  def recv_getCountForAmazonlistedItems(self, ):
4163 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4164 
    if mtype == TMessageType.EXCEPTION:
4165 
      x = TApplicationException()
4166 
      x.read(self._iprot)
4167 
      self._iprot.readMessageEnd()
4168 
      raise x
4169 
    result = getCountForAmazonlistedItems_result()
4170 
    result.read(self._iprot)
4171 
    self._iprot.readMessageEnd()
4172 
    if result.success is not None:
4173 
      return result.success
4174 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForAmazonlistedItems failed: unknown result");
4175 
 
7281 kshitij.so 4176 
  def getAmazonItemDetails(self, itemId):
4177 
    """
4178 
    Parameters:
4179 
     - itemId
4180 
    """
4181 
    self.send_getAmazonItemDetails(itemId)
4182 
    return self.recv_getAmazonItemDetails()
4183 
 
4184 
  def send_getAmazonItemDetails(self, itemId):
4185 
    self._oprot.writeMessageBegin('getAmazonItemDetails', TMessageType.CALL, self._seqid)
4186 
    args = getAmazonItemDetails_args()
4187 
    args.itemId = itemId
4188 
    args.write(self._oprot)
4189 
    self._oprot.writeMessageEnd()
4190 
    self._oprot.trans.flush()
4191 
 
4192 
  def recv_getAmazonItemDetails(self, ):
4193 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4194 
    if mtype == TMessageType.EXCEPTION:
4195 
      x = TApplicationException()
4196 
      x.read(self._iprot)
4197 
      self._iprot.readMessageEnd()
4198 
      raise x
4199 
    result = getAmazonItemDetails_result()
4200 
    result.read(self._iprot)
4201 
    self._iprot.readMessageEnd()
4202 
    if result.success is not None:
4203 
      return result.success
4204 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonItemDetails failed: unknown result");
4205 
 
8168 kshitij.so 4206 
  def updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4207 
    """
4208 
    Parameters:
8168 kshitij.so 4209 
     - amazonlisted
7281 kshitij.so 4210 
    """
8168 kshitij.so 4211 
    self.send_updateAmazonItemDetails(amazonlisted)
7281 kshitij.so 4212 
    self.recv_updateAmazonItemDetails()
4213 
 
8168 kshitij.so 4214 
  def send_updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4215 
    self._oprot.writeMessageBegin('updateAmazonItemDetails', TMessageType.CALL, self._seqid)
4216 
    args = updateAmazonItemDetails_args()
8168 kshitij.so 4217 
    args.amazonlisted = amazonlisted
7281 kshitij.so 4218 
    args.write(self._oprot)
4219 
    self._oprot.writeMessageEnd()
4220 
    self._oprot.trans.flush()
4221 
 
4222 
  def recv_updateAmazonItemDetails(self, ):
4223 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4224 
    if mtype == TMessageType.EXCEPTION:
4225 
      x = TApplicationException()
4226 
      x.read(self._iprot)
4227 
      self._iprot.readMessageEnd()
4228 
      raise x
4229 
    result = updateAmazonItemDetails_result()
4230 
    result.read(self._iprot)
4231 
    self._iprot.readMessageEnd()
4232 
    return
4233 
 
4234 
  def addAmazonItem(self, amazonlisted):
4235 
    """
4236 
    Parameters:
4237 
     - amazonlisted
4238 
    """
4239 
    self.send_addAmazonItem(amazonlisted)
4240 
    self.recv_addAmazonItem()
4241 
 
4242 
  def send_addAmazonItem(self, amazonlisted):
4243 
    self._oprot.writeMessageBegin('addAmazonItem', TMessageType.CALL, self._seqid)
4244 
    args = addAmazonItem_args()
4245 
    args.amazonlisted = amazonlisted
4246 
    args.write(self._oprot)
4247 
    self._oprot.writeMessageEnd()
4248 
    self._oprot.trans.flush()
4249 
 
4250 
  def recv_addAmazonItem(self, ):
4251 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4252 
    if mtype == TMessageType.EXCEPTION:
4253 
      x = TApplicationException()
4254 
      x.read(self._iprot)
4255 
      self._iprot.readMessageEnd()
4256 
      raise x
4257 
    result = addAmazonItem_result()
4258 
    result.read(self._iprot)
4259 
    self._iprot.readMessageEnd()
4260 
    return
4261 
 
7291 vikram.rag 4262 
  def getAsinItems(self, ):
4263 
    self.send_getAsinItems()
4264 
    return self.recv_getAsinItems()
7281 kshitij.so 4265 
 
7291 vikram.rag 4266 
  def send_getAsinItems(self, ):
4267 
    self._oprot.writeMessageBegin('getAsinItems', TMessageType.CALL, self._seqid)
4268 
    args = getAsinItems_args()
4269 
    args.write(self._oprot)
4270 
    self._oprot.writeMessageEnd()
4271 
    self._oprot.trans.flush()
4272 
 
4273 
  def recv_getAsinItems(self, ):
4274 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4275 
    if mtype == TMessageType.EXCEPTION:
4276 
      x = TApplicationException()
4277 
      x.read(self._iprot)
4278 
      self._iprot.readMessageEnd()
4279 
      raise x
4280 
    result = getAsinItems_result()
4281 
    result.read(self._iprot)
4282 
    self._iprot.readMessageEnd()
4283 
    if result.success is not None:
4284 
      return result.success
4285 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAsinItems failed: unknown result");
4286 
 
4287 
  def getAllFbaListedItems(self, ):
4288 
    self.send_getAllFbaListedItems()
4289 
    return self.recv_getAllFbaListedItems()
4290 
 
4291 
  def send_getAllFbaListedItems(self, ):
4292 
    self._oprot.writeMessageBegin('getAllFbaListedItems', TMessageType.CALL, self._seqid)
4293 
    args = getAllFbaListedItems_args()
4294 
    args.write(self._oprot)
4295 
    self._oprot.writeMessageEnd()
4296 
    self._oprot.trans.flush()
4297 
 
4298 
  def recv_getAllFbaListedItems(self, ):
4299 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4300 
    if mtype == TMessageType.EXCEPTION:
4301 
      x = TApplicationException()
4302 
      x.read(self._iprot)
4303 
      self._iprot.readMessageEnd()
4304 
      raise x
4305 
    result = getAllFbaListedItems_result()
4306 
    result.read(self._iprot)
4307 
    self._iprot.readMessageEnd()
4308 
    if result.success is not None:
4309 
      return result.success
4310 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbaListedItems failed: unknown result");
4311 
 
4312 
  def getAllNonFbaListedItems(self, ):
4313 
    self.send_getAllNonFbaListedItems()
4314 
    return self.recv_getAllNonFbaListedItems()
4315 
 
4316 
  def send_getAllNonFbaListedItems(self, ):
4317 
    self._oprot.writeMessageBegin('getAllNonFbaListedItems', TMessageType.CALL, self._seqid)
4318 
    args = getAllNonFbaListedItems_args()
4319 
    args.write(self._oprot)
4320 
    self._oprot.writeMessageEnd()
4321 
    self._oprot.trans.flush()
4322 
 
4323 
  def recv_getAllNonFbaListedItems(self, ):
4324 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4325 
    if mtype == TMessageType.EXCEPTION:
4326 
      x = TApplicationException()
4327 
      x.read(self._iprot)
4328 
      self._iprot.readMessageEnd()
4329 
      raise x
4330 
    result = getAllNonFbaListedItems_result()
4331 
    result.read(self._iprot)
4332 
    self._iprot.readMessageEnd()
4333 
    if result.success is not None:
4334 
      return result.success
4335 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllNonFbaListedItems failed: unknown result");
4336 
 
7460 kshitij.so 4337 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
4338 
    """
4339 
    Parameters:
4340 
     - itemId
4341 
     - holdInventory
4342 
     - defaultInventory
4343 
    """
4344 
    self.send_updateItemInventory(itemId, holdInventory, defaultInventory)
4345 
    return self.recv_updateItemInventory()
7291 vikram.rag 4346 
 
7460 kshitij.so 4347 
  def send_updateItemInventory(self, itemId, holdInventory, defaultInventory):
4348 
    self._oprot.writeMessageBegin('updateItemInventory', TMessageType.CALL, self._seqid)
4349 
    args = updateItemInventory_args()
4350 
    args.itemId = itemId
4351 
    args.holdInventory = holdInventory
4352 
    args.defaultInventory = defaultInventory
4353 
    args.write(self._oprot)
4354 
    self._oprot.writeMessageEnd()
4355 
    self._oprot.trans.flush()
4356 
 
4357 
  def recv_updateItemInventory(self, ):
4358 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4359 
    if mtype == TMessageType.EXCEPTION:
4360 
      x = TApplicationException()
4361 
      x.read(self._iprot)
4362 
      self._iprot.readMessageEnd()
4363 
      raise x
4364 
    result = updateItemInventory_result()
4365 
    result.read(self._iprot)
4366 
    self._iprot.readMessageEnd()
4367 
    if result.success is not None:
4368 
      return result.success
4369 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItemInventory failed: unknown result");
4370 
 
7770 kshitij.so 4371 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4372 
    """
4373 
    Parameters:
4374 
     - type
4375 
     - sku
4376 
     - timestamp
4377 
    """
4378 
    self.send_updateTimestampForAmazonFeeds(type, sku, timestamp)
4379 
    return self.recv_updateTimestampForAmazonFeeds()
7460 kshitij.so 4380 
 
7770 kshitij.so 4381 
  def send_updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4382 
    self._oprot.writeMessageBegin('updateTimestampForAmazonFeeds', TMessageType.CALL, self._seqid)
4383 
    args = updateTimestampForAmazonFeeds_args()
4384 
    args.type = type
4385 
    args.sku = sku
4386 
    args.timestamp = timestamp
4387 
    args.write(self._oprot)
4388 
    self._oprot.writeMessageEnd()
4389 
    self._oprot.trans.flush()
4390 
 
4391 
  def recv_updateTimestampForAmazonFeeds(self, ):
4392 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4393 
    if mtype == TMessageType.EXCEPTION:
4394 
      x = TApplicationException()
4395 
      x.read(self._iprot)
4396 
      self._iprot.readMessageEnd()
4397 
      raise x
4398 
    result = updateTimestampForAmazonFeeds_result()
4399 
    result.read(self._iprot)
4400 
    self._iprot.readMessageEnd()
4401 
    if result.success is not None:
4402 
      return result.success
4403 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateTimestampForAmazonFeeds failed: unknown result");
4404 
 
7897 amar.kumar 4405 
  def getAllParentCategories(self, ):
4406 
    self.send_getAllParentCategories()
4407 
    return self.recv_getAllParentCategories()
7770 kshitij.so 4408 
 
7897 amar.kumar 4409 
  def send_getAllParentCategories(self, ):
4410 
    self._oprot.writeMessageBegin('getAllParentCategories', TMessageType.CALL, self._seqid)
4411 
    args = getAllParentCategories_args()
4412 
    args.write(self._oprot)
4413 
    self._oprot.writeMessageEnd()
4414 
    self._oprot.trans.flush()
4415 
 
4416 
  def recv_getAllParentCategories(self, ):
4417 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4418 
    if mtype == TMessageType.EXCEPTION:
4419 
      x = TApplicationException()
4420 
      x.read(self._iprot)
4421 
      self._iprot.readMessageEnd()
4422 
      raise x
4423 
    result = getAllParentCategories_result()
4424 
    result.read(self._iprot)
4425 
    self._iprot.readMessageEnd()
4426 
    if result.success is not None:
4427 
      return result.success
4428 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllParentCategories failed: unknown result");
4429 
 
7977 kshitij.so 4430 
  def addPageViewEvent(self, pageViewEvents):
4431 
    """
4432 
    Parameters:
4433 
     - pageViewEvents
4434 
    """
4435 
    self.send_addPageViewEvent(pageViewEvents)
4436 
    self.recv_addPageViewEvent()
7897 amar.kumar 4437 
 
7977 kshitij.so 4438 
  def send_addPageViewEvent(self, pageViewEvents):
4439 
    self._oprot.writeMessageBegin('addPageViewEvent', TMessageType.CALL, self._seqid)
4440 
    args = addPageViewEvent_args()
4441 
    args.pageViewEvents = pageViewEvents
4442 
    args.write(self._oprot)
4443 
    self._oprot.writeMessageEnd()
4444 
    self._oprot.trans.flush()
4445 
 
4446 
  def recv_addPageViewEvent(self, ):
4447 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4448 
    if mtype == TMessageType.EXCEPTION:
4449 
      x = TApplicationException()
4450 
      x.read(self._iprot)
4451 
      self._iprot.readMessageEnd()
4452 
      raise x
4453 
    result = addPageViewEvent_result()
4454 
    result.read(self._iprot)
4455 
    self._iprot.readMessageEnd()
4456 
    return
4457 
 
4458 
  def addCartEvent(self, cartEvents):
4459 
    """
4460 
    Parameters:
4461 
     - cartEvents
4462 
    """
4463 
    self.send_addCartEvent(cartEvents)
4464 
    self.recv_addCartEvent()
4465 
 
4466 
  def send_addCartEvent(self, cartEvents):
4467 
    self._oprot.writeMessageBegin('addCartEvent', TMessageType.CALL, self._seqid)
4468 
    args = addCartEvent_args()
4469 
    args.cartEvents = cartEvents
4470 
    args.write(self._oprot)
4471 
    self._oprot.writeMessageEnd()
4472 
    self._oprot.trans.flush()
4473 
 
4474 
  def recv_addCartEvent(self, ):
4475 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4476 
    if mtype == TMessageType.EXCEPTION:
4477 
      x = TApplicationException()
4478 
      x.read(self._iprot)
4479 
      self._iprot.readMessageEnd()
4480 
      raise x
4481 
    result = addCartEvent_result()
4482 
    result.read(self._iprot)
4483 
    self._iprot.readMessageEnd()
4484 
    return
4485 
 
8182 amar.kumar 4486 
  def addEbayItem(self, ebayItem):
4487 
    """
4488 
    Parameters:
4489 
     - ebayItem
4490 
    """
4491 
    self.send_addEbayItem(ebayItem)
4492 
    self.recv_addEbayItem()
4493 
 
4494 
  def send_addEbayItem(self, ebayItem):
4495 
    self._oprot.writeMessageBegin('addEbayItem', TMessageType.CALL, self._seqid)
4496 
    args = addEbayItem_args()
4497 
    args.ebayItem = ebayItem
4498 
    args.write(self._oprot)
4499 
    self._oprot.writeMessageEnd()
4500 
    self._oprot.trans.flush()
4501 
 
4502 
  def recv_addEbayItem(self, ):
4503 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4504 
    if mtype == TMessageType.EXCEPTION:
4505 
      x = TApplicationException()
4506 
      x.read(self._iprot)
4507 
      self._iprot.readMessageEnd()
4508 
      raise x
4509 
    result = addEbayItem_result()
4510 
    result.read(self._iprot)
4511 
    self._iprot.readMessageEnd()
4512 
    return
4513 
 
4514 
  def getEbayItem(self, listingId):
4515 
    """
4516 
    Parameters:
4517 
     - listingId
4518 
    """
4519 
    self.send_getEbayItem(listingId)
4520 
    return self.recv_getEbayItem()
4521 
 
4522 
  def send_getEbayItem(self, listingId):
4523 
    self._oprot.writeMessageBegin('getEbayItem', TMessageType.CALL, self._seqid)
4524 
    args = getEbayItem_args()
4525 
    args.listingId = listingId
4526 
    args.write(self._oprot)
4527 
    self._oprot.writeMessageEnd()
4528 
    self._oprot.trans.flush()
4529 
 
4530 
  def recv_getEbayItem(self, ):
4531 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4532 
    if mtype == TMessageType.EXCEPTION:
4533 
      x = TApplicationException()
4534 
      x.read(self._iprot)
4535 
      self._iprot.readMessageEnd()
4536 
      raise x
4537 
    result = getEbayItem_result()
4538 
    result.read(self._iprot)
4539 
    self._iprot.readMessageEnd()
4540 
    if result.success is not None:
4541 
      return result.success
4542 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEbayItem failed: unknown result");
4543 
 
4544 
  def updateEbayItem(self, ebayItem):
4545 
    """
4546 
    Parameters:
4547 
     - ebayItem
4548 
    """
4549 
    self.send_updateEbayItem(ebayItem)
4550 
    self.recv_updateEbayItem()
4551 
 
4552 
  def send_updateEbayItem(self, ebayItem):
4553 
    self._oprot.writeMessageBegin('updateEbayItem', TMessageType.CALL, self._seqid)
4554 
    args = updateEbayItem_args()
4555 
    args.ebayItem = ebayItem
4556 
    args.write(self._oprot)
4557 
    self._oprot.writeMessageEnd()
4558 
    self._oprot.trans.flush()
4559 
 
4560 
  def recv_updateEbayItem(self, ):
4561 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4562 
    if mtype == TMessageType.EXCEPTION:
4563 
      x = TApplicationException()
4564 
      x.read(self._iprot)
4565 
      self._iprot.readMessageEnd()
4566 
      raise x
4567 
    result = updateEbayItem_result()
4568 
    result.read(self._iprot)
4569 
    self._iprot.readMessageEnd()
4570 
    return
4571 
 
8139 kshitij.so 4572 
  def getAmazonListedItems(self, offset, limit):
4573 
    """
4574 
    Parameters:
4575 
     - offset
4576 
     - limit
4577 
    """
4578 
    self.send_getAmazonListedItems(offset, limit)
4579 
    return self.recv_getAmazonListedItems()
7977 kshitij.so 4580 
 
8139 kshitij.so 4581 
  def send_getAmazonListedItems(self, offset, limit):
4582 
    self._oprot.writeMessageBegin('getAmazonListedItems', TMessageType.CALL, self._seqid)
4583 
    args = getAmazonListedItems_args()
4584 
    args.offset = offset
4585 
    args.limit = limit
4586 
    args.write(self._oprot)
4587 
    self._oprot.writeMessageEnd()
4588 
    self._oprot.trans.flush()
4589 
 
4590 
  def recv_getAmazonListedItems(self, ):
4591 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4592 
    if mtype == TMessageType.EXCEPTION:
4593 
      x = TApplicationException()
4594 
      x.read(self._iprot)
4595 
      self._iprot.readMessageEnd()
4596 
      raise x
4597 
    result = getAmazonListedItems_result()
4598 
    result.read(self._iprot)
4599 
    self._iprot.readMessageEnd()
4600 
    if result.success is not None:
4601 
      return result.success
4602 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonListedItems failed: unknown result");
4603 
 
8168 kshitij.so 4604 
  def updateAmazonAttributesInBulk(self, amazonlisted):
4605 
    """
4606 
    Parameters:
4607 
     - amazonlisted
4608 
    """
4609 
    self.send_updateAmazonAttributesInBulk(amazonlisted)
4610 
    return self.recv_updateAmazonAttributesInBulk()
8139 kshitij.so 4611 
 
8168 kshitij.so 4612 
  def send_updateAmazonAttributesInBulk(self, amazonlisted):
4613 
    self._oprot.writeMessageBegin('updateAmazonAttributesInBulk', TMessageType.CALL, self._seqid)
4614 
    args = updateAmazonAttributesInBulk_args()
4615 
    args.amazonlisted = amazonlisted
4616 
    args.write(self._oprot)
4617 
    self._oprot.writeMessageEnd()
4618 
    self._oprot.trans.flush()
4619 
 
4620 
  def recv_updateAmazonAttributesInBulk(self, ):
4621 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4622 
    if mtype == TMessageType.EXCEPTION:
4623 
      x = TApplicationException()
4624 
      x.read(self._iprot)
4625 
      self._iprot.readMessageEnd()
4626 
      raise x
4627 
    result = updateAmazonAttributesInBulk_result()
4628 
    result.read(self._iprot)
4629 
    self._iprot.readMessageEnd()
4630 
    if result.success is not None:
4631 
      return result.success
4632 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateAmazonAttributesInBulk failed: unknown result");
4633 
 
8379 vikram.rag 4634 
  def getAllItemstoListOnFba(self, ):
4635 
    self.send_getAllItemstoListOnFba()
4636 
    return self.recv_getAllItemstoListOnFba()
8168 kshitij.so 4637 
 
8379 vikram.rag 4638 
  def send_getAllItemstoListOnFba(self, ):
4639 
    self._oprot.writeMessageBegin('getAllItemstoListOnFba', TMessageType.CALL, self._seqid)
4640 
    args = getAllItemstoListOnFba_args()
4641 
    args.write(self._oprot)
4642 
    self._oprot.writeMessageEnd()
4643 
    self._oprot.trans.flush()
4644 
 
4645 
  def recv_getAllItemstoListOnFba(self, ):
4646 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4647 
    if mtype == TMessageType.EXCEPTION:
4648 
      x = TApplicationException()
4649 
      x.read(self._iprot)
4650 
      self._iprot.readMessageEnd()
4651 
      raise x
4652 
    result = getAllItemstoListOnFba_result()
4653 
    result.read(self._iprot)
4654 
    self._iprot.readMessageEnd()
4655 
    if result.success is not None:
4656 
      return result.success
4657 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnFba failed: unknown result");
4658 
 
4659 
  def getAllItemstoListOnNonFba(self, ):
4660 
    self.send_getAllItemstoListOnNonFba()
4661 
    return self.recv_getAllItemstoListOnNonFba()
4662 
 
4663 
  def send_getAllItemstoListOnNonFba(self, ):
4664 
    self._oprot.writeMessageBegin('getAllItemstoListOnNonFba', TMessageType.CALL, self._seqid)
4665 
    args = getAllItemstoListOnNonFba_args()
4666 
    args.write(self._oprot)
4667 
    self._oprot.writeMessageEnd()
4668 
    self._oprot.trans.flush()
4669 
 
4670 
  def recv_getAllItemstoListOnNonFba(self, ):
4671 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4672 
    if mtype == TMessageType.EXCEPTION:
4673 
      x = TApplicationException()
4674 
      x.read(self._iprot)
4675 
      self._iprot.readMessageEnd()
4676 
      raise x
4677 
    result = getAllItemstoListOnNonFba_result()
4678 
    result.read(self._iprot)
4679 
    self._iprot.readMessageEnd()
4680 
    if result.success is not None:
4681 
      return result.success
4682 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnNonFba failed: unknown result");
4683 
 
8619 kshitij.so 4684 
  def updateAsin(self, item):
4685 
    """
4686 
    Parameters:
4687 
     - item
4688 
    """
4689 
    self.send_updateAsin(item)
4690 
    self.recv_updateAsin()
8616 vikram.rag 4691 
 
8619 kshitij.so 4692 
  def send_updateAsin(self, item):
4693 
    self._oprot.writeMessageBegin('updateAsin', TMessageType.CALL, self._seqid)
4694 
    args = updateAsin_args()
4695 
    args.item = item
4696 
    args.write(self._oprot)
4697 
    self._oprot.writeMessageEnd()
4698 
    self._oprot.trans.flush()
4699 
 
4700 
  def recv_updateAsin(self, ):
4701 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4702 
    if mtype == TMessageType.EXCEPTION:
4703 
      x = TApplicationException()
4704 
      x.read(self._iprot)
4705 
      self._iprot.readMessageEnd()
4706 
      raise x
4707 
    result = updateAsin_result()
4708 
    result.read(self._iprot)
4709 
    self._iprot.readMessageEnd()
4710 
    return
4711 
 
8739 vikram.rag 4712 
  def addOrUpdateSnapdealItem(self, snapdealitem):
4713 
    """
4714 
    Parameters:
4715 
     - snapdealitem
4716 
    """
4717 
    self.send_addOrUpdateSnapdealItem(snapdealitem)
4718 
    return self.recv_addOrUpdateSnapdealItem()
8619 kshitij.so 4719 
 
8739 vikram.rag 4720 
  def send_addOrUpdateSnapdealItem(self, snapdealitem):
4721 
    self._oprot.writeMessageBegin('addOrUpdateSnapdealItem', TMessageType.CALL, self._seqid)
4722 
    args = addOrUpdateSnapdealItem_args()
4723 
    args.snapdealitem = snapdealitem
4724 
    args.write(self._oprot)
4725 
    self._oprot.writeMessageEnd()
4726 
    self._oprot.trans.flush()
4727 
 
4728 
  def recv_addOrUpdateSnapdealItem(self, ):
4729 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4730 
    if mtype == TMessageType.EXCEPTION:
4731 
      x = TApplicationException()
4732 
      x.read(self._iprot)
4733 
      self._iprot.readMessageEnd()
4734 
      raise x
4735 
    result = addOrUpdateSnapdealItem_result()
4736 
    result.read(self._iprot)
4737 
    self._iprot.readMessageEnd()
4738 
    if result.success is not None:
4739 
      return result.success
4740 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addOrUpdateSnapdealItem failed: unknown result");
4741 
 
4742 
  def getSnapdealItem(self, item_id):
4743 
    """
4744 
    Parameters:
4745 
     - item_id
4746 
    """
4747 
    self.send_getSnapdealItem(item_id)
4748 
    return self.recv_getSnapdealItem()
4749 
 
4750 
  def send_getSnapdealItem(self, item_id):
4751 
    self._oprot.writeMessageBegin('getSnapdealItem', TMessageType.CALL, self._seqid)
4752 
    args = getSnapdealItem_args()
4753 
    args.item_id = item_id
4754 
    args.write(self._oprot)
4755 
    self._oprot.writeMessageEnd()
4756 
    self._oprot.trans.flush()
4757 
 
4758 
  def recv_getSnapdealItem(self, ):
4759 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4760 
    if mtype == TMessageType.EXCEPTION:
4761 
      x = TApplicationException()
4762 
      x.read(self._iprot)
4763 
      self._iprot.readMessageEnd()
4764 
      raise x
4765 
    result = getSnapdealItem_result()
4766 
    result.read(self._iprot)
4767 
    self._iprot.readMessageEnd()
4768 
    if result.success is not None:
4769 
      return result.success
4770 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItem failed: unknown result");
4771 
 
9242 kshitij.so 4772 
  def getSnapdealItemDetails(self, item_id):
4773 
    """
4774 
    Parameters:
4775 
     - item_id
4776 
    """
4777 
    self.send_getSnapdealItemDetails(item_id)
4778 
    return self.recv_getSnapdealItemDetails()
4779 
 
4780 
  def send_getSnapdealItemDetails(self, item_id):
4781 
    self._oprot.writeMessageBegin('getSnapdealItemDetails', TMessageType.CALL, self._seqid)
4782 
    args = getSnapdealItemDetails_args()
4783 
    args.item_id = item_id
4784 
    args.write(self._oprot)
4785 
    self._oprot.writeMessageEnd()
4786 
    self._oprot.trans.flush()
4787 
 
4788 
  def recv_getSnapdealItemDetails(self, ):
4789 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4790 
    if mtype == TMessageType.EXCEPTION:
4791 
      x = TApplicationException()
4792 
      x.read(self._iprot)
4793 
      self._iprot.readMessageEnd()
4794 
      raise x
4795 
    result = getSnapdealItemDetails_result()
4796 
    result.read(self._iprot)
4797 
    self._iprot.readMessageEnd()
4798 
    if result.success is not None:
4799 
      return result.success
4800 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItemDetails failed: unknown result");
4801 
 
8739 vikram.rag 4802 
  def getAllSnapdealItems(self, ):
4803 
    self.send_getAllSnapdealItems()
4804 
    return self.recv_getAllSnapdealItems()
4805 
 
4806 
  def send_getAllSnapdealItems(self, ):
4807 
    self._oprot.writeMessageBegin('getAllSnapdealItems', TMessageType.CALL, self._seqid)
4808 
    args = getAllSnapdealItems_args()
4809 
    args.write(self._oprot)
4810 
    self._oprot.writeMessageEnd()
4811 
    self._oprot.trans.flush()
4812 
 
4813 
  def recv_getAllSnapdealItems(self, ):
4814 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4815 
    if mtype == TMessageType.EXCEPTION:
4816 
      x = TApplicationException()
4817 
      x.read(self._iprot)
4818 
      self._iprot.readMessageEnd()
4819 
      raise x
4820 
    result = getAllSnapdealItems_result()
4821 
    result.read(self._iprot)
4822 
    self._iprot.readMessageEnd()
4823 
    if result.success is not None:
4824 
      return result.success
4825 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSnapdealItems failed: unknown result");
4826 
 
9242 kshitij.so 4827 
  def getSnapdealItems(self, offset, limit):
4828 
    """
4829 
    Parameters:
4830 
     - offset
4831 
     - limit
4832 
    """
4833 
    self.send_getSnapdealItems(offset, limit)
4834 
    return self.recv_getSnapdealItems()
8739 vikram.rag 4835 
 
9242 kshitij.so 4836 
  def send_getSnapdealItems(self, offset, limit):
4837 
    self._oprot.writeMessageBegin('getSnapdealItems', TMessageType.CALL, self._seqid)
4838 
    args = getSnapdealItems_args()
4839 
    args.offset = offset
4840 
    args.limit = limit
4841 
    args.write(self._oprot)
4842 
    self._oprot.writeMessageEnd()
4843 
    self._oprot.trans.flush()
4844 
 
4845 
  def recv_getSnapdealItems(self, ):
4846 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4847 
    if mtype == TMessageType.EXCEPTION:
4848 
      x = TApplicationException()
4849 
      x.read(self._iprot)
4850 
      self._iprot.readMessageEnd()
4851 
      raise x
4852 
    result = getSnapdealItems_result()
4853 
    result.read(self._iprot)
4854 
    self._iprot.readMessageEnd()
4855 
    if result.success is not None:
4856 
      return result.success
4857 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItems failed: unknown result");
4858 
 
4859 
  def searchSnapdealItems(self, searchTerm, offset, limit):
4860 
    """
4861 
    Parameters:
4862 
     - searchTerm
4863 
     - offset
4864 
     - limit
4865 
    """
4866 
    self.send_searchSnapdealItems(searchTerm, offset, limit)
4867 
    return self.recv_searchSnapdealItems()
4868 
 
4869 
  def send_searchSnapdealItems(self, searchTerm, offset, limit):
4870 
    self._oprot.writeMessageBegin('searchSnapdealItems', TMessageType.CALL, self._seqid)
4871 
    args = searchSnapdealItems_args()
4872 
    args.searchTerm = searchTerm
4873 
    args.offset = offset
4874 
    args.limit = limit
4875 
    args.write(self._oprot)
4876 
    self._oprot.writeMessageEnd()
4877 
    self._oprot.trans.flush()
4878 
 
4879 
  def recv_searchSnapdealItems(self, ):
4880 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4881 
    if mtype == TMessageType.EXCEPTION:
4882 
      x = TApplicationException()
4883 
      x.read(self._iprot)
4884 
      self._iprot.readMessageEnd()
4885 
      raise x
4886 
    result = searchSnapdealItems_result()
4887 
    result.read(self._iprot)
4888 
    self._iprot.readMessageEnd()
4889 
    if result.success is not None:
4890 
      return result.success
4891 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchSnapdealItems failed: unknown result");
4892 
 
4893 
  def getCountForSnapdealItems(self, ):
4894 
    self.send_getCountForSnapdealItems()
4895 
    return self.recv_getCountForSnapdealItems()
4896 
 
4897 
  def send_getCountForSnapdealItems(self, ):
4898 
    self._oprot.writeMessageBegin('getCountForSnapdealItems', TMessageType.CALL, self._seqid)
4899 
    args = getCountForSnapdealItems_args()
4900 
    args.write(self._oprot)
4901 
    self._oprot.writeMessageEnd()
4902 
    self._oprot.trans.flush()
4903 
 
4904 
  def recv_getCountForSnapdealItems(self, ):
4905 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4906 
    if mtype == TMessageType.EXCEPTION:
4907 
      x = TApplicationException()
4908 
      x.read(self._iprot)
4909 
      self._iprot.readMessageEnd()
4910 
      raise x
4911 
    result = getCountForSnapdealItems_result()
4912 
    result.read(self._iprot)
4913 
    self._iprot.readMessageEnd()
4914 
    if result.success is not None:
4915 
      return result.success
4916 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForSnapdealItems failed: unknown result");
4917 
 
4918 
  def getSnapdealSearchResultCount(self, searchTerm):
4919 
    """
4920 
    Parameters:
4921 
     - searchTerm
4922 
    """
4923 
    self.send_getSnapdealSearchResultCount(searchTerm)
4924 
    return self.recv_getSnapdealSearchResultCount()
4925 
 
4926 
  def send_getSnapdealSearchResultCount(self, searchTerm):
4927 
    self._oprot.writeMessageBegin('getSnapdealSearchResultCount', TMessageType.CALL, self._seqid)
4928 
    args = getSnapdealSearchResultCount_args()
4929 
    args.searchTerm = searchTerm
4930 
    args.write(self._oprot)
4931 
    self._oprot.writeMessageEnd()
4932 
    self._oprot.trans.flush()
4933 
 
4934 
  def recv_getSnapdealSearchResultCount(self, ):
4935 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4936 
    if mtype == TMessageType.EXCEPTION:
4937 
      x = TApplicationException()
4938 
      x.read(self._iprot)
4939 
      self._iprot.readMessageEnd()
4940 
      raise x
4941 
    result = getSnapdealSearchResultCount_result()
4942 
    result.read(self._iprot)
4943 
    self._iprot.readMessageEnd()
4944 
    if result.success is not None:
4945 
      return result.success
4946 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealSearchResultCount failed: unknown result");
4947 
 
4948 
 
5944 mandeep.dh 4949 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
4950 
  def __init__(self, handler):
4951 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
4952 
    self._processMap["addItem"] = Processor.process_addItem
4953 
    self._processMap["updateItem"] = Processor.process_updateItem
4954 
    self._processMap["isActive"] = Processor.process_isActive
7438 amit.gupta 4955 
    self._processMap["getItemsStatus"] = Processor.process_getItemsStatus
5944 mandeep.dh 4956 
    self._processMap["getItemStatusDescription"] = Processor.process_getItemStatusDescription
4957 
    self._processMap["startItemOn"] = Processor.process_startItemOn
4958 
    self._processMap["retireItemOn"] = Processor.process_retireItemOn
4959 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
4960 
    self._processMap["getItem"] = Processor.process_getItem
4961 
    self._processMap["getItemsByCatalogId"] = Processor.process_getItemsByCatalogId
4962 
    self._processMap["getValidItemsByCatalogId"] = Processor.process_getValidItemsByCatalogId
4963 
    self._processMap["getAllItems"] = Processor.process_getAllItems
4964 
    self._processMap["getAllItemsByStatus"] = Processor.process_getAllItemsByStatus
4965 
    self._processMap["markItemAsContentComplete"] = Processor.process_markItemAsContentComplete
4966 
    self._processMap["getAllItemsInRange"] = Processor.process_getAllItemsInRange
4967 
    self._processMap["getAllItemsByStatusInRange"] = Processor.process_getAllItemsByStatusInRange
4968 
    self._processMap["getItemCountByStatus"] = Processor.process_getItemCountByStatus
4969 
    self._processMap["getBestSellers"] = Processor.process_getBestSellers
4970 
    self._processMap["getBestSellersCatalogIds"] = Processor.process_getBestSellersCatalogIds
4971 
    self._processMap["getBestSellersCount"] = Processor.process_getBestSellersCount
4972 
    self._processMap["getBestDeals"] = Processor.process_getBestDeals
4973 
    self._processMap["getBestDealsCatalogIds"] = Processor.process_getBestDealsCatalogIds
4974 
    self._processMap["getBestDealsCount"] = Processor.process_getBestDealsCount
4975 
    self._processMap["getComingSoon"] = Processor.process_getComingSoon
4976 
    self._processMap["getComingSoonCatalogIds"] = Processor.process_getComingSoonCatalogIds
4977 
    self._processMap["getComingSoonCount"] = Processor.process_getComingSoonCount
4978 
    self._processMap["getLatestArrivals"] = Processor.process_getLatestArrivals
4979 
    self._processMap["getLatestArrivalsCatalogIds"] = Processor.process_getLatestArrivalsCatalogIds
4980 
    self._processMap["getLatestArrivalsCount"] = Processor.process_getLatestArrivalsCount
4981 
    self._processMap["generateNewEntityID"] = Processor.process_generateNewEntityID
4982 
    self._processMap["addCategory"] = Processor.process_addCategory
4983 
    self._processMap["getCategory"] = Processor.process_getCategory
4984 
    self._processMap["getAllCategories"] = Processor.process_getAllCategories
4985 
    self._processMap["getAllSimilarItems"] = Processor.process_getAllSimilarItems
4986 
    self._processMap["addSimilarItem"] = Processor.process_addSimilarItem
6512 kshitij.so 4987 
    self._processMap["addTag"] = Processor.process_addTag
4988 
    self._processMap["deleteEntityTag"] = Processor.process_deleteEntityTag
4989 
    self._processMap["deleteTag"] = Processor.process_deleteTag
4990 
    self._processMap["getAllTags"] = Processor.process_getAllTags
4991 
    self._processMap["getAllEntitiesByTagName"] = Processor.process_getAllEntitiesByTagName
6845 amit.gupta 4992 
    self._processMap["getAllEntityTags"] = Processor.process_getAllEntityTags
6850 kshitij.so 4993 
    self._processMap["addBanner"] = Processor.process_addBanner
8579 kshitij.so 4994 
    self._processMap["updateBanner"] = Processor.process_updateBanner
6850 kshitij.so 4995 
    self._processMap["getAllBanners"] = Processor.process_getAllBanners
4996 
    self._processMap["deleteBanner"] = Processor.process_deleteBanner
4997 
    self._processMap["getBannerDetails"] = Processor.process_getBannerDetails
4998 
    self._processMap["getActiveBanners"] = Processor.process_getActiveBanners
6849 kshitij.so 4999 
    self._processMap["addBannerMap"] = Processor.process_addBannerMap
8579 kshitij.so 5000 
    self._processMap["updateBannerMap"] = Processor.process_updateBannerMap
6849 kshitij.so 5001 
    self._processMap["deleteBannerMap"] = Processor.process_deleteBannerMap
5002 
    self._processMap["getBannerMapDetails"] = Processor.process_getBannerMapDetails
8579 kshitij.so 5003 
    self._processMap["addBannerUri"] = Processor.process_addBannerUri
5004 
    self._processMap["getUriMapping"] = Processor.process_getUriMapping
5005 
    self._processMap["addCampaign"] = Processor.process_addCampaign
5006 
    self._processMap["getCampaigns"] = Processor.process_getCampaigns
5007 
    self._processMap["deleteCampaign"] = Processor.process_deleteCampaign
5008 
    self._processMap["getAllCampaigns"] = Processor.process_getAllCampaigns
9155 kshitij.so 5009 
    self._processMap["getActiveBannersForMobileSite"] = Processor.process_getActiveBannersForMobileSite
5944 mandeep.dh 5010 
    self._processMap["deleteSimilarItem"] = Processor.process_deleteSimilarItem
5011 
    self._processMap["checkSimilarItem"] = Processor.process_checkSimilarItem
5012 
    self._processMap["validateRiskyStatus"] = Processor.process_validateRiskyStatus
5013 
    self._processMap["changeItemRiskyFlag"] = Processor.process_changeItemRiskyFlag
5014 
    self._processMap["getItemsByRiskyFlag"] = Processor.process_getItemsByRiskyFlag
5015 
    self._processMap["getItemsForMasterSheet"] = Processor.process_getItemsForMasterSheet
5016 
    self._processMap["getSimilarItemsCatalogIds"] = Processor.process_getSimilarItemsCatalogIds
5017 
    self._processMap["addProductNotification"] = Processor.process_addProductNotification
5018 
    self._processMap["sendProductNotifications"] = Processor.process_sendProductNotifications
5019 
    self._processMap["getAllBrandsByCategory"] = Processor.process_getAllBrandsByCategory
5020 
    self._processMap["getAllBrands"] = Processor.process_getAllBrands
5021 
    self._processMap["getAllSources"] = Processor.process_getAllSources
5022 
    self._processMap["getItemPricingBySource"] = Processor.process_getItemPricingBySource
5023 
    self._processMap["addSourceItemPricing"] = Processor.process_addSourceItemPricing
5024 
    self._processMap["getAllSourcePricing"] = Processor.process_getAllSourcePricing
5025 
    self._processMap["getItemForSource"] = Processor.process_getItemForSource
5026 
    self._processMap["searchItemsInRange"] = Processor.process_searchItemsInRange
5027 
    self._processMap["getSearchResultCount"] = Processor.process_getSearchResultCount
5028 
    self._processMap["getProductNotifications"] = Processor.process_getProductNotifications
5029 
    self._processMap["getProductNotificationRequestCount"] = Processor.process_getProductNotificationRequestCount
5030 
    self._processMap["addAuthorizationLog"] = Processor.process_addAuthorizationLog
5031 
    self._processMap["addupdateVoucherForItem"] = Processor.process_addupdateVoucherForItem
5032 
    self._processMap["deleteVoucherForItem"] = Processor.process_deleteVoucherForItem
5033 
    self._processMap["getVoucherAmount"] = Processor.process_getVoucherAmount
5034 
    self._processMap["getAllItemVouchers"] = Processor.process_getAllItemVouchers
5035 
    self._processMap["isValidCatalogItemId"] = Processor.process_isValidCatalogItemId
6039 amit.gupta 5036 
    self._processMap["getVatPercentageForItem"] = Processor.process_getVatPercentageForItem
5037 
    self._processMap["getVatAmountForItem"] = Processor.process_getVatAmountForItem
6531 vikram.rag 5038 
    self._processMap["getAllIgnoredInventoryUpdateItemsList"] = Processor.process_getAllIgnoredInventoryUpdateItemsList
6821 amar.kumar 5039 
    self._processMap["getAllAliveItems"] = Processor.process_getAllAliveItems
6805 anupam.sin 5040 
    self._processMap["getInsuranceAmount"] = Processor.process_getInsuranceAmount
5041 
    self._processMap["getInsurer"] = Processor.process_getInsurer
6838 vikram.rag 5042 
    self._processMap["getAllInsurers"] = Processor.process_getAllInsurers
6962 rajveer 5043 
    self._processMap["updateInsuranceDeclaredAmount"] = Processor.process_updateInsuranceDeclaredAmount
7190 amar.kumar 5044 
    self._processMap["getFreebieForItem"] = Processor.process_getFreebieForItem
5045 
    self._processMap["addOrUpdateFreebieForItem"] = Processor.process_addOrUpdateFreebieForItem
7272 amit.gupta 5046 
    self._processMap["addOrUpdateBrandInfo"] = Processor.process_addOrUpdateBrandInfo
5047 
    self._processMap["getBrandInfo"] = Processor.process_getBrandInfo
7256 rajveer 5048 
    self._processMap["getStorePricing"] = Processor.process_getStorePricing
7306 rajveer 5049 
    self._processMap["getStorePricings"] = Processor.process_getStorePricings
7265 rajveer 5050 
    self._processMap["updateStorePricing"] = Processor.process_updateStorePricing
7281 kshitij.so 5051 
    self._processMap["getAllAmazonListedItems"] = Processor.process_getAllAmazonListedItems
8619 kshitij.so 5052 
    self._processMap["searchAmazonItems"] = Processor.process_searchAmazonItems
5053 
    self._processMap["getAmazonSearchResultCount"] = Processor.process_getAmazonSearchResultCount
5054 
    self._processMap["getCountForAmazonlistedItems"] = Processor.process_getCountForAmazonlistedItems
7281 kshitij.so 5055 
    self._processMap["getAmazonItemDetails"] = Processor.process_getAmazonItemDetails
5056 
    self._processMap["updateAmazonItemDetails"] = Processor.process_updateAmazonItemDetails
5057 
    self._processMap["addAmazonItem"] = Processor.process_addAmazonItem
7291 vikram.rag 5058 
    self._processMap["getAsinItems"] = Processor.process_getAsinItems
5059 
    self._processMap["getAllFbaListedItems"] = Processor.process_getAllFbaListedItems
5060 
    self._processMap["getAllNonFbaListedItems"] = Processor.process_getAllNonFbaListedItems
7460 kshitij.so 5061 
    self._processMap["updateItemInventory"] = Processor.process_updateItemInventory
7770 kshitij.so 5062 
    self._processMap["updateTimestampForAmazonFeeds"] = Processor.process_updateTimestampForAmazonFeeds
7897 amar.kumar 5063 
    self._processMap["getAllParentCategories"] = Processor.process_getAllParentCategories
7977 kshitij.so 5064 
    self._processMap["addPageViewEvent"] = Processor.process_addPageViewEvent
5065 
    self._processMap["addCartEvent"] = Processor.process_addCartEvent
8182 amar.kumar 5066 
    self._processMap["addEbayItem"] = Processor.process_addEbayItem
5067 
    self._processMap["getEbayItem"] = Processor.process_getEbayItem
5068 
    self._processMap["updateEbayItem"] = Processor.process_updateEbayItem
8139 kshitij.so 5069 
    self._processMap["getAmazonListedItems"] = Processor.process_getAmazonListedItems
8168 kshitij.so 5070 
    self._processMap["updateAmazonAttributesInBulk"] = Processor.process_updateAmazonAttributesInBulk
8379 vikram.rag 5071 
    self._processMap["getAllItemstoListOnFba"] = Processor.process_getAllItemstoListOnFba
5072 
    self._processMap["getAllItemstoListOnNonFba"] = Processor.process_getAllItemstoListOnNonFba
8619 kshitij.so 5073 
    self._processMap["updateAsin"] = Processor.process_updateAsin
8739 vikram.rag 5074 
    self._processMap["addOrUpdateSnapdealItem"] = Processor.process_addOrUpdateSnapdealItem
5075 
    self._processMap["getSnapdealItem"] = Processor.process_getSnapdealItem
9242 kshitij.so 5076 
    self._processMap["getSnapdealItemDetails"] = Processor.process_getSnapdealItemDetails
8739 vikram.rag 5077 
    self._processMap["getAllSnapdealItems"] = Processor.process_getAllSnapdealItems
9242 kshitij.so 5078 
    self._processMap["getSnapdealItems"] = Processor.process_getSnapdealItems
5079 
    self._processMap["searchSnapdealItems"] = Processor.process_searchSnapdealItems
5080 
    self._processMap["getCountForSnapdealItems"] = Processor.process_getCountForSnapdealItems
5081 
    self._processMap["getSnapdealSearchResultCount"] = Processor.process_getSnapdealSearchResultCount
5944 mandeep.dh 5082 
 
5083 
  def process(self, iprot, oprot):
5084 
    (name, type, seqid) = iprot.readMessageBegin()
5085 
    if name not in self._processMap:
5086 
      iprot.skip(TType.STRUCT)
5087 
      iprot.readMessageEnd()
5088 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
5089 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
5090 
      x.write(oprot)
5091 
      oprot.writeMessageEnd()
5092 
      oprot.trans.flush()
5093 
      return
5094 
    else:
5095 
      self._processMap[name](self, seqid, iprot, oprot)
5096 
    return True
5097 
 
5098 
  def process_addItem(self, seqid, iprot, oprot):
5099 
    args = addItem_args()
5100 
    args.read(iprot)
5101 
    iprot.readMessageEnd()
5102 
    result = addItem_result()
5103 
    try:
5104 
      result.success = self._handler.addItem(args.item)
5105 
    except CatalogServiceException, cex:
5106 
      result.cex = cex
5107 
    oprot.writeMessageBegin("addItem", TMessageType.REPLY, seqid)
5108 
    result.write(oprot)
5109 
    oprot.writeMessageEnd()
5110 
    oprot.trans.flush()
5111 
 
5112 
  def process_updateItem(self, seqid, iprot, oprot):
5113 
    args = updateItem_args()
5114 
    args.read(iprot)
5115 
    iprot.readMessageEnd()
5116 
    result = updateItem_result()
5117 
    try:
5118 
      result.success = self._handler.updateItem(args.item)
5119 
    except CatalogServiceException, cex:
5120 
      result.cex = cex
5121 
    oprot.writeMessageBegin("updateItem", TMessageType.REPLY, seqid)
5122 
    result.write(oprot)
5123 
    oprot.writeMessageEnd()
5124 
    oprot.trans.flush()
5125 
 
5126 
  def process_isActive(self, seqid, iprot, oprot):
5127 
    args = isActive_args()
5128 
    args.read(iprot)
5129 
    iprot.readMessageEnd()
5130 
    result = isActive_result()
5131 
    try:
5132 
      result.success = self._handler.isActive(args.itemId)
5133 
    except CatalogServiceException, isex:
5134 
      result.isex = isex
5135 
    oprot.writeMessageBegin("isActive", TMessageType.REPLY, seqid)
5136 
    result.write(oprot)
5137 
    oprot.writeMessageEnd()
5138 
    oprot.trans.flush()
5139 
 
7438 amit.gupta 5140 
  def process_getItemsStatus(self, seqid, iprot, oprot):
5141 
    args = getItemsStatus_args()
5142 
    args.read(iprot)
5143 
    iprot.readMessageEnd()
5144 
    result = getItemsStatus_result()
5145 
    try:
5146 
      result.success = self._handler.getItemsStatus(args.itemIds)
5147 
    except CatalogServiceException, isex:
5148 
      result.isex = isex
5149 
    oprot.writeMessageBegin("getItemsStatus", TMessageType.REPLY, seqid)
5150 
    result.write(oprot)
5151 
    oprot.writeMessageEnd()
5152 
    oprot.trans.flush()
5153 
 
5944 mandeep.dh 5154 
  def process_getItemStatusDescription(self, seqid, iprot, oprot):
5155 
    args = getItemStatusDescription_args()
5156 
    args.read(iprot)
5157 
    iprot.readMessageEnd()
5158 
    result = getItemStatusDescription_result()
5159 
    try:
5160 
      result.success = self._handler.getItemStatusDescription(args.itemId)
5161 
    except CatalogServiceException, isex:
5162 
      result.isex = isex
5163 
    oprot.writeMessageBegin("getItemStatusDescription", TMessageType.REPLY, seqid)
5164 
    result.write(oprot)
5165 
    oprot.writeMessageEnd()
5166 
    oprot.trans.flush()
5167 
 
5168 
  def process_startItemOn(self, seqid, iprot, oprot):
5169 
    args = startItemOn_args()
5170 
    args.read(iprot)
5171 
    iprot.readMessageEnd()
5172 
    result = startItemOn_result()
5173 
    try:
5174 
      self._handler.startItemOn(args.item_id, args.timestamp)
5175 
    except CatalogServiceException, cex:
5176 
      result.cex = cex
5177 
    oprot.writeMessageBegin("startItemOn", TMessageType.REPLY, seqid)
5178 
    result.write(oprot)
5179 
    oprot.writeMessageEnd()
5180 
    oprot.trans.flush()
5181 
 
5182 
  def process_retireItemOn(self, seqid, iprot, oprot):
5183 
    args = retireItemOn_args()
5184 
    args.read(iprot)
5185 
    iprot.readMessageEnd()
5186 
    result = retireItemOn_result()
5187 
    try:
5188 
      self._handler.retireItemOn(args.item_id, args.timestamp)
5189 
    except CatalogServiceException, cex:
5190 
      result.cex = cex
5191 
    oprot.writeMessageBegin("retireItemOn", TMessageType.REPLY, seqid)
5192 
    result.write(oprot)
5193 
    oprot.writeMessageEnd()
5194 
    oprot.trans.flush()
5195 
 
5196 
  def process_changeItemStatus(self, seqid, iprot, oprot):
5197 
    args = changeItemStatus_args()
5198 
    args.read(iprot)
5199 
    iprot.readMessageEnd()
5200 
    result = changeItemStatus_result()
5201 
    try:
5202 
      self._handler.changeItemStatus(args.item_id, args.timestamp, args.newstatus)
5203 
    except CatalogServiceException, cex:
5204 
      result.cex = cex
5205 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
5206 
    result.write(oprot)
5207 
    oprot.writeMessageEnd()
5208 
    oprot.trans.flush()
5209 
 
5210 
  def process_getItem(self, seqid, iprot, oprot):
5211 
    args = getItem_args()
5212 
    args.read(iprot)
5213 
    iprot.readMessageEnd()
5214 
    result = getItem_result()
5215 
    try:
5216 
      result.success = self._handler.getItem(args.item_id)
5217 
    except CatalogServiceException, cex:
5218 
      result.cex = cex
5219 
    oprot.writeMessageBegin("getItem", TMessageType.REPLY, seqid)
5220 
    result.write(oprot)
5221 
    oprot.writeMessageEnd()
5222 
    oprot.trans.flush()
5223 
 
5224 
  def process_getItemsByCatalogId(self, seqid, iprot, oprot):
5225 
    args = getItemsByCatalogId_args()
5226 
    args.read(iprot)
5227 
    iprot.readMessageEnd()
5228 
    result = getItemsByCatalogId_result()
5229 
    try:
5230 
      result.success = self._handler.getItemsByCatalogId(args.catalog_item_id)
5231 
    except CatalogServiceException, cex:
5232 
      result.cex = cex
5233 
    oprot.writeMessageBegin("getItemsByCatalogId", TMessageType.REPLY, seqid)
5234 
    result.write(oprot)
5235 
    oprot.writeMessageEnd()
5236 
    oprot.trans.flush()
5237 
 
5238 
  def process_getValidItemsByCatalogId(self, seqid, iprot, oprot):
5239 
    args = getValidItemsByCatalogId_args()
5240 
    args.read(iprot)
5241 
    iprot.readMessageEnd()
5242 
    result = getValidItemsByCatalogId_result()
5243 
    try:
5244 
      result.success = self._handler.getValidItemsByCatalogId(args.catalog_item_id)
5245 
    except CatalogServiceException, cex:
5246 
      result.cex = cex
5247 
    oprot.writeMessageBegin("getValidItemsByCatalogId", TMessageType.REPLY, seqid)
5248 
    result.write(oprot)
5249 
    oprot.writeMessageEnd()
5250 
    oprot.trans.flush()
5251 
 
5252 
  def process_getAllItems(self, seqid, iprot, oprot):
5253 
    args = getAllItems_args()
5254 
    args.read(iprot)
5255 
    iprot.readMessageEnd()
5256 
    result = getAllItems_result()
5257 
    try:
5258 
      result.success = self._handler.getAllItems(args.isActive)
5259 
    except CatalogServiceException, cex:
5260 
      result.cex = cex
5261 
    oprot.writeMessageBegin("getAllItems", TMessageType.REPLY, seqid)
5262 
    result.write(oprot)
5263 
    oprot.writeMessageEnd()
5264 
    oprot.trans.flush()
5265 
 
5266 
  def process_getAllItemsByStatus(self, seqid, iprot, oprot):
5267 
    args = getAllItemsByStatus_args()
5268 
    args.read(iprot)
5269 
    iprot.readMessageEnd()
5270 
    result = getAllItemsByStatus_result()
5271 
    try:
5272 
      result.success = self._handler.getAllItemsByStatus(args.itemStatus)
5273 
    except CatalogServiceException, cex:
5274 
      result.cex = cex
5275 
    oprot.writeMessageBegin("getAllItemsByStatus", TMessageType.REPLY, seqid)
5276 
    result.write(oprot)
5277 
    oprot.writeMessageEnd()
5278 
    oprot.trans.flush()
5279 
 
5280 
  def process_markItemAsContentComplete(self, seqid, iprot, oprot):
5281 
    args = markItemAsContentComplete_args()
5282 
    args.read(iprot)
5283 
    iprot.readMessageEnd()
5284 
    result = markItemAsContentComplete_result()
5285 
    try:
5286 
      result.success = self._handler.markItemAsContentComplete(args.entityId, args.category, args.brand, args.modelName, args.modelNumber)
5287 
    except CatalogServiceException, cex:
5288 
      result.cex = cex
5289 
    oprot.writeMessageBegin("markItemAsContentComplete", TMessageType.REPLY, seqid)
5290 
    result.write(oprot)
5291 
    oprot.writeMessageEnd()
5292 
    oprot.trans.flush()
5293 
 
5294 
  def process_getAllItemsInRange(self, seqid, iprot, oprot):
5295 
    args = getAllItemsInRange_args()
5296 
    args.read(iprot)
5297 
    iprot.readMessageEnd()
5298 
    result = getAllItemsInRange_result()
5299 
    try:
5300 
      result.success = self._handler.getAllItemsInRange(args.offset, args.limit)
5301 
    except CatalogServiceException, cex:
5302 
      result.cex = cex
5303 
    oprot.writeMessageBegin("getAllItemsInRange", TMessageType.REPLY, seqid)
5304 
    result.write(oprot)
5305 
    oprot.writeMessageEnd()
5306 
    oprot.trans.flush()
5307 
 
5308 
  def process_getAllItemsByStatusInRange(self, seqid, iprot, oprot):
5309 
    args = getAllItemsByStatusInRange_args()
5310 
    args.read(iprot)
5311 
    iprot.readMessageEnd()
5312 
    result = getAllItemsByStatusInRange_result()
5313 
    try:
5314 
      result.success = self._handler.getAllItemsByStatusInRange(args.itemStatus, args.offset, args.limit)
5315 
    except CatalogServiceException, cex:
5316 
      result.cex = cex
5317 
    oprot.writeMessageBegin("getAllItemsByStatusInRange", TMessageType.REPLY, seqid)
5318 
    result.write(oprot)
5319 
    oprot.writeMessageEnd()
5320 
    oprot.trans.flush()
5321 
 
5322 
  def process_getItemCountByStatus(self, seqid, iprot, oprot):
5323 
    args = getItemCountByStatus_args()
5324 
    args.read(iprot)
5325 
    iprot.readMessageEnd()
5326 
    result = getItemCountByStatus_result()
5327 
    result.success = self._handler.getItemCountByStatus(args.useStatus, args.itemStatus)
5328 
    oprot.writeMessageBegin("getItemCountByStatus", TMessageType.REPLY, seqid)
5329 
    result.write(oprot)
5330 
    oprot.writeMessageEnd()
5331 
    oprot.trans.flush()
5332 
 
5333 
  def process_getBestSellers(self, seqid, iprot, oprot):
5334 
    args = getBestSellers_args()
5335 
    args.read(iprot)
5336 
    iprot.readMessageEnd()
5337 
    result = getBestSellers_result()
5338 
    try:
5339 
      result.success = self._handler.getBestSellers()
5340 
    except CatalogServiceException, isex:
5341 
      result.isex = isex
5342 
    oprot.writeMessageBegin("getBestSellers", TMessageType.REPLY, seqid)
5343 
    result.write(oprot)
5344 
    oprot.writeMessageEnd()
5345 
    oprot.trans.flush()
5346 
 
5347 
  def process_getBestSellersCatalogIds(self, seqid, iprot, oprot):
5348 
    args = getBestSellersCatalogIds_args()
5349 
    args.read(iprot)
5350 
    iprot.readMessageEnd()
5351 
    result = getBestSellersCatalogIds_result()
5352 
    try:
5353 
      result.success = self._handler.getBestSellersCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
5354 
    except CatalogServiceException, cex:
5355 
      result.cex = cex
5356 
    oprot.writeMessageBegin("getBestSellersCatalogIds", TMessageType.REPLY, seqid)
5357 
    result.write(oprot)
5358 
    oprot.writeMessageEnd()
5359 
    oprot.trans.flush()
5360 
 
5361 
  def process_getBestSellersCount(self, seqid, iprot, oprot):
5362 
    args = getBestSellersCount_args()
5363 
    args.read(iprot)
5364 
    iprot.readMessageEnd()
5365 
    result = getBestSellersCount_result()
5366 
    try:
5367 
      result.success = self._handler.getBestSellersCount()
5368 
    except CatalogServiceException, cex:
5369 
      result.cex = cex
5370 
    oprot.writeMessageBegin("getBestSellersCount", TMessageType.REPLY, seqid)
5371 
    result.write(oprot)
5372 
    oprot.writeMessageEnd()
5373 
    oprot.trans.flush()
5374 
 
5375 
  def process_getBestDeals(self, seqid, iprot, oprot):
5376 
    args = getBestDeals_args()
5377 
    args.read(iprot)
5378 
    iprot.readMessageEnd()
5379 
    result = getBestDeals_result()
5380 
    try:
5381 
      result.success = self._handler.getBestDeals()
5382 
    except CatalogServiceException, isex:
5383 
      result.isex = isex
5384 
    oprot.writeMessageBegin("getBestDeals", TMessageType.REPLY, seqid)
5385 
    result.write(oprot)
5386 
    oprot.writeMessageEnd()
5387 
    oprot.trans.flush()
5388 
 
5389 
  def process_getBestDealsCatalogIds(self, seqid, iprot, oprot):
5390 
    args = getBestDealsCatalogIds_args()
5391 
    args.read(iprot)
5392 
    iprot.readMessageEnd()
5393 
    result = getBestDealsCatalogIds_result()
5394 
    try:
5395 
      result.success = self._handler.getBestDealsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
5396 
    except CatalogServiceException, cex:
5397 
      result.cex = cex
5398 
    oprot.writeMessageBegin("getBestDealsCatalogIds", TMessageType.REPLY, seqid)
5399 
    result.write(oprot)
5400 
    oprot.writeMessageEnd()
5401 
    oprot.trans.flush()
5402 
 
5403 
  def process_getBestDealsCount(self, seqid, iprot, oprot):
5404 
    args = getBestDealsCount_args()
5405 
    args.read(iprot)
5406 
    iprot.readMessageEnd()
5407 
    result = getBestDealsCount_result()
5408 
    try:
5409 
      result.success = self._handler.getBestDealsCount()
5410 
    except CatalogServiceException, cex:
5411 
      result.cex = cex
5412 
    oprot.writeMessageBegin("getBestDealsCount", TMessageType.REPLY, seqid)
5413 
    result.write(oprot)
5414 
    oprot.writeMessageEnd()
5415 
    oprot.trans.flush()
5416 
 
5417 
  def process_getComingSoon(self, seqid, iprot, oprot):
5418 
    args = getComingSoon_args()
5419 
    args.read(iprot)
5420 
    iprot.readMessageEnd()
5421 
    result = getComingSoon_result()
5422 
    try:
5423 
      result.success = self._handler.getComingSoon()
5424 
    except CatalogServiceException, isex:
5425 
      result.isex = isex
5426 
    oprot.writeMessageBegin("getComingSoon", TMessageType.REPLY, seqid)
5427 
    result.write(oprot)
5428 
    oprot.writeMessageEnd()
5429 
    oprot.trans.flush()
5430 
 
5431 
  def process_getComingSoonCatalogIds(self, seqid, iprot, oprot):
5432 
    args = getComingSoonCatalogIds_args()
5433 
    args.read(iprot)
5434 
    iprot.readMessageEnd()
5435 
    result = getComingSoonCatalogIds_result()
5436 
    try:
5437 
      result.success = self._handler.getComingSoonCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
5438 
    except CatalogServiceException, cex:
5439 
      result.cex = cex
5440 
    oprot.writeMessageBegin("getComingSoonCatalogIds", TMessageType.REPLY, seqid)
5441 
    result.write(oprot)
5442 
    oprot.writeMessageEnd()
5443 
    oprot.trans.flush()
5444 
 
5445 
  def process_getComingSoonCount(self, seqid, iprot, oprot):
5446 
    args = getComingSoonCount_args()
5447 
    args.read(iprot)
5448 
    iprot.readMessageEnd()
5449 
    result = getComingSoonCount_result()
5450 
    try:
5451 
      result.success = self._handler.getComingSoonCount()
5452 
    except CatalogServiceException, cex:
5453 
      result.cex = cex
5454 
    oprot.writeMessageBegin("getComingSoonCount", TMessageType.REPLY, seqid)
5455 
    result.write(oprot)
5456 
    oprot.writeMessageEnd()
5457 
    oprot.trans.flush()
5458 
 
5459 
  def process_getLatestArrivals(self, seqid, iprot, oprot):
5460 
    args = getLatestArrivals_args()
5461 
    args.read(iprot)
5462 
    iprot.readMessageEnd()
5463 
    result = getLatestArrivals_result()
5464 
    try:
5465 
      result.success = self._handler.getLatestArrivals()
5466 
    except CatalogServiceException, isex:
5467 
      result.isex = isex
5468 
    oprot.writeMessageBegin("getLatestArrivals", TMessageType.REPLY, seqid)
5469 
    result.write(oprot)
5470 
    oprot.writeMessageEnd()
5471 
    oprot.trans.flush()
5472 
 
5473 
  def process_getLatestArrivalsCatalogIds(self, seqid, iprot, oprot):
5474 
    args = getLatestArrivalsCatalogIds_args()
5475 
    args.read(iprot)
5476 
    iprot.readMessageEnd()
5477 
    result = getLatestArrivalsCatalogIds_result()
5478 
    try:
5479 
      result.success = self._handler.getLatestArrivalsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.categories)
5480 
    except CatalogServiceException, cex:
5481 
      result.cex = cex
5482 
    oprot.writeMessageBegin("getLatestArrivalsCatalogIds", TMessageType.REPLY, seqid)
5483 
    result.write(oprot)
5484 
    oprot.writeMessageEnd()
5485 
    oprot.trans.flush()
5486 
 
5487 
  def process_getLatestArrivalsCount(self, seqid, iprot, oprot):
5488 
    args = getLatestArrivalsCount_args()
5489 
    args.read(iprot)
5490 
    iprot.readMessageEnd()
5491 
    result = getLatestArrivalsCount_result()
5492 
    try:
5493 
      result.success = self._handler.getLatestArrivalsCount()
5494 
    except CatalogServiceException, cex:
5495 
      result.cex = cex
5496 
    oprot.writeMessageBegin("getLatestArrivalsCount", TMessageType.REPLY, seqid)
5497 
    result.write(oprot)
5498 
    oprot.writeMessageEnd()
5499 
    oprot.trans.flush()
5500 
 
5501 
  def process_generateNewEntityID(self, seqid, iprot, oprot):
5502 
    args = generateNewEntityID_args()
5503 
    args.read(iprot)
5504 
    iprot.readMessageEnd()
5505 
    result = generateNewEntityID_result()
5506 
    result.success = self._handler.generateNewEntityID()
5507 
    oprot.writeMessageBegin("generateNewEntityID", TMessageType.REPLY, seqid)
5508 
    result.write(oprot)
5509 
    oprot.writeMessageEnd()
5510 
    oprot.trans.flush()
5511 
 
5512 
  def process_addCategory(self, seqid, iprot, oprot):
5513 
    args = addCategory_args()
5514 
    args.read(iprot)
5515 
    iprot.readMessageEnd()
5516 
    result = addCategory_result()
5517 
    result.success = self._handler.addCategory(args.category)
5518 
    oprot.writeMessageBegin("addCategory", TMessageType.REPLY, seqid)
5519 
    result.write(oprot)
5520 
    oprot.writeMessageEnd()
5521 
    oprot.trans.flush()
5522 
 
5523 
  def process_getCategory(self, seqid, iprot, oprot):
5524 
    args = getCategory_args()
5525 
    args.read(iprot)
5526 
    iprot.readMessageEnd()
5527 
    result = getCategory_result()
5528 
    result.success = self._handler.getCategory(args.id)
5529 
    oprot.writeMessageBegin("getCategory", TMessageType.REPLY, seqid)
5530 
    result.write(oprot)
5531 
    oprot.writeMessageEnd()
5532 
    oprot.trans.flush()
5533 
 
5534 
  def process_getAllCategories(self, seqid, iprot, oprot):
5535 
    args = getAllCategories_args()
5536 
    args.read(iprot)
5537 
    iprot.readMessageEnd()
5538 
    result = getAllCategories_result()
5539 
    result.success = self._handler.getAllCategories()
5540 
    oprot.writeMessageBegin("getAllCategories", TMessageType.REPLY, seqid)
5541 
    result.write(oprot)
5542 
    oprot.writeMessageEnd()
5543 
    oprot.trans.flush()
5544 
 
5545 
  def process_getAllSimilarItems(self, seqid, iprot, oprot):
5546 
    args = getAllSimilarItems_args()
5547 
    args.read(iprot)
5548 
    iprot.readMessageEnd()
5549 
    result = getAllSimilarItems_result()
5550 
    result.success = self._handler.getAllSimilarItems(args.itemId)
5551 
    oprot.writeMessageBegin("getAllSimilarItems", TMessageType.REPLY, seqid)
5552 
    result.write(oprot)
5553 
    oprot.writeMessageEnd()
5554 
    oprot.trans.flush()
5555 
 
5556 
  def process_addSimilarItem(self, seqid, iprot, oprot):
5557 
    args = addSimilarItem_args()
5558 
    args.read(iprot)
5559 
    iprot.readMessageEnd()
5560 
    result = addSimilarItem_result()
5561 
    try:
5562 
      result.success = self._handler.addSimilarItem(args.itemId, args.catalogItemId)
5563 
    except CatalogServiceException, cex:
5564 
      result.cex = cex
5565 
    oprot.writeMessageBegin("addSimilarItem", TMessageType.REPLY, seqid)
5566 
    result.write(oprot)
5567 
    oprot.writeMessageEnd()
5568 
    oprot.trans.flush()
5569 
 
6512 kshitij.so 5570 
  def process_addTag(self, seqid, iprot, oprot):
5571 
    args = addTag_args()
5572 
    args.read(iprot)
5573 
    iprot.readMessageEnd()
5574 
    result = addTag_result()
5575 
    result.success = self._handler.addTag(args.displayName, args.itemId)
5576 
    oprot.writeMessageBegin("addTag", TMessageType.REPLY, seqid)
5577 
    result.write(oprot)
5578 
    oprot.writeMessageEnd()
5579 
    oprot.trans.flush()
5580 
 
5581 
  def process_deleteEntityTag(self, seqid, iprot, oprot):
5582 
    args = deleteEntityTag_args()
5583 
    args.read(iprot)
5584 
    iprot.readMessageEnd()
5585 
    result = deleteEntityTag_result()
5586 
    result.success = self._handler.deleteEntityTag(args.displayName, args.itemId)
5587 
    oprot.writeMessageBegin("deleteEntityTag", TMessageType.REPLY, seqid)
5588 
    result.write(oprot)
5589 
    oprot.writeMessageEnd()
5590 
    oprot.trans.flush()
5591 
 
5592 
  def process_deleteTag(self, seqid, iprot, oprot):
5593 
    args = deleteTag_args()
5594 
    args.read(iprot)
5595 
    iprot.readMessageEnd()
5596 
    result = deleteTag_result()
5597 
    result.success = self._handler.deleteTag(args.displayName)
5598 
    oprot.writeMessageBegin("deleteTag", TMessageType.REPLY, seqid)
5599 
    result.write(oprot)
5600 
    oprot.writeMessageEnd()
5601 
    oprot.trans.flush()
5602 
 
5603 
  def process_getAllTags(self, seqid, iprot, oprot):
5604 
    args = getAllTags_args()
5605 
    args.read(iprot)
5606 
    iprot.readMessageEnd()
5607 
    result = getAllTags_result()
5608 
    result.success = self._handler.getAllTags()
5609 
    oprot.writeMessageBegin("getAllTags", TMessageType.REPLY, seqid)
5610 
    result.write(oprot)
5611 
    oprot.writeMessageEnd()
5612 
    oprot.trans.flush()
5613 
 
5614 
  def process_getAllEntitiesByTagName(self, seqid, iprot, oprot):
5615 
    args = getAllEntitiesByTagName_args()
5616 
    args.read(iprot)
5617 
    iprot.readMessageEnd()
5618 
    result = getAllEntitiesByTagName_result()
5619 
    result.success = self._handler.getAllEntitiesByTagName(args.displayName)
5620 
    oprot.writeMessageBegin("getAllEntitiesByTagName", TMessageType.REPLY, seqid)
5621 
    result.write(oprot)
5622 
    oprot.writeMessageEnd()
5623 
    oprot.trans.flush()
5624 
 
6845 amit.gupta 5625 
  def process_getAllEntityTags(self, seqid, iprot, oprot):
5626 
    args = getAllEntityTags_args()
5627 
    args.read(iprot)
5628 
    iprot.readMessageEnd()
5629 
    result = getAllEntityTags_result()
5630 
    result.success = self._handler.getAllEntityTags()
5631 
    oprot.writeMessageBegin("getAllEntityTags", TMessageType.REPLY, seqid)
5632 
    result.write(oprot)
5633 
    oprot.writeMessageEnd()
5634 
    oprot.trans.flush()
5635 
 
6850 kshitij.so 5636 
  def process_addBanner(self, seqid, iprot, oprot):
5637 
    args = addBanner_args()
5638 
    args.read(iprot)
5639 
    iprot.readMessageEnd()
5640 
    result = addBanner_result()
8590 kshitij.so 5641 
    self._handler.addBanner(args.bannerCongregate)
6850 kshitij.so 5642 
    oprot.writeMessageBegin("addBanner", TMessageType.REPLY, seqid)
5643 
    result.write(oprot)
5644 
    oprot.writeMessageEnd()
5645 
    oprot.trans.flush()
5646 
 
8579 kshitij.so 5647 
  def process_updateBanner(self, seqid, iprot, oprot):
5648 
    args = updateBanner_args()
5649 
    args.read(iprot)
5650 
    iprot.readMessageEnd()
5651 
    result = updateBanner_result()
5652 
    result.success = self._handler.updateBanner(args.banner)
5653 
    oprot.writeMessageBegin("updateBanner", TMessageType.REPLY, seqid)
5654 
    result.write(oprot)
5655 
    oprot.writeMessageEnd()
5656 
    oprot.trans.flush()
5657 
 
6850 kshitij.so 5658 
  def process_getAllBanners(self, seqid, iprot, oprot):
5659 
    args = getAllBanners_args()
5660 
    args.read(iprot)
5661 
    iprot.readMessageEnd()
5662 
    result = getAllBanners_result()
5663 
    result.success = self._handler.getAllBanners()
5664 
    oprot.writeMessageBegin("getAllBanners", TMessageType.REPLY, seqid)
5665 
    result.write(oprot)
5666 
    oprot.writeMessageEnd()
5667 
    oprot.trans.flush()
5668 
 
5669 
  def process_deleteBanner(self, seqid, iprot, oprot):
5670 
    args = deleteBanner_args()
5671 
    args.read(iprot)
5672 
    iprot.readMessageEnd()
5673 
    result = deleteBanner_result()
9155 kshitij.so 5674 
    result.success = self._handler.deleteBanner(args.bannerName, args.bannerType)
6850 kshitij.so 5675 
    oprot.writeMessageBegin("deleteBanner", TMessageType.REPLY, seqid)
5676 
    result.write(oprot)
5677 
    oprot.writeMessageEnd()
5678 
    oprot.trans.flush()
5679 
 
5680 
  def process_getBannerDetails(self, seqid, iprot, oprot):
5681 
    args = getBannerDetails_args()
5682 
    args.read(iprot)
5683 
    iprot.readMessageEnd()
5684 
    result = getBannerDetails_result()
9155 kshitij.so 5685 
    result.success = self._handler.getBannerDetails(args.bannerName, args.bannerType)
6850 kshitij.so 5686 
    oprot.writeMessageBegin("getBannerDetails", TMessageType.REPLY, seqid)
5687 
    result.write(oprot)
5688 
    oprot.writeMessageEnd()
5689 
    oprot.trans.flush()
5690 
 
5691 
  def process_getActiveBanners(self, seqid, iprot, oprot):
5692 
    args = getActiveBanners_args()
5693 
    args.read(iprot)
5694 
    iprot.readMessageEnd()
5695 
    result = getActiveBanners_result()
5696 
    result.success = self._handler.getActiveBanners()
5697 
    oprot.writeMessageBegin("getActiveBanners", TMessageType.REPLY, seqid)
5698 
    result.write(oprot)
5699 
    oprot.writeMessageEnd()
5700 
    oprot.trans.flush()
5701 
 
6849 kshitij.so 5702 
  def process_addBannerMap(self, seqid, iprot, oprot):
5703 
    args = addBannerMap_args()
5704 
    args.read(iprot)
5705 
    iprot.readMessageEnd()
5706 
    result = addBannerMap_result()
8579 kshitij.so 5707 
    result.success = self._handler.addBannerMap(args.bannerMaps)
6849 kshitij.so 5708 
    oprot.writeMessageBegin("addBannerMap", TMessageType.REPLY, seqid)
5709 
    result.write(oprot)
5710 
    oprot.writeMessageEnd()
5711 
    oprot.trans.flush()
5712 
 
8579 kshitij.so 5713 
  def process_updateBannerMap(self, seqid, iprot, oprot):
5714 
    args = updateBannerMap_args()
5715 
    args.read(iprot)
5716 
    iprot.readMessageEnd()
5717 
    result = updateBannerMap_result()
5718 
    result.success = self._handler.updateBannerMap(args.bannerMap)
5719 
    oprot.writeMessageBegin("updateBannerMap", TMessageType.REPLY, seqid)
5720 
    result.write(oprot)
5721 
    oprot.writeMessageEnd()
5722 
    oprot.trans.flush()
5723 
 
6849 kshitij.so 5724 
  def process_deleteBannerMap(self, seqid, iprot, oprot):
5725 
    args = deleteBannerMap_args()
5726 
    args.read(iprot)
5727 
    iprot.readMessageEnd()
5728 
    result = deleteBannerMap_result()
5729 
    result.success = self._handler.deleteBannerMap(args.bannerName)
5730 
    oprot.writeMessageBegin("deleteBannerMap", TMessageType.REPLY, seqid)
5731 
    result.write(oprot)
5732 
    oprot.writeMessageEnd()
5733 
    oprot.trans.flush()
5734 
 
5735 
  def process_getBannerMapDetails(self, seqid, iprot, oprot):
5736 
    args = getBannerMapDetails_args()
5737 
    args.read(iprot)
5738 
    iprot.readMessageEnd()
5739 
    result = getBannerMapDetails_result()
9155 kshitij.so 5740 
    result.success = self._handler.getBannerMapDetails(args.bannerName, args.bannerType)
6849 kshitij.so 5741 
    oprot.writeMessageBegin("getBannerMapDetails", TMessageType.REPLY, seqid)
5742 
    result.write(oprot)
5743 
    oprot.writeMessageEnd()
5744 
    oprot.trans.flush()
5745 
 
8579 kshitij.so 5746 
  def process_addBannerUri(self, seqid, iprot, oprot):
5747 
    args = addBannerUri_args()
5748 
    args.read(iprot)
5749 
    iprot.readMessageEnd()
5750 
    result = addBannerUri_result()
5751 
    self._handler.addBannerUri(args.bannerUriMappings)
5752 
    oprot.writeMessageBegin("addBannerUri", TMessageType.REPLY, seqid)
5753 
    result.write(oprot)
5754 
    oprot.writeMessageEnd()
5755 
    oprot.trans.flush()
5756 
 
5757 
  def process_getUriMapping(self, seqid, iprot, oprot):
5758 
    args = getUriMapping_args()
5759 
    args.read(iprot)
5760 
    iprot.readMessageEnd()
5761 
    result = getUriMapping_result()
9155 kshitij.so 5762 
    result.success = self._handler.getUriMapping(args.bannerName, args.bannerType)
8579 kshitij.so 5763 
    oprot.writeMessageBegin("getUriMapping", TMessageType.REPLY, seqid)
5764 
    result.write(oprot)
5765 
    oprot.writeMessageEnd()
5766 
    oprot.trans.flush()
5767 
 
5768 
  def process_addCampaign(self, seqid, iprot, oprot):
5769 
    args = addCampaign_args()
5770 
    args.read(iprot)
5771 
    iprot.readMessageEnd()
5772 
    result = addCampaign_result()
5773 
    self._handler.addCampaign(args.campaign)
5774 
    oprot.writeMessageBegin("addCampaign", TMessageType.REPLY, seqid)
5775 
    result.write(oprot)
5776 
    oprot.writeMessageEnd()
5777 
    oprot.trans.flush()
5778 
 
5779 
  def process_getCampaigns(self, seqid, iprot, oprot):
5780 
    args = getCampaigns_args()
5781 
    args.read(iprot)
5782 
    iprot.readMessageEnd()
5783 
    result = getCampaigns_result()
5784 
    result.success = self._handler.getCampaigns(args.campaignName)
5785 
    oprot.writeMessageBegin("getCampaigns", TMessageType.REPLY, seqid)
5786 
    result.write(oprot)
5787 
    oprot.writeMessageEnd()
5788 
    oprot.trans.flush()
5789 
 
5790 
  def process_deleteCampaign(self, seqid, iprot, oprot):
5791 
    args = deleteCampaign_args()
5792 
    args.read(iprot)
5793 
    iprot.readMessageEnd()
5794 
    result = deleteCampaign_result()
5795 
    self._handler.deleteCampaign(args.campaignId)
5796 
    oprot.writeMessageBegin("deleteCampaign", TMessageType.REPLY, seqid)
5797 
    result.write(oprot)
5798 
    oprot.writeMessageEnd()
5799 
    oprot.trans.flush()
5800 
 
5801 
  def process_getAllCampaigns(self, seqid, iprot, oprot):
5802 
    args = getAllCampaigns_args()
5803 
    args.read(iprot)
5804 
    iprot.readMessageEnd()
5805 
    result = getAllCampaigns_result()
5806 
    result.success = self._handler.getAllCampaigns()
5807 
    oprot.writeMessageBegin("getAllCampaigns", TMessageType.REPLY, seqid)
5808 
    result.write(oprot)
5809 
    oprot.writeMessageEnd()
5810 
    oprot.trans.flush()
5811 
 
9155 kshitij.so 5812 
  def process_getActiveBannersForMobileSite(self, seqid, iprot, oprot):
5813 
    args = getActiveBannersForMobileSite_args()
5814 
    args.read(iprot)
5815 
    iprot.readMessageEnd()
5816 
    result = getActiveBannersForMobileSite_result()
5817 
    result.success = self._handler.getActiveBannersForMobileSite()
5818 
    oprot.writeMessageBegin("getActiveBannersForMobileSite", TMessageType.REPLY, seqid)
5819 
    result.write(oprot)
5820 
    oprot.writeMessageEnd()
5821 
    oprot.trans.flush()
5822 
 
5944 mandeep.dh 5823 
  def process_deleteSimilarItem(self, seqid, iprot, oprot):
5824 
    args = deleteSimilarItem_args()
5825 
    args.read(iprot)
5826 
    iprot.readMessageEnd()
5827 
    result = deleteSimilarItem_result()
5828 
    try:
5829 
      result.success = self._handler.deleteSimilarItem(args.itemId, args.catalogItemId)
5830 
    except CatalogServiceException, cex:
5831 
      result.cex = cex
5832 
    oprot.writeMessageBegin("deleteSimilarItem", TMessageType.REPLY, seqid)
5833 
    result.write(oprot)
5834 
    oprot.writeMessageEnd()
5835 
    oprot.trans.flush()
5836 
 
5837 
  def process_checkSimilarItem(self, seqid, iprot, oprot):
5838 
    args = checkSimilarItem_args()
5839 
    args.read(iprot)
5840 
    iprot.readMessageEnd()
5841 
    result = checkSimilarItem_result()
5842 
    result.success = self._handler.checkSimilarItem(args.brand, args.modelNumber, args.modelName, args.color)
5843 
    oprot.writeMessageBegin("checkSimilarItem", TMessageType.REPLY, seqid)
5844 
    result.write(oprot)
5845 
    oprot.writeMessageEnd()
5846 
    oprot.trans.flush()
5847 
 
5848 
  def process_validateRiskyStatus(self, seqid, iprot, oprot):
5849 
    args = validateRiskyStatus_args()
5850 
    args.read(iprot)
5851 
    iprot.readMessageEnd()
5852 
    result = validateRiskyStatus_result()
5853 
    self._handler.validateRiskyStatus(args.itemId)
5854 
    oprot.writeMessageBegin("validateRiskyStatus", TMessageType.REPLY, seqid)
5855 
    result.write(oprot)
5856 
    oprot.writeMessageEnd()
5857 
    oprot.trans.flush()
5858 
 
5859 
  def process_changeItemRiskyFlag(self, seqid, iprot, oprot):
5860 
    args = changeItemRiskyFlag_args()
5861 
    args.read(iprot)
5862 
    iprot.readMessageEnd()
5863 
    result = changeItemRiskyFlag_result()
5864 
    self._handler.changeItemRiskyFlag(args.itemId, args.risky)
5865 
    oprot.writeMessageBegin("changeItemRiskyFlag", TMessageType.REPLY, seqid)
5866 
    result.write(oprot)
5867 
    oprot.writeMessageEnd()
5868 
    oprot.trans.flush()
5869 
 
5870 
  def process_getItemsByRiskyFlag(self, seqid, iprot, oprot):
5871 
    args = getItemsByRiskyFlag_args()
5872 
    args.read(iprot)
5873 
    iprot.readMessageEnd()
5874 
    result = getItemsByRiskyFlag_result()
5875 
    result.success = self._handler.getItemsByRiskyFlag()
5876 
    oprot.writeMessageBegin("getItemsByRiskyFlag", TMessageType.REPLY, seqid)
5877 
    result.write(oprot)
5878 
    oprot.writeMessageEnd()
5879 
    oprot.trans.flush()
5880 
 
5881 
  def process_getItemsForMasterSheet(self, seqid, iprot, oprot):
5882 
    args = getItemsForMasterSheet_args()
5883 
    args.read(iprot)
5884 
    iprot.readMessageEnd()
5885 
    result = getItemsForMasterSheet_result()
5886 
    result.success = self._handler.getItemsForMasterSheet(args.category, args.brand)
5887 
    oprot.writeMessageBegin("getItemsForMasterSheet", TMessageType.REPLY, seqid)
5888 
    result.write(oprot)
5889 
    oprot.writeMessageEnd()
5890 
    oprot.trans.flush()
5891 
 
5892 
  def process_getSimilarItemsCatalogIds(self, seqid, iprot, oprot):
5893 
    args = getSimilarItemsCatalogIds_args()
5894 
    args.read(iprot)
5895 
    iprot.readMessageEnd()
5896 
    result = getSimilarItemsCatalogIds_result()
5897 
    result.success = self._handler.getSimilarItemsCatalogIds(args.beginIndex, args.totalItems, args.itemId)
5898 
    oprot.writeMessageBegin("getSimilarItemsCatalogIds", TMessageType.REPLY, seqid)
5899 
    result.write(oprot)
5900 
    oprot.writeMessageEnd()
5901 
    oprot.trans.flush()
5902 
 
5903 
  def process_addProductNotification(self, seqid, iprot, oprot):
5904 
    args = addProductNotification_args()
5905 
    args.read(iprot)
5906 
    iprot.readMessageEnd()
5907 
    result = addProductNotification_result()
5908 
    result.success = self._handler.addProductNotification(args.itemId, args.email)
5909 
    oprot.writeMessageBegin("addProductNotification", TMessageType.REPLY, seqid)
5910 
    result.write(oprot)
5911 
    oprot.writeMessageEnd()
5912 
    oprot.trans.flush()
5913 
 
5914 
  def process_sendProductNotifications(self, seqid, iprot, oprot):
5915 
    args = sendProductNotifications_args()
5916 
    args.read(iprot)
5917 
    iprot.readMessageEnd()
5918 
    result = sendProductNotifications_result()
5919 
    result.success = self._handler.sendProductNotifications()
5920 
    oprot.writeMessageBegin("sendProductNotifications", TMessageType.REPLY, seqid)
5921 
    result.write(oprot)
5922 
    oprot.writeMessageEnd()
5923 
    oprot.trans.flush()
5924 
 
5925 
  def process_getAllBrandsByCategory(self, seqid, iprot, oprot):
5926 
    args = getAllBrandsByCategory_args()
5927 
    args.read(iprot)
5928 
    iprot.readMessageEnd()
5929 
    result = getAllBrandsByCategory_result()
5930 
    result.success = self._handler.getAllBrandsByCategory(args.categoryId)
5931 
    oprot.writeMessageBegin("getAllBrandsByCategory", TMessageType.REPLY, seqid)
5932 
    result.write(oprot)
5933 
    oprot.writeMessageEnd()
5934 
    oprot.trans.flush()
5935 
 
5936 
  def process_getAllBrands(self, seqid, iprot, oprot):
5937 
    args = getAllBrands_args()
5938 
    args.read(iprot)
5939 
    iprot.readMessageEnd()
5940 
    result = getAllBrands_result()
5941 
    result.success = self._handler.getAllBrands()
5942 
    oprot.writeMessageBegin("getAllBrands", TMessageType.REPLY, seqid)
5943 
    result.write(oprot)
5944 
    oprot.writeMessageEnd()
5945 
    oprot.trans.flush()
5946 
 
5947 
  def process_getAllSources(self, seqid, iprot, oprot):
5948 
    args = getAllSources_args()
5949 
    args.read(iprot)
5950 
    iprot.readMessageEnd()
5951 
    result = getAllSources_result()
5952 
    result.success = self._handler.getAllSources()
5953 
    oprot.writeMessageBegin("getAllSources", TMessageType.REPLY, seqid)
5954 
    result.write(oprot)
5955 
    oprot.writeMessageEnd()
5956 
    oprot.trans.flush()
5957 
 
5958 
  def process_getItemPricingBySource(self, seqid, iprot, oprot):
5959 
    args = getItemPricingBySource_args()
5960 
    args.read(iprot)
5961 
    iprot.readMessageEnd()
5962 
    result = getItemPricingBySource_result()
5963 
    try:
5964 
      result.success = self._handler.getItemPricingBySource(args.itemId, args.sourceId)
5965 
    except CatalogServiceException, cex:
5966 
      result.cex = cex
5967 
    oprot.writeMessageBegin("getItemPricingBySource", TMessageType.REPLY, seqid)
5968 
    result.write(oprot)
5969 
    oprot.writeMessageEnd()
5970 
    oprot.trans.flush()
5971 
 
5972 
  def process_addSourceItemPricing(self, seqid, iprot, oprot):
5973 
    args = addSourceItemPricing_args()
5974 
    args.read(iprot)
5975 
    iprot.readMessageEnd()
5976 
    result = addSourceItemPricing_result()
5977 
    try:
5978 
      self._handler.addSourceItemPricing(args.sourceItemPricing)
5979 
    except CatalogServiceException, cex:
5980 
      result.cex = cex
5981 
    oprot.writeMessageBegin("addSourceItemPricing", TMessageType.REPLY, seqid)
5982 
    result.write(oprot)
5983 
    oprot.writeMessageEnd()
5984 
    oprot.trans.flush()
5985 
 
5986 
  def process_getAllSourcePricing(self, seqid, iprot, oprot):
5987 
    args = getAllSourcePricing_args()
5988 
    args.read(iprot)
5989 
    iprot.readMessageEnd()
5990 
    result = getAllSourcePricing_result()
5991 
    try:
5992 
      result.success = self._handler.getAllSourcePricing(args.itemId)
5993 
    except CatalogServiceException, cex:
5994 
      result.cex = cex
5995 
    oprot.writeMessageBegin("getAllSourcePricing", TMessageType.REPLY, seqid)
5996 
    result.write(oprot)
5997 
    oprot.writeMessageEnd()
5998 
    oprot.trans.flush()
5999 
 
6000 
  def process_getItemForSource(self, seqid, iprot, oprot):
6001 
    args = getItemForSource_args()
6002 
    args.read(iprot)
6003 
    iprot.readMessageEnd()
6004 
    result = getItemForSource_result()
6005 
    try:
6006 
      result.success = self._handler.getItemForSource(args.item_id, args.sourceId)
6007 
    except CatalogServiceException, cex:
6008 
      result.cex = cex
6009 
    oprot.writeMessageBegin("getItemForSource", TMessageType.REPLY, seqid)
6010 
    result.write(oprot)
6011 
    oprot.writeMessageEnd()
6012 
    oprot.trans.flush()
6013 
 
6014 
  def process_searchItemsInRange(self, seqid, iprot, oprot):
6015 
    args = searchItemsInRange_args()
6016 
    args.read(iprot)
6017 
    iprot.readMessageEnd()
6018 
    result = searchItemsInRange_result()
6019 
    result.success = self._handler.searchItemsInRange(args.searchTerms, args.offset, args.limit)
6020 
    oprot.writeMessageBegin("searchItemsInRange", TMessageType.REPLY, seqid)
6021 
    result.write(oprot)
6022 
    oprot.writeMessageEnd()
6023 
    oprot.trans.flush()
6024 
 
6025 
  def process_getSearchResultCount(self, seqid, iprot, oprot):
6026 
    args = getSearchResultCount_args()
6027 
    args.read(iprot)
6028 
    iprot.readMessageEnd()
6029 
    result = getSearchResultCount_result()
6030 
    result.success = self._handler.getSearchResultCount(args.searchTerms)
6031 
    oprot.writeMessageBegin("getSearchResultCount", TMessageType.REPLY, seqid)
6032 
    result.write(oprot)
6033 
    oprot.writeMessageEnd()
6034 
    oprot.trans.flush()
6035 
 
6036 
  def process_getProductNotifications(self, seqid, iprot, oprot):
6037 
    args = getProductNotifications_args()
6038 
    args.read(iprot)
6039 
    iprot.readMessageEnd()
6040 
    result = getProductNotifications_result()
6041 
    result.success = self._handler.getProductNotifications(args.startDateTime)
6042 
    oprot.writeMessageBegin("getProductNotifications", TMessageType.REPLY, seqid)
6043 
    result.write(oprot)
6044 
    oprot.writeMessageEnd()
6045 
    oprot.trans.flush()
6046 
 
6047 
  def process_getProductNotificationRequestCount(self, seqid, iprot, oprot):
6048 
    args = getProductNotificationRequestCount_args()
6049 
    args.read(iprot)
6050 
    iprot.readMessageEnd()
6051 
    result = getProductNotificationRequestCount_result()
7897 amar.kumar 6052 
    result.success = self._handler.getProductNotificationRequestCount(args.startDateTime, args.categoryId)
5944 mandeep.dh 6053 
    oprot.writeMessageBegin("getProductNotificationRequestCount", TMessageType.REPLY, seqid)
6054 
    result.write(oprot)
6055 
    oprot.writeMessageEnd()
6056 
    oprot.trans.flush()
6057 
 
6058 
  def process_addAuthorizationLog(self, seqid, iprot, oprot):
6059 
    args = addAuthorizationLog_args()
6060 
    args.read(iprot)
6061 
    iprot.readMessageEnd()
6062 
    result = addAuthorizationLog_result()
6063 
    try:
6064 
      result.success = self._handler.addAuthorizationLog(args.itemId, args.username, args.reason)
6065 
    except CatalogServiceException, cex:
6066 
      result.cex = cex
6067 
    oprot.writeMessageBegin("addAuthorizationLog", TMessageType.REPLY, seqid)
6068 
    result.write(oprot)
6069 
    oprot.writeMessageEnd()
6070 
    oprot.trans.flush()
6071 
 
6072 
  def process_addupdateVoucherForItem(self, seqid, iprot, oprot):
6073 
    args = addupdateVoucherForItem_args()
6074 
    args.read(iprot)
6075 
    iprot.readMessageEnd()
6076 
    result = addupdateVoucherForItem_result()
6077 
    try:
6078 
      result.success = self._handler.addupdateVoucherForItem(args.catalog_item_id, args.voucherType, args.voucherAmount)
6079 
    except CatalogServiceException, cex:
6080 
      result.cex = cex
6081 
    oprot.writeMessageBegin("addupdateVoucherForItem", TMessageType.REPLY, seqid)
6082 
    result.write(oprot)
6083 
    oprot.writeMessageEnd()
6084 
    oprot.trans.flush()
6085 
 
6086 
  def process_deleteVoucherForItem(self, seqid, iprot, oprot):
6087 
    args = deleteVoucherForItem_args()
6088 
    args.read(iprot)
6089 
    iprot.readMessageEnd()
6090 
    result = deleteVoucherForItem_result()
6091 
    try:
6092 
      result.success = self._handler.deleteVoucherForItem(args.catalog_item_id, args.voucherType)
6093 
    except CatalogServiceException, cex:
6094 
      result.cex = cex
6095 
    oprot.writeMessageBegin("deleteVoucherForItem", TMessageType.REPLY, seqid)
6096 
    result.write(oprot)
6097 
    oprot.writeMessageEnd()
6098 
    oprot.trans.flush()
6099 
 
6100 
  def process_getVoucherAmount(self, seqid, iprot, oprot):
6101 
    args = getVoucherAmount_args()
6102 
    args.read(iprot)
6103 
    iprot.readMessageEnd()
6104 
    result = getVoucherAmount_result()
6105 
    result.success = self._handler.getVoucherAmount(args.itemId, args.voucherType)
6106 
    oprot.writeMessageBegin("getVoucherAmount", TMessageType.REPLY, seqid)
6107 
    result.write(oprot)
6108 
    oprot.writeMessageEnd()
6109 
    oprot.trans.flush()
6110 
 
6111 
  def process_getAllItemVouchers(self, seqid, iprot, oprot):
6112 
    args = getAllItemVouchers_args()
6113 
    args.read(iprot)
6114 
    iprot.readMessageEnd()
6115 
    result = getAllItemVouchers_result()
6116 
    result.success = self._handler.getAllItemVouchers(args.itemId)
6117 
    oprot.writeMessageBegin("getAllItemVouchers", TMessageType.REPLY, seqid)
6118 
    result.write(oprot)
6119 
    oprot.writeMessageEnd()
6120 
    oprot.trans.flush()
6121 
 
6122 
  def process_isValidCatalogItemId(self, seqid, iprot, oprot):
6123 
    args = isValidCatalogItemId_args()
6124 
    args.read(iprot)
6125 
    iprot.readMessageEnd()
6126 
    result = isValidCatalogItemId_result()
6127 
    result.success = self._handler.isValidCatalogItemId(args.catalog_item_id)
6128 
    oprot.writeMessageBegin("isValidCatalogItemId", TMessageType.REPLY, seqid)
6129 
    result.write(oprot)
6130 
    oprot.writeMessageEnd()
6131 
    oprot.trans.flush()
6132 
 
6039 amit.gupta 6133 
  def process_getVatPercentageForItem(self, seqid, iprot, oprot):
6134 
    args = getVatPercentageForItem_args()
6135 
    args.read(iprot)
6136 
    iprot.readMessageEnd()
6137 
    result = getVatPercentageForItem_result()
7340 amit.gupta 6138 
    try:
6139 
      result.success = self._handler.getVatPercentageForItem(args.itemId, args.stateId, args.price)
6140 
    except CatalogServiceException, cex:
6141 
      result.cex = cex
6039 amit.gupta 6142 
    oprot.writeMessageBegin("getVatPercentageForItem", TMessageType.REPLY, seqid)
6143 
    result.write(oprot)
6144 
    oprot.writeMessageEnd()
6145 
    oprot.trans.flush()
5944 mandeep.dh 6146 
 
6039 amit.gupta 6147 
  def process_getVatAmountForItem(self, seqid, iprot, oprot):
6148 
    args = getVatAmountForItem_args()
6149 
    args.read(iprot)
6150 
    iprot.readMessageEnd()
6151 
    result = getVatAmountForItem_result()
6152 
    result.success = self._handler.getVatAmountForItem(args.itemId, args.price)
6153 
    oprot.writeMessageBegin("getVatAmountForItem", TMessageType.REPLY, seqid)
6154 
    result.write(oprot)
6155 
    oprot.writeMessageEnd()
6156 
    oprot.trans.flush()
6157 
 
6531 vikram.rag 6158 
  def process_getAllIgnoredInventoryUpdateItemsList(self, seqid, iprot, oprot):
6159 
    args = getAllIgnoredInventoryUpdateItemsList_args()
6160 
    args.read(iprot)
6161 
    iprot.readMessageEnd()
6162 
    result = getAllIgnoredInventoryUpdateItemsList_result()
6163 
    result.success = self._handler.getAllIgnoredInventoryUpdateItemsList(args.offset, args.limit)
6164 
    oprot.writeMessageBegin("getAllIgnoredInventoryUpdateItemsList", TMessageType.REPLY, seqid)
6165 
    result.write(oprot)
6166 
    oprot.writeMessageEnd()
6167 
    oprot.trans.flush()
6039 amit.gupta 6168 
 
6821 amar.kumar 6169 
  def process_getAllAliveItems(self, seqid, iprot, oprot):
6170 
    args = getAllAliveItems_args()
6171 
    args.read(iprot)
6172 
    iprot.readMessageEnd()
6173 
    result = getAllAliveItems_result()
6174 
    result.success = self._handler.getAllAliveItems()
6175 
    oprot.writeMessageBegin("getAllAliveItems", TMessageType.REPLY, seqid)
6176 
    result.write(oprot)
6177 
    oprot.writeMessageEnd()
6178 
    oprot.trans.flush()
6179 
 
6805 anupam.sin 6180 
  def process_getInsuranceAmount(self, seqid, iprot, oprot):
6181 
    args = getInsuranceAmount_args()
6182 
    args.read(iprot)
6183 
    iprot.readMessageEnd()
6184 
    result = getInsuranceAmount_result()
6921 anupam.sin 6185 
    result.success = self._handler.getInsuranceAmount(args.itemId, args.price, args.insurerId, args.quantity)
6805 anupam.sin 6186 
    oprot.writeMessageBegin("getInsuranceAmount", TMessageType.REPLY, seqid)
6187 
    result.write(oprot)
6188 
    oprot.writeMessageEnd()
6189 
    oprot.trans.flush()
6531 vikram.rag 6190 
 
6805 anupam.sin 6191 
  def process_getInsurer(self, seqid, iprot, oprot):
6192 
    args = getInsurer_args()
6193 
    args.read(iprot)
6194 
    iprot.readMessageEnd()
6195 
    result = getInsurer_result()
6196 
    result.success = self._handler.getInsurer(args.insurerId)
6197 
    oprot.writeMessageBegin("getInsurer", TMessageType.REPLY, seqid)
6198 
    result.write(oprot)
6199 
    oprot.writeMessageEnd()
6200 
    oprot.trans.flush()
6201 
 
6838 vikram.rag 6202 
  def process_getAllInsurers(self, seqid, iprot, oprot):
6203 
    args = getAllInsurers_args()
6204 
    args.read(iprot)
6205 
    iprot.readMessageEnd()
6206 
    result = getAllInsurers_result()
6207 
    result.success = self._handler.getAllInsurers()
6208 
    oprot.writeMessageBegin("getAllInsurers", TMessageType.REPLY, seqid)
6209 
    result.write(oprot)
6210 
    oprot.writeMessageEnd()
6211 
    oprot.trans.flush()
6805 anupam.sin 6212 
 
6962 rajveer 6213 
  def process_updateInsuranceDeclaredAmount(self, seqid, iprot, oprot):
6214 
    args = updateInsuranceDeclaredAmount_args()
6215 
    args.read(iprot)
6216 
    iprot.readMessageEnd()
6217 
    result = updateInsuranceDeclaredAmount_result()
6218 
    self._handler.updateInsuranceDeclaredAmount(args.insurerId, args.amount)
6219 
    oprot.writeMessageBegin("updateInsuranceDeclaredAmount", TMessageType.REPLY, seqid)
6220 
    result.write(oprot)
6221 
    oprot.writeMessageEnd()
6222 
    oprot.trans.flush()
6838 vikram.rag 6223 
 
7190 amar.kumar 6224 
  def process_getFreebieForItem(self, seqid, iprot, oprot):
6225 
    args = getFreebieForItem_args()
6226 
    args.read(iprot)
6227 
    iprot.readMessageEnd()
6228 
    result = getFreebieForItem_result()
6229 
    result.success = self._handler.getFreebieForItem(args.itemId)
6230 
    oprot.writeMessageBegin("getFreebieForItem", TMessageType.REPLY, seqid)
6231 
    result.write(oprot)
6232 
    oprot.writeMessageEnd()
6233 
    oprot.trans.flush()
6962 rajveer 6234 
 
7190 amar.kumar 6235 
  def process_addOrUpdateFreebieForItem(self, seqid, iprot, oprot):
6236 
    args = addOrUpdateFreebieForItem_args()
6237 
    args.read(iprot)
6238 
    iprot.readMessageEnd()
6239 
    result = addOrUpdateFreebieForItem_result()
6240 
    self._handler.addOrUpdateFreebieForItem(args.freebieItem)
6241 
    oprot.writeMessageBegin("addOrUpdateFreebieForItem", TMessageType.REPLY, seqid)
6242 
    result.write(oprot)
6243 
    oprot.writeMessageEnd()
6244 
    oprot.trans.flush()
6245 
 
7272 amit.gupta 6246 
  def process_addOrUpdateBrandInfo(self, seqid, iprot, oprot):
6247 
    args = addOrUpdateBrandInfo_args()
6248 
    args.read(iprot)
6249 
    iprot.readMessageEnd()
6250 
    result = addOrUpdateBrandInfo_result()
6251 
    self._handler.addOrUpdateBrandInfo(args.brandInfo)
6252 
    oprot.writeMessageBegin("addOrUpdateBrandInfo", TMessageType.REPLY, seqid)
6253 
    result.write(oprot)
6254 
    oprot.writeMessageEnd()
6255 
    oprot.trans.flush()
6256 
 
6257 
  def process_getBrandInfo(self, seqid, iprot, oprot):
6258 
    args = getBrandInfo_args()
6259 
    args.read(iprot)
6260 
    iprot.readMessageEnd()
6261 
    result = getBrandInfo_result()
6262 
    result.success = self._handler.getBrandInfo()
6263 
    oprot.writeMessageBegin("getBrandInfo", TMessageType.REPLY, seqid)
6264 
    result.write(oprot)
6265 
    oprot.writeMessageEnd()
6266 
    oprot.trans.flush()
6267 
 
7256 rajveer 6268 
  def process_getStorePricing(self, seqid, iprot, oprot):
6269 
    args = getStorePricing_args()
6270 
    args.read(iprot)
6271 
    iprot.readMessageEnd()
6272 
    result = getStorePricing_result()
6273 
    result.success = self._handler.getStorePricing(args.itemId)
6274 
    oprot.writeMessageBegin("getStorePricing", TMessageType.REPLY, seqid)
6275 
    result.write(oprot)
6276 
    oprot.writeMessageEnd()
6277 
    oprot.trans.flush()
7190 amar.kumar 6278 
 
7306 rajveer 6279 
  def process_getStorePricings(self, seqid, iprot, oprot):
6280 
    args = getStorePricings_args()
6281 
    args.read(iprot)
6282 
    iprot.readMessageEnd()
6283 
    result = getStorePricings_result()
6284 
    result.success = self._handler.getStorePricings(args.itemIds)
6285 
    oprot.writeMessageBegin("getStorePricings", TMessageType.REPLY, seqid)
6286 
    result.write(oprot)
6287 
    oprot.writeMessageEnd()
6288 
    oprot.trans.flush()
6289 
 
7265 rajveer 6290 
  def process_updateStorePricing(self, seqid, iprot, oprot):
6291 
    args = updateStorePricing_args()
6292 
    args.read(iprot)
6293 
    iprot.readMessageEnd()
6294 
    result = updateStorePricing_result()
7382 rajveer 6295 
    self._handler.updateStorePricing(args.sp, args.allColors)
7265 rajveer 6296 
    oprot.writeMessageBegin("updateStorePricing", TMessageType.REPLY, seqid)
6297 
    result.write(oprot)
6298 
    oprot.writeMessageEnd()
6299 
    oprot.trans.flush()
7256 rajveer 6300 
 
7281 kshitij.so 6301 
  def process_getAllAmazonListedItems(self, seqid, iprot, oprot):
6302 
    args = getAllAmazonListedItems_args()
6303 
    args.read(iprot)
6304 
    iprot.readMessageEnd()
6305 
    result = getAllAmazonListedItems_result()
6306 
    result.success = self._handler.getAllAmazonListedItems()
6307 
    oprot.writeMessageBegin("getAllAmazonListedItems", TMessageType.REPLY, seqid)
6308 
    result.write(oprot)
6309 
    oprot.writeMessageEnd()
6310 
    oprot.trans.flush()
7265 rajveer 6311 
 
8619 kshitij.so 6312 
  def process_searchAmazonItems(self, seqid, iprot, oprot):
6313 
    args = searchAmazonItems_args()
6314 
    args.read(iprot)
6315 
    iprot.readMessageEnd()
6316 
    result = searchAmazonItems_result()
6317 
    result.success = self._handler.searchAmazonItems(args.searchTerm, args.offset, args.limit)
6318 
    oprot.writeMessageBegin("searchAmazonItems", TMessageType.REPLY, seqid)
6319 
    result.write(oprot)
6320 
    oprot.writeMessageEnd()
6321 
    oprot.trans.flush()
6322 
 
6323 
  def process_getAmazonSearchResultCount(self, seqid, iprot, oprot):
6324 
    args = getAmazonSearchResultCount_args()
6325 
    args.read(iprot)
6326 
    iprot.readMessageEnd()
6327 
    result = getAmazonSearchResultCount_result()
6328 
    result.success = self._handler.getAmazonSearchResultCount(args.searchTerm)
6329 
    oprot.writeMessageBegin("getAmazonSearchResultCount", TMessageType.REPLY, seqid)
6330 
    result.write(oprot)
6331 
    oprot.writeMessageEnd()
6332 
    oprot.trans.flush()
6333 
 
6334 
  def process_getCountForAmazonlistedItems(self, seqid, iprot, oprot):
6335 
    args = getCountForAmazonlistedItems_args()
6336 
    args.read(iprot)
6337 
    iprot.readMessageEnd()
6338 
    result = getCountForAmazonlistedItems_result()
6339 
    result.success = self._handler.getCountForAmazonlistedItems()
6340 
    oprot.writeMessageBegin("getCountForAmazonlistedItems", TMessageType.REPLY, seqid)
6341 
    result.write(oprot)
6342 
    oprot.writeMessageEnd()
6343 
    oprot.trans.flush()
6344 
 
7281 kshitij.so 6345 
  def process_getAmazonItemDetails(self, seqid, iprot, oprot):
6346 
    args = getAmazonItemDetails_args()
6347 
    args.read(iprot)
6348 
    iprot.readMessageEnd()
6349 
    result = getAmazonItemDetails_result()
6350 
    result.success = self._handler.getAmazonItemDetails(args.itemId)
6351 
    oprot.writeMessageBegin("getAmazonItemDetails", TMessageType.REPLY, seqid)
6352 
    result.write(oprot)
6353 
    oprot.writeMessageEnd()
6354 
    oprot.trans.flush()
6355 
 
6356 
  def process_updateAmazonItemDetails(self, seqid, iprot, oprot):
6357 
    args = updateAmazonItemDetails_args()
6358 
    args.read(iprot)
6359 
    iprot.readMessageEnd()
6360 
    result = updateAmazonItemDetails_result()
8168 kshitij.so 6361 
    self._handler.updateAmazonItemDetails(args.amazonlisted)
7281 kshitij.so 6362 
    oprot.writeMessageBegin("updateAmazonItemDetails", TMessageType.REPLY, seqid)
6363 
    result.write(oprot)
6364 
    oprot.writeMessageEnd()
6365 
    oprot.trans.flush()
6366 
 
6367 
  def process_addAmazonItem(self, seqid, iprot, oprot):
6368 
    args = addAmazonItem_args()
6369 
    args.read(iprot)
6370 
    iprot.readMessageEnd()
6371 
    result = addAmazonItem_result()
6372 
    self._handler.addAmazonItem(args.amazonlisted)
6373 
    oprot.writeMessageBegin("addAmazonItem", TMessageType.REPLY, seqid)
6374 
    result.write(oprot)
6375 
    oprot.writeMessageEnd()
6376 
    oprot.trans.flush()
6377 
 
7291 vikram.rag 6378 
  def process_getAsinItems(self, seqid, iprot, oprot):
6379 
    args = getAsinItems_args()
6380 
    args.read(iprot)
6381 
    iprot.readMessageEnd()
6382 
    result = getAsinItems_result()
6383 
    result.success = self._handler.getAsinItems()
6384 
    oprot.writeMessageBegin("getAsinItems", TMessageType.REPLY, seqid)
6385 
    result.write(oprot)
6386 
    oprot.writeMessageEnd()
6387 
    oprot.trans.flush()
7281 kshitij.so 6388 
 
7291 vikram.rag 6389 
  def process_getAllFbaListedItems(self, seqid, iprot, oprot):
6390 
    args = getAllFbaListedItems_args()
6391 
    args.read(iprot)
6392 
    iprot.readMessageEnd()
6393 
    result = getAllFbaListedItems_result()
6394 
    result.success = self._handler.getAllFbaListedItems()
6395 
    oprot.writeMessageBegin("getAllFbaListedItems", TMessageType.REPLY, seqid)
6396 
    result.write(oprot)
6397 
    oprot.writeMessageEnd()
6398 
    oprot.trans.flush()
6399 
 
6400 
  def process_getAllNonFbaListedItems(self, seqid, iprot, oprot):
6401 
    args = getAllNonFbaListedItems_args()
6402 
    args.read(iprot)
6403 
    iprot.readMessageEnd()
6404 
    result = getAllNonFbaListedItems_result()
6405 
    result.success = self._handler.getAllNonFbaListedItems()
6406 
    oprot.writeMessageBegin("getAllNonFbaListedItems", TMessageType.REPLY, seqid)
6407 
    result.write(oprot)
6408 
    oprot.writeMessageEnd()
6409 
    oprot.trans.flush()
6410 
 
7460 kshitij.so 6411 
  def process_updateItemInventory(self, seqid, iprot, oprot):
6412 
    args = updateItemInventory_args()
6413 
    args.read(iprot)
6414 
    iprot.readMessageEnd()
6415 
    result = updateItemInventory_result()
6416 
    result.success = self._handler.updateItemInventory(args.itemId, args.holdInventory, args.defaultInventory)
6417 
    oprot.writeMessageBegin("updateItemInventory", TMessageType.REPLY, seqid)
6418 
    result.write(oprot)
6419 
    oprot.writeMessageEnd()
6420 
    oprot.trans.flush()
7291 vikram.rag 6421 
 
7770 kshitij.so 6422 
  def process_updateTimestampForAmazonFeeds(self, seqid, iprot, oprot):
6423 
    args = updateTimestampForAmazonFeeds_args()
6424 
    args.read(iprot)
6425 
    iprot.readMessageEnd()
6426 
    result = updateTimestampForAmazonFeeds_result()
6427 
    result.success = self._handler.updateTimestampForAmazonFeeds(args.type, args.sku, args.timestamp)
6428 
    oprot.writeMessageBegin("updateTimestampForAmazonFeeds", TMessageType.REPLY, seqid)
6429 
    result.write(oprot)
6430 
    oprot.writeMessageEnd()
6431 
    oprot.trans.flush()
7460 kshitij.so 6432 
 
7897 amar.kumar 6433 
  def process_getAllParentCategories(self, seqid, iprot, oprot):
6434 
    args = getAllParentCategories_args()
6435 
    args.read(iprot)
6436 
    iprot.readMessageEnd()
6437 
    result = getAllParentCategories_result()
6438 
    result.success = self._handler.getAllParentCategories()
6439 
    oprot.writeMessageBegin("getAllParentCategories", TMessageType.REPLY, seqid)
6440 
    result.write(oprot)
6441 
    oprot.writeMessageEnd()
6442 
    oprot.trans.flush()
7770 kshitij.so 6443 
 
7977 kshitij.so 6444 
  def process_addPageViewEvent(self, seqid, iprot, oprot):
6445 
    args = addPageViewEvent_args()
6446 
    args.read(iprot)
6447 
    iprot.readMessageEnd()
6448 
    result = addPageViewEvent_result()
6449 
    self._handler.addPageViewEvent(args.pageViewEvents)
6450 
    oprot.writeMessageBegin("addPageViewEvent", TMessageType.REPLY, seqid)
6451 
    result.write(oprot)
6452 
    oprot.writeMessageEnd()
6453 
    oprot.trans.flush()
7897 amar.kumar 6454 
 
7977 kshitij.so 6455 
  def process_addCartEvent(self, seqid, iprot, oprot):
6456 
    args = addCartEvent_args()
6457 
    args.read(iprot)
6458 
    iprot.readMessageEnd()
6459 
    result = addCartEvent_result()
6460 
    self._handler.addCartEvent(args.cartEvents)
6461 
    oprot.writeMessageBegin("addCartEvent", TMessageType.REPLY, seqid)
6462 
    result.write(oprot)
6463 
    oprot.writeMessageEnd()
6464 
    oprot.trans.flush()
6465 
 
8182 amar.kumar 6466 
  def process_addEbayItem(self, seqid, iprot, oprot):
6467 
    args = addEbayItem_args()
6468 
    args.read(iprot)
6469 
    iprot.readMessageEnd()
6470 
    result = addEbayItem_result()
6471 
    self._handler.addEbayItem(args.ebayItem)
6472 
    oprot.writeMessageBegin("addEbayItem", TMessageType.REPLY, seqid)
6473 
    result.write(oprot)
6474 
    oprot.writeMessageEnd()
6475 
    oprot.trans.flush()
6476 
 
6477 
  def process_getEbayItem(self, seqid, iprot, oprot):
6478 
    args = getEbayItem_args()
6479 
    args.read(iprot)
6480 
    iprot.readMessageEnd()
6481 
    result = getEbayItem_result()
6482 
    result.success = self._handler.getEbayItem(args.listingId)
6483 
    oprot.writeMessageBegin("getEbayItem", TMessageType.REPLY, seqid)
6484 
    result.write(oprot)
6485 
    oprot.writeMessageEnd()
6486 
    oprot.trans.flush()
6487 
 
6488 
  def process_updateEbayItem(self, seqid, iprot, oprot):
6489 
    args = updateEbayItem_args()
6490 
    args.read(iprot)
6491 
    iprot.readMessageEnd()
6492 
    result = updateEbayItem_result()
6493 
    self._handler.updateEbayItem(args.ebayItem)
6494 
    oprot.writeMessageBegin("updateEbayItem", TMessageType.REPLY, seqid)
6495 
    result.write(oprot)
6496 
    oprot.writeMessageEnd()
6497 
    oprot.trans.flush()
6498 
 
8139 kshitij.so 6499 
  def process_getAmazonListedItems(self, seqid, iprot, oprot):
6500 
    args = getAmazonListedItems_args()
6501 
    args.read(iprot)
6502 
    iprot.readMessageEnd()
6503 
    result = getAmazonListedItems_result()
6504 
    result.success = self._handler.getAmazonListedItems(args.offset, args.limit)
6505 
    oprot.writeMessageBegin("getAmazonListedItems", TMessageType.REPLY, seqid)
6506 
    result.write(oprot)
6507 
    oprot.writeMessageEnd()
6508 
    oprot.trans.flush()
7977 kshitij.so 6509 
 
8168 kshitij.so 6510 
  def process_updateAmazonAttributesInBulk(self, seqid, iprot, oprot):
6511 
    args = updateAmazonAttributesInBulk_args()
6512 
    args.read(iprot)
6513 
    iprot.readMessageEnd()
6514 
    result = updateAmazonAttributesInBulk_result()
6515 
    result.success = self._handler.updateAmazonAttributesInBulk(args.amazonlisted)
6516 
    oprot.writeMessageBegin("updateAmazonAttributesInBulk", TMessageType.REPLY, seqid)
6517 
    result.write(oprot)
6518 
    oprot.writeMessageEnd()
6519 
    oprot.trans.flush()
8139 kshitij.so 6520 
 
8379 vikram.rag 6521 
  def process_getAllItemstoListOnFba(self, seqid, iprot, oprot):
6522 
    args = getAllItemstoListOnFba_args()
6523 
    args.read(iprot)
6524 
    iprot.readMessageEnd()
6525 
    result = getAllItemstoListOnFba_result()
6526 
    result.success = self._handler.getAllItemstoListOnFba()
6527 
    oprot.writeMessageBegin("getAllItemstoListOnFba", TMessageType.REPLY, seqid)
6528 
    result.write(oprot)
6529 
    oprot.writeMessageEnd()
6530 
    oprot.trans.flush()
8168 kshitij.so 6531 
 
8379 vikram.rag 6532 
  def process_getAllItemstoListOnNonFba(self, seqid, iprot, oprot):
6533 
    args = getAllItemstoListOnNonFba_args()
6534 
    args.read(iprot)
6535 
    iprot.readMessageEnd()
6536 
    result = getAllItemstoListOnNonFba_result()
6537 
    result.success = self._handler.getAllItemstoListOnNonFba()
6538 
    oprot.writeMessageBegin("getAllItemstoListOnNonFba", TMessageType.REPLY, seqid)
6539 
    result.write(oprot)
6540 
    oprot.writeMessageEnd()
6541 
    oprot.trans.flush()
6542 
 
8619 kshitij.so 6543 
  def process_updateAsin(self, seqid, iprot, oprot):
6544 
    args = updateAsin_args()
6545 
    args.read(iprot)
6546 
    iprot.readMessageEnd()
6547 
    result = updateAsin_result()
6548 
    self._handler.updateAsin(args.item)
6549 
    oprot.writeMessageBegin("updateAsin", TMessageType.REPLY, seqid)
6550 
    result.write(oprot)
6551 
    oprot.writeMessageEnd()
6552 
    oprot.trans.flush()
8616 vikram.rag 6553 
 
8739 vikram.rag 6554 
  def process_addOrUpdateSnapdealItem(self, seqid, iprot, oprot):
6555 
    args = addOrUpdateSnapdealItem_args()
6556 
    args.read(iprot)
6557 
    iprot.readMessageEnd()
6558 
    result = addOrUpdateSnapdealItem_result()
6559 
    result.success = self._handler.addOrUpdateSnapdealItem(args.snapdealitem)
6560 
    oprot.writeMessageBegin("addOrUpdateSnapdealItem", TMessageType.REPLY, seqid)
6561 
    result.write(oprot)
6562 
    oprot.writeMessageEnd()
6563 
    oprot.trans.flush()
8619 kshitij.so 6564 
 
8739 vikram.rag 6565 
  def process_getSnapdealItem(self, seqid, iprot, oprot):
6566 
    args = getSnapdealItem_args()
6567 
    args.read(iprot)
6568 
    iprot.readMessageEnd()
6569 
    result = getSnapdealItem_result()
6570 
    result.success = self._handler.getSnapdealItem(args.item_id)
6571 
    oprot.writeMessageBegin("getSnapdealItem", TMessageType.REPLY, seqid)
6572 
    result.write(oprot)
6573 
    oprot.writeMessageEnd()
6574 
    oprot.trans.flush()
6575 
 
9242 kshitij.so 6576 
  def process_getSnapdealItemDetails(self, seqid, iprot, oprot):
6577 
    args = getSnapdealItemDetails_args()
6578 
    args.read(iprot)
6579 
    iprot.readMessageEnd()
6580 
    result = getSnapdealItemDetails_result()
6581 
    result.success = self._handler.getSnapdealItemDetails(args.item_id)
6582 
    oprot.writeMessageBegin("getSnapdealItemDetails", TMessageType.REPLY, seqid)
6583 
    result.write(oprot)
6584 
    oprot.writeMessageEnd()
6585 
    oprot.trans.flush()
6586 
 
8739 vikram.rag 6587 
  def process_getAllSnapdealItems(self, seqid, iprot, oprot):
6588 
    args = getAllSnapdealItems_args()
6589 
    args.read(iprot)
6590 
    iprot.readMessageEnd()
6591 
    result = getAllSnapdealItems_result()
6592 
    result.success = self._handler.getAllSnapdealItems()
6593 
    oprot.writeMessageBegin("getAllSnapdealItems", TMessageType.REPLY, seqid)
6594 
    result.write(oprot)
6595 
    oprot.writeMessageEnd()
6596 
    oprot.trans.flush()
6597 
 
9242 kshitij.so 6598 
  def process_getSnapdealItems(self, seqid, iprot, oprot):
6599 
    args = getSnapdealItems_args()
6600 
    args.read(iprot)
6601 
    iprot.readMessageEnd()
6602 
    result = getSnapdealItems_result()
6603 
    result.success = self._handler.getSnapdealItems(args.offset, args.limit)
6604 
    oprot.writeMessageBegin("getSnapdealItems", TMessageType.REPLY, seqid)
6605 
    result.write(oprot)
6606 
    oprot.writeMessageEnd()
6607 
    oprot.trans.flush()
8739 vikram.rag 6608 
 
9242 kshitij.so 6609 
  def process_searchSnapdealItems(self, seqid, iprot, oprot):
6610 
    args = searchSnapdealItems_args()
6611 
    args.read(iprot)
6612 
    iprot.readMessageEnd()
6613 
    result = searchSnapdealItems_result()
6614 
    result.success = self._handler.searchSnapdealItems(args.searchTerm, args.offset, args.limit)
6615 
    oprot.writeMessageBegin("searchSnapdealItems", TMessageType.REPLY, seqid)
6616 
    result.write(oprot)
6617 
    oprot.writeMessageEnd()
6618 
    oprot.trans.flush()
6619 
 
6620 
  def process_getCountForSnapdealItems(self, seqid, iprot, oprot):
6621 
    args = getCountForSnapdealItems_args()
6622 
    args.read(iprot)
6623 
    iprot.readMessageEnd()
6624 
    result = getCountForSnapdealItems_result()
6625 
    result.success = self._handler.getCountForSnapdealItems()
6626 
    oprot.writeMessageBegin("getCountForSnapdealItems", TMessageType.REPLY, seqid)
6627 
    result.write(oprot)
6628 
    oprot.writeMessageEnd()
6629 
    oprot.trans.flush()
6630 
 
6631 
  def process_getSnapdealSearchResultCount(self, seqid, iprot, oprot):
6632 
    args = getSnapdealSearchResultCount_args()
6633 
    args.read(iprot)
6634 
    iprot.readMessageEnd()
6635 
    result = getSnapdealSearchResultCount_result()
6636 
    result.success = self._handler.getSnapdealSearchResultCount(args.searchTerm)
6637 
    oprot.writeMessageBegin("getSnapdealSearchResultCount", TMessageType.REPLY, seqid)
6638 
    result.write(oprot)
6639 
    oprot.writeMessageEnd()
6640 
    oprot.trans.flush()
6641 
 
6642 
 
5944 mandeep.dh 6643 
# HELPER FUNCTIONS AND STRUCTURES
6644 
 
6645 
class addItem_args:
6646 
  """
6647 
  Attributes:
6648 
   - item
6649 
  """
6650 
 
6651 
  thrift_spec = (
6652 
    None, # 0
6653 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
6654 
  )
6655 
 
6656 
  def __init__(self, item=None,):
6657 
    self.item = item
6658 
 
6659 
  def read(self, iprot):
6660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6662 
      return
6663 
    iprot.readStructBegin()
6664 
    while True:
6665 
      (fname, ftype, fid) = iprot.readFieldBegin()
6666 
      if ftype == TType.STOP:
6667 
        break
6668 
      if fid == 1:
6669 
        if ftype == TType.STRUCT:
6670 
          self.item = Item()
6671 
          self.item.read(iprot)
6672 
        else:
6673 
          iprot.skip(ftype)
6674 
      else:
6675 
        iprot.skip(ftype)
6676 
      iprot.readFieldEnd()
6677 
    iprot.readStructEnd()
6678 
 
6679 
  def write(self, oprot):
6680 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6681 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6682 
      return
6683 
    oprot.writeStructBegin('addItem_args')
6684 
    if self.item is not None:
6685 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
6686 
      self.item.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 addItem_result:
6707 
  """
6708 
  Attributes:
6709 
   - success
6710 
   - cex
6711 
  """
6712 
 
6713 
  thrift_spec = (
6714 
    (0, TType.I64, 'success', None, None, ), # 0
6715 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6716 
  )
6717 
 
6718 
  def __init__(self, success=None, cex=None,):
6719 
    self.success = success
6720 
    self.cex = cex
6721 
 
6722 
  def read(self, iprot):
6723 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6724 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6725 
      return
6726 
    iprot.readStructBegin()
6727 
    while True:
6728 
      (fname, ftype, fid) = iprot.readFieldBegin()
6729 
      if ftype == TType.STOP:
6730 
        break
6731 
      if fid == 0:
6732 
        if ftype == TType.I64:
6733 
          self.success = iprot.readI64();
6734 
        else:
6735 
          iprot.skip(ftype)
6736 
      elif fid == 1:
6737 
        if ftype == TType.STRUCT:
6738 
          self.cex = CatalogServiceException()
6739 
          self.cex.read(iprot)
6740 
        else:
6741 
          iprot.skip(ftype)
6742 
      else:
6743 
        iprot.skip(ftype)
6744 
      iprot.readFieldEnd()
6745 
    iprot.readStructEnd()
6746 
 
6747 
  def write(self, oprot):
6748 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6749 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6750 
      return
6751 
    oprot.writeStructBegin('addItem_result')
6752 
    if self.success is not None:
6753 
      oprot.writeFieldBegin('success', TType.I64, 0)
6754 
      oprot.writeI64(self.success)
6755 
      oprot.writeFieldEnd()
6756 
    if self.cex is not None:
6757 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6758 
      self.cex.write(oprot)
6759 
      oprot.writeFieldEnd()
6760 
    oprot.writeFieldStop()
6761 
    oprot.writeStructEnd()
6762 
 
6763 
  def validate(self):
6764 
    return
6765 
 
6766 
 
6767 
  def __repr__(self):
6768 
    L = ['%s=%r' % (key, value)
6769 
      for key, value in self.__dict__.iteritems()]
6770 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6771 
 
6772 
  def __eq__(self, other):
6773 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6774 
 
6775 
  def __ne__(self, other):
6776 
    return not (self == other)
6777 
 
6778 
class updateItem_args:
6779 
  """
6780 
  Attributes:
6781 
   - item
6782 
  """
6783 
 
6784 
  thrift_spec = (
6785 
    None, # 0
6786 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
6787 
  )
6788 
 
6789 
  def __init__(self, item=None,):
6790 
    self.item = item
6791 
 
6792 
  def read(self, iprot):
6793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6795 
      return
6796 
    iprot.readStructBegin()
6797 
    while True:
6798 
      (fname, ftype, fid) = iprot.readFieldBegin()
6799 
      if ftype == TType.STOP:
6800 
        break
6801 
      if fid == 1:
6802 
        if ftype == TType.STRUCT:
6803 
          self.item = Item()
6804 
          self.item.read(iprot)
6805 
        else:
6806 
          iprot.skip(ftype)
6807 
      else:
6808 
        iprot.skip(ftype)
6809 
      iprot.readFieldEnd()
6810 
    iprot.readStructEnd()
6811 
 
6812 
  def write(self, oprot):
6813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6815 
      return
6816 
    oprot.writeStructBegin('updateItem_args')
6817 
    if self.item is not None:
6818 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
6819 
      self.item.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 
 
6839 
class updateItem_result:
6840 
  """
6841 
  Attributes:
6842 
   - success
6843 
   - cex
6844 
  """
6845 
 
6846 
  thrift_spec = (
6847 
    (0, TType.I64, 'success', None, None, ), # 0
6848 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6849 
  )
6850 
 
6851 
  def __init__(self, success=None, cex=None,):
6852 
    self.success = success
6853 
    self.cex = cex
6854 
 
6855 
  def read(self, iprot):
6856 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6857 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6858 
      return
6859 
    iprot.readStructBegin()
6860 
    while True:
6861 
      (fname, ftype, fid) = iprot.readFieldBegin()
6862 
      if ftype == TType.STOP:
6863 
        break
6864 
      if fid == 0:
6865 
        if ftype == TType.I64:
6866 
          self.success = iprot.readI64();
6867 
        else:
6868 
          iprot.skip(ftype)
6869 
      elif fid == 1:
6870 
        if ftype == TType.STRUCT:
6871 
          self.cex = CatalogServiceException()
6872 
          self.cex.read(iprot)
6873 
        else:
6874 
          iprot.skip(ftype)
6875 
      else:
6876 
        iprot.skip(ftype)
6877 
      iprot.readFieldEnd()
6878 
    iprot.readStructEnd()
6879 
 
6880 
  def write(self, oprot):
6881 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6882 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6883 
      return
6884 
    oprot.writeStructBegin('updateItem_result')
6885 
    if self.success is not None:
6886 
      oprot.writeFieldBegin('success', TType.I64, 0)
6887 
      oprot.writeI64(self.success)
6888 
      oprot.writeFieldEnd()
6889 
    if self.cex is not None:
6890 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6891 
      self.cex.write(oprot)
6892 
      oprot.writeFieldEnd()
6893 
    oprot.writeFieldStop()
6894 
    oprot.writeStructEnd()
6895 
 
6896 
  def validate(self):
6897 
    return
6898 
 
6899 
 
6900 
  def __repr__(self):
6901 
    L = ['%s=%r' % (key, value)
6902 
      for key, value in self.__dict__.iteritems()]
6903 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6904 
 
6905 
  def __eq__(self, other):
6906 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6907 
 
6908 
  def __ne__(self, other):
6909 
    return not (self == other)
6910 
 
6911 
class isActive_args:
6912 
  """
6913 
  Attributes:
6914 
   - itemId
6915 
  """
6916 
 
6917 
  thrift_spec = (
6918 
    None, # 0
6919 
    (1, TType.I64, 'itemId', None, None, ), # 1
6920 
  )
6921 
 
6922 
  def __init__(self, itemId=None,):
6923 
    self.itemId = itemId
6924 
 
6925 
  def read(self, iprot):
6926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6928 
      return
6929 
    iprot.readStructBegin()
6930 
    while True:
6931 
      (fname, ftype, fid) = iprot.readFieldBegin()
6932 
      if ftype == TType.STOP:
6933 
        break
6934 
      if fid == 1:
6935 
        if ftype == TType.I64:
6936 
          self.itemId = iprot.readI64();
6937 
        else:
6938 
          iprot.skip(ftype)
6939 
      else:
6940 
        iprot.skip(ftype)
6941 
      iprot.readFieldEnd()
6942 
    iprot.readStructEnd()
6943 
 
6944 
  def write(self, oprot):
6945 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6946 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6947 
      return
6948 
    oprot.writeStructBegin('isActive_args')
6949 
    if self.itemId is not None:
6950 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
6951 
      oprot.writeI64(self.itemId)
6952 
      oprot.writeFieldEnd()
6953 
    oprot.writeFieldStop()
6954 
    oprot.writeStructEnd()
6955 
 
6956 
  def validate(self):
6957 
    return
6958 
 
6959 
 
6960 
  def __repr__(self):
6961 
    L = ['%s=%r' % (key, value)
6962 
      for key, value in self.__dict__.iteritems()]
6963 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6964 
 
6965 
  def __eq__(self, other):
6966 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6967 
 
6968 
  def __ne__(self, other):
6969 
    return not (self == other)
6970 
 
6971 
class isActive_result:
6972 
  """
6973 
  Attributes:
6974 
   - success
6975 
   - isex
6976 
  """
6977 
 
6978 
  thrift_spec = (
6979 
    (0, TType.STRUCT, 'success', (ItemShippingInfo, ItemShippingInfo.thrift_spec), None, ), # 0
6980 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6981 
  )
6982 
 
6983 
  def __init__(self, success=None, isex=None,):
6984 
    self.success = success
6985 
    self.isex = isex
6986 
 
6987 
  def read(self, iprot):
6988 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6989 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6990 
      return
6991 
    iprot.readStructBegin()
6992 
    while True:
6993 
      (fname, ftype, fid) = iprot.readFieldBegin()
6994 
      if ftype == TType.STOP:
6995 
        break
6996 
      if fid == 0:
6997 
        if ftype == TType.STRUCT:
6998 
          self.success = ItemShippingInfo()
6999 
          self.success.read(iprot)
7000 
        else:
7001 
          iprot.skip(ftype)
7002 
      elif fid == 1:
7003 
        if ftype == TType.STRUCT:
7004 
          self.isex = CatalogServiceException()
7005 
          self.isex.read(iprot)
7006 
        else:
7007 
          iprot.skip(ftype)
7008 
      else:
7009 
        iprot.skip(ftype)
7010 
      iprot.readFieldEnd()
7011 
    iprot.readStructEnd()
7012 
 
7013 
  def write(self, oprot):
7014 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7015 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7016 
      return
7017 
    oprot.writeStructBegin('isActive_result')
7018 
    if self.success is not None:
7019 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7020 
      self.success.write(oprot)
7021 
      oprot.writeFieldEnd()
7022 
    if self.isex is not None:
7023 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7024 
      self.isex.write(oprot)
7025 
      oprot.writeFieldEnd()
7026 
    oprot.writeFieldStop()
7027 
    oprot.writeStructEnd()
7028 
 
7029 
  def validate(self):
7030 
    return
7031 
 
7032 
 
7033 
  def __repr__(self):
7034 
    L = ['%s=%r' % (key, value)
7035 
      for key, value in self.__dict__.iteritems()]
7036 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7037 
 
7038 
  def __eq__(self, other):
7039 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7040 
 
7041 
  def __ne__(self, other):
7042 
    return not (self == other)
7043 
 
7438 amit.gupta 7044 
class getItemsStatus_args:
7045 
  """
7046 
  Attributes:
7047 
   - itemIds
7048 
  """
7049 
 
7050 
  thrift_spec = (
7051 
    None, # 0
7052 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
7053 
  )
7054 
 
7055 
  def __init__(self, itemIds=None,):
7056 
    self.itemIds = itemIds
7057 
 
7058 
  def read(self, iprot):
7059 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7060 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7061 
      return
7062 
    iprot.readStructBegin()
7063 
    while True:
7064 
      (fname, ftype, fid) = iprot.readFieldBegin()
7065 
      if ftype == TType.STOP:
7066 
        break
7067 
      if fid == 1:
7068 
        if ftype == TType.LIST:
7069 
          self.itemIds = []
8590 kshitij.so 7070 
          (_etype33, _size30) = iprot.readListBegin()
7071 
          for _i34 in xrange(_size30):
7072 
            _elem35 = iprot.readI64();
7073 
            self.itemIds.append(_elem35)
7438 amit.gupta 7074 
          iprot.readListEnd()
7075 
        else:
7076 
          iprot.skip(ftype)
7077 
      else:
7078 
        iprot.skip(ftype)
7079 
      iprot.readFieldEnd()
7080 
    iprot.readStructEnd()
7081 
 
7082 
  def write(self, oprot):
7083 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7084 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7085 
      return
7086 
    oprot.writeStructBegin('getItemsStatus_args')
7087 
    if self.itemIds is not None:
7088 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
7089 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
8590 kshitij.so 7090 
      for iter36 in self.itemIds:
7091 
        oprot.writeI64(iter36)
7438 amit.gupta 7092 
      oprot.writeListEnd()
7093 
      oprot.writeFieldEnd()
7094 
    oprot.writeFieldStop()
7095 
    oprot.writeStructEnd()
7096 
 
7097 
  def validate(self):
7098 
    return
7099 
 
7100 
 
7101 
  def __repr__(self):
7102 
    L = ['%s=%r' % (key, value)
7103 
      for key, value in self.__dict__.iteritems()]
7104 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7105 
 
7106 
  def __eq__(self, other):
7107 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7108 
 
7109 
  def __ne__(self, other):
7110 
    return not (self == other)
7111 
 
7112 
class getItemsStatus_result:
7113 
  """
7114 
  Attributes:
7115 
   - success
7116 
   - isex
7117 
  """
7118 
 
7119 
  thrift_spec = (
7120 
    (0, TType.MAP, 'success', (TType.I64,None,TType.BOOL,None), None, ), # 0
7121 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7122 
  )
7123 
 
7124 
  def __init__(self, success=None, isex=None,):
7125 
    self.success = success
7126 
    self.isex = isex
7127 
 
7128 
  def read(self, iprot):
7129 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7130 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7131 
      return
7132 
    iprot.readStructBegin()
7133 
    while True:
7134 
      (fname, ftype, fid) = iprot.readFieldBegin()
7135 
      if ftype == TType.STOP:
7136 
        break
7137 
      if fid == 0:
7138 
        if ftype == TType.MAP:
7139 
          self.success = {}
8590 kshitij.so 7140 
          (_ktype38, _vtype39, _size37 ) = iprot.readMapBegin()
7141 
          for _i41 in xrange(_size37):
7142 
            _key42 = iprot.readI64();
7143 
            _val43 = iprot.readBool();
7144 
            self.success[_key42] = _val43
7438 amit.gupta 7145 
          iprot.readMapEnd()
7146 
        else:
7147 
          iprot.skip(ftype)
7148 
      elif fid == 1:
7149 
        if ftype == TType.STRUCT:
7150 
          self.isex = CatalogServiceException()
7151 
          self.isex.read(iprot)
7152 
        else:
7153 
          iprot.skip(ftype)
7154 
      else:
7155 
        iprot.skip(ftype)
7156 
      iprot.readFieldEnd()
7157 
    iprot.readStructEnd()
7158 
 
7159 
  def write(self, oprot):
7160 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7161 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7162 
      return
7163 
    oprot.writeStructBegin('getItemsStatus_result')
7164 
    if self.success is not None:
7165 
      oprot.writeFieldBegin('success', TType.MAP, 0)
7166 
      oprot.writeMapBegin(TType.I64, TType.BOOL, len(self.success))
8590 kshitij.so 7167 
      for kiter44,viter45 in self.success.items():
7168 
        oprot.writeI64(kiter44)
7169 
        oprot.writeBool(viter45)
7438 amit.gupta 7170 
      oprot.writeMapEnd()
7171 
      oprot.writeFieldEnd()
7172 
    if self.isex is not None:
7173 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7174 
      self.isex.write(oprot)
7175 
      oprot.writeFieldEnd()
7176 
    oprot.writeFieldStop()
7177 
    oprot.writeStructEnd()
7178 
 
7179 
  def validate(self):
7180 
    return
7181 
 
7182 
 
7183 
  def __repr__(self):
7184 
    L = ['%s=%r' % (key, value)
7185 
      for key, value in self.__dict__.iteritems()]
7186 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7187 
 
7188 
  def __eq__(self, other):
7189 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7190 
 
7191 
  def __ne__(self, other):
7192 
    return not (self == other)
7193 
 
5944 mandeep.dh 7194 
class getItemStatusDescription_args:
7195 
  """
7196 
  Attributes:
7197 
   - itemId
7198 
  """
7199 
 
7200 
  thrift_spec = (
7201 
    None, # 0
7202 
    (1, TType.I64, 'itemId', None, None, ), # 1
7203 
  )
7204 
 
7205 
  def __init__(self, itemId=None,):
7206 
    self.itemId = itemId
7207 
 
7208 
  def read(self, iprot):
7209 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7210 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7211 
      return
7212 
    iprot.readStructBegin()
7213 
    while True:
7214 
      (fname, ftype, fid) = iprot.readFieldBegin()
7215 
      if ftype == TType.STOP:
7216 
        break
7217 
      if fid == 1:
7218 
        if ftype == TType.I64:
7219 
          self.itemId = iprot.readI64();
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('getItemStatusDescription_args')
7232 
    if self.itemId is not None:
7233 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
7234 
      oprot.writeI64(self.itemId)
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 getItemStatusDescription_result:
7255 
  """
7256 
  Attributes:
7257 
   - success
7258 
   - isex
7259 
  """
7260 
 
7261 
  thrift_spec = (
7262 
    (0, TType.STRING, 'success', None, None, ), # 0
7263 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7264 
  )
7265 
 
7266 
  def __init__(self, success=None, isex=None,):
7267 
    self.success = success
7268 
    self.isex = isex
7269 
 
7270 
  def read(self, iprot):
7271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7273 
      return
7274 
    iprot.readStructBegin()
7275 
    while True:
7276 
      (fname, ftype, fid) = iprot.readFieldBegin()
7277 
      if ftype == TType.STOP:
7278 
        break
7279 
      if fid == 0:
7280 
        if ftype == TType.STRING:
7281 
          self.success = iprot.readString();
7282 
        else:
7283 
          iprot.skip(ftype)
7284 
      elif fid == 1:
7285 
        if ftype == TType.STRUCT:
7286 
          self.isex = CatalogServiceException()
7287 
          self.isex.read(iprot)
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('getItemStatusDescription_result')
7300 
    if self.success is not None:
7301 
      oprot.writeFieldBegin('success', TType.STRING, 0)
7302 
      oprot.writeString(self.success)
7303 
      oprot.writeFieldEnd()
7304 
    if self.isex is not None:
7305 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7306 
      self.isex.write(oprot)
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 startItemOn_args:
7327 
  """
7328 
  Attributes:
7329 
   - item_id
7330 
   - timestamp
7331 
  """
7332 
 
7333 
  thrift_spec = (
7334 
    None, # 0
7335 
    (1, TType.I64, 'item_id', None, None, ), # 1
7336 
    (2, TType.I64, 'timestamp', None, None, ), # 2
7337 
  )
7338 
 
7339 
  def __init__(self, item_id=None, timestamp=None,):
7340 
    self.item_id = item_id
7341 
    self.timestamp = timestamp
7342 
 
7343 
  def read(self, iprot):
7344 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7345 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7346 
      return
7347 
    iprot.readStructBegin()
7348 
    while True:
7349 
      (fname, ftype, fid) = iprot.readFieldBegin()
7350 
      if ftype == TType.STOP:
7351 
        break
7352 
      if fid == 1:
7353 
        if ftype == TType.I64:
7354 
          self.item_id = iprot.readI64();
7355 
        else:
7356 
          iprot.skip(ftype)
7357 
      elif fid == 2:
7358 
        if ftype == TType.I64:
7359 
          self.timestamp = iprot.readI64();
7360 
        else:
7361 
          iprot.skip(ftype)
7362 
      else:
7363 
        iprot.skip(ftype)
7364 
      iprot.readFieldEnd()
7365 
    iprot.readStructEnd()
7366 
 
7367 
  def write(self, oprot):
7368 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7369 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7370 
      return
7371 
    oprot.writeStructBegin('startItemOn_args')
7372 
    if self.item_id is not None:
7373 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
7374 
      oprot.writeI64(self.item_id)
7375 
      oprot.writeFieldEnd()
7376 
    if self.timestamp is not None:
7377 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
7378 
      oprot.writeI64(self.timestamp)
7379 
      oprot.writeFieldEnd()
7380 
    oprot.writeFieldStop()
7381 
    oprot.writeStructEnd()
7382 
 
7383 
  def validate(self):
7384 
    return
7385 
 
7386 
 
7387 
  def __repr__(self):
7388 
    L = ['%s=%r' % (key, value)
7389 
      for key, value in self.__dict__.iteritems()]
7390 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7391 
 
7392 
  def __eq__(self, other):
7393 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7394 
 
7395 
  def __ne__(self, other):
7396 
    return not (self == other)
7397 
 
7398 
class startItemOn_result:
7399 
  """
7400 
  Attributes:
7401 
   - cex
7402 
  """
7403 
 
7404 
  thrift_spec = (
7405 
    None, # 0
7406 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7407 
  )
7408 
 
7409 
  def __init__(self, cex=None,):
7410 
    self.cex = cex
7411 
 
7412 
  def read(self, iprot):
7413 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7414 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7415 
      return
7416 
    iprot.readStructBegin()
7417 
    while True:
7418 
      (fname, ftype, fid) = iprot.readFieldBegin()
7419 
      if ftype == TType.STOP:
7420 
        break
7421 
      if fid == 1:
7422 
        if ftype == TType.STRUCT:
7423 
          self.cex = CatalogServiceException()
7424 
          self.cex.read(iprot)
7425 
        else:
7426 
          iprot.skip(ftype)
7427 
      else:
7428 
        iprot.skip(ftype)
7429 
      iprot.readFieldEnd()
7430 
    iprot.readStructEnd()
7431 
 
7432 
  def write(self, oprot):
7433 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7434 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7435 
      return
7436 
    oprot.writeStructBegin('startItemOn_result')
7437 
    if self.cex is not None:
7438 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7439 
      self.cex.write(oprot)
7440 
      oprot.writeFieldEnd()
7441 
    oprot.writeFieldStop()
7442 
    oprot.writeStructEnd()
7443 
 
7444 
  def validate(self):
7445 
    return
7446 
 
7447 
 
7448 
  def __repr__(self):
7449 
    L = ['%s=%r' % (key, value)
7450 
      for key, value in self.__dict__.iteritems()]
7451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7452 
 
7453 
  def __eq__(self, other):
7454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7455 
 
7456 
  def __ne__(self, other):
7457 
    return not (self == other)
7458 
 
7459 
class retireItemOn_args:
7460 
  """
7461 
  Attributes:
7462 
   - item_id
7463 
   - timestamp
7464 
  """
7465 
 
7466 
  thrift_spec = (
7467 
    None, # 0
7468 
    (1, TType.I64, 'item_id', None, None, ), # 1
7469 
    (2, TType.I64, 'timestamp', None, None, ), # 2
7470 
  )
7471 
 
7472 
  def __init__(self, item_id=None, timestamp=None,):
7473 
    self.item_id = item_id
7474 
    self.timestamp = timestamp
7475 
 
7476 
  def read(self, iprot):
7477 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7478 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7479 
      return
7480 
    iprot.readStructBegin()
7481 
    while True:
7482 
      (fname, ftype, fid) = iprot.readFieldBegin()
7483 
      if ftype == TType.STOP:
7484 
        break
7485 
      if fid == 1:
7486 
        if ftype == TType.I64:
7487 
          self.item_id = iprot.readI64();
7488 
        else:
7489 
          iprot.skip(ftype)
7490 
      elif fid == 2:
7491 
        if ftype == TType.I64:
7492 
          self.timestamp = iprot.readI64();
7493 
        else:
7494 
          iprot.skip(ftype)
7495 
      else:
7496 
        iprot.skip(ftype)
7497 
      iprot.readFieldEnd()
7498 
    iprot.readStructEnd()
7499 
 
7500 
  def write(self, oprot):
7501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7503 
      return
7504 
    oprot.writeStructBegin('retireItemOn_args')
7505 
    if self.item_id is not None:
7506 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
7507 
      oprot.writeI64(self.item_id)
7508 
      oprot.writeFieldEnd()
7509 
    if self.timestamp is not None:
7510 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
7511 
      oprot.writeI64(self.timestamp)
7512 
      oprot.writeFieldEnd()
7513 
    oprot.writeFieldStop()
7514 
    oprot.writeStructEnd()
7515 
 
7516 
  def validate(self):
7517 
    return
7518 
 
7519 
 
7520 
  def __repr__(self):
7521 
    L = ['%s=%r' % (key, value)
7522 
      for key, value in self.__dict__.iteritems()]
7523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7524 
 
7525 
  def __eq__(self, other):
7526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7527 
 
7528 
  def __ne__(self, other):
7529 
    return not (self == other)
7530 
 
7531 
class retireItemOn_result:
7532 
  """
7533 
  Attributes:
7534 
   - cex
7535 
  """
7536 
 
7537 
  thrift_spec = (
7538 
    None, # 0
7539 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7540 
  )
7541 
 
7542 
  def __init__(self, cex=None,):
7543 
    self.cex = cex
7544 
 
7545 
  def read(self, iprot):
7546 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7547 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7548 
      return
7549 
    iprot.readStructBegin()
7550 
    while True:
7551 
      (fname, ftype, fid) = iprot.readFieldBegin()
7552 
      if ftype == TType.STOP:
7553 
        break
7554 
      if fid == 1:
7555 
        if ftype == TType.STRUCT:
7556 
          self.cex = CatalogServiceException()
7557 
          self.cex.read(iprot)
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('retireItemOn_result')
7570 
    if self.cex is not None:
7571 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7572 
      self.cex.write(oprot)
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 changeItemStatus_args:
7593 
  """
7594 
  Attributes:
7595 
   - item_id
7596 
   - timestamp
7597 
   - newstatus
7598 
  """
7599 
 
7600 
  thrift_spec = (
7601 
    None, # 0
7602 
    (1, TType.I64, 'item_id', None, None, ), # 1
7603 
    (2, TType.I64, 'timestamp', None, None, ), # 2
7604 
    (3, TType.I32, 'newstatus', None, None, ), # 3
7605 
  )
7606 
 
7607 
  def __init__(self, item_id=None, timestamp=None, newstatus=None,):
7608 
    self.item_id = item_id
7609 
    self.timestamp = timestamp
7610 
    self.newstatus = newstatus
7611 
 
7612 
  def read(self, iprot):
7613 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7614 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7615 
      return
7616 
    iprot.readStructBegin()
7617 
    while True:
7618 
      (fname, ftype, fid) = iprot.readFieldBegin()
7619 
      if ftype == TType.STOP:
7620 
        break
7621 
      if fid == 1:
7622 
        if ftype == TType.I64:
7623 
          self.item_id = iprot.readI64();
7624 
        else:
7625 
          iprot.skip(ftype)
7626 
      elif fid == 2:
7627 
        if ftype == TType.I64:
7628 
          self.timestamp = iprot.readI64();
7629 
        else:
7630 
          iprot.skip(ftype)
7631 
      elif fid == 3:
7632 
        if ftype == TType.I32:
7633 
          self.newstatus = iprot.readI32();
7634 
        else:
7635 
          iprot.skip(ftype)
7636 
      else:
7637 
        iprot.skip(ftype)
7638 
      iprot.readFieldEnd()
7639 
    iprot.readStructEnd()
7640 
 
7641 
  def write(self, oprot):
7642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7644 
      return
7645 
    oprot.writeStructBegin('changeItemStatus_args')
7646 
    if self.item_id is not None:
7647 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
7648 
      oprot.writeI64(self.item_id)
7649 
      oprot.writeFieldEnd()
7650 
    if self.timestamp is not None:
7651 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
7652 
      oprot.writeI64(self.timestamp)
7653 
      oprot.writeFieldEnd()
7654 
    if self.newstatus is not None:
7655 
      oprot.writeFieldBegin('newstatus', TType.I32, 3)
7656 
      oprot.writeI32(self.newstatus)
7657 
      oprot.writeFieldEnd()
7658 
    oprot.writeFieldStop()
7659 
    oprot.writeStructEnd()
7660 
 
7661 
  def validate(self):
7662 
    return
7663 
 
7664 
 
7665 
  def __repr__(self):
7666 
    L = ['%s=%r' % (key, value)
7667 
      for key, value in self.__dict__.iteritems()]
7668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7669 
 
7670 
  def __eq__(self, other):
7671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7672 
 
7673 
  def __ne__(self, other):
7674 
    return not (self == other)
7675 
 
7676 
class changeItemStatus_result:
7677 
  """
7678 
  Attributes:
7679 
   - cex
7680 
  """
7681 
 
7682 
  thrift_spec = (
7683 
    None, # 0
7684 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7685 
  )
7686 
 
7687 
  def __init__(self, cex=None,):
7688 
    self.cex = cex
7689 
 
7690 
  def read(self, iprot):
7691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7693 
      return
7694 
    iprot.readStructBegin()
7695 
    while True:
7696 
      (fname, ftype, fid) = iprot.readFieldBegin()
7697 
      if ftype == TType.STOP:
7698 
        break
7699 
      if fid == 1:
7700 
        if ftype == TType.STRUCT:
7701 
          self.cex = CatalogServiceException()
7702 
          self.cex.read(iprot)
7703 
        else:
7704 
          iprot.skip(ftype)
7705 
      else:
7706 
        iprot.skip(ftype)
7707 
      iprot.readFieldEnd()
7708 
    iprot.readStructEnd()
7709 
 
7710 
  def write(self, oprot):
7711 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7712 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7713 
      return
7714 
    oprot.writeStructBegin('changeItemStatus_result')
7715 
    if self.cex is not None:
7716 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7717 
      self.cex.write(oprot)
7718 
      oprot.writeFieldEnd()
7719 
    oprot.writeFieldStop()
7720 
    oprot.writeStructEnd()
7721 
 
7722 
  def validate(self):
7723 
    return
7724 
 
7725 
 
7726 
  def __repr__(self):
7727 
    L = ['%s=%r' % (key, value)
7728 
      for key, value in self.__dict__.iteritems()]
7729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7730 
 
7731 
  def __eq__(self, other):
7732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7733 
 
7734 
  def __ne__(self, other):
7735 
    return not (self == other)
7736 
 
7737 
class getItem_args:
7738 
  """
7739 
  Attributes:
7740 
   - item_id
7741 
  """
7742 
 
7743 
  thrift_spec = (
7744 
    None, # 0
7745 
    (1, TType.I64, 'item_id', None, None, ), # 1
7746 
  )
7747 
 
7748 
  def __init__(self, item_id=None,):
7749 
    self.item_id = item_id
7750 
 
7751 
  def read(self, iprot):
7752 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7753 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7754 
      return
7755 
    iprot.readStructBegin()
7756 
    while True:
7757 
      (fname, ftype, fid) = iprot.readFieldBegin()
7758 
      if ftype == TType.STOP:
7759 
        break
7760 
      if fid == 1:
7761 
        if ftype == TType.I64:
7762 
          self.item_id = iprot.readI64();
7763 
        else:
7764 
          iprot.skip(ftype)
7765 
      else:
7766 
        iprot.skip(ftype)
7767 
      iprot.readFieldEnd()
7768 
    iprot.readStructEnd()
7769 
 
7770 
  def write(self, oprot):
7771 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7772 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7773 
      return
7774 
    oprot.writeStructBegin('getItem_args')
7775 
    if self.item_id is not None:
7776 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
7777 
      oprot.writeI64(self.item_id)
7778 
      oprot.writeFieldEnd()
7779 
    oprot.writeFieldStop()
7780 
    oprot.writeStructEnd()
7781 
 
7782 
  def validate(self):
7783 
    return
7784 
 
7785 
 
7786 
  def __repr__(self):
7787 
    L = ['%s=%r' % (key, value)
7788 
      for key, value in self.__dict__.iteritems()]
7789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7790 
 
7791 
  def __eq__(self, other):
7792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7793 
 
7794 
  def __ne__(self, other):
7795 
    return not (self == other)
7796 
 
7797 
class getItem_result:
7798 
  """
7799 
  Attributes:
7800 
   - success
7801 
   - cex
7802 
  """
7803 
 
7804 
  thrift_spec = (
7805 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
7806 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7807 
  )
7808 
 
7809 
  def __init__(self, success=None, cex=None,):
7810 
    self.success = success
7811 
    self.cex = cex
7812 
 
7813 
  def read(self, iprot):
7814 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7815 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7816 
      return
7817 
    iprot.readStructBegin()
7818 
    while True:
7819 
      (fname, ftype, fid) = iprot.readFieldBegin()
7820 
      if ftype == TType.STOP:
7821 
        break
7822 
      if fid == 0:
7823 
        if ftype == TType.STRUCT:
7824 
          self.success = Item()
7825 
          self.success.read(iprot)
7826 
        else:
7827 
          iprot.skip(ftype)
7828 
      elif fid == 1:
7829 
        if ftype == TType.STRUCT:
7830 
          self.cex = CatalogServiceException()
7831 
          self.cex.read(iprot)
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('getItem_result')
7844 
    if self.success is not None:
7845 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7846 
      self.success.write(oprot)
7847 
      oprot.writeFieldEnd()
7848 
    if self.cex is not None:
7849 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7850 
      self.cex.write(oprot)
7851 
      oprot.writeFieldEnd()
7852 
    oprot.writeFieldStop()
7853 
    oprot.writeStructEnd()
7854 
 
7855 
  def validate(self):
7856 
    return
7857 
 
7858 
 
7859 
  def __repr__(self):
7860 
    L = ['%s=%r' % (key, value)
7861 
      for key, value in self.__dict__.iteritems()]
7862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7863 
 
7864 
  def __eq__(self, other):
7865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7866 
 
7867 
  def __ne__(self, other):
7868 
    return not (self == other)
7869 
 
7870 
class getItemsByCatalogId_args:
7871 
  """
7872 
  Attributes:
7873 
   - catalog_item_id
7874 
  """
7875 
 
7876 
  thrift_spec = (
7877 
    None, # 0
7878 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
7879 
  )
7880 
 
7881 
  def __init__(self, catalog_item_id=None,):
7882 
    self.catalog_item_id = catalog_item_id
7883 
 
7884 
  def read(self, iprot):
7885 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7886 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7887 
      return
7888 
    iprot.readStructBegin()
7889 
    while True:
7890 
      (fname, ftype, fid) = iprot.readFieldBegin()
7891 
      if ftype == TType.STOP:
7892 
        break
7893 
      if fid == 1:
7894 
        if ftype == TType.I64:
7895 
          self.catalog_item_id = iprot.readI64();
7896 
        else:
7897 
          iprot.skip(ftype)
7898 
      else:
7899 
        iprot.skip(ftype)
7900 
      iprot.readFieldEnd()
7901 
    iprot.readStructEnd()
7902 
 
7903 
  def write(self, oprot):
7904 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7905 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7906 
      return
7907 
    oprot.writeStructBegin('getItemsByCatalogId_args')
7908 
    if self.catalog_item_id is not None:
7909 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
7910 
      oprot.writeI64(self.catalog_item_id)
7911 
      oprot.writeFieldEnd()
7912 
    oprot.writeFieldStop()
7913 
    oprot.writeStructEnd()
7914 
 
7915 
  def validate(self):
7916 
    return
7917 
 
7918 
 
7919 
  def __repr__(self):
7920 
    L = ['%s=%r' % (key, value)
7921 
      for key, value in self.__dict__.iteritems()]
7922 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7923 
 
7924 
  def __eq__(self, other):
7925 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7926 
 
7927 
  def __ne__(self, other):
7928 
    return not (self == other)
7929 
 
7930 
class getItemsByCatalogId_result:
7931 
  """
7932 
  Attributes:
7933 
   - success
7934 
   - cex
7935 
  """
7936 
 
7937 
  thrift_spec = (
7938 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7939 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7940 
  )
7941 
 
7942 
  def __init__(self, success=None, cex=None,):
7943 
    self.success = success
7944 
    self.cex = cex
7945 
 
7946 
  def read(self, iprot):
7947 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7948 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7949 
      return
7950 
    iprot.readStructBegin()
7951 
    while True:
7952 
      (fname, ftype, fid) = iprot.readFieldBegin()
7953 
      if ftype == TType.STOP:
7954 
        break
7955 
      if fid == 0:
7956 
        if ftype == TType.LIST:
7957 
          self.success = []
8590 kshitij.so 7958 
          (_etype49, _size46) = iprot.readListBegin()
7959 
          for _i50 in xrange(_size46):
7960 
            _elem51 = Item()
7961 
            _elem51.read(iprot)
7962 
            self.success.append(_elem51)
5944 mandeep.dh 7963 
          iprot.readListEnd()
7964 
        else:
7965 
          iprot.skip(ftype)
7966 
      elif fid == 1:
7967 
        if ftype == TType.STRUCT:
7968 
          self.cex = CatalogServiceException()
7969 
          self.cex.read(iprot)
7970 
        else:
7971 
          iprot.skip(ftype)
7972 
      else:
7973 
        iprot.skip(ftype)
7974 
      iprot.readFieldEnd()
7975 
    iprot.readStructEnd()
7976 
 
7977 
  def write(self, oprot):
7978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7980 
      return
7981 
    oprot.writeStructBegin('getItemsByCatalogId_result')
7982 
    if self.success is not None:
7983 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7984 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 7985 
      for iter52 in self.success:
7986 
        iter52.write(oprot)
5944 mandeep.dh 7987 
      oprot.writeListEnd()
7988 
      oprot.writeFieldEnd()
7989 
    if self.cex is not None:
7990 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7991 
      self.cex.write(oprot)
7992 
      oprot.writeFieldEnd()
7993 
    oprot.writeFieldStop()
7994 
    oprot.writeStructEnd()
7995 
 
7996 
  def validate(self):
7997 
    return
7998 
 
7999 
 
8000 
  def __repr__(self):
8001 
    L = ['%s=%r' % (key, value)
8002 
      for key, value in self.__dict__.iteritems()]
8003 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8004 
 
8005 
  def __eq__(self, other):
8006 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8007 
 
8008 
  def __ne__(self, other):
8009 
    return not (self == other)
8010 
 
8011 
class getValidItemsByCatalogId_args:
8012 
  """
8013 
  Attributes:
8014 
   - catalog_item_id
8015 
  """
8016 
 
8017 
  thrift_spec = (
8018 
    None, # 0
8019 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
8020 
  )
8021 
 
8022 
  def __init__(self, catalog_item_id=None,):
8023 
    self.catalog_item_id = catalog_item_id
8024 
 
8025 
  def read(self, iprot):
8026 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8027 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8028 
      return
8029 
    iprot.readStructBegin()
8030 
    while True:
8031 
      (fname, ftype, fid) = iprot.readFieldBegin()
8032 
      if ftype == TType.STOP:
8033 
        break
8034 
      if fid == 1:
8035 
        if ftype == TType.I64:
8036 
          self.catalog_item_id = iprot.readI64();
8037 
        else:
8038 
          iprot.skip(ftype)
8039 
      else:
8040 
        iprot.skip(ftype)
8041 
      iprot.readFieldEnd()
8042 
    iprot.readStructEnd()
8043 
 
8044 
  def write(self, oprot):
8045 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8046 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8047 
      return
8048 
    oprot.writeStructBegin('getValidItemsByCatalogId_args')
8049 
    if self.catalog_item_id is not None:
8050 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
8051 
      oprot.writeI64(self.catalog_item_id)
8052 
      oprot.writeFieldEnd()
8053 
    oprot.writeFieldStop()
8054 
    oprot.writeStructEnd()
8055 
 
8056 
  def validate(self):
8057 
    return
8058 
 
8059 
 
8060 
  def __repr__(self):
8061 
    L = ['%s=%r' % (key, value)
8062 
      for key, value in self.__dict__.iteritems()]
8063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8064 
 
8065 
  def __eq__(self, other):
8066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8067 
 
8068 
  def __ne__(self, other):
8069 
    return not (self == other)
8070 
 
8071 
class getValidItemsByCatalogId_result:
8072 
  """
8073 
  Attributes:
8074 
   - success
8075 
   - cex
8076 
  """
8077 
 
8078 
  thrift_spec = (
8079 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8080 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8081 
  )
8082 
 
8083 
  def __init__(self, success=None, cex=None,):
8084 
    self.success = success
8085 
    self.cex = cex
8086 
 
8087 
  def read(self, iprot):
8088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8090 
      return
8091 
    iprot.readStructBegin()
8092 
    while True:
8093 
      (fname, ftype, fid) = iprot.readFieldBegin()
8094 
      if ftype == TType.STOP:
8095 
        break
8096 
      if fid == 0:
8097 
        if ftype == TType.LIST:
8098 
          self.success = []
8590 kshitij.so 8099 
          (_etype56, _size53) = iprot.readListBegin()
8100 
          for _i57 in xrange(_size53):
8101 
            _elem58 = Item()
8102 
            _elem58.read(iprot)
8103 
            self.success.append(_elem58)
5944 mandeep.dh 8104 
          iprot.readListEnd()
8105 
        else:
8106 
          iprot.skip(ftype)
8107 
      elif fid == 1:
8108 
        if ftype == TType.STRUCT:
8109 
          self.cex = CatalogServiceException()
8110 
          self.cex.read(iprot)
8111 
        else:
8112 
          iprot.skip(ftype)
8113 
      else:
8114 
        iprot.skip(ftype)
8115 
      iprot.readFieldEnd()
8116 
    iprot.readStructEnd()
8117 
 
8118 
  def write(self, oprot):
8119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8121 
      return
8122 
    oprot.writeStructBegin('getValidItemsByCatalogId_result')
8123 
    if self.success is not None:
8124 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8125 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8126 
      for iter59 in self.success:
8127 
        iter59.write(oprot)
5944 mandeep.dh 8128 
      oprot.writeListEnd()
8129 
      oprot.writeFieldEnd()
8130 
    if self.cex is not None:
8131 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8132 
      self.cex.write(oprot)
8133 
      oprot.writeFieldEnd()
8134 
    oprot.writeFieldStop()
8135 
    oprot.writeStructEnd()
8136 
 
8137 
  def validate(self):
8138 
    return
8139 
 
8140 
 
8141 
  def __repr__(self):
8142 
    L = ['%s=%r' % (key, value)
8143 
      for key, value in self.__dict__.iteritems()]
8144 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8145 
 
8146 
  def __eq__(self, other):
8147 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8148 
 
8149 
  def __ne__(self, other):
8150 
    return not (self == other)
8151 
 
8152 
class getAllItems_args:
8153 
  """
8154 
  Attributes:
8155 
   - isActive
8156 
  """
8157 
 
8158 
  thrift_spec = (
8159 
    None, # 0
8160 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
8161 
  )
8162 
 
8163 
  def __init__(self, isActive=None,):
8164 
    self.isActive = isActive
8165 
 
8166 
  def read(self, iprot):
8167 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8168 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8169 
      return
8170 
    iprot.readStructBegin()
8171 
    while True:
8172 
      (fname, ftype, fid) = iprot.readFieldBegin()
8173 
      if ftype == TType.STOP:
8174 
        break
8175 
      if fid == 1:
8176 
        if ftype == TType.BOOL:
8177 
          self.isActive = iprot.readBool();
8178 
        else:
8179 
          iprot.skip(ftype)
8180 
      else:
8181 
        iprot.skip(ftype)
8182 
      iprot.readFieldEnd()
8183 
    iprot.readStructEnd()
8184 
 
8185 
  def write(self, oprot):
8186 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8187 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8188 
      return
8189 
    oprot.writeStructBegin('getAllItems_args')
8190 
    if self.isActive is not None:
8191 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
8192 
      oprot.writeBool(self.isActive)
8193 
      oprot.writeFieldEnd()
8194 
    oprot.writeFieldStop()
8195 
    oprot.writeStructEnd()
8196 
 
8197 
  def validate(self):
8198 
    return
8199 
 
8200 
 
8201 
  def __repr__(self):
8202 
    L = ['%s=%r' % (key, value)
8203 
      for key, value in self.__dict__.iteritems()]
8204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8205 
 
8206 
  def __eq__(self, other):
8207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8208 
 
8209 
  def __ne__(self, other):
8210 
    return not (self == other)
8211 
 
8212 
class getAllItems_result:
8213 
  """
8214 
  Attributes:
8215 
   - success
8216 
   - cex
8217 
  """
8218 
 
8219 
  thrift_spec = (
8220 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8221 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8222 
  )
8223 
 
8224 
  def __init__(self, success=None, cex=None,):
8225 
    self.success = success
8226 
    self.cex = cex
8227 
 
8228 
  def read(self, iprot):
8229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8231 
      return
8232 
    iprot.readStructBegin()
8233 
    while True:
8234 
      (fname, ftype, fid) = iprot.readFieldBegin()
8235 
      if ftype == TType.STOP:
8236 
        break
8237 
      if fid == 0:
8238 
        if ftype == TType.LIST:
8239 
          self.success = []
8590 kshitij.so 8240 
          (_etype63, _size60) = iprot.readListBegin()
8241 
          for _i64 in xrange(_size60):
8242 
            _elem65 = Item()
8243 
            _elem65.read(iprot)
8244 
            self.success.append(_elem65)
5944 mandeep.dh 8245 
          iprot.readListEnd()
8246 
        else:
8247 
          iprot.skip(ftype)
8248 
      elif fid == 1:
8249 
        if ftype == TType.STRUCT:
8250 
          self.cex = CatalogServiceException()
8251 
          self.cex.read(iprot)
8252 
        else:
8253 
          iprot.skip(ftype)
8254 
      else:
8255 
        iprot.skip(ftype)
8256 
      iprot.readFieldEnd()
8257 
    iprot.readStructEnd()
8258 
 
8259 
  def write(self, oprot):
8260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8262 
      return
8263 
    oprot.writeStructBegin('getAllItems_result')
8264 
    if self.success is not None:
8265 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8266 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8267 
      for iter66 in self.success:
8268 
        iter66.write(oprot)
5944 mandeep.dh 8269 
      oprot.writeListEnd()
8270 
      oprot.writeFieldEnd()
8271 
    if self.cex is not None:
8272 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8273 
      self.cex.write(oprot)
8274 
      oprot.writeFieldEnd()
8275 
    oprot.writeFieldStop()
8276 
    oprot.writeStructEnd()
8277 
 
8278 
  def validate(self):
8279 
    return
8280 
 
8281 
 
8282 
  def __repr__(self):
8283 
    L = ['%s=%r' % (key, value)
8284 
      for key, value in self.__dict__.iteritems()]
8285 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8286 
 
8287 
  def __eq__(self, other):
8288 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8289 
 
8290 
  def __ne__(self, other):
8291 
    return not (self == other)
8292 
 
8293 
class getAllItemsByStatus_args:
8294 
  """
8295 
  Attributes:
8296 
   - itemStatus
8297 
  """
8298 
 
8299 
  thrift_spec = (
8300 
    None, # 0
8301 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
8302 
  )
8303 
 
8304 
  def __init__(self, itemStatus=None,):
8305 
    self.itemStatus = itemStatus
8306 
 
8307 
  def read(self, iprot):
8308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8310 
      return
8311 
    iprot.readStructBegin()
8312 
    while True:
8313 
      (fname, ftype, fid) = iprot.readFieldBegin()
8314 
      if ftype == TType.STOP:
8315 
        break
8316 
      if fid == 1:
8317 
        if ftype == TType.I32:
8318 
          self.itemStatus = iprot.readI32();
8319 
        else:
8320 
          iprot.skip(ftype)
8321 
      else:
8322 
        iprot.skip(ftype)
8323 
      iprot.readFieldEnd()
8324 
    iprot.readStructEnd()
8325 
 
8326 
  def write(self, oprot):
8327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8329 
      return
8330 
    oprot.writeStructBegin('getAllItemsByStatus_args')
8331 
    if self.itemStatus is not None:
8332 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
8333 
      oprot.writeI32(self.itemStatus)
8334 
      oprot.writeFieldEnd()
8335 
    oprot.writeFieldStop()
8336 
    oprot.writeStructEnd()
8337 
 
8338 
  def validate(self):
8339 
    return
8340 
 
8341 
 
8342 
  def __repr__(self):
8343 
    L = ['%s=%r' % (key, value)
8344 
      for key, value in self.__dict__.iteritems()]
8345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8346 
 
8347 
  def __eq__(self, other):
8348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8349 
 
8350 
  def __ne__(self, other):
8351 
    return not (self == other)
8352 
 
8353 
class getAllItemsByStatus_result:
8354 
  """
8355 
  Attributes:
8356 
   - success
8357 
   - cex
8358 
  """
8359 
 
8360 
  thrift_spec = (
8361 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8362 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8363 
  )
8364 
 
8365 
  def __init__(self, success=None, cex=None,):
8366 
    self.success = success
8367 
    self.cex = cex
8368 
 
8369 
  def read(self, iprot):
8370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8372 
      return
8373 
    iprot.readStructBegin()
8374 
    while True:
8375 
      (fname, ftype, fid) = iprot.readFieldBegin()
8376 
      if ftype == TType.STOP:
8377 
        break
8378 
      if fid == 0:
8379 
        if ftype == TType.LIST:
8380 
          self.success = []
8590 kshitij.so 8381 
          (_etype70, _size67) = iprot.readListBegin()
8382 
          for _i71 in xrange(_size67):
8383 
            _elem72 = Item()
8384 
            _elem72.read(iprot)
8385 
            self.success.append(_elem72)
5944 mandeep.dh 8386 
          iprot.readListEnd()
8387 
        else:
8388 
          iprot.skip(ftype)
8389 
      elif fid == 1:
8390 
        if ftype == TType.STRUCT:
8391 
          self.cex = CatalogServiceException()
8392 
          self.cex.read(iprot)
8393 
        else:
8394 
          iprot.skip(ftype)
8395 
      else:
8396 
        iprot.skip(ftype)
8397 
      iprot.readFieldEnd()
8398 
    iprot.readStructEnd()
8399 
 
8400 
  def write(self, oprot):
8401 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8402 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8403 
      return
8404 
    oprot.writeStructBegin('getAllItemsByStatus_result')
8405 
    if self.success is not None:
8406 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8407 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8408 
      for iter73 in self.success:
8409 
        iter73.write(oprot)
5944 mandeep.dh 8410 
      oprot.writeListEnd()
8411 
      oprot.writeFieldEnd()
8412 
    if self.cex is not None:
8413 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8414 
      self.cex.write(oprot)
8415 
      oprot.writeFieldEnd()
8416 
    oprot.writeFieldStop()
8417 
    oprot.writeStructEnd()
8418 
 
8419 
  def validate(self):
8420 
    return
8421 
 
8422 
 
8423 
  def __repr__(self):
8424 
    L = ['%s=%r' % (key, value)
8425 
      for key, value in self.__dict__.iteritems()]
8426 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8427 
 
8428 
  def __eq__(self, other):
8429 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8430 
 
8431 
  def __ne__(self, other):
8432 
    return not (self == other)
8433 
 
8434 
class markItemAsContentComplete_args:
8435 
  """
8436 
  Attributes:
8437 
   - entityId
8438 
   - category
8439 
   - brand
8440 
   - modelName
8441 
   - modelNumber
8442 
  """
8443 
 
8444 
  thrift_spec = (
8445 
    None, # 0
8446 
    (1, TType.I64, 'entityId', None, None, ), # 1
8447 
    (2, TType.I64, 'category', None, None, ), # 2
8448 
    (3, TType.STRING, 'brand', None, None, ), # 3
8449 
    (4, TType.STRING, 'modelName', None, None, ), # 4
8450 
    (5, TType.STRING, 'modelNumber', None, None, ), # 5
8451 
  )
8452 
 
8453 
  def __init__(self, entityId=None, category=None, brand=None, modelName=None, modelNumber=None,):
8454 
    self.entityId = entityId
8455 
    self.category = category
8456 
    self.brand = brand
8457 
    self.modelName = modelName
8458 
    self.modelNumber = modelNumber
8459 
 
8460 
  def read(self, iprot):
8461 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8462 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8463 
      return
8464 
    iprot.readStructBegin()
8465 
    while True:
8466 
      (fname, ftype, fid) = iprot.readFieldBegin()
8467 
      if ftype == TType.STOP:
8468 
        break
8469 
      if fid == 1:
8470 
        if ftype == TType.I64:
8471 
          self.entityId = iprot.readI64();
8472 
        else:
8473 
          iprot.skip(ftype)
8474 
      elif fid == 2:
8475 
        if ftype == TType.I64:
8476 
          self.category = iprot.readI64();
8477 
        else:
8478 
          iprot.skip(ftype)
8479 
      elif fid == 3:
8480 
        if ftype == TType.STRING:
8481 
          self.brand = iprot.readString();
8482 
        else:
8483 
          iprot.skip(ftype)
8484 
      elif fid == 4:
8485 
        if ftype == TType.STRING:
8486 
          self.modelName = iprot.readString();
8487 
        else:
8488 
          iprot.skip(ftype)
8489 
      elif fid == 5:
8490 
        if ftype == TType.STRING:
8491 
          self.modelNumber = iprot.readString();
8492 
        else:
8493 
          iprot.skip(ftype)
8494 
      else:
8495 
        iprot.skip(ftype)
8496 
      iprot.readFieldEnd()
8497 
    iprot.readStructEnd()
8498 
 
8499 
  def write(self, oprot):
8500 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8501 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8502 
      return
8503 
    oprot.writeStructBegin('markItemAsContentComplete_args')
8504 
    if self.entityId is not None:
8505 
      oprot.writeFieldBegin('entityId', TType.I64, 1)
8506 
      oprot.writeI64(self.entityId)
8507 
      oprot.writeFieldEnd()
8508 
    if self.category is not None:
8509 
      oprot.writeFieldBegin('category', TType.I64, 2)
8510 
      oprot.writeI64(self.category)
8511 
      oprot.writeFieldEnd()
8512 
    if self.brand is not None:
8513 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8514 
      oprot.writeString(self.brand)
8515 
      oprot.writeFieldEnd()
8516 
    if self.modelName is not None:
8517 
      oprot.writeFieldBegin('modelName', TType.STRING, 4)
8518 
      oprot.writeString(self.modelName)
8519 
      oprot.writeFieldEnd()
8520 
    if self.modelNumber is not None:
8521 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 5)
8522 
      oprot.writeString(self.modelNumber)
8523 
      oprot.writeFieldEnd()
8524 
    oprot.writeFieldStop()
8525 
    oprot.writeStructEnd()
8526 
 
8527 
  def validate(self):
8528 
    return
8529 
 
8530 
 
8531 
  def __repr__(self):
8532 
    L = ['%s=%r' % (key, value)
8533 
      for key, value in self.__dict__.iteritems()]
8534 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8535 
 
8536 
  def __eq__(self, other):
8537 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8538 
 
8539 
  def __ne__(self, other):
8540 
    return not (self == other)
8541 
 
8542 
class markItemAsContentComplete_result:
8543 
  """
8544 
  Attributes:
8545 
   - success
8546 
   - cex
8547 
  """
8548 
 
8549 
  thrift_spec = (
8550 
    (0, TType.BOOL, 'success', None, None, ), # 0
8551 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8552 
  )
8553 
 
8554 
  def __init__(self, success=None, cex=None,):
8555 
    self.success = success
8556 
    self.cex = cex
8557 
 
8558 
  def read(self, iprot):
8559 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8560 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8561 
      return
8562 
    iprot.readStructBegin()
8563 
    while True:
8564 
      (fname, ftype, fid) = iprot.readFieldBegin()
8565 
      if ftype == TType.STOP:
8566 
        break
8567 
      if fid == 0:
8568 
        if ftype == TType.BOOL:
8569 
          self.success = iprot.readBool();
8570 
        else:
8571 
          iprot.skip(ftype)
8572 
      elif fid == 1:
8573 
        if ftype == TType.STRUCT:
8574 
          self.cex = CatalogServiceException()
8575 
          self.cex.read(iprot)
8576 
        else:
8577 
          iprot.skip(ftype)
8578 
      else:
8579 
        iprot.skip(ftype)
8580 
      iprot.readFieldEnd()
8581 
    iprot.readStructEnd()
8582 
 
8583 
  def write(self, oprot):
8584 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8585 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8586 
      return
8587 
    oprot.writeStructBegin('markItemAsContentComplete_result')
8588 
    if self.success is not None:
8589 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8590 
      oprot.writeBool(self.success)
8591 
      oprot.writeFieldEnd()
8592 
    if self.cex is not None:
8593 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8594 
      self.cex.write(oprot)
8595 
      oprot.writeFieldEnd()
8596 
    oprot.writeFieldStop()
8597 
    oprot.writeStructEnd()
8598 
 
8599 
  def validate(self):
8600 
    return
8601 
 
8602 
 
8603 
  def __repr__(self):
8604 
    L = ['%s=%r' % (key, value)
8605 
      for key, value in self.__dict__.iteritems()]
8606 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8607 
 
8608 
  def __eq__(self, other):
8609 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8610 
 
8611 
  def __ne__(self, other):
8612 
    return not (self == other)
8613 
 
8614 
class getAllItemsInRange_args:
8615 
  """
8616 
  Attributes:
8617 
   - offset
8618 
   - limit
8619 
  """
8620 
 
8621 
  thrift_spec = (
8622 
    None, # 0
8623 
    (1, TType.I64, 'offset', None, None, ), # 1
8624 
    (2, TType.I64, 'limit', None, None, ), # 2
8625 
  )
8626 
 
8627 
  def __init__(self, offset=None, limit=None,):
8628 
    self.offset = offset
8629 
    self.limit = limit
8630 
 
8631 
  def read(self, iprot):
8632 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8633 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8634 
      return
8635 
    iprot.readStructBegin()
8636 
    while True:
8637 
      (fname, ftype, fid) = iprot.readFieldBegin()
8638 
      if ftype == TType.STOP:
8639 
        break
8640 
      if fid == 1:
8641 
        if ftype == TType.I64:
8642 
          self.offset = iprot.readI64();
8643 
        else:
8644 
          iprot.skip(ftype)
8645 
      elif fid == 2:
8646 
        if ftype == TType.I64:
8647 
          self.limit = iprot.readI64();
8648 
        else:
8649 
          iprot.skip(ftype)
8650 
      else:
8651 
        iprot.skip(ftype)
8652 
      iprot.readFieldEnd()
8653 
    iprot.readStructEnd()
8654 
 
8655 
  def write(self, oprot):
8656 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8657 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8658 
      return
8659 
    oprot.writeStructBegin('getAllItemsInRange_args')
8660 
    if self.offset is not None:
8661 
      oprot.writeFieldBegin('offset', TType.I64, 1)
8662 
      oprot.writeI64(self.offset)
8663 
      oprot.writeFieldEnd()
8664 
    if self.limit is not None:
8665 
      oprot.writeFieldBegin('limit', TType.I64, 2)
8666 
      oprot.writeI64(self.limit)
8667 
      oprot.writeFieldEnd()
8668 
    oprot.writeFieldStop()
8669 
    oprot.writeStructEnd()
8670 
 
8671 
  def validate(self):
8672 
    return
8673 
 
8674 
 
8675 
  def __repr__(self):
8676 
    L = ['%s=%r' % (key, value)
8677 
      for key, value in self.__dict__.iteritems()]
8678 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8679 
 
8680 
  def __eq__(self, other):
8681 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8682 
 
8683 
  def __ne__(self, other):
8684 
    return not (self == other)
8685 
 
8686 
class getAllItemsInRange_result:
8687 
  """
8688 
  Attributes:
8689 
   - success
8690 
   - cex
8691 
  """
8692 
 
8693 
  thrift_spec = (
8694 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8695 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8696 
  )
8697 
 
8698 
  def __init__(self, success=None, cex=None,):
8699 
    self.success = success
8700 
    self.cex = cex
8701 
 
8702 
  def read(self, iprot):
8703 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8704 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8705 
      return
8706 
    iprot.readStructBegin()
8707 
    while True:
8708 
      (fname, ftype, fid) = iprot.readFieldBegin()
8709 
      if ftype == TType.STOP:
8710 
        break
8711 
      if fid == 0:
8712 
        if ftype == TType.LIST:
8713 
          self.success = []
8590 kshitij.so 8714 
          (_etype77, _size74) = iprot.readListBegin()
8715 
          for _i78 in xrange(_size74):
8716 
            _elem79 = Item()
8717 
            _elem79.read(iprot)
8718 
            self.success.append(_elem79)
5944 mandeep.dh 8719 
          iprot.readListEnd()
8720 
        else:
8721 
          iprot.skip(ftype)
8722 
      elif fid == 1:
8723 
        if ftype == TType.STRUCT:
8724 
          self.cex = CatalogServiceException()
8725 
          self.cex.read(iprot)
8726 
        else:
8727 
          iprot.skip(ftype)
8728 
      else:
8729 
        iprot.skip(ftype)
8730 
      iprot.readFieldEnd()
8731 
    iprot.readStructEnd()
8732 
 
8733 
  def write(self, oprot):
8734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8736 
      return
8737 
    oprot.writeStructBegin('getAllItemsInRange_result')
8738 
    if self.success is not None:
8739 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8740 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8741 
      for iter80 in self.success:
8742 
        iter80.write(oprot)
5944 mandeep.dh 8743 
      oprot.writeListEnd()
8744 
      oprot.writeFieldEnd()
8745 
    if self.cex is not None:
8746 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8747 
      self.cex.write(oprot)
8748 
      oprot.writeFieldEnd()
8749 
    oprot.writeFieldStop()
8750 
    oprot.writeStructEnd()
8751 
 
8752 
  def validate(self):
8753 
    return
8754 
 
8755 
 
8756 
  def __repr__(self):
8757 
    L = ['%s=%r' % (key, value)
8758 
      for key, value in self.__dict__.iteritems()]
8759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8760 
 
8761 
  def __eq__(self, other):
8762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8763 
 
8764 
  def __ne__(self, other):
8765 
    return not (self == other)
8766 
 
8767 
class getAllItemsByStatusInRange_args:
8768 
  """
8769 
  Attributes:
8770 
   - itemStatus
8771 
   - offset
8772 
   - limit
8773 
  """
8774 
 
8775 
  thrift_spec = (
8776 
    None, # 0
8777 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
8778 
    (2, TType.I64, 'offset', None, None, ), # 2
8779 
    (3, TType.I64, 'limit', None, None, ), # 3
8780 
  )
8781 
 
8782 
  def __init__(self, itemStatus=None, offset=None, limit=None,):
8783 
    self.itemStatus = itemStatus
8784 
    self.offset = offset
8785 
    self.limit = limit
8786 
 
8787 
  def read(self, iprot):
8788 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8789 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8790 
      return
8791 
    iprot.readStructBegin()
8792 
    while True:
8793 
      (fname, ftype, fid) = iprot.readFieldBegin()
8794 
      if ftype == TType.STOP:
8795 
        break
8796 
      if fid == 1:
8797 
        if ftype == TType.I32:
8798 
          self.itemStatus = iprot.readI32();
8799 
        else:
8800 
          iprot.skip(ftype)
8801 
      elif fid == 2:
8802 
        if ftype == TType.I64:
8803 
          self.offset = iprot.readI64();
8804 
        else:
8805 
          iprot.skip(ftype)
8806 
      elif fid == 3:
8807 
        if ftype == TType.I64:
8808 
          self.limit = iprot.readI64();
8809 
        else:
8810 
          iprot.skip(ftype)
8811 
      else:
8812 
        iprot.skip(ftype)
8813 
      iprot.readFieldEnd()
8814 
    iprot.readStructEnd()
8815 
 
8816 
  def write(self, oprot):
8817 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8818 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8819 
      return
8820 
    oprot.writeStructBegin('getAllItemsByStatusInRange_args')
8821 
    if self.itemStatus is not None:
8822 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
8823 
      oprot.writeI32(self.itemStatus)
8824 
      oprot.writeFieldEnd()
8825 
    if self.offset is not None:
8826 
      oprot.writeFieldBegin('offset', TType.I64, 2)
8827 
      oprot.writeI64(self.offset)
8828 
      oprot.writeFieldEnd()
8829 
    if self.limit is not None:
8830 
      oprot.writeFieldBegin('limit', TType.I64, 3)
8831 
      oprot.writeI64(self.limit)
8832 
      oprot.writeFieldEnd()
8833 
    oprot.writeFieldStop()
8834 
    oprot.writeStructEnd()
8835 
 
8836 
  def validate(self):
8837 
    return
8838 
 
8839 
 
8840 
  def __repr__(self):
8841 
    L = ['%s=%r' % (key, value)
8842 
      for key, value in self.__dict__.iteritems()]
8843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8844 
 
8845 
  def __eq__(self, other):
8846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8847 
 
8848 
  def __ne__(self, other):
8849 
    return not (self == other)
8850 
 
8851 
class getAllItemsByStatusInRange_result:
8852 
  """
8853 
  Attributes:
8854 
   - success
8855 
   - cex
8856 
  """
8857 
 
8858 
  thrift_spec = (
8859 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8860 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8861 
  )
8862 
 
8863 
  def __init__(self, success=None, cex=None,):
8864 
    self.success = success
8865 
    self.cex = cex
8866 
 
8867 
  def read(self, iprot):
8868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8870 
      return
8871 
    iprot.readStructBegin()
8872 
    while True:
8873 
      (fname, ftype, fid) = iprot.readFieldBegin()
8874 
      if ftype == TType.STOP:
8875 
        break
8876 
      if fid == 0:
8877 
        if ftype == TType.LIST:
8878 
          self.success = []
8590 kshitij.so 8879 
          (_etype84, _size81) = iprot.readListBegin()
8880 
          for _i85 in xrange(_size81):
8881 
            _elem86 = Item()
8882 
            _elem86.read(iprot)
8883 
            self.success.append(_elem86)
5944 mandeep.dh 8884 
          iprot.readListEnd()
8885 
        else:
8886 
          iprot.skip(ftype)
8887 
      elif fid == 1:
8888 
        if ftype == TType.STRUCT:
8889 
          self.cex = CatalogServiceException()
8890 
          self.cex.read(iprot)
8891 
        else:
8892 
          iprot.skip(ftype)
8893 
      else:
8894 
        iprot.skip(ftype)
8895 
      iprot.readFieldEnd()
8896 
    iprot.readStructEnd()
8897 
 
8898 
  def write(self, oprot):
8899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8901 
      return
8902 
    oprot.writeStructBegin('getAllItemsByStatusInRange_result')
8903 
    if self.success is not None:
8904 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8905 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8906 
      for iter87 in self.success:
8907 
        iter87.write(oprot)
5944 mandeep.dh 8908 
      oprot.writeListEnd()
8909 
      oprot.writeFieldEnd()
8910 
    if self.cex is not None:
8911 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8912 
      self.cex.write(oprot)
8913 
      oprot.writeFieldEnd()
8914 
    oprot.writeFieldStop()
8915 
    oprot.writeStructEnd()
8916 
 
8917 
  def validate(self):
8918 
    return
8919 
 
8920 
 
8921 
  def __repr__(self):
8922 
    L = ['%s=%r' % (key, value)
8923 
      for key, value in self.__dict__.iteritems()]
8924 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8925 
 
8926 
  def __eq__(self, other):
8927 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8928 
 
8929 
  def __ne__(self, other):
8930 
    return not (self == other)
8931 
 
8932 
class getItemCountByStatus_args:
8933 
  """
8934 
  Attributes:
8935 
   - useStatus
8936 
   - itemStatus
8937 
  """
8938 
 
8939 
  thrift_spec = (
8940 
    None, # 0
8941 
    (1, TType.BOOL, 'useStatus', None, None, ), # 1
8942 
    (2, TType.I32, 'itemStatus', None, None, ), # 2
8943 
  )
8944 
 
8945 
  def __init__(self, useStatus=None, itemStatus=None,):
8946 
    self.useStatus = useStatus
8947 
    self.itemStatus = itemStatus
8948 
 
8949 
  def read(self, iprot):
8950 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8951 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8952 
      return
8953 
    iprot.readStructBegin()
8954 
    while True:
8955 
      (fname, ftype, fid) = iprot.readFieldBegin()
8956 
      if ftype == TType.STOP:
8957 
        break
8958 
      if fid == 1:
8959 
        if ftype == TType.BOOL:
8960 
          self.useStatus = iprot.readBool();
8961 
        else:
8962 
          iprot.skip(ftype)
8963 
      elif fid == 2:
8964 
        if ftype == TType.I32:
8965 
          self.itemStatus = iprot.readI32();
8966 
        else:
8967 
          iprot.skip(ftype)
8968 
      else:
8969 
        iprot.skip(ftype)
8970 
      iprot.readFieldEnd()
8971 
    iprot.readStructEnd()
8972 
 
8973 
  def write(self, oprot):
8974 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8975 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8976 
      return
8977 
    oprot.writeStructBegin('getItemCountByStatus_args')
8978 
    if self.useStatus is not None:
8979 
      oprot.writeFieldBegin('useStatus', TType.BOOL, 1)
8980 
      oprot.writeBool(self.useStatus)
8981 
      oprot.writeFieldEnd()
8982 
    if self.itemStatus is not None:
8983 
      oprot.writeFieldBegin('itemStatus', TType.I32, 2)
8984 
      oprot.writeI32(self.itemStatus)
8985 
      oprot.writeFieldEnd()
8986 
    oprot.writeFieldStop()
8987 
    oprot.writeStructEnd()
8988 
 
8989 
  def validate(self):
8990 
    return
8991 
 
8992 
 
8993 
  def __repr__(self):
8994 
    L = ['%s=%r' % (key, value)
8995 
      for key, value in self.__dict__.iteritems()]
8996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8997 
 
8998 
  def __eq__(self, other):
8999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9000 
 
9001 
  def __ne__(self, other):
9002 
    return not (self == other)
9003 
 
9004 
class getItemCountByStatus_result:
9005 
  """
9006 
  Attributes:
9007 
   - success
9008 
  """
9009 
 
9010 
  thrift_spec = (
9011 
    (0, TType.I32, 'success', None, None, ), # 0
9012 
  )
9013 
 
9014 
  def __init__(self, success=None,):
9015 
    self.success = success
9016 
 
9017 
  def read(self, iprot):
9018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9020 
      return
9021 
    iprot.readStructBegin()
9022 
    while True:
9023 
      (fname, ftype, fid) = iprot.readFieldBegin()
9024 
      if ftype == TType.STOP:
9025 
        break
9026 
      if fid == 0:
9027 
        if ftype == TType.I32:
9028 
          self.success = iprot.readI32();
9029 
        else:
9030 
          iprot.skip(ftype)
9031 
      else:
9032 
        iprot.skip(ftype)
9033 
      iprot.readFieldEnd()
9034 
    iprot.readStructEnd()
9035 
 
9036 
  def write(self, oprot):
9037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9039 
      return
9040 
    oprot.writeStructBegin('getItemCountByStatus_result')
9041 
    if self.success is not None:
9042 
      oprot.writeFieldBegin('success', TType.I32, 0)
9043 
      oprot.writeI32(self.success)
9044 
      oprot.writeFieldEnd()
9045 
    oprot.writeFieldStop()
9046 
    oprot.writeStructEnd()
9047 
 
9048 
  def validate(self):
9049 
    return
9050 
 
9051 
 
9052 
  def __repr__(self):
9053 
    L = ['%s=%r' % (key, value)
9054 
      for key, value in self.__dict__.iteritems()]
9055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9056 
 
9057 
  def __eq__(self, other):
9058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9059 
 
9060 
  def __ne__(self, other):
9061 
    return not (self == other)
9062 
 
9063 
class getBestSellers_args:
9064 
 
9065 
  thrift_spec = (
9066 
  )
9067 
 
9068 
  def read(self, iprot):
9069 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9070 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9071 
      return
9072 
    iprot.readStructBegin()
9073 
    while True:
9074 
      (fname, ftype, fid) = iprot.readFieldBegin()
9075 
      if ftype == TType.STOP:
9076 
        break
9077 
      else:
9078 
        iprot.skip(ftype)
9079 
      iprot.readFieldEnd()
9080 
    iprot.readStructEnd()
9081 
 
9082 
  def write(self, oprot):
9083 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9084 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9085 
      return
9086 
    oprot.writeStructBegin('getBestSellers_args')
9087 
    oprot.writeFieldStop()
9088 
    oprot.writeStructEnd()
9089 
 
9090 
  def validate(self):
9091 
    return
9092 
 
9093 
 
9094 
  def __repr__(self):
9095 
    L = ['%s=%r' % (key, value)
9096 
      for key, value in self.__dict__.iteritems()]
9097 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9098 
 
9099 
  def __eq__(self, other):
9100 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9101 
 
9102 
  def __ne__(self, other):
9103 
    return not (self == other)
9104 
 
9105 
class getBestSellers_result:
9106 
  """
9107 
  Attributes:
9108 
   - success
9109 
   - isex
9110 
  """
9111 
 
9112 
  thrift_spec = (
9113 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9114 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9115 
  )
9116 
 
9117 
  def __init__(self, success=None, isex=None,):
9118 
    self.success = success
9119 
    self.isex = isex
9120 
 
9121 
  def read(self, iprot):
9122 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9123 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9124 
      return
9125 
    iprot.readStructBegin()
9126 
    while True:
9127 
      (fname, ftype, fid) = iprot.readFieldBegin()
9128 
      if ftype == TType.STOP:
9129 
        break
9130 
      if fid == 0:
9131 
        if ftype == TType.LIST:
9132 
          self.success = []
8590 kshitij.so 9133 
          (_etype91, _size88) = iprot.readListBegin()
9134 
          for _i92 in xrange(_size88):
9135 
            _elem93 = Item()
9136 
            _elem93.read(iprot)
9137 
            self.success.append(_elem93)
5944 mandeep.dh 9138 
          iprot.readListEnd()
9139 
        else:
9140 
          iprot.skip(ftype)
9141 
      elif fid == 1:
9142 
        if ftype == TType.STRUCT:
9143 
          self.isex = CatalogServiceException()
9144 
          self.isex.read(iprot)
9145 
        else:
9146 
          iprot.skip(ftype)
9147 
      else:
9148 
        iprot.skip(ftype)
9149 
      iprot.readFieldEnd()
9150 
    iprot.readStructEnd()
9151 
 
9152 
  def write(self, oprot):
9153 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9154 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9155 
      return
9156 
    oprot.writeStructBegin('getBestSellers_result')
9157 
    if self.success is not None:
9158 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9159 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9160 
      for iter94 in self.success:
9161 
        iter94.write(oprot)
5944 mandeep.dh 9162 
      oprot.writeListEnd()
9163 
      oprot.writeFieldEnd()
9164 
    if self.isex is not None:
9165 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
9166 
      self.isex.write(oprot)
9167 
      oprot.writeFieldEnd()
9168 
    oprot.writeFieldStop()
9169 
    oprot.writeStructEnd()
9170 
 
9171 
  def validate(self):
9172 
    return
9173 
 
9174 
 
9175 
  def __repr__(self):
9176 
    L = ['%s=%r' % (key, value)
9177 
      for key, value in self.__dict__.iteritems()]
9178 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9179 
 
9180 
  def __eq__(self, other):
9181 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9182 
 
9183 
  def __ne__(self, other):
9184 
    return not (self == other)
9185 
 
9186 
class getBestSellersCatalogIds_args:
9187 
  """
9188 
  Attributes:
9189 
   - beginIndex
9190 
   - totalItems
9191 
   - brand
9192 
   - category
9193 
  """
9194 
 
9195 
  thrift_spec = (
9196 
    None, # 0
9197 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
9198 
    (2, TType.I64, 'totalItems', None, None, ), # 2
9199 
    (3, TType.STRING, 'brand', None, None, ), # 3
9200 
    (4, TType.I64, 'category', None, None, ), # 4
9201 
  )
9202 
 
9203 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
9204 
    self.beginIndex = beginIndex
9205 
    self.totalItems = totalItems
9206 
    self.brand = brand
9207 
    self.category = category
9208 
 
9209 
  def read(self, iprot):
9210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9212 
      return
9213 
    iprot.readStructBegin()
9214 
    while True:
9215 
      (fname, ftype, fid) = iprot.readFieldBegin()
9216 
      if ftype == TType.STOP:
9217 
        break
9218 
      if fid == 1:
9219 
        if ftype == TType.I64:
9220 
          self.beginIndex = iprot.readI64();
9221 
        else:
9222 
          iprot.skip(ftype)
9223 
      elif fid == 2:
9224 
        if ftype == TType.I64:
9225 
          self.totalItems = iprot.readI64();
9226 
        else:
9227 
          iprot.skip(ftype)
9228 
      elif fid == 3:
9229 
        if ftype == TType.STRING:
9230 
          self.brand = iprot.readString();
9231 
        else:
9232 
          iprot.skip(ftype)
9233 
      elif fid == 4:
9234 
        if ftype == TType.I64:
9235 
          self.category = iprot.readI64();
9236 
        else:
9237 
          iprot.skip(ftype)
9238 
      else:
9239 
        iprot.skip(ftype)
9240 
      iprot.readFieldEnd()
9241 
    iprot.readStructEnd()
9242 
 
9243 
  def write(self, oprot):
9244 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9245 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9246 
      return
9247 
    oprot.writeStructBegin('getBestSellersCatalogIds_args')
9248 
    if self.beginIndex is not None:
9249 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
9250 
      oprot.writeI64(self.beginIndex)
9251 
      oprot.writeFieldEnd()
9252 
    if self.totalItems is not None:
9253 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
9254 
      oprot.writeI64(self.totalItems)
9255 
      oprot.writeFieldEnd()
9256 
    if self.brand is not None:
9257 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9258 
      oprot.writeString(self.brand)
9259 
      oprot.writeFieldEnd()
9260 
    if self.category is not None:
9261 
      oprot.writeFieldBegin('category', TType.I64, 4)
9262 
      oprot.writeI64(self.category)
9263 
      oprot.writeFieldEnd()
9264 
    oprot.writeFieldStop()
9265 
    oprot.writeStructEnd()
9266 
 
9267 
  def validate(self):
9268 
    return
9269 
 
9270 
 
9271 
  def __repr__(self):
9272 
    L = ['%s=%r' % (key, value)
9273 
      for key, value in self.__dict__.iteritems()]
9274 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9275 
 
9276 
  def __eq__(self, other):
9277 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9278 
 
9279 
  def __ne__(self, other):
9280 
    return not (self == other)
9281 
 
9282 
class getBestSellersCatalogIds_result:
9283 
  """
9284 
  Attributes:
9285 
   - success
9286 
   - cex
9287 
  """
9288 
 
9289 
  thrift_spec = (
9290 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9291 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9292 
  )
9293 
 
9294 
  def __init__(self, success=None, cex=None,):
9295 
    self.success = success
9296 
    self.cex = cex
9297 
 
9298 
  def read(self, iprot):
9299 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9300 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9301 
      return
9302 
    iprot.readStructBegin()
9303 
    while True:
9304 
      (fname, ftype, fid) = iprot.readFieldBegin()
9305 
      if ftype == TType.STOP:
9306 
        break
9307 
      if fid == 0:
9308 
        if ftype == TType.LIST:
9309 
          self.success = []
8590 kshitij.so 9310 
          (_etype98, _size95) = iprot.readListBegin()
9311 
          for _i99 in xrange(_size95):
9312 
            _elem100 = iprot.readI64();
9313 
            self.success.append(_elem100)
5944 mandeep.dh 9314 
          iprot.readListEnd()
9315 
        else:
9316 
          iprot.skip(ftype)
9317 
      elif fid == 1:
9318 
        if ftype == TType.STRUCT:
9319 
          self.cex = CatalogServiceException()
9320 
          self.cex.read(iprot)
9321 
        else:
9322 
          iprot.skip(ftype)
9323 
      else:
9324 
        iprot.skip(ftype)
9325 
      iprot.readFieldEnd()
9326 
    iprot.readStructEnd()
9327 
 
9328 
  def write(self, oprot):
9329 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9330 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9331 
      return
9332 
    oprot.writeStructBegin('getBestSellersCatalogIds_result')
9333 
    if self.success is not None:
9334 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9335 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 9336 
      for iter101 in self.success:
9337 
        oprot.writeI64(iter101)
5944 mandeep.dh 9338 
      oprot.writeListEnd()
9339 
      oprot.writeFieldEnd()
9340 
    if self.cex is not None:
9341 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9342 
      self.cex.write(oprot)
9343 
      oprot.writeFieldEnd()
9344 
    oprot.writeFieldStop()
9345 
    oprot.writeStructEnd()
9346 
 
9347 
  def validate(self):
9348 
    return
9349 
 
9350 
 
9351 
  def __repr__(self):
9352 
    L = ['%s=%r' % (key, value)
9353 
      for key, value in self.__dict__.iteritems()]
9354 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9355 
 
9356 
  def __eq__(self, other):
9357 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9358 
 
9359 
  def __ne__(self, other):
9360 
    return not (self == other)
9361 
 
9362 
class getBestSellersCount_args:
9363 
 
9364 
  thrift_spec = (
9365 
  )
9366 
 
9367 
  def read(self, iprot):
9368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9370 
      return
9371 
    iprot.readStructBegin()
9372 
    while True:
9373 
      (fname, ftype, fid) = iprot.readFieldBegin()
9374 
      if ftype == TType.STOP:
9375 
        break
9376 
      else:
9377 
        iprot.skip(ftype)
9378 
      iprot.readFieldEnd()
9379 
    iprot.readStructEnd()
9380 
 
9381 
  def write(self, oprot):
9382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9384 
      return
9385 
    oprot.writeStructBegin('getBestSellersCount_args')
9386 
    oprot.writeFieldStop()
9387 
    oprot.writeStructEnd()
9388 
 
9389 
  def validate(self):
9390 
    return
9391 
 
9392 
 
9393 
  def __repr__(self):
9394 
    L = ['%s=%r' % (key, value)
9395 
      for key, value in self.__dict__.iteritems()]
9396 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9397 
 
9398 
  def __eq__(self, other):
9399 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9400 
 
9401 
  def __ne__(self, other):
9402 
    return not (self == other)
9403 
 
9404 
class getBestSellersCount_result:
9405 
  """
9406 
  Attributes:
9407 
   - success
9408 
   - cex
9409 
  """
9410 
 
9411 
  thrift_spec = (
9412 
    (0, TType.I64, 'success', None, None, ), # 0
9413 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9414 
  )
9415 
 
9416 
  def __init__(self, success=None, cex=None,):
9417 
    self.success = success
9418 
    self.cex = cex
9419 
 
9420 
  def read(self, iprot):
9421 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9422 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9423 
      return
9424 
    iprot.readStructBegin()
9425 
    while True:
9426 
      (fname, ftype, fid) = iprot.readFieldBegin()
9427 
      if ftype == TType.STOP:
9428 
        break
9429 
      if fid == 0:
9430 
        if ftype == TType.I64:
9431 
          self.success = iprot.readI64();
9432 
        else:
9433 
          iprot.skip(ftype)
9434 
      elif fid == 1:
9435 
        if ftype == TType.STRUCT:
9436 
          self.cex = CatalogServiceException()
9437 
          self.cex.read(iprot)
9438 
        else:
9439 
          iprot.skip(ftype)
9440 
      else:
9441 
        iprot.skip(ftype)
9442 
      iprot.readFieldEnd()
9443 
    iprot.readStructEnd()
9444 
 
9445 
  def write(self, oprot):
9446 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9447 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9448 
      return
9449 
    oprot.writeStructBegin('getBestSellersCount_result')
9450 
    if self.success is not None:
9451 
      oprot.writeFieldBegin('success', TType.I64, 0)
9452 
      oprot.writeI64(self.success)
9453 
      oprot.writeFieldEnd()
9454 
    if self.cex is not None:
9455 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9456 
      self.cex.write(oprot)
9457 
      oprot.writeFieldEnd()
9458 
    oprot.writeFieldStop()
9459 
    oprot.writeStructEnd()
9460 
 
9461 
  def validate(self):
9462 
    return
9463 
 
9464 
 
9465 
  def __repr__(self):
9466 
    L = ['%s=%r' % (key, value)
9467 
      for key, value in self.__dict__.iteritems()]
9468 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9469 
 
9470 
  def __eq__(self, other):
9471 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9472 
 
9473 
  def __ne__(self, other):
9474 
    return not (self == other)
9475 
 
9476 
class getBestDeals_args:
9477 
 
9478 
  thrift_spec = (
9479 
  )
9480 
 
9481 
  def read(self, iprot):
9482 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9483 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9484 
      return
9485 
    iprot.readStructBegin()
9486 
    while True:
9487 
      (fname, ftype, fid) = iprot.readFieldBegin()
9488 
      if ftype == TType.STOP:
9489 
        break
9490 
      else:
9491 
        iprot.skip(ftype)
9492 
      iprot.readFieldEnd()
9493 
    iprot.readStructEnd()
9494 
 
9495 
  def write(self, oprot):
9496 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9497 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9498 
      return
9499 
    oprot.writeStructBegin('getBestDeals_args')
9500 
    oprot.writeFieldStop()
9501 
    oprot.writeStructEnd()
9502 
 
9503 
  def validate(self):
9504 
    return
9505 
 
9506 
 
9507 
  def __repr__(self):
9508 
    L = ['%s=%r' % (key, value)
9509 
      for key, value in self.__dict__.iteritems()]
9510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9511 
 
9512 
  def __eq__(self, other):
9513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9514 
 
9515 
  def __ne__(self, other):
9516 
    return not (self == other)
9517 
 
9518 
class getBestDeals_result:
9519 
  """
9520 
  Attributes:
9521 
   - success
9522 
   - isex
9523 
  """
9524 
 
9525 
  thrift_spec = (
9526 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9527 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9528 
  )
9529 
 
9530 
  def __init__(self, success=None, isex=None,):
9531 
    self.success = success
9532 
    self.isex = isex
9533 
 
9534 
  def read(self, iprot):
9535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9537 
      return
9538 
    iprot.readStructBegin()
9539 
    while True:
9540 
      (fname, ftype, fid) = iprot.readFieldBegin()
9541 
      if ftype == TType.STOP:
9542 
        break
9543 
      if fid == 0:
9544 
        if ftype == TType.LIST:
9545 
          self.success = []
8590 kshitij.so 9546 
          (_etype105, _size102) = iprot.readListBegin()
9547 
          for _i106 in xrange(_size102):
9548 
            _elem107 = Item()
9549 
            _elem107.read(iprot)
9550 
            self.success.append(_elem107)
5944 mandeep.dh 9551 
          iprot.readListEnd()
9552 
        else:
9553 
          iprot.skip(ftype)
9554 
      elif fid == 1:
9555 
        if ftype == TType.STRUCT:
9556 
          self.isex = CatalogServiceException()
9557 
          self.isex.read(iprot)
9558 
        else:
9559 
          iprot.skip(ftype)
9560 
      else:
9561 
        iprot.skip(ftype)
9562 
      iprot.readFieldEnd()
9563 
    iprot.readStructEnd()
9564 
 
9565 
  def write(self, oprot):
9566 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9567 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9568 
      return
9569 
    oprot.writeStructBegin('getBestDeals_result')
9570 
    if self.success is not None:
9571 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9572 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9573 
      for iter108 in self.success:
9574 
        iter108.write(oprot)
5944 mandeep.dh 9575 
      oprot.writeListEnd()
9576 
      oprot.writeFieldEnd()
9577 
    if self.isex is not None:
9578 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
9579 
      self.isex.write(oprot)
9580 
      oprot.writeFieldEnd()
9581 
    oprot.writeFieldStop()
9582 
    oprot.writeStructEnd()
9583 
 
9584 
  def validate(self):
9585 
    return
9586 
 
9587 
 
9588 
  def __repr__(self):
9589 
    L = ['%s=%r' % (key, value)
9590 
      for key, value in self.__dict__.iteritems()]
9591 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9592 
 
9593 
  def __eq__(self, other):
9594 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9595 
 
9596 
  def __ne__(self, other):
9597 
    return not (self == other)
9598 
 
9599 
class getBestDealsCatalogIds_args:
9600 
  """
9601 
  Attributes:
9602 
   - beginIndex
9603 
   - totalItems
9604 
   - brand
9605 
   - category
9606 
  """
9607 
 
9608 
  thrift_spec = (
9609 
    None, # 0
9610 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
9611 
    (2, TType.I64, 'totalItems', None, None, ), # 2
9612 
    (3, TType.STRING, 'brand', None, None, ), # 3
9613 
    (4, TType.I64, 'category', None, None, ), # 4
9614 
  )
9615 
 
9616 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
9617 
    self.beginIndex = beginIndex
9618 
    self.totalItems = totalItems
9619 
    self.brand = brand
9620 
    self.category = category
9621 
 
9622 
  def read(self, iprot):
9623 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9624 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9625 
      return
9626 
    iprot.readStructBegin()
9627 
    while True:
9628 
      (fname, ftype, fid) = iprot.readFieldBegin()
9629 
      if ftype == TType.STOP:
9630 
        break
9631 
      if fid == 1:
9632 
        if ftype == TType.I64:
9633 
          self.beginIndex = iprot.readI64();
9634 
        else:
9635 
          iprot.skip(ftype)
9636 
      elif fid == 2:
9637 
        if ftype == TType.I64:
9638 
          self.totalItems = iprot.readI64();
9639 
        else:
9640 
          iprot.skip(ftype)
9641 
      elif fid == 3:
9642 
        if ftype == TType.STRING:
9643 
          self.brand = iprot.readString();
9644 
        else:
9645 
          iprot.skip(ftype)
9646 
      elif fid == 4:
9647 
        if ftype == TType.I64:
9648 
          self.category = iprot.readI64();
9649 
        else:
9650 
          iprot.skip(ftype)
9651 
      else:
9652 
        iprot.skip(ftype)
9653 
      iprot.readFieldEnd()
9654 
    iprot.readStructEnd()
9655 
 
9656 
  def write(self, oprot):
9657 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9658 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9659 
      return
9660 
    oprot.writeStructBegin('getBestDealsCatalogIds_args')
9661 
    if self.beginIndex is not None:
9662 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
9663 
      oprot.writeI64(self.beginIndex)
9664 
      oprot.writeFieldEnd()
9665 
    if self.totalItems is not None:
9666 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
9667 
      oprot.writeI64(self.totalItems)
9668 
      oprot.writeFieldEnd()
9669 
    if self.brand is not None:
9670 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9671 
      oprot.writeString(self.brand)
9672 
      oprot.writeFieldEnd()
9673 
    if self.category is not None:
9674 
      oprot.writeFieldBegin('category', TType.I64, 4)
9675 
      oprot.writeI64(self.category)
9676 
      oprot.writeFieldEnd()
9677 
    oprot.writeFieldStop()
9678 
    oprot.writeStructEnd()
9679 
 
9680 
  def validate(self):
9681 
    return
9682 
 
9683 
 
9684 
  def __repr__(self):
9685 
    L = ['%s=%r' % (key, value)
9686 
      for key, value in self.__dict__.iteritems()]
9687 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9688 
 
9689 
  def __eq__(self, other):
9690 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9691 
 
9692 
  def __ne__(self, other):
9693 
    return not (self == other)
9694 
 
9695 
class getBestDealsCatalogIds_result:
9696 
  """
9697 
  Attributes:
9698 
   - success
9699 
   - cex
9700 
  """
9701 
 
9702 
  thrift_spec = (
9703 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9704 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9705 
  )
9706 
 
9707 
  def __init__(self, success=None, cex=None,):
9708 
    self.success = success
9709 
    self.cex = cex
9710 
 
9711 
  def read(self, iprot):
9712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9714 
      return
9715 
    iprot.readStructBegin()
9716 
    while True:
9717 
      (fname, ftype, fid) = iprot.readFieldBegin()
9718 
      if ftype == TType.STOP:
9719 
        break
9720 
      if fid == 0:
9721 
        if ftype == TType.LIST:
9722 
          self.success = []
8590 kshitij.so 9723 
          (_etype112, _size109) = iprot.readListBegin()
9724 
          for _i113 in xrange(_size109):
9725 
            _elem114 = iprot.readI64();
9726 
            self.success.append(_elem114)
5944 mandeep.dh 9727 
          iprot.readListEnd()
9728 
        else:
9729 
          iprot.skip(ftype)
9730 
      elif fid == 1:
9731 
        if ftype == TType.STRUCT:
9732 
          self.cex = CatalogServiceException()
9733 
          self.cex.read(iprot)
9734 
        else:
9735 
          iprot.skip(ftype)
9736 
      else:
9737 
        iprot.skip(ftype)
9738 
      iprot.readFieldEnd()
9739 
    iprot.readStructEnd()
9740 
 
9741 
  def write(self, oprot):
9742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9744 
      return
9745 
    oprot.writeStructBegin('getBestDealsCatalogIds_result')
9746 
    if self.success is not None:
9747 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9748 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 9749 
      for iter115 in self.success:
9750 
        oprot.writeI64(iter115)
5944 mandeep.dh 9751 
      oprot.writeListEnd()
9752 
      oprot.writeFieldEnd()
9753 
    if self.cex is not None:
9754 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9755 
      self.cex.write(oprot)
9756 
      oprot.writeFieldEnd()
9757 
    oprot.writeFieldStop()
9758 
    oprot.writeStructEnd()
9759 
 
9760 
  def validate(self):
9761 
    return
9762 
 
9763 
 
9764 
  def __repr__(self):
9765 
    L = ['%s=%r' % (key, value)
9766 
      for key, value in self.__dict__.iteritems()]
9767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9768 
 
9769 
  def __eq__(self, other):
9770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9771 
 
9772 
  def __ne__(self, other):
9773 
    return not (self == other)
9774 
 
9775 
class getBestDealsCount_args:
9776 
 
9777 
  thrift_spec = (
9778 
  )
9779 
 
9780 
  def read(self, iprot):
9781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9783 
      return
9784 
    iprot.readStructBegin()
9785 
    while True:
9786 
      (fname, ftype, fid) = iprot.readFieldBegin()
9787 
      if ftype == TType.STOP:
9788 
        break
9789 
      else:
9790 
        iprot.skip(ftype)
9791 
      iprot.readFieldEnd()
9792 
    iprot.readStructEnd()
9793 
 
9794 
  def write(self, oprot):
9795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9797 
      return
9798 
    oprot.writeStructBegin('getBestDealsCount_args')
9799 
    oprot.writeFieldStop()
9800 
    oprot.writeStructEnd()
9801 
 
9802 
  def validate(self):
9803 
    return
9804 
 
9805 
 
9806 
  def __repr__(self):
9807 
    L = ['%s=%r' % (key, value)
9808 
      for key, value in self.__dict__.iteritems()]
9809 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9810 
 
9811 
  def __eq__(self, other):
9812 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9813 
 
9814 
  def __ne__(self, other):
9815 
    return not (self == other)
9816 
 
9817 
class getBestDealsCount_result:
9818 
  """
9819 
  Attributes:
9820 
   - success
9821 
   - cex
9822 
  """
9823 
 
9824 
  thrift_spec = (
9825 
    (0, TType.I64, 'success', None, None, ), # 0
9826 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9827 
  )
9828 
 
9829 
  def __init__(self, success=None, cex=None,):
9830 
    self.success = success
9831 
    self.cex = cex
9832 
 
9833 
  def read(self, iprot):
9834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9836 
      return
9837 
    iprot.readStructBegin()
9838 
    while True:
9839 
      (fname, ftype, fid) = iprot.readFieldBegin()
9840 
      if ftype == TType.STOP:
9841 
        break
9842 
      if fid == 0:
9843 
        if ftype == TType.I64:
9844 
          self.success = iprot.readI64();
9845 
        else:
9846 
          iprot.skip(ftype)
9847 
      elif fid == 1:
9848 
        if ftype == TType.STRUCT:
9849 
          self.cex = CatalogServiceException()
9850 
          self.cex.read(iprot)
9851 
        else:
9852 
          iprot.skip(ftype)
9853 
      else:
9854 
        iprot.skip(ftype)
9855 
      iprot.readFieldEnd()
9856 
    iprot.readStructEnd()
9857 
 
9858 
  def write(self, oprot):
9859 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9860 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9861 
      return
9862 
    oprot.writeStructBegin('getBestDealsCount_result')
9863 
    if self.success is not None:
9864 
      oprot.writeFieldBegin('success', TType.I64, 0)
9865 
      oprot.writeI64(self.success)
9866 
      oprot.writeFieldEnd()
9867 
    if self.cex is not None:
9868 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9869 
      self.cex.write(oprot)
9870 
      oprot.writeFieldEnd()
9871 
    oprot.writeFieldStop()
9872 
    oprot.writeStructEnd()
9873 
 
9874 
  def validate(self):
9875 
    return
9876 
 
9877 
 
9878 
  def __repr__(self):
9879 
    L = ['%s=%r' % (key, value)
9880 
      for key, value in self.__dict__.iteritems()]
9881 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9882 
 
9883 
  def __eq__(self, other):
9884 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9885 
 
9886 
  def __ne__(self, other):
9887 
    return not (self == other)
9888 
 
9889 
class getComingSoon_args:
9890 
 
9891 
  thrift_spec = (
9892 
  )
9893 
 
9894 
  def read(self, iprot):
9895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9897 
      return
9898 
    iprot.readStructBegin()
9899 
    while True:
9900 
      (fname, ftype, fid) = iprot.readFieldBegin()
9901 
      if ftype == TType.STOP:
9902 
        break
9903 
      else:
9904 
        iprot.skip(ftype)
9905 
      iprot.readFieldEnd()
9906 
    iprot.readStructEnd()
9907 
 
9908 
  def write(self, oprot):
9909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9911 
      return
9912 
    oprot.writeStructBegin('getComingSoon_args')
9913 
    oprot.writeFieldStop()
9914 
    oprot.writeStructEnd()
9915 
 
9916 
  def validate(self):
9917 
    return
9918 
 
9919 
 
9920 
  def __repr__(self):
9921 
    L = ['%s=%r' % (key, value)
9922 
      for key, value in self.__dict__.iteritems()]
9923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9924 
 
9925 
  def __eq__(self, other):
9926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9927 
 
9928 
  def __ne__(self, other):
9929 
    return not (self == other)
9930 
 
9931 
class getComingSoon_result:
9932 
  """
9933 
  Attributes:
9934 
   - success
9935 
   - isex
9936 
  """
9937 
 
9938 
  thrift_spec = (
9939 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9940 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9941 
  )
9942 
 
9943 
  def __init__(self, success=None, isex=None,):
9944 
    self.success = success
9945 
    self.isex = isex
9946 
 
9947 
  def read(self, iprot):
9948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9950 
      return
9951 
    iprot.readStructBegin()
9952 
    while True:
9953 
      (fname, ftype, fid) = iprot.readFieldBegin()
9954 
      if ftype == TType.STOP:
9955 
        break
9956 
      if fid == 0:
9957 
        if ftype == TType.LIST:
9958 
          self.success = []
8590 kshitij.so 9959 
          (_etype119, _size116) = iprot.readListBegin()
9960 
          for _i120 in xrange(_size116):
9961 
            _elem121 = Item()
9962 
            _elem121.read(iprot)
9963 
            self.success.append(_elem121)
5944 mandeep.dh 9964 
          iprot.readListEnd()
9965 
        else:
9966 
          iprot.skip(ftype)
9967 
      elif fid == 1:
9968 
        if ftype == TType.STRUCT:
9969 
          self.isex = CatalogServiceException()
9970 
          self.isex.read(iprot)
9971 
        else:
9972 
          iprot.skip(ftype)
9973 
      else:
9974 
        iprot.skip(ftype)
9975 
      iprot.readFieldEnd()
9976 
    iprot.readStructEnd()
9977 
 
9978 
  def write(self, oprot):
9979 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9980 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9981 
      return
9982 
    oprot.writeStructBegin('getComingSoon_result')
9983 
    if self.success is not None:
9984 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9985 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9986 
      for iter122 in self.success:
9987 
        iter122.write(oprot)
5944 mandeep.dh 9988 
      oprot.writeListEnd()
9989 
      oprot.writeFieldEnd()
9990 
    if self.isex is not None:
9991 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
9992 
      self.isex.write(oprot)
9993 
      oprot.writeFieldEnd()
9994 
    oprot.writeFieldStop()
9995 
    oprot.writeStructEnd()
9996 
 
9997 
  def validate(self):
9998 
    return
9999 
 
10000 
 
10001 
  def __repr__(self):
10002 
    L = ['%s=%r' % (key, value)
10003 
      for key, value in self.__dict__.iteritems()]
10004 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10005 
 
10006 
  def __eq__(self, other):
10007 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10008 
 
10009 
  def __ne__(self, other):
10010 
    return not (self == other)
10011 
 
10012 
class getComingSoonCatalogIds_args:
10013 
  """
10014 
  Attributes:
10015 
   - beginIndex
10016 
   - totalItems
10017 
   - brand
10018 
   - category
10019 
  """
10020 
 
10021 
  thrift_spec = (
10022 
    None, # 0
10023 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
10024 
    (2, TType.I64, 'totalItems', None, None, ), # 2
10025 
    (3, TType.STRING, 'brand', None, None, ), # 3
10026 
    (4, TType.I64, 'category', None, None, ), # 4
10027 
  )
10028 
 
10029 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
10030 
    self.beginIndex = beginIndex
10031 
    self.totalItems = totalItems
10032 
    self.brand = brand
10033 
    self.category = category
10034 
 
10035 
  def read(self, iprot):
10036 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10037 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10038 
      return
10039 
    iprot.readStructBegin()
10040 
    while True:
10041 
      (fname, ftype, fid) = iprot.readFieldBegin()
10042 
      if ftype == TType.STOP:
10043 
        break
10044 
      if fid == 1:
10045 
        if ftype == TType.I64:
10046 
          self.beginIndex = iprot.readI64();
10047 
        else:
10048 
          iprot.skip(ftype)
10049 
      elif fid == 2:
10050 
        if ftype == TType.I64:
10051 
          self.totalItems = iprot.readI64();
10052 
        else:
10053 
          iprot.skip(ftype)
10054 
      elif fid == 3:
10055 
        if ftype == TType.STRING:
10056 
          self.brand = iprot.readString();
10057 
        else:
10058 
          iprot.skip(ftype)
10059 
      elif fid == 4:
10060 
        if ftype == TType.I64:
10061 
          self.category = iprot.readI64();
10062 
        else:
10063 
          iprot.skip(ftype)
10064 
      else:
10065 
        iprot.skip(ftype)
10066 
      iprot.readFieldEnd()
10067 
    iprot.readStructEnd()
10068 
 
10069 
  def write(self, oprot):
10070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10072 
      return
10073 
    oprot.writeStructBegin('getComingSoonCatalogIds_args')
10074 
    if self.beginIndex is not None:
10075 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
10076 
      oprot.writeI64(self.beginIndex)
10077 
      oprot.writeFieldEnd()
10078 
    if self.totalItems is not None:
10079 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
10080 
      oprot.writeI64(self.totalItems)
10081 
      oprot.writeFieldEnd()
10082 
    if self.brand is not None:
10083 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
10084 
      oprot.writeString(self.brand)
10085 
      oprot.writeFieldEnd()
10086 
    if self.category is not None:
10087 
      oprot.writeFieldBegin('category', TType.I64, 4)
10088 
      oprot.writeI64(self.category)
10089 
      oprot.writeFieldEnd()
10090 
    oprot.writeFieldStop()
10091 
    oprot.writeStructEnd()
10092 
 
10093 
  def validate(self):
10094 
    return
10095 
 
10096 
 
10097 
  def __repr__(self):
10098 
    L = ['%s=%r' % (key, value)
10099 
      for key, value in self.__dict__.iteritems()]
10100 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10101 
 
10102 
  def __eq__(self, other):
10103 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10104 
 
10105 
  def __ne__(self, other):
10106 
    return not (self == other)
10107 
 
10108 
class getComingSoonCatalogIds_result:
10109 
  """
10110 
  Attributes:
10111 
   - success
10112 
   - cex
10113 
  """
10114 
 
10115 
  thrift_spec = (
10116 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10117 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10118 
  )
10119 
 
10120 
  def __init__(self, success=None, cex=None,):
10121 
    self.success = success
10122 
    self.cex = cex
10123 
 
10124 
  def read(self, iprot):
10125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10127 
      return
10128 
    iprot.readStructBegin()
10129 
    while True:
10130 
      (fname, ftype, fid) = iprot.readFieldBegin()
10131 
      if ftype == TType.STOP:
10132 
        break
10133 
      if fid == 0:
10134 
        if ftype == TType.LIST:
10135 
          self.success = []
8590 kshitij.so 10136 
          (_etype126, _size123) = iprot.readListBegin()
10137 
          for _i127 in xrange(_size123):
10138 
            _elem128 = iprot.readI64();
10139 
            self.success.append(_elem128)
5944 mandeep.dh 10140 
          iprot.readListEnd()
10141 
        else:
10142 
          iprot.skip(ftype)
10143 
      elif fid == 1:
10144 
        if ftype == TType.STRUCT:
10145 
          self.cex = CatalogServiceException()
10146 
          self.cex.read(iprot)
10147 
        else:
10148 
          iprot.skip(ftype)
10149 
      else:
10150 
        iprot.skip(ftype)
10151 
      iprot.readFieldEnd()
10152 
    iprot.readStructEnd()
10153 
 
10154 
  def write(self, oprot):
10155 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10156 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10157 
      return
10158 
    oprot.writeStructBegin('getComingSoonCatalogIds_result')
10159 
    if self.success is not None:
10160 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10161 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 10162 
      for iter129 in self.success:
10163 
        oprot.writeI64(iter129)
5944 mandeep.dh 10164 
      oprot.writeListEnd()
10165 
      oprot.writeFieldEnd()
10166 
    if self.cex is not None:
10167 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10168 
      self.cex.write(oprot)
10169 
      oprot.writeFieldEnd()
10170 
    oprot.writeFieldStop()
10171 
    oprot.writeStructEnd()
10172 
 
10173 
  def validate(self):
10174 
    return
10175 
 
10176 
 
10177 
  def __repr__(self):
10178 
    L = ['%s=%r' % (key, value)
10179 
      for key, value in self.__dict__.iteritems()]
10180 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10181 
 
10182 
  def __eq__(self, other):
10183 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10184 
 
10185 
  def __ne__(self, other):
10186 
    return not (self == other)
10187 
 
10188 
class getComingSoonCount_args:
10189 
 
10190 
  thrift_spec = (
10191 
  )
10192 
 
10193 
  def read(self, iprot):
10194 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10195 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10196 
      return
10197 
    iprot.readStructBegin()
10198 
    while True:
10199 
      (fname, ftype, fid) = iprot.readFieldBegin()
10200 
      if ftype == TType.STOP:
10201 
        break
10202 
      else:
10203 
        iprot.skip(ftype)
10204 
      iprot.readFieldEnd()
10205 
    iprot.readStructEnd()
10206 
 
10207 
  def write(self, oprot):
10208 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10209 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10210 
      return
10211 
    oprot.writeStructBegin('getComingSoonCount_args')
10212 
    oprot.writeFieldStop()
10213 
    oprot.writeStructEnd()
10214 
 
10215 
  def validate(self):
10216 
    return
10217 
 
10218 
 
10219 
  def __repr__(self):
10220 
    L = ['%s=%r' % (key, value)
10221 
      for key, value in self.__dict__.iteritems()]
10222 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10223 
 
10224 
  def __eq__(self, other):
10225 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10226 
 
10227 
  def __ne__(self, other):
10228 
    return not (self == other)
10229 
 
10230 
class getComingSoonCount_result:
10231 
  """
10232 
  Attributes:
10233 
   - success
10234 
   - cex
10235 
  """
10236 
 
10237 
  thrift_spec = (
10238 
    (0, TType.I64, 'success', None, None, ), # 0
10239 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10240 
  )
10241 
 
10242 
  def __init__(self, success=None, cex=None,):
10243 
    self.success = success
10244 
    self.cex = cex
10245 
 
10246 
  def read(self, iprot):
10247 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10248 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10249 
      return
10250 
    iprot.readStructBegin()
10251 
    while True:
10252 
      (fname, ftype, fid) = iprot.readFieldBegin()
10253 
      if ftype == TType.STOP:
10254 
        break
10255 
      if fid == 0:
10256 
        if ftype == TType.I64:
10257 
          self.success = iprot.readI64();
10258 
        else:
10259 
          iprot.skip(ftype)
10260 
      elif fid == 1:
10261 
        if ftype == TType.STRUCT:
10262 
          self.cex = CatalogServiceException()
10263 
          self.cex.read(iprot)
10264 
        else:
10265 
          iprot.skip(ftype)
10266 
      else:
10267 
        iprot.skip(ftype)
10268 
      iprot.readFieldEnd()
10269 
    iprot.readStructEnd()
10270 
 
10271 
  def write(self, oprot):
10272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10274 
      return
10275 
    oprot.writeStructBegin('getComingSoonCount_result')
10276 
    if self.success is not None:
10277 
      oprot.writeFieldBegin('success', TType.I64, 0)
10278 
      oprot.writeI64(self.success)
10279 
      oprot.writeFieldEnd()
10280 
    if self.cex is not None:
10281 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10282 
      self.cex.write(oprot)
10283 
      oprot.writeFieldEnd()
10284 
    oprot.writeFieldStop()
10285 
    oprot.writeStructEnd()
10286 
 
10287 
  def validate(self):
10288 
    return
10289 
 
10290 
 
10291 
  def __repr__(self):
10292 
    L = ['%s=%r' % (key, value)
10293 
      for key, value in self.__dict__.iteritems()]
10294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10295 
 
10296 
  def __eq__(self, other):
10297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10298 
 
10299 
  def __ne__(self, other):
10300 
    return not (self == other)
10301 
 
10302 
class getLatestArrivals_args:
10303 
 
10304 
  thrift_spec = (
10305 
  )
10306 
 
10307 
  def read(self, iprot):
10308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10310 
      return
10311 
    iprot.readStructBegin()
10312 
    while True:
10313 
      (fname, ftype, fid) = iprot.readFieldBegin()
10314 
      if ftype == TType.STOP:
10315 
        break
10316 
      else:
10317 
        iprot.skip(ftype)
10318 
      iprot.readFieldEnd()
10319 
    iprot.readStructEnd()
10320 
 
10321 
  def write(self, oprot):
10322 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10323 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10324 
      return
10325 
    oprot.writeStructBegin('getLatestArrivals_args')
10326 
    oprot.writeFieldStop()
10327 
    oprot.writeStructEnd()
10328 
 
10329 
  def validate(self):
10330 
    return
10331 
 
10332 
 
10333 
  def __repr__(self):
10334 
    L = ['%s=%r' % (key, value)
10335 
      for key, value in self.__dict__.iteritems()]
10336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10337 
 
10338 
  def __eq__(self, other):
10339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10340 
 
10341 
  def __ne__(self, other):
10342 
    return not (self == other)
10343 
 
10344 
class getLatestArrivals_result:
10345 
  """
10346 
  Attributes:
10347 
   - success
10348 
   - isex
10349 
  """
10350 
 
10351 
  thrift_spec = (
10352 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10353 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10354 
  )
10355 
 
10356 
  def __init__(self, success=None, isex=None,):
10357 
    self.success = success
10358 
    self.isex = isex
10359 
 
10360 
  def read(self, iprot):
10361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10363 
      return
10364 
    iprot.readStructBegin()
10365 
    while True:
10366 
      (fname, ftype, fid) = iprot.readFieldBegin()
10367 
      if ftype == TType.STOP:
10368 
        break
10369 
      if fid == 0:
10370 
        if ftype == TType.LIST:
10371 
          self.success = []
8590 kshitij.so 10372 
          (_etype133, _size130) = iprot.readListBegin()
10373 
          for _i134 in xrange(_size130):
10374 
            _elem135 = Item()
10375 
            _elem135.read(iprot)
10376 
            self.success.append(_elem135)
5944 mandeep.dh 10377 
          iprot.readListEnd()
10378 
        else:
10379 
          iprot.skip(ftype)
10380 
      elif fid == 1:
10381 
        if ftype == TType.STRUCT:
10382 
          self.isex = CatalogServiceException()
10383 
          self.isex.read(iprot)
10384 
        else:
10385 
          iprot.skip(ftype)
10386 
      else:
10387 
        iprot.skip(ftype)
10388 
      iprot.readFieldEnd()
10389 
    iprot.readStructEnd()
10390 
 
10391 
  def write(self, oprot):
10392 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10393 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10394 
      return
10395 
    oprot.writeStructBegin('getLatestArrivals_result')
10396 
    if self.success is not None:
10397 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10398 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10399 
      for iter136 in self.success:
10400 
        iter136.write(oprot)
5944 mandeep.dh 10401 
      oprot.writeListEnd()
10402 
      oprot.writeFieldEnd()
10403 
    if self.isex is not None:
10404 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
10405 
      self.isex.write(oprot)
10406 
      oprot.writeFieldEnd()
10407 
    oprot.writeFieldStop()
10408 
    oprot.writeStructEnd()
10409 
 
10410 
  def validate(self):
10411 
    return
10412 
 
10413 
 
10414 
  def __repr__(self):
10415 
    L = ['%s=%r' % (key, value)
10416 
      for key, value in self.__dict__.iteritems()]
10417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10418 
 
10419 
  def __eq__(self, other):
10420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10421 
 
10422 
  def __ne__(self, other):
10423 
    return not (self == other)
10424 
 
10425 
class getLatestArrivalsCatalogIds_args:
10426 
  """
10427 
  Attributes:
10428 
   - beginIndex
10429 
   - totalItems
10430 
   - brand
10431 
   - categories
10432 
  """
10433 
 
10434 
  thrift_spec = (
10435 
    None, # 0
10436 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
10437 
    (2, TType.I64, 'totalItems', None, None, ), # 2
10438 
    (3, TType.STRING, 'brand', None, None, ), # 3
10439 
    (4, TType.LIST, 'categories', (TType.I64,None), None, ), # 4
10440 
  )
10441 
 
10442 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, categories=None,):
10443 
    self.beginIndex = beginIndex
10444 
    self.totalItems = totalItems
10445 
    self.brand = brand
10446 
    self.categories = categories
10447 
 
10448 
  def read(self, iprot):
10449 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10450 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10451 
      return
10452 
    iprot.readStructBegin()
10453 
    while True:
10454 
      (fname, ftype, fid) = iprot.readFieldBegin()
10455 
      if ftype == TType.STOP:
10456 
        break
10457 
      if fid == 1:
10458 
        if ftype == TType.I64:
10459 
          self.beginIndex = iprot.readI64();
10460 
        else:
10461 
          iprot.skip(ftype)
10462 
      elif fid == 2:
10463 
        if ftype == TType.I64:
10464 
          self.totalItems = iprot.readI64();
10465 
        else:
10466 
          iprot.skip(ftype)
10467 
      elif fid == 3:
10468 
        if ftype == TType.STRING:
10469 
          self.brand = iprot.readString();
10470 
        else:
10471 
          iprot.skip(ftype)
10472 
      elif fid == 4:
10473 
        if ftype == TType.LIST:
10474 
          self.categories = []
8590 kshitij.so 10475 
          (_etype140, _size137) = iprot.readListBegin()
10476 
          for _i141 in xrange(_size137):
10477 
            _elem142 = iprot.readI64();
10478 
            self.categories.append(_elem142)
5944 mandeep.dh 10479 
          iprot.readListEnd()
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('getLatestArrivalsCatalogIds_args')
10492 
    if self.beginIndex is not None:
10493 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
10494 
      oprot.writeI64(self.beginIndex)
10495 
      oprot.writeFieldEnd()
10496 
    if self.totalItems is not None:
10497 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
10498 
      oprot.writeI64(self.totalItems)
10499 
      oprot.writeFieldEnd()
10500 
    if self.brand is not None:
10501 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
10502 
      oprot.writeString(self.brand)
10503 
      oprot.writeFieldEnd()
10504 
    if self.categories is not None:
10505 
      oprot.writeFieldBegin('categories', TType.LIST, 4)
10506 
      oprot.writeListBegin(TType.I64, len(self.categories))
8590 kshitij.so 10507 
      for iter143 in self.categories:
10508 
        oprot.writeI64(iter143)
5944 mandeep.dh 10509 
      oprot.writeListEnd()
10510 
      oprot.writeFieldEnd()
10511 
    oprot.writeFieldStop()
10512 
    oprot.writeStructEnd()
10513 
 
10514 
  def validate(self):
10515 
    return
10516 
 
10517 
 
10518 
  def __repr__(self):
10519 
    L = ['%s=%r' % (key, value)
10520 
      for key, value in self.__dict__.iteritems()]
10521 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10522 
 
10523 
  def __eq__(self, other):
10524 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10525 
 
10526 
  def __ne__(self, other):
10527 
    return not (self == other)
10528 
 
10529 
class getLatestArrivalsCatalogIds_result:
10530 
  """
10531 
  Attributes:
10532 
   - success
10533 
   - cex
10534 
  """
10535 
 
10536 
  thrift_spec = (
10537 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10538 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10539 
  )
10540 
 
10541 
  def __init__(self, success=None, cex=None,):
10542 
    self.success = success
10543 
    self.cex = cex
10544 
 
10545 
  def read(self, iprot):
10546 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10547 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10548 
      return
10549 
    iprot.readStructBegin()
10550 
    while True:
10551 
      (fname, ftype, fid) = iprot.readFieldBegin()
10552 
      if ftype == TType.STOP:
10553 
        break
10554 
      if fid == 0:
10555 
        if ftype == TType.LIST:
10556 
          self.success = []
8590 kshitij.so 10557 
          (_etype147, _size144) = iprot.readListBegin()
10558 
          for _i148 in xrange(_size144):
10559 
            _elem149 = iprot.readI64();
10560 
            self.success.append(_elem149)
5944 mandeep.dh 10561 
          iprot.readListEnd()
10562 
        else:
10563 
          iprot.skip(ftype)
10564 
      elif fid == 1:
10565 
        if ftype == TType.STRUCT:
10566 
          self.cex = CatalogServiceException()
10567 
          self.cex.read(iprot)
10568 
        else:
10569 
          iprot.skip(ftype)
10570 
      else:
10571 
        iprot.skip(ftype)
10572 
      iprot.readFieldEnd()
10573 
    iprot.readStructEnd()
10574 
 
10575 
  def write(self, oprot):
10576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10578 
      return
10579 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_result')
10580 
    if self.success is not None:
10581 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10582 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 10583 
      for iter150 in self.success:
10584 
        oprot.writeI64(iter150)
5944 mandeep.dh 10585 
      oprot.writeListEnd()
10586 
      oprot.writeFieldEnd()
10587 
    if self.cex is not None:
10588 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10589 
      self.cex.write(oprot)
10590 
      oprot.writeFieldEnd()
10591 
    oprot.writeFieldStop()
10592 
    oprot.writeStructEnd()
10593 
 
10594 
  def validate(self):
10595 
    return
10596 
 
10597 
 
10598 
  def __repr__(self):
10599 
    L = ['%s=%r' % (key, value)
10600 
      for key, value in self.__dict__.iteritems()]
10601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10602 
 
10603 
  def __eq__(self, other):
10604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10605 
 
10606 
  def __ne__(self, other):
10607 
    return not (self == other)
10608 
 
10609 
class getLatestArrivalsCount_args:
10610 
 
10611 
  thrift_spec = (
10612 
  )
10613 
 
10614 
  def read(self, iprot):
10615 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10616 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10617 
      return
10618 
    iprot.readStructBegin()
10619 
    while True:
10620 
      (fname, ftype, fid) = iprot.readFieldBegin()
10621 
      if ftype == TType.STOP:
10622 
        break
10623 
      else:
10624 
        iprot.skip(ftype)
10625 
      iprot.readFieldEnd()
10626 
    iprot.readStructEnd()
10627 
 
10628 
  def write(self, oprot):
10629 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10630 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10631 
      return
10632 
    oprot.writeStructBegin('getLatestArrivalsCount_args')
10633 
    oprot.writeFieldStop()
10634 
    oprot.writeStructEnd()
10635 
 
10636 
  def validate(self):
10637 
    return
10638 
 
10639 
 
10640 
  def __repr__(self):
10641 
    L = ['%s=%r' % (key, value)
10642 
      for key, value in self.__dict__.iteritems()]
10643 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10644 
 
10645 
  def __eq__(self, other):
10646 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10647 
 
10648 
  def __ne__(self, other):
10649 
    return not (self == other)
10650 
 
10651 
class getLatestArrivalsCount_result:
10652 
  """
10653 
  Attributes:
10654 
   - success
10655 
   - cex
10656 
  """
10657 
 
10658 
  thrift_spec = (
10659 
    (0, TType.I64, 'success', None, None, ), # 0
10660 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10661 
  )
10662 
 
10663 
  def __init__(self, success=None, cex=None,):
10664 
    self.success = success
10665 
    self.cex = cex
10666 
 
10667 
  def read(self, iprot):
10668 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10669 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10670 
      return
10671 
    iprot.readStructBegin()
10672 
    while True:
10673 
      (fname, ftype, fid) = iprot.readFieldBegin()
10674 
      if ftype == TType.STOP:
10675 
        break
10676 
      if fid == 0:
10677 
        if ftype == TType.I64:
10678 
          self.success = iprot.readI64();
10679 
        else:
10680 
          iprot.skip(ftype)
10681 
      elif fid == 1:
10682 
        if ftype == TType.STRUCT:
10683 
          self.cex = CatalogServiceException()
10684 
          self.cex.read(iprot)
10685 
        else:
10686 
          iprot.skip(ftype)
10687 
      else:
10688 
        iprot.skip(ftype)
10689 
      iprot.readFieldEnd()
10690 
    iprot.readStructEnd()
10691 
 
10692 
  def write(self, oprot):
10693 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10694 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10695 
      return
10696 
    oprot.writeStructBegin('getLatestArrivalsCount_result')
10697 
    if self.success is not None:
10698 
      oprot.writeFieldBegin('success', TType.I64, 0)
10699 
      oprot.writeI64(self.success)
10700 
      oprot.writeFieldEnd()
10701 
    if self.cex is not None:
10702 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10703 
      self.cex.write(oprot)
10704 
      oprot.writeFieldEnd()
10705 
    oprot.writeFieldStop()
10706 
    oprot.writeStructEnd()
10707 
 
10708 
  def validate(self):
10709 
    return
10710 
 
10711 
 
10712 
  def __repr__(self):
10713 
    L = ['%s=%r' % (key, value)
10714 
      for key, value in self.__dict__.iteritems()]
10715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10716 
 
10717 
  def __eq__(self, other):
10718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10719 
 
10720 
  def __ne__(self, other):
10721 
    return not (self == other)
10722 
 
10723 
class generateNewEntityID_args:
10724 
 
10725 
  thrift_spec = (
10726 
  )
10727 
 
10728 
  def read(self, iprot):
10729 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10730 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10731 
      return
10732 
    iprot.readStructBegin()
10733 
    while True:
10734 
      (fname, ftype, fid) = iprot.readFieldBegin()
10735 
      if ftype == TType.STOP:
10736 
        break
10737 
      else:
10738 
        iprot.skip(ftype)
10739 
      iprot.readFieldEnd()
10740 
    iprot.readStructEnd()
10741 
 
10742 
  def write(self, oprot):
10743 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10744 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10745 
      return
10746 
    oprot.writeStructBegin('generateNewEntityID_args')
10747 
    oprot.writeFieldStop()
10748 
    oprot.writeStructEnd()
10749 
 
10750 
  def validate(self):
10751 
    return
10752 
 
10753 
 
10754 
  def __repr__(self):
10755 
    L = ['%s=%r' % (key, value)
10756 
      for key, value in self.__dict__.iteritems()]
10757 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10758 
 
10759 
  def __eq__(self, other):
10760 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10761 
 
10762 
  def __ne__(self, other):
10763 
    return not (self == other)
10764 
 
10765 
class generateNewEntityID_result:
10766 
  """
10767 
  Attributes:
10768 
   - success
10769 
  """
10770 
 
10771 
  thrift_spec = (
10772 
    (0, TType.I64, 'success', None, None, ), # 0
10773 
  )
10774 
 
10775 
  def __init__(self, success=None,):
10776 
    self.success = success
10777 
 
10778 
  def read(self, iprot):
10779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10781 
      return
10782 
    iprot.readStructBegin()
10783 
    while True:
10784 
      (fname, ftype, fid) = iprot.readFieldBegin()
10785 
      if ftype == TType.STOP:
10786 
        break
10787 
      if fid == 0:
10788 
        if ftype == TType.I64:
10789 
          self.success = iprot.readI64();
10790 
        else:
10791 
          iprot.skip(ftype)
10792 
      else:
10793 
        iprot.skip(ftype)
10794 
      iprot.readFieldEnd()
10795 
    iprot.readStructEnd()
10796 
 
10797 
  def write(self, oprot):
10798 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10799 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10800 
      return
10801 
    oprot.writeStructBegin('generateNewEntityID_result')
10802 
    if self.success is not None:
10803 
      oprot.writeFieldBegin('success', TType.I64, 0)
10804 
      oprot.writeI64(self.success)
10805 
      oprot.writeFieldEnd()
10806 
    oprot.writeFieldStop()
10807 
    oprot.writeStructEnd()
10808 
 
10809 
  def validate(self):
10810 
    return
10811 
 
10812 
 
10813 
  def __repr__(self):
10814 
    L = ['%s=%r' % (key, value)
10815 
      for key, value in self.__dict__.iteritems()]
10816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10817 
 
10818 
  def __eq__(self, other):
10819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10820 
 
10821 
  def __ne__(self, other):
10822 
    return not (self == other)
10823 
 
10824 
class addCategory_args:
10825 
  """
10826 
  Attributes:
10827 
   - category
10828 
  """
10829 
 
10830 
  thrift_spec = (
10831 
    None, # 0
10832 
    (1, TType.STRUCT, 'category', (Category, Category.thrift_spec), None, ), # 1
10833 
  )
10834 
 
10835 
  def __init__(self, category=None,):
10836 
    self.category = category
10837 
 
10838 
  def read(self, iprot):
10839 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10840 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10841 
      return
10842 
    iprot.readStructBegin()
10843 
    while True:
10844 
      (fname, ftype, fid) = iprot.readFieldBegin()
10845 
      if ftype == TType.STOP:
10846 
        break
10847 
      if fid == 1:
10848 
        if ftype == TType.STRUCT:
10849 
          self.category = Category()
10850 
          self.category.read(iprot)
10851 
        else:
10852 
          iprot.skip(ftype)
10853 
      else:
10854 
        iprot.skip(ftype)
10855 
      iprot.readFieldEnd()
10856 
    iprot.readStructEnd()
10857 
 
10858 
  def write(self, oprot):
10859 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10860 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10861 
      return
10862 
    oprot.writeStructBegin('addCategory_args')
10863 
    if self.category is not None:
10864 
      oprot.writeFieldBegin('category', TType.STRUCT, 1)
10865 
      self.category.write(oprot)
10866 
      oprot.writeFieldEnd()
10867 
    oprot.writeFieldStop()
10868 
    oprot.writeStructEnd()
10869 
 
10870 
  def validate(self):
10871 
    return
10872 
 
10873 
 
10874 
  def __repr__(self):
10875 
    L = ['%s=%r' % (key, value)
10876 
      for key, value in self.__dict__.iteritems()]
10877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10878 
 
10879 
  def __eq__(self, other):
10880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10881 
 
10882 
  def __ne__(self, other):
10883 
    return not (self == other)
10884 
 
10885 
class addCategory_result:
10886 
  """
10887 
  Attributes:
10888 
   - success
10889 
  """
10890 
 
10891 
  thrift_spec = (
10892 
    (0, TType.BOOL, 'success', None, None, ), # 0
10893 
  )
10894 
 
10895 
  def __init__(self, success=None,):
10896 
    self.success = success
10897 
 
10898 
  def read(self, iprot):
10899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10901 
      return
10902 
    iprot.readStructBegin()
10903 
    while True:
10904 
      (fname, ftype, fid) = iprot.readFieldBegin()
10905 
      if ftype == TType.STOP:
10906 
        break
10907 
      if fid == 0:
10908 
        if ftype == TType.BOOL:
10909 
          self.success = iprot.readBool();
10910 
        else:
10911 
          iprot.skip(ftype)
10912 
      else:
10913 
        iprot.skip(ftype)
10914 
      iprot.readFieldEnd()
10915 
    iprot.readStructEnd()
10916 
 
10917 
  def write(self, oprot):
10918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10920 
      return
10921 
    oprot.writeStructBegin('addCategory_result')
10922 
    if self.success is not None:
10923 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10924 
      oprot.writeBool(self.success)
10925 
      oprot.writeFieldEnd()
10926 
    oprot.writeFieldStop()
10927 
    oprot.writeStructEnd()
10928 
 
10929 
  def validate(self):
10930 
    return
10931 
 
10932 
 
10933 
  def __repr__(self):
10934 
    L = ['%s=%r' % (key, value)
10935 
      for key, value in self.__dict__.iteritems()]
10936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10937 
 
10938 
  def __eq__(self, other):
10939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10940 
 
10941 
  def __ne__(self, other):
10942 
    return not (self == other)
10943 
 
10944 
class getCategory_args:
10945 
  """
10946 
  Attributes:
10947 
   - id
10948 
  """
10949 
 
10950 
  thrift_spec = (
10951 
    None, # 0
10952 
    (1, TType.I64, 'id', None, None, ), # 1
10953 
  )
10954 
 
10955 
  def __init__(self, id=None,):
10956 
    self.id = id
10957 
 
10958 
  def read(self, iprot):
10959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10961 
      return
10962 
    iprot.readStructBegin()
10963 
    while True:
10964 
      (fname, ftype, fid) = iprot.readFieldBegin()
10965 
      if ftype == TType.STOP:
10966 
        break
10967 
      if fid == 1:
10968 
        if ftype == TType.I64:
10969 
          self.id = iprot.readI64();
10970 
        else:
10971 
          iprot.skip(ftype)
10972 
      else:
10973 
        iprot.skip(ftype)
10974 
      iprot.readFieldEnd()
10975 
    iprot.readStructEnd()
10976 
 
10977 
  def write(self, oprot):
10978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10980 
      return
10981 
    oprot.writeStructBegin('getCategory_args')
10982 
    if self.id is not None:
10983 
      oprot.writeFieldBegin('id', TType.I64, 1)
10984 
      oprot.writeI64(self.id)
10985 
      oprot.writeFieldEnd()
10986 
    oprot.writeFieldStop()
10987 
    oprot.writeStructEnd()
10988 
 
10989 
  def validate(self):
10990 
    return
10991 
 
10992 
 
10993 
  def __repr__(self):
10994 
    L = ['%s=%r' % (key, value)
10995 
      for key, value in self.__dict__.iteritems()]
10996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10997 
 
10998 
  def __eq__(self, other):
10999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11000 
 
11001 
  def __ne__(self, other):
11002 
    return not (self == other)
11003 
 
11004 
class getCategory_result:
11005 
  """
11006 
  Attributes:
11007 
   - success
11008 
  """
11009 
 
11010 
  thrift_spec = (
11011 
    (0, TType.STRUCT, 'success', (Category, Category.thrift_spec), None, ), # 0
11012 
  )
11013 
 
11014 
  def __init__(self, success=None,):
11015 
    self.success = success
11016 
 
11017 
  def read(self, iprot):
11018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11020 
      return
11021 
    iprot.readStructBegin()
11022 
    while True:
11023 
      (fname, ftype, fid) = iprot.readFieldBegin()
11024 
      if ftype == TType.STOP:
11025 
        break
11026 
      if fid == 0:
11027 
        if ftype == TType.STRUCT:
11028 
          self.success = Category()
11029 
          self.success.read(iprot)
11030 
        else:
11031 
          iprot.skip(ftype)
11032 
      else:
11033 
        iprot.skip(ftype)
11034 
      iprot.readFieldEnd()
11035 
    iprot.readStructEnd()
11036 
 
11037 
  def write(self, oprot):
11038 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11039 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11040 
      return
11041 
    oprot.writeStructBegin('getCategory_result')
11042 
    if self.success is not None:
11043 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11044 
      self.success.write(oprot)
11045 
      oprot.writeFieldEnd()
11046 
    oprot.writeFieldStop()
11047 
    oprot.writeStructEnd()
11048 
 
11049 
  def validate(self):
11050 
    return
11051 
 
11052 
 
11053 
  def __repr__(self):
11054 
    L = ['%s=%r' % (key, value)
11055 
      for key, value in self.__dict__.iteritems()]
11056 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11057 
 
11058 
  def __eq__(self, other):
11059 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11060 
 
11061 
  def __ne__(self, other):
11062 
    return not (self == other)
11063 
 
11064 
class getAllCategories_args:
11065 
 
11066 
  thrift_spec = (
11067 
  )
11068 
 
11069 
  def read(self, iprot):
11070 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11071 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11072 
      return
11073 
    iprot.readStructBegin()
11074 
    while True:
11075 
      (fname, ftype, fid) = iprot.readFieldBegin()
11076 
      if ftype == TType.STOP:
11077 
        break
11078 
      else:
11079 
        iprot.skip(ftype)
11080 
      iprot.readFieldEnd()
11081 
    iprot.readStructEnd()
11082 
 
11083 
  def write(self, oprot):
11084 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11085 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11086 
      return
11087 
    oprot.writeStructBegin('getAllCategories_args')
11088 
    oprot.writeFieldStop()
11089 
    oprot.writeStructEnd()
11090 
 
11091 
  def validate(self):
11092 
    return
11093 
 
11094 
 
11095 
  def __repr__(self):
11096 
    L = ['%s=%r' % (key, value)
11097 
      for key, value in self.__dict__.iteritems()]
11098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11099 
 
11100 
  def __eq__(self, other):
11101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11102 
 
11103 
  def __ne__(self, other):
11104 
    return not (self == other)
11105 
 
11106 
class getAllCategories_result:
11107 
  """
11108 
  Attributes:
11109 
   - success
11110 
  """
11111 
 
11112 
  thrift_spec = (
11113 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
11114 
  )
11115 
 
11116 
  def __init__(self, success=None,):
11117 
    self.success = success
11118 
 
11119 
  def read(self, iprot):
11120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11122 
      return
11123 
    iprot.readStructBegin()
11124 
    while True:
11125 
      (fname, ftype, fid) = iprot.readFieldBegin()
11126 
      if ftype == TType.STOP:
11127 
        break
11128 
      if fid == 0:
11129 
        if ftype == TType.LIST:
11130 
          self.success = []
8590 kshitij.so 11131 
          (_etype154, _size151) = iprot.readListBegin()
11132 
          for _i155 in xrange(_size151):
11133 
            _elem156 = Category()
11134 
            _elem156.read(iprot)
11135 
            self.success.append(_elem156)
5944 mandeep.dh 11136 
          iprot.readListEnd()
11137 
        else:
11138 
          iprot.skip(ftype)
11139 
      else:
11140 
        iprot.skip(ftype)
11141 
      iprot.readFieldEnd()
11142 
    iprot.readStructEnd()
11143 
 
11144 
  def write(self, oprot):
11145 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11146 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11147 
      return
11148 
    oprot.writeStructBegin('getAllCategories_result')
11149 
    if self.success is not None:
11150 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11151 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 11152 
      for iter157 in self.success:
11153 
        iter157.write(oprot)
5944 mandeep.dh 11154 
      oprot.writeListEnd()
11155 
      oprot.writeFieldEnd()
11156 
    oprot.writeFieldStop()
11157 
    oprot.writeStructEnd()
11158 
 
11159 
  def validate(self):
11160 
    return
11161 
 
11162 
 
11163 
  def __repr__(self):
11164 
    L = ['%s=%r' % (key, value)
11165 
      for key, value in self.__dict__.iteritems()]
11166 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11167 
 
11168 
  def __eq__(self, other):
11169 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11170 
 
11171 
  def __ne__(self, other):
11172 
    return not (self == other)
11173 
 
11174 
class getAllSimilarItems_args:
11175 
  """
11176 
  Attributes:
11177 
   - itemId
11178 
  """
11179 
 
11180 
  thrift_spec = (
11181 
    None, # 0
11182 
    (1, TType.I64, 'itemId', None, None, ), # 1
11183 
  )
11184 
 
11185 
  def __init__(self, itemId=None,):
11186 
    self.itemId = itemId
11187 
 
11188 
  def read(self, iprot):
11189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11191 
      return
11192 
    iprot.readStructBegin()
11193 
    while True:
11194 
      (fname, ftype, fid) = iprot.readFieldBegin()
11195 
      if ftype == TType.STOP:
11196 
        break
11197 
      if fid == 1:
11198 
        if ftype == TType.I64:
11199 
          self.itemId = iprot.readI64();
11200 
        else:
11201 
          iprot.skip(ftype)
11202 
      else:
11203 
        iprot.skip(ftype)
11204 
      iprot.readFieldEnd()
11205 
    iprot.readStructEnd()
11206 
 
11207 
  def write(self, oprot):
11208 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11209 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11210 
      return
11211 
    oprot.writeStructBegin('getAllSimilarItems_args')
11212 
    if self.itemId is not None:
11213 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11214 
      oprot.writeI64(self.itemId)
11215 
      oprot.writeFieldEnd()
11216 
    oprot.writeFieldStop()
11217 
    oprot.writeStructEnd()
11218 
 
11219 
  def validate(self):
11220 
    return
11221 
 
11222 
 
11223 
  def __repr__(self):
11224 
    L = ['%s=%r' % (key, value)
11225 
      for key, value in self.__dict__.iteritems()]
11226 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11227 
 
11228 
  def __eq__(self, other):
11229 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11230 
 
11231 
  def __ne__(self, other):
11232 
    return not (self == other)
11233 
 
11234 
class getAllSimilarItems_result:
11235 
  """
11236 
  Attributes:
11237 
   - success
11238 
  """
11239 
 
11240 
  thrift_spec = (
11241 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11242 
  )
11243 
 
11244 
  def __init__(self, success=None,):
11245 
    self.success = success
11246 
 
11247 
  def read(self, iprot):
11248 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11249 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11250 
      return
11251 
    iprot.readStructBegin()
11252 
    while True:
11253 
      (fname, ftype, fid) = iprot.readFieldBegin()
11254 
      if ftype == TType.STOP:
11255 
        break
11256 
      if fid == 0:
11257 
        if ftype == TType.LIST:
11258 
          self.success = []
8590 kshitij.so 11259 
          (_etype161, _size158) = iprot.readListBegin()
11260 
          for _i162 in xrange(_size158):
11261 
            _elem163 = Item()
11262 
            _elem163.read(iprot)
11263 
            self.success.append(_elem163)
5944 mandeep.dh 11264 
          iprot.readListEnd()
11265 
        else:
11266 
          iprot.skip(ftype)
11267 
      else:
11268 
        iprot.skip(ftype)
11269 
      iprot.readFieldEnd()
11270 
    iprot.readStructEnd()
11271 
 
11272 
  def write(self, oprot):
11273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11275 
      return
11276 
    oprot.writeStructBegin('getAllSimilarItems_result')
11277 
    if self.success is not None:
11278 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11279 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 11280 
      for iter164 in self.success:
11281 
        iter164.write(oprot)
5944 mandeep.dh 11282 
      oprot.writeListEnd()
11283 
      oprot.writeFieldEnd()
11284 
    oprot.writeFieldStop()
11285 
    oprot.writeStructEnd()
11286 
 
11287 
  def validate(self):
11288 
    return
11289 
 
11290 
 
11291 
  def __repr__(self):
11292 
    L = ['%s=%r' % (key, value)
11293 
      for key, value in self.__dict__.iteritems()]
11294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11295 
 
11296 
  def __eq__(self, other):
11297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11298 
 
11299 
  def __ne__(self, other):
11300 
    return not (self == other)
11301 
 
11302 
class addSimilarItem_args:
11303 
  """
11304 
  Attributes:
11305 
   - itemId
11306 
   - catalogItemId
11307 
  """
11308 
 
11309 
  thrift_spec = (
11310 
    None, # 0
11311 
    (1, TType.I64, 'itemId', None, None, ), # 1
11312 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
11313 
  )
11314 
 
11315 
  def __init__(self, itemId=None, catalogItemId=None,):
11316 
    self.itemId = itemId
11317 
    self.catalogItemId = catalogItemId
11318 
 
11319 
  def read(self, iprot):
11320 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11321 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11322 
      return
11323 
    iprot.readStructBegin()
11324 
    while True:
11325 
      (fname, ftype, fid) = iprot.readFieldBegin()
11326 
      if ftype == TType.STOP:
11327 
        break
11328 
      if fid == 1:
11329 
        if ftype == TType.I64:
11330 
          self.itemId = iprot.readI64();
11331 
        else:
11332 
          iprot.skip(ftype)
11333 
      elif fid == 2:
11334 
        if ftype == TType.I64:
11335 
          self.catalogItemId = iprot.readI64();
11336 
        else:
11337 
          iprot.skip(ftype)
11338 
      else:
11339 
        iprot.skip(ftype)
11340 
      iprot.readFieldEnd()
11341 
    iprot.readStructEnd()
11342 
 
11343 
  def write(self, oprot):
11344 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11345 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11346 
      return
11347 
    oprot.writeStructBegin('addSimilarItem_args')
11348 
    if self.itemId is not None:
11349 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11350 
      oprot.writeI64(self.itemId)
11351 
      oprot.writeFieldEnd()
11352 
    if self.catalogItemId is not None:
11353 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
11354 
      oprot.writeI64(self.catalogItemId)
11355 
      oprot.writeFieldEnd()
11356 
    oprot.writeFieldStop()
11357 
    oprot.writeStructEnd()
11358 
 
11359 
  def validate(self):
11360 
    return
11361 
 
11362 
 
11363 
  def __repr__(self):
11364 
    L = ['%s=%r' % (key, value)
11365 
      for key, value in self.__dict__.iteritems()]
11366 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11367 
 
11368 
  def __eq__(self, other):
11369 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11370 
 
11371 
  def __ne__(self, other):
11372 
    return not (self == other)
11373 
 
11374 
class addSimilarItem_result:
11375 
  """
11376 
  Attributes:
11377 
   - success
11378 
   - cex
11379 
  """
11380 
 
11381 
  thrift_spec = (
11382 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
11383 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11384 
  )
11385 
 
11386 
  def __init__(self, success=None, cex=None,):
11387 
    self.success = success
11388 
    self.cex = cex
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 == 0:
11400 
        if ftype == TType.STRUCT:
11401 
          self.success = Item()
11402 
          self.success.read(iprot)
11403 
        else:
11404 
          iprot.skip(ftype)
11405 
      elif fid == 1:
11406 
        if ftype == TType.STRUCT:
11407 
          self.cex = CatalogServiceException()
11408 
          self.cex.read(iprot)
11409 
        else:
11410 
          iprot.skip(ftype)
11411 
      else:
11412 
        iprot.skip(ftype)
11413 
      iprot.readFieldEnd()
11414 
    iprot.readStructEnd()
11415 
 
11416 
  def write(self, oprot):
11417 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11418 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11419 
      return
11420 
    oprot.writeStructBegin('addSimilarItem_result')
11421 
    if self.success is not None:
11422 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11423 
      self.success.write(oprot)
11424 
      oprot.writeFieldEnd()
11425 
    if self.cex is not None:
11426 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11427 
      self.cex.write(oprot)
11428 
      oprot.writeFieldEnd()
11429 
    oprot.writeFieldStop()
11430 
    oprot.writeStructEnd()
11431 
 
11432 
  def validate(self):
11433 
    return
11434 
 
11435 
 
11436 
  def __repr__(self):
11437 
    L = ['%s=%r' % (key, value)
11438 
      for key, value in self.__dict__.iteritems()]
11439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11440 
 
11441 
  def __eq__(self, other):
11442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11443 
 
11444 
  def __ne__(self, other):
11445 
    return not (self == other)
11446 
 
6512 kshitij.so 11447 
class addTag_args:
11448 
  """
11449 
  Attributes:
11450 
   - displayName
11451 
   - itemId
11452 
  """
11453 
 
11454 
  thrift_spec = (
11455 
    None, # 0
11456 
    (1, TType.STRING, 'displayName', None, None, ), # 1
11457 
    (2, TType.I64, 'itemId', None, None, ), # 2
11458 
  )
11459 
 
11460 
  def __init__(self, displayName=None, itemId=None,):
11461 
    self.displayName = displayName
11462 
    self.itemId = itemId
11463 
 
11464 
  def read(self, iprot):
11465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11467 
      return
11468 
    iprot.readStructBegin()
11469 
    while True:
11470 
      (fname, ftype, fid) = iprot.readFieldBegin()
11471 
      if ftype == TType.STOP:
11472 
        break
11473 
      if fid == 1:
11474 
        if ftype == TType.STRING:
11475 
          self.displayName = iprot.readString();
11476 
        else:
11477 
          iprot.skip(ftype)
11478 
      elif fid == 2:
11479 
        if ftype == TType.I64:
11480 
          self.itemId = iprot.readI64();
11481 
        else:
11482 
          iprot.skip(ftype)
11483 
      else:
11484 
        iprot.skip(ftype)
11485 
      iprot.readFieldEnd()
11486 
    iprot.readStructEnd()
11487 
 
11488 
  def write(self, oprot):
11489 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11490 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11491 
      return
11492 
    oprot.writeStructBegin('addTag_args')
11493 
    if self.displayName is not None:
11494 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
11495 
      oprot.writeString(self.displayName)
11496 
      oprot.writeFieldEnd()
11497 
    if self.itemId is not None:
11498 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11499 
      oprot.writeI64(self.itemId)
11500 
      oprot.writeFieldEnd()
11501 
    oprot.writeFieldStop()
11502 
    oprot.writeStructEnd()
11503 
 
11504 
  def validate(self):
11505 
    return
11506 
 
11507 
 
11508 
  def __repr__(self):
11509 
    L = ['%s=%r' % (key, value)
11510 
      for key, value in self.__dict__.iteritems()]
11511 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11512 
 
11513 
  def __eq__(self, other):
11514 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11515 
 
11516 
  def __ne__(self, other):
11517 
    return not (self == other)
11518 
 
11519 
class addTag_result:
11520 
  """
11521 
  Attributes:
11522 
   - success
11523 
  """
11524 
 
11525 
  thrift_spec = (
11526 
    (0, TType.BOOL, 'success', None, None, ), # 0
11527 
  )
11528 
 
11529 
  def __init__(self, success=None,):
11530 
    self.success = success
11531 
 
11532 
  def read(self, iprot):
11533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11535 
      return
11536 
    iprot.readStructBegin()
11537 
    while True:
11538 
      (fname, ftype, fid) = iprot.readFieldBegin()
11539 
      if ftype == TType.STOP:
11540 
        break
11541 
      if fid == 0:
11542 
        if ftype == TType.BOOL:
11543 
          self.success = iprot.readBool();
11544 
        else:
11545 
          iprot.skip(ftype)
11546 
      else:
11547 
        iprot.skip(ftype)
11548 
      iprot.readFieldEnd()
11549 
    iprot.readStructEnd()
11550 
 
11551 
  def write(self, oprot):
11552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11554 
      return
11555 
    oprot.writeStructBegin('addTag_result')
11556 
    if self.success is not None:
11557 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11558 
      oprot.writeBool(self.success)
11559 
      oprot.writeFieldEnd()
11560 
    oprot.writeFieldStop()
11561 
    oprot.writeStructEnd()
11562 
 
11563 
  def validate(self):
11564 
    return
11565 
 
11566 
 
11567 
  def __repr__(self):
11568 
    L = ['%s=%r' % (key, value)
11569 
      for key, value in self.__dict__.iteritems()]
11570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11571 
 
11572 
  def __eq__(self, other):
11573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11574 
 
11575 
  def __ne__(self, other):
11576 
    return not (self == other)
11577 
 
11578 
class deleteEntityTag_args:
11579 
  """
11580 
  Attributes:
11581 
   - displayName
11582 
   - itemId
11583 
  """
11584 
 
11585 
  thrift_spec = (
11586 
    None, # 0
11587 
    (1, TType.STRING, 'displayName', None, None, ), # 1
11588 
    (2, TType.I64, 'itemId', None, None, ), # 2
11589 
  )
11590 
 
11591 
  def __init__(self, displayName=None, itemId=None,):
11592 
    self.displayName = displayName
11593 
    self.itemId = itemId
11594 
 
11595 
  def read(self, iprot):
11596 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11597 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11598 
      return
11599 
    iprot.readStructBegin()
11600 
    while True:
11601 
      (fname, ftype, fid) = iprot.readFieldBegin()
11602 
      if ftype == TType.STOP:
11603 
        break
11604 
      if fid == 1:
11605 
        if ftype == TType.STRING:
11606 
          self.displayName = iprot.readString();
11607 
        else:
11608 
          iprot.skip(ftype)
11609 
      elif fid == 2:
11610 
        if ftype == TType.I64:
11611 
          self.itemId = iprot.readI64();
11612 
        else:
11613 
          iprot.skip(ftype)
11614 
      else:
11615 
        iprot.skip(ftype)
11616 
      iprot.readFieldEnd()
11617 
    iprot.readStructEnd()
11618 
 
11619 
  def write(self, oprot):
11620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11622 
      return
11623 
    oprot.writeStructBegin('deleteEntityTag_args')
11624 
    if self.displayName is not None:
11625 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
11626 
      oprot.writeString(self.displayName)
11627 
      oprot.writeFieldEnd()
11628 
    if self.itemId is not None:
11629 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11630 
      oprot.writeI64(self.itemId)
11631 
      oprot.writeFieldEnd()
11632 
    oprot.writeFieldStop()
11633 
    oprot.writeStructEnd()
11634 
 
11635 
  def validate(self):
11636 
    return
11637 
 
11638 
 
11639 
  def __repr__(self):
11640 
    L = ['%s=%r' % (key, value)
11641 
      for key, value in self.__dict__.iteritems()]
11642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11643 
 
11644 
  def __eq__(self, other):
11645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11646 
 
11647 
  def __ne__(self, other):
11648 
    return not (self == other)
11649 
 
11650 
class deleteEntityTag_result:
11651 
  """
11652 
  Attributes:
11653 
   - success
11654 
  """
11655 
 
11656 
  thrift_spec = (
11657 
    (0, TType.BOOL, 'success', None, None, ), # 0
11658 
  )
11659 
 
11660 
  def __init__(self, success=None,):
11661 
    self.success = success
11662 
 
11663 
  def read(self, iprot):
11664 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11665 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11666 
      return
11667 
    iprot.readStructBegin()
11668 
    while True:
11669 
      (fname, ftype, fid) = iprot.readFieldBegin()
11670 
      if ftype == TType.STOP:
11671 
        break
11672 
      if fid == 0:
11673 
        if ftype == TType.BOOL:
11674 
          self.success = iprot.readBool();
11675 
        else:
11676 
          iprot.skip(ftype)
11677 
      else:
11678 
        iprot.skip(ftype)
11679 
      iprot.readFieldEnd()
11680 
    iprot.readStructEnd()
11681 
 
11682 
  def write(self, oprot):
11683 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11684 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11685 
      return
11686 
    oprot.writeStructBegin('deleteEntityTag_result')
11687 
    if self.success is not None:
11688 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11689 
      oprot.writeBool(self.success)
11690 
      oprot.writeFieldEnd()
11691 
    oprot.writeFieldStop()
11692 
    oprot.writeStructEnd()
11693 
 
11694 
  def validate(self):
11695 
    return
11696 
 
11697 
 
11698 
  def __repr__(self):
11699 
    L = ['%s=%r' % (key, value)
11700 
      for key, value in self.__dict__.iteritems()]
11701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11702 
 
11703 
  def __eq__(self, other):
11704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11705 
 
11706 
  def __ne__(self, other):
11707 
    return not (self == other)
11708 
 
11709 
class deleteTag_args:
11710 
  """
11711 
  Attributes:
11712 
   - displayName
11713 
  """
11714 
 
11715 
  thrift_spec = (
11716 
    None, # 0
11717 
    (1, TType.STRING, 'displayName', None, None, ), # 1
11718 
  )
11719 
 
11720 
  def __init__(self, displayName=None,):
11721 
    self.displayName = displayName
11722 
 
11723 
  def read(self, iprot):
11724 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11725 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11726 
      return
11727 
    iprot.readStructBegin()
11728 
    while True:
11729 
      (fname, ftype, fid) = iprot.readFieldBegin()
11730 
      if ftype == TType.STOP:
11731 
        break
11732 
      if fid == 1:
11733 
        if ftype == TType.STRING:
11734 
          self.displayName = iprot.readString();
11735 
        else:
11736 
          iprot.skip(ftype)
11737 
      else:
11738 
        iprot.skip(ftype)
11739 
      iprot.readFieldEnd()
11740 
    iprot.readStructEnd()
11741 
 
11742 
  def write(self, oprot):
11743 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11744 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11745 
      return
11746 
    oprot.writeStructBegin('deleteTag_args')
11747 
    if self.displayName is not None:
11748 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
11749 
      oprot.writeString(self.displayName)
11750 
      oprot.writeFieldEnd()
11751 
    oprot.writeFieldStop()
11752 
    oprot.writeStructEnd()
11753 
 
11754 
  def validate(self):
11755 
    return
11756 
 
11757 
 
11758 
  def __repr__(self):
11759 
    L = ['%s=%r' % (key, value)
11760 
      for key, value in self.__dict__.iteritems()]
11761 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11762 
 
11763 
  def __eq__(self, other):
11764 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11765 
 
11766 
  def __ne__(self, other):
11767 
    return not (self == other)
11768 
 
11769 
class deleteTag_result:
11770 
  """
11771 
  Attributes:
11772 
   - success
11773 
  """
11774 
 
11775 
  thrift_spec = (
11776 
    (0, TType.BOOL, 'success', None, None, ), # 0
11777 
  )
11778 
 
11779 
  def __init__(self, success=None,):
11780 
    self.success = success
11781 
 
11782 
  def read(self, iprot):
11783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11785 
      return
11786 
    iprot.readStructBegin()
11787 
    while True:
11788 
      (fname, ftype, fid) = iprot.readFieldBegin()
11789 
      if ftype == TType.STOP:
11790 
        break
11791 
      if fid == 0:
11792 
        if ftype == TType.BOOL:
11793 
          self.success = iprot.readBool();
11794 
        else:
11795 
          iprot.skip(ftype)
11796 
      else:
11797 
        iprot.skip(ftype)
11798 
      iprot.readFieldEnd()
11799 
    iprot.readStructEnd()
11800 
 
11801 
  def write(self, oprot):
11802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11804 
      return
11805 
    oprot.writeStructBegin('deleteTag_result')
11806 
    if self.success is not None:
11807 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11808 
      oprot.writeBool(self.success)
11809 
      oprot.writeFieldEnd()
11810 
    oprot.writeFieldStop()
11811 
    oprot.writeStructEnd()
11812 
 
11813 
  def validate(self):
11814 
    return
11815 
 
11816 
 
11817 
  def __repr__(self):
11818 
    L = ['%s=%r' % (key, value)
11819 
      for key, value in self.__dict__.iteritems()]
11820 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11821 
 
11822 
  def __eq__(self, other):
11823 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11824 
 
11825 
  def __ne__(self, other):
11826 
    return not (self == other)
11827 
 
11828 
class getAllTags_args:
11829 
 
11830 
  thrift_spec = (
11831 
  )
11832 
 
11833 
  def read(self, iprot):
11834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11836 
      return
11837 
    iprot.readStructBegin()
11838 
    while True:
11839 
      (fname, ftype, fid) = iprot.readFieldBegin()
11840 
      if ftype == TType.STOP:
11841 
        break
11842 
      else:
11843 
        iprot.skip(ftype)
11844 
      iprot.readFieldEnd()
11845 
    iprot.readStructEnd()
11846 
 
11847 
  def write(self, oprot):
11848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11850 
      return
11851 
    oprot.writeStructBegin('getAllTags_args')
11852 
    oprot.writeFieldStop()
11853 
    oprot.writeStructEnd()
11854 
 
11855 
  def validate(self):
11856 
    return
11857 
 
11858 
 
11859 
  def __repr__(self):
11860 
    L = ['%s=%r' % (key, value)
11861 
      for key, value in self.__dict__.iteritems()]
11862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11863 
 
11864 
  def __eq__(self, other):
11865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11866 
 
11867 
  def __ne__(self, other):
11868 
    return not (self == other)
11869 
 
11870 
class getAllTags_result:
11871 
  """
11872 
  Attributes:
11873 
   - success
11874 
  """
11875 
 
11876 
  thrift_spec = (
11877 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
11878 
  )
11879 
 
11880 
  def __init__(self, success=None,):
11881 
    self.success = success
11882 
 
11883 
  def read(self, iprot):
11884 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11885 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11886 
      return
11887 
    iprot.readStructBegin()
11888 
    while True:
11889 
      (fname, ftype, fid) = iprot.readFieldBegin()
11890 
      if ftype == TType.STOP:
11891 
        break
11892 
      if fid == 0:
11893 
        if ftype == TType.LIST:
11894 
          self.success = []
8590 kshitij.so 11895 
          (_etype168, _size165) = iprot.readListBegin()
11896 
          for _i169 in xrange(_size165):
11897 
            _elem170 = iprot.readString();
11898 
            self.success.append(_elem170)
6512 kshitij.so 11899 
          iprot.readListEnd()
11900 
        else:
11901 
          iprot.skip(ftype)
11902 
      else:
11903 
        iprot.skip(ftype)
11904 
      iprot.readFieldEnd()
11905 
    iprot.readStructEnd()
11906 
 
11907 
  def write(self, oprot):
11908 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11909 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11910 
      return
11911 
    oprot.writeStructBegin('getAllTags_result')
11912 
    if self.success is not None:
11913 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11914 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 11915 
      for iter171 in self.success:
11916 
        oprot.writeString(iter171)
6512 kshitij.so 11917 
      oprot.writeListEnd()
11918 
      oprot.writeFieldEnd()
11919 
    oprot.writeFieldStop()
11920 
    oprot.writeStructEnd()
11921 
 
11922 
  def validate(self):
11923 
    return
11924 
 
11925 
 
11926 
  def __repr__(self):
11927 
    L = ['%s=%r' % (key, value)
11928 
      for key, value in self.__dict__.iteritems()]
11929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11930 
 
11931 
  def __eq__(self, other):
11932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11933 
 
11934 
  def __ne__(self, other):
11935 
    return not (self == other)
11936 
 
11937 
class getAllEntitiesByTagName_args:
11938 
  """
11939 
  Attributes:
11940 
   - displayName
11941 
  """
11942 
 
11943 
  thrift_spec = (
11944 
    None, # 0
11945 
    (1, TType.STRING, 'displayName', None, None, ), # 1
11946 
  )
11947 
 
11948 
  def __init__(self, displayName=None,):
11949 
    self.displayName = displayName
11950 
 
11951 
  def read(self, iprot):
11952 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11953 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11954 
      return
11955 
    iprot.readStructBegin()
11956 
    while True:
11957 
      (fname, ftype, fid) = iprot.readFieldBegin()
11958 
      if ftype == TType.STOP:
11959 
        break
11960 
      if fid == 1:
11961 
        if ftype == TType.STRING:
11962 
          self.displayName = iprot.readString();
11963 
        else:
11964 
          iprot.skip(ftype)
11965 
      else:
11966 
        iprot.skip(ftype)
11967 
      iprot.readFieldEnd()
11968 
    iprot.readStructEnd()
11969 
 
11970 
  def write(self, oprot):
11971 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11972 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11973 
      return
11974 
    oprot.writeStructBegin('getAllEntitiesByTagName_args')
11975 
    if self.displayName is not None:
11976 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
11977 
      oprot.writeString(self.displayName)
11978 
      oprot.writeFieldEnd()
11979 
    oprot.writeFieldStop()
11980 
    oprot.writeStructEnd()
11981 
 
11982 
  def validate(self):
11983 
    return
11984 
 
11985 
 
11986 
  def __repr__(self):
11987 
    L = ['%s=%r' % (key, value)
11988 
      for key, value in self.__dict__.iteritems()]
11989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11990 
 
11991 
  def __eq__(self, other):
11992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11993 
 
11994 
  def __ne__(self, other):
11995 
    return not (self == other)
11996 
 
11997 
class getAllEntitiesByTagName_result:
11998 
  """
11999 
  Attributes:
12000 
   - success
12001 
  """
12002 
 
12003 
  thrift_spec = (
12004 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12005 
  )
12006 
 
12007 
  def __init__(self, success=None,):
12008 
    self.success = success
12009 
 
12010 
  def read(self, iprot):
12011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12013 
      return
12014 
    iprot.readStructBegin()
12015 
    while True:
12016 
      (fname, ftype, fid) = iprot.readFieldBegin()
12017 
      if ftype == TType.STOP:
12018 
        break
12019 
      if fid == 0:
12020 
        if ftype == TType.LIST:
12021 
          self.success = []
8590 kshitij.so 12022 
          (_etype175, _size172) = iprot.readListBegin()
12023 
          for _i176 in xrange(_size172):
12024 
            _elem177 = iprot.readI64();
12025 
            self.success.append(_elem177)
6512 kshitij.so 12026 
          iprot.readListEnd()
12027 
        else:
12028 
          iprot.skip(ftype)
12029 
      else:
12030 
        iprot.skip(ftype)
12031 
      iprot.readFieldEnd()
12032 
    iprot.readStructEnd()
12033 
 
12034 
  def write(self, oprot):
12035 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12036 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12037 
      return
12038 
    oprot.writeStructBegin('getAllEntitiesByTagName_result')
12039 
    if self.success is not None:
12040 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12041 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 12042 
      for iter178 in self.success:
12043 
        oprot.writeI64(iter178)
6512 kshitij.so 12044 
      oprot.writeListEnd()
12045 
      oprot.writeFieldEnd()
12046 
    oprot.writeFieldStop()
12047 
    oprot.writeStructEnd()
12048 
 
12049 
  def validate(self):
12050 
    return
12051 
 
12052 
 
12053 
  def __repr__(self):
12054 
    L = ['%s=%r' % (key, value)
12055 
      for key, value in self.__dict__.iteritems()]
12056 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12057 
 
12058 
  def __eq__(self, other):
12059 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12060 
 
12061 
  def __ne__(self, other):
12062 
    return not (self == other)
12063 
 
6845 amit.gupta 12064 
class getAllEntityTags_args:
12065 
 
12066 
  thrift_spec = (
12067 
  )
12068 
 
12069 
  def read(self, iprot):
12070 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12071 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12072 
      return
12073 
    iprot.readStructBegin()
12074 
    while True:
12075 
      (fname, ftype, fid) = iprot.readFieldBegin()
12076 
      if ftype == TType.STOP:
12077 
        break
12078 
      else:
12079 
        iprot.skip(ftype)
12080 
      iprot.readFieldEnd()
12081 
    iprot.readStructEnd()
12082 
 
12083 
  def write(self, oprot):
12084 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12085 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12086 
      return
12087 
    oprot.writeStructBegin('getAllEntityTags_args')
12088 
    oprot.writeFieldStop()
12089 
    oprot.writeStructEnd()
12090 
 
12091 
  def validate(self):
12092 
    return
12093 
 
12094 
 
12095 
  def __repr__(self):
12096 
    L = ['%s=%r' % (key, value)
12097 
      for key, value in self.__dict__.iteritems()]
12098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12099 
 
12100 
  def __eq__(self, other):
12101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12102 
 
12103 
  def __ne__(self, other):
12104 
    return not (self == other)
12105 
 
12106 
class getAllEntityTags_result:
12107 
  """
12108 
  Attributes:
12109 
   - success
12110 
  """
12111 
 
12112 
  thrift_spec = (
12113 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRING,None)), None, ), # 0
12114 
  )
12115 
 
12116 
  def __init__(self, success=None,):
12117 
    self.success = success
12118 
 
12119 
  def read(self, iprot):
12120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12122 
      return
12123 
    iprot.readStructBegin()
12124 
    while True:
12125 
      (fname, ftype, fid) = iprot.readFieldBegin()
12126 
      if ftype == TType.STOP:
12127 
        break
12128 
      if fid == 0:
12129 
        if ftype == TType.MAP:
12130 
          self.success = {}
8590 kshitij.so 12131 
          (_ktype180, _vtype181, _size179 ) = iprot.readMapBegin()
12132 
          for _i183 in xrange(_size179):
12133 
            _key184 = iprot.readI64();
12134 
            _val185 = []
12135 
            (_etype189, _size186) = iprot.readListBegin()
12136 
            for _i190 in xrange(_size186):
12137 
              _elem191 = iprot.readString();
12138 
              _val185.append(_elem191)
6845 amit.gupta 12139 
            iprot.readListEnd()
8590 kshitij.so 12140 
            self.success[_key184] = _val185
6845 amit.gupta 12141 
          iprot.readMapEnd()
12142 
        else:
12143 
          iprot.skip(ftype)
12144 
      else:
12145 
        iprot.skip(ftype)
12146 
      iprot.readFieldEnd()
12147 
    iprot.readStructEnd()
12148 
 
12149 
  def write(self, oprot):
12150 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12151 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12152 
      return
12153 
    oprot.writeStructBegin('getAllEntityTags_result')
12154 
    if self.success is not None:
12155 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12156 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
8590 kshitij.so 12157 
      for kiter192,viter193 in self.success.items():
12158 
        oprot.writeI64(kiter192)
12159 
        oprot.writeListBegin(TType.STRING, len(viter193))
12160 
        for iter194 in viter193:
12161 
          oprot.writeString(iter194)
6845 amit.gupta 12162 
        oprot.writeListEnd()
12163 
      oprot.writeMapEnd()
12164 
      oprot.writeFieldEnd()
12165 
    oprot.writeFieldStop()
12166 
    oprot.writeStructEnd()
12167 
 
12168 
  def validate(self):
12169 
    return
12170 
 
12171 
 
12172 
  def __repr__(self):
12173 
    L = ['%s=%r' % (key, value)
12174 
      for key, value in self.__dict__.iteritems()]
12175 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12176 
 
12177 
  def __eq__(self, other):
12178 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12179 
 
12180 
  def __ne__(self, other):
12181 
    return not (self == other)
12182 
 
6850 kshitij.so 12183 
class addBanner_args:
12184 
  """
12185 
  Attributes:
8590 kshitij.so 12186 
   - bannerCongregate
6850 kshitij.so 12187 
  """
12188 
 
12189 
  thrift_spec = (
12190 
    None, # 0
8590 kshitij.so 12191 
    (1, TType.STRUCT, 'bannerCongregate', (BannerCongregate, BannerCongregate.thrift_spec), None, ), # 1
6850 kshitij.so 12192 
  )
12193 
 
8590 kshitij.so 12194 
  def __init__(self, bannerCongregate=None,):
12195 
    self.bannerCongregate = bannerCongregate
6850 kshitij.so 12196 
 
12197 
  def read(self, iprot):
12198 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12199 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12200 
      return
12201 
    iprot.readStructBegin()
12202 
    while True:
12203 
      (fname, ftype, fid) = iprot.readFieldBegin()
12204 
      if ftype == TType.STOP:
12205 
        break
12206 
      if fid == 1:
8579 kshitij.so 12207 
        if ftype == TType.STRUCT:
8590 kshitij.so 12208 
          self.bannerCongregate = BannerCongregate()
12209 
          self.bannerCongregate.read(iprot)
6850 kshitij.so 12210 
        else:
12211 
          iprot.skip(ftype)
8579 kshitij.so 12212 
      else:
12213 
        iprot.skip(ftype)
12214 
      iprot.readFieldEnd()
12215 
    iprot.readStructEnd()
12216 
 
12217 
  def write(self, oprot):
12218 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12219 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12220 
      return
12221 
    oprot.writeStructBegin('addBanner_args')
8590 kshitij.so 12222 
    if self.bannerCongregate is not None:
12223 
      oprot.writeFieldBegin('bannerCongregate', TType.STRUCT, 1)
12224 
      self.bannerCongregate.write(oprot)
8579 kshitij.so 12225 
      oprot.writeFieldEnd()
12226 
    oprot.writeFieldStop()
12227 
    oprot.writeStructEnd()
12228 
 
12229 
  def validate(self):
12230 
    return
12231 
 
12232 
 
12233 
  def __repr__(self):
12234 
    L = ['%s=%r' % (key, value)
12235 
      for key, value in self.__dict__.iteritems()]
12236 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12237 
 
12238 
  def __eq__(self, other):
12239 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12240 
 
12241 
  def __ne__(self, other):
12242 
    return not (self == other)
12243 
 
12244 
class addBanner_result:
12245 
 
12246 
  thrift_spec = (
12247 
  )
12248 
 
12249 
  def read(self, iprot):
12250 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12251 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12252 
      return
12253 
    iprot.readStructBegin()
12254 
    while True:
12255 
      (fname, ftype, fid) = iprot.readFieldBegin()
12256 
      if ftype == TType.STOP:
12257 
        break
12258 
      else:
12259 
        iprot.skip(ftype)
12260 
      iprot.readFieldEnd()
12261 
    iprot.readStructEnd()
12262 
 
12263 
  def write(self, oprot):
12264 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12265 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12266 
      return
12267 
    oprot.writeStructBegin('addBanner_result')
12268 
    oprot.writeFieldStop()
12269 
    oprot.writeStructEnd()
12270 
 
12271 
  def validate(self):
12272 
    return
12273 
 
12274 
 
12275 
  def __repr__(self):
12276 
    L = ['%s=%r' % (key, value)
12277 
      for key, value in self.__dict__.iteritems()]
12278 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12279 
 
12280 
  def __eq__(self, other):
12281 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12282 
 
12283 
  def __ne__(self, other):
12284 
    return not (self == other)
12285 
 
12286 
class updateBanner_args:
12287 
  """
12288 
  Attributes:
12289 
   - banner
12290 
  """
12291 
 
12292 
  thrift_spec = (
12293 
    None, # 0
12294 
    (1, TType.STRUCT, 'banner', (Banner, Banner.thrift_spec), None, ), # 1
12295 
  )
12296 
 
12297 
  def __init__(self, banner=None,):
12298 
    self.banner = banner
12299 
 
12300 
  def read(self, iprot):
12301 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12302 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12303 
      return
12304 
    iprot.readStructBegin()
12305 
    while True:
12306 
      (fname, ftype, fid) = iprot.readFieldBegin()
12307 
      if ftype == TType.STOP:
12308 
        break
12309 
      if fid == 1:
12310 
        if ftype == TType.STRUCT:
12311 
          self.banner = Banner()
12312 
          self.banner.read(iprot)
6850 kshitij.so 12313 
        else:
12314 
          iprot.skip(ftype)
12315 
      else:
12316 
        iprot.skip(ftype)
12317 
      iprot.readFieldEnd()
12318 
    iprot.readStructEnd()
12319 
 
12320 
  def write(self, oprot):
12321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12323 
      return
8579 kshitij.so 12324 
    oprot.writeStructBegin('updateBanner_args')
12325 
    if self.banner is not None:
12326 
      oprot.writeFieldBegin('banner', TType.STRUCT, 1)
12327 
      self.banner.write(oprot)
6850 kshitij.so 12328 
      oprot.writeFieldEnd()
12329 
    oprot.writeFieldStop()
12330 
    oprot.writeStructEnd()
12331 
 
12332 
  def validate(self):
12333 
    return
12334 
 
12335 
 
12336 
  def __repr__(self):
12337 
    L = ['%s=%r' % (key, value)
12338 
      for key, value in self.__dict__.iteritems()]
12339 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12340 
 
12341 
  def __eq__(self, other):
12342 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12343 
 
12344 
  def __ne__(self, other):
12345 
    return not (self == other)
12346 
 
8579 kshitij.so 12347 
class updateBanner_result:
6850 kshitij.so 12348 
  """
12349 
  Attributes:
12350 
   - success
12351 
  """
12352 
 
12353 
  thrift_spec = (
12354 
    (0, TType.BOOL, 'success', None, None, ), # 0
12355 
  )
12356 
 
12357 
  def __init__(self, success=None,):
12358 
    self.success = success
12359 
 
12360 
  def read(self, iprot):
12361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12363 
      return
12364 
    iprot.readStructBegin()
12365 
    while True:
12366 
      (fname, ftype, fid) = iprot.readFieldBegin()
12367 
      if ftype == TType.STOP:
12368 
        break
12369 
      if fid == 0:
12370 
        if ftype == TType.BOOL:
12371 
          self.success = iprot.readBool();
12372 
        else:
12373 
          iprot.skip(ftype)
12374 
      else:
12375 
        iprot.skip(ftype)
12376 
      iprot.readFieldEnd()
12377 
    iprot.readStructEnd()
12378 
 
12379 
  def write(self, oprot):
12380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12382 
      return
8579 kshitij.so 12383 
    oprot.writeStructBegin('updateBanner_result')
6850 kshitij.so 12384 
    if self.success is not None:
12385 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12386 
      oprot.writeBool(self.success)
12387 
      oprot.writeFieldEnd()
12388 
    oprot.writeFieldStop()
12389 
    oprot.writeStructEnd()
12390 
 
12391 
  def validate(self):
12392 
    return
12393 
 
12394 
 
12395 
  def __repr__(self):
12396 
    L = ['%s=%r' % (key, value)
12397 
      for key, value in self.__dict__.iteritems()]
12398 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12399 
 
12400 
  def __eq__(self, other):
12401 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12402 
 
12403 
  def __ne__(self, other):
12404 
    return not (self == other)
12405 
 
12406 
class getAllBanners_args:
12407 
 
12408 
  thrift_spec = (
12409 
  )
12410 
 
12411 
  def read(self, iprot):
12412 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12413 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12414 
      return
12415 
    iprot.readStructBegin()
12416 
    while True:
12417 
      (fname, ftype, fid) = iprot.readFieldBegin()
12418 
      if ftype == TType.STOP:
12419 
        break
12420 
      else:
12421 
        iprot.skip(ftype)
12422 
      iprot.readFieldEnd()
12423 
    iprot.readStructEnd()
12424 
 
12425 
  def write(self, oprot):
12426 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12427 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12428 
      return
12429 
    oprot.writeStructBegin('getAllBanners_args')
12430 
    oprot.writeFieldStop()
12431 
    oprot.writeStructEnd()
12432 
 
12433 
  def validate(self):
12434 
    return
12435 
 
12436 
 
12437 
  def __repr__(self):
12438 
    L = ['%s=%r' % (key, value)
12439 
      for key, value in self.__dict__.iteritems()]
12440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12441 
 
12442 
  def __eq__(self, other):
12443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12444 
 
12445 
  def __ne__(self, other):
12446 
    return not (self == other)
12447 
 
12448 
class getAllBanners_result:
12449 
  """
12450 
  Attributes:
12451 
   - success
12452 
  """
12453 
 
12454 
  thrift_spec = (
8579 kshitij.so 12455 
    (0, TType.LIST, 'success', (TType.STRUCT,(Banner, Banner.thrift_spec)), None, ), # 0
6850 kshitij.so 12456 
  )
12457 
 
12458 
  def __init__(self, success=None,):
12459 
    self.success = success
12460 
 
12461 
  def read(self, iprot):
12462 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12463 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12464 
      return
12465 
    iprot.readStructBegin()
12466 
    while True:
12467 
      (fname, ftype, fid) = iprot.readFieldBegin()
12468 
      if ftype == TType.STOP:
12469 
        break
12470 
      if fid == 0:
12471 
        if ftype == TType.LIST:
12472 
          self.success = []
8590 kshitij.so 12473 
          (_etype198, _size195) = iprot.readListBegin()
12474 
          for _i199 in xrange(_size195):
12475 
            _elem200 = Banner()
12476 
            _elem200.read(iprot)
12477 
            self.success.append(_elem200)
6850 kshitij.so 12478 
          iprot.readListEnd()
12479 
        else:
12480 
          iprot.skip(ftype)
12481 
      else:
12482 
        iprot.skip(ftype)
12483 
      iprot.readFieldEnd()
12484 
    iprot.readStructEnd()
12485 
 
12486 
  def write(self, oprot):
12487 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12488 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12489 
      return
12490 
    oprot.writeStructBegin('getAllBanners_result')
12491 
    if self.success is not None:
12492 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8579 kshitij.so 12493 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 12494 
      for iter201 in self.success:
12495 
        iter201.write(oprot)
6850 kshitij.so 12496 
      oprot.writeListEnd()
12497 
      oprot.writeFieldEnd()
12498 
    oprot.writeFieldStop()
12499 
    oprot.writeStructEnd()
12500 
 
12501 
  def validate(self):
12502 
    return
12503 
 
12504 
 
12505 
  def __repr__(self):
12506 
    L = ['%s=%r' % (key, value)
12507 
      for key, value in self.__dict__.iteritems()]
12508 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12509 
 
12510 
  def __eq__(self, other):
12511 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12512 
 
12513 
  def __ne__(self, other):
12514 
    return not (self == other)
12515 
 
12516 
class deleteBanner_args:
12517 
  """
12518 
  Attributes:
12519 
   - bannerName
9155 kshitij.so 12520 
   - bannerType
6850 kshitij.so 12521 
  """
12522 
 
12523 
  thrift_spec = (
12524 
    None, # 0
12525 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 12526 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6850 kshitij.so 12527 
  )
12528 
 
9155 kshitij.so 12529 
  def __init__(self, bannerName=None, bannerType=None,):
6850 kshitij.so 12530 
    self.bannerName = bannerName
9155 kshitij.so 12531 
    self.bannerType = bannerType
6850 kshitij.so 12532 
 
12533 
  def read(self, iprot):
12534 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12535 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12536 
      return
12537 
    iprot.readStructBegin()
12538 
    while True:
12539 
      (fname, ftype, fid) = iprot.readFieldBegin()
12540 
      if ftype == TType.STOP:
12541 
        break
12542 
      if fid == 1:
12543 
        if ftype == TType.STRING:
12544 
          self.bannerName = iprot.readString();
12545 
        else:
12546 
          iprot.skip(ftype)
9155 kshitij.so 12547 
      elif fid == 2:
12548 
        if ftype == TType.I32:
12549 
          self.bannerType = iprot.readI32();
12550 
        else:
12551 
          iprot.skip(ftype)
6850 kshitij.so 12552 
      else:
12553 
        iprot.skip(ftype)
12554 
      iprot.readFieldEnd()
12555 
    iprot.readStructEnd()
12556 
 
12557 
  def write(self, oprot):
12558 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12559 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12560 
      return
12561 
    oprot.writeStructBegin('deleteBanner_args')
12562 
    if self.bannerName is not None:
12563 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
12564 
      oprot.writeString(self.bannerName)
12565 
      oprot.writeFieldEnd()
9155 kshitij.so 12566 
    if self.bannerType is not None:
12567 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
12568 
      oprot.writeI32(self.bannerType)
12569 
      oprot.writeFieldEnd()
6850 kshitij.so 12570 
    oprot.writeFieldStop()
12571 
    oprot.writeStructEnd()
12572 
 
12573 
  def validate(self):
12574 
    return
12575 
 
12576 
 
12577 
  def __repr__(self):
12578 
    L = ['%s=%r' % (key, value)
12579 
      for key, value in self.__dict__.iteritems()]
12580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12581 
 
12582 
  def __eq__(self, other):
12583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12584 
 
12585 
  def __ne__(self, other):
12586 
    return not (self == other)
12587 
 
12588 
class deleteBanner_result:
12589 
  """
12590 
  Attributes:
12591 
   - success
12592 
  """
12593 
 
12594 
  thrift_spec = (
12595 
    (0, TType.BOOL, 'success', None, None, ), # 0
12596 
  )
12597 
 
12598 
  def __init__(self, success=None,):
12599 
    self.success = success
12600 
 
12601 
  def read(self, iprot):
12602 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12603 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12604 
      return
12605 
    iprot.readStructBegin()
12606 
    while True:
12607 
      (fname, ftype, fid) = iprot.readFieldBegin()
12608 
      if ftype == TType.STOP:
12609 
        break
12610 
      if fid == 0:
12611 
        if ftype == TType.BOOL:
12612 
          self.success = iprot.readBool();
12613 
        else:
12614 
          iprot.skip(ftype)
12615 
      else:
12616 
        iprot.skip(ftype)
12617 
      iprot.readFieldEnd()
12618 
    iprot.readStructEnd()
12619 
 
12620 
  def write(self, oprot):
12621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12623 
      return
12624 
    oprot.writeStructBegin('deleteBanner_result')
12625 
    if self.success is not None:
12626 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12627 
      oprot.writeBool(self.success)
12628 
      oprot.writeFieldEnd()
12629 
    oprot.writeFieldStop()
12630 
    oprot.writeStructEnd()
12631 
 
12632 
  def validate(self):
12633 
    return
12634 
 
12635 
 
12636 
  def __repr__(self):
12637 
    L = ['%s=%r' % (key, value)
12638 
      for key, value in self.__dict__.iteritems()]
12639 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12640 
 
12641 
  def __eq__(self, other):
12642 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12643 
 
12644 
  def __ne__(self, other):
12645 
    return not (self == other)
12646 
 
12647 
class getBannerDetails_args:
12648 
  """
12649 
  Attributes:
12650 
   - bannerName
9155 kshitij.so 12651 
   - bannerType
6850 kshitij.so 12652 
  """
12653 
 
12654 
  thrift_spec = (
12655 
    None, # 0
12656 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 12657 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6850 kshitij.so 12658 
  )
12659 
 
9155 kshitij.so 12660 
  def __init__(self, bannerName=None, bannerType=None,):
6850 kshitij.so 12661 
    self.bannerName = bannerName
9155 kshitij.so 12662 
    self.bannerType = bannerType
6850 kshitij.so 12663 
 
12664 
  def read(self, iprot):
12665 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12666 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12667 
      return
12668 
    iprot.readStructBegin()
12669 
    while True:
12670 
      (fname, ftype, fid) = iprot.readFieldBegin()
12671 
      if ftype == TType.STOP:
12672 
        break
12673 
      if fid == 1:
12674 
        if ftype == TType.STRING:
12675 
          self.bannerName = iprot.readString();
12676 
        else:
12677 
          iprot.skip(ftype)
9155 kshitij.so 12678 
      elif fid == 2:
12679 
        if ftype == TType.I32:
12680 
          self.bannerType = iprot.readI32();
12681 
        else:
12682 
          iprot.skip(ftype)
6850 kshitij.so 12683 
      else:
12684 
        iprot.skip(ftype)
12685 
      iprot.readFieldEnd()
12686 
    iprot.readStructEnd()
12687 
 
12688 
  def write(self, oprot):
12689 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12690 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12691 
      return
12692 
    oprot.writeStructBegin('getBannerDetails_args')
12693 
    if self.bannerName is not None:
12694 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
12695 
      oprot.writeString(self.bannerName)
12696 
      oprot.writeFieldEnd()
9155 kshitij.so 12697 
    if self.bannerType is not None:
12698 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
12699 
      oprot.writeI32(self.bannerType)
12700 
      oprot.writeFieldEnd()
6850 kshitij.so 12701 
    oprot.writeFieldStop()
12702 
    oprot.writeStructEnd()
12703 
 
12704 
  def validate(self):
12705 
    return
12706 
 
12707 
 
12708 
  def __repr__(self):
12709 
    L = ['%s=%r' % (key, value)
12710 
      for key, value in self.__dict__.iteritems()]
12711 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12712 
 
12713 
  def __eq__(self, other):
12714 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12715 
 
12716 
  def __ne__(self, other):
12717 
    return not (self == other)
12718 
 
12719 
class getBannerDetails_result:
12720 
  """
12721 
  Attributes:
12722 
   - success
12723 
  """
12724 
 
12725 
  thrift_spec = (
12726 
    (0, TType.STRUCT, 'success', (Banner, Banner.thrift_spec), None, ), # 0
12727 
  )
12728 
 
12729 
  def __init__(self, success=None,):
12730 
    self.success = success
12731 
 
12732 
  def read(self, iprot):
12733 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12734 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12735 
      return
12736 
    iprot.readStructBegin()
12737 
    while True:
12738 
      (fname, ftype, fid) = iprot.readFieldBegin()
12739 
      if ftype == TType.STOP:
12740 
        break
12741 
      if fid == 0:
12742 
        if ftype == TType.STRUCT:
12743 
          self.success = Banner()
12744 
          self.success.read(iprot)
12745 
        else:
12746 
          iprot.skip(ftype)
12747 
      else:
12748 
        iprot.skip(ftype)
12749 
      iprot.readFieldEnd()
12750 
    iprot.readStructEnd()
12751 
 
12752 
  def write(self, oprot):
12753 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12754 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12755 
      return
12756 
    oprot.writeStructBegin('getBannerDetails_result')
12757 
    if self.success is not None:
12758 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12759 
      self.success.write(oprot)
12760 
      oprot.writeFieldEnd()
12761 
    oprot.writeFieldStop()
12762 
    oprot.writeStructEnd()
12763 
 
12764 
  def validate(self):
12765 
    return
12766 
 
12767 
 
12768 
  def __repr__(self):
12769 
    L = ['%s=%r' % (key, value)
12770 
      for key, value in self.__dict__.iteritems()]
12771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12772 
 
12773 
  def __eq__(self, other):
12774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12775 
 
12776 
  def __ne__(self, other):
12777 
    return not (self == other)
12778 
 
12779 
class getActiveBanners_args:
12780 
 
12781 
  thrift_spec = (
12782 
  )
12783 
 
12784 
  def read(self, iprot):
12785 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12786 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12787 
      return
12788 
    iprot.readStructBegin()
12789 
    while True:
12790 
      (fname, ftype, fid) = iprot.readFieldBegin()
12791 
      if ftype == TType.STOP:
12792 
        break
12793 
      else:
12794 
        iprot.skip(ftype)
12795 
      iprot.readFieldEnd()
12796 
    iprot.readStructEnd()
12797 
 
12798 
  def write(self, oprot):
12799 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12800 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12801 
      return
12802 
    oprot.writeStructBegin('getActiveBanners_args')
12803 
    oprot.writeFieldStop()
12804 
    oprot.writeStructEnd()
12805 
 
12806 
  def validate(self):
12807 
    return
12808 
 
12809 
 
12810 
  def __repr__(self):
12811 
    L = ['%s=%r' % (key, value)
12812 
      for key, value in self.__dict__.iteritems()]
12813 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12814 
 
12815 
  def __eq__(self, other):
12816 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12817 
 
12818 
  def __ne__(self, other):
12819 
    return not (self == other)
12820 
 
12821 
class getActiveBanners_result:
12822 
  """
12823 
  Attributes:
12824 
   - success
12825 
  """
12826 
 
12827 
  thrift_spec = (
8579 kshitij.so 12828 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
6850 kshitij.so 12829 
  )
12830 
 
12831 
  def __init__(self, success=None,):
12832 
    self.success = success
12833 
 
12834 
  def read(self, iprot):
12835 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12836 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12837 
      return
12838 
    iprot.readStructBegin()
12839 
    while True:
12840 
      (fname, ftype, fid) = iprot.readFieldBegin()
12841 
      if ftype == TType.STOP:
12842 
        break
12843 
      if fid == 0:
8579 kshitij.so 12844 
        if ftype == TType.MAP:
12845 
          self.success = {}
8590 kshitij.so 12846 
          (_ktype203, _vtype204, _size202 ) = iprot.readMapBegin()
12847 
          for _i206 in xrange(_size202):
12848 
            _key207 = iprot.readString();
12849 
            _val208 = []
12850 
            (_etype212, _size209) = iprot.readListBegin()
12851 
            for _i213 in xrange(_size209):
12852 
              _elem214 = Banner()
12853 
              _elem214.read(iprot)
12854 
              _val208.append(_elem214)
8579 kshitij.so 12855 
            iprot.readListEnd()
8590 kshitij.so 12856 
            self.success[_key207] = _val208
8579 kshitij.so 12857 
          iprot.readMapEnd()
6850 kshitij.so 12858 
        else:
12859 
          iprot.skip(ftype)
12860 
      else:
12861 
        iprot.skip(ftype)
12862 
      iprot.readFieldEnd()
12863 
    iprot.readStructEnd()
12864 
 
12865 
  def write(self, oprot):
12866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12868 
      return
12869 
    oprot.writeStructBegin('getActiveBanners_result')
12870 
    if self.success is not None:
8579 kshitij.so 12871 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12872 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
8590 kshitij.so 12873 
      for kiter215,viter216 in self.success.items():
12874 
        oprot.writeString(kiter215)
12875 
        oprot.writeListBegin(TType.STRUCT, len(viter216))
12876 
        for iter217 in viter216:
12877 
          iter217.write(oprot)
8579 kshitij.so 12878 
        oprot.writeListEnd()
12879 
      oprot.writeMapEnd()
6850 kshitij.so 12880 
      oprot.writeFieldEnd()
12881 
    oprot.writeFieldStop()
12882 
    oprot.writeStructEnd()
12883 
 
12884 
  def validate(self):
12885 
    return
12886 
 
12887 
 
12888 
  def __repr__(self):
12889 
    L = ['%s=%r' % (key, value)
12890 
      for key, value in self.__dict__.iteritems()]
12891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12892 
 
12893 
  def __eq__(self, other):
12894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12895 
 
12896 
  def __ne__(self, other):
12897 
    return not (self == other)
12898 
 
6849 kshitij.so 12899 
class addBannerMap_args:
12900 
  """
12901 
  Attributes:
8579 kshitij.so 12902 
   - bannerMaps
6849 kshitij.so 12903 
  """
12904 
 
12905 
  thrift_spec = (
12906 
    None, # 0
8579 kshitij.so 12907 
    (1, TType.LIST, 'bannerMaps', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 1
6849 kshitij.so 12908 
  )
12909 
 
8579 kshitij.so 12910 
  def __init__(self, bannerMaps=None,):
12911 
    self.bannerMaps = bannerMaps
6849 kshitij.so 12912 
 
12913 
  def read(self, iprot):
12914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12916 
      return
12917 
    iprot.readStructBegin()
12918 
    while True:
12919 
      (fname, ftype, fid) = iprot.readFieldBegin()
12920 
      if ftype == TType.STOP:
12921 
        break
12922 
      if fid == 1:
8579 kshitij.so 12923 
        if ftype == TType.LIST:
12924 
          self.bannerMaps = []
8590 kshitij.so 12925 
          (_etype221, _size218) = iprot.readListBegin()
12926 
          for _i222 in xrange(_size218):
12927 
            _elem223 = BannerMap()
12928 
            _elem223.read(iprot)
12929 
            self.bannerMaps.append(_elem223)
8579 kshitij.so 12930 
          iprot.readListEnd()
6849 kshitij.so 12931 
        else:
12932 
          iprot.skip(ftype)
8579 kshitij.so 12933 
      else:
12934 
        iprot.skip(ftype)
12935 
      iprot.readFieldEnd()
12936 
    iprot.readStructEnd()
12937 
 
12938 
  def write(self, oprot):
12939 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12940 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12941 
      return
12942 
    oprot.writeStructBegin('addBannerMap_args')
12943 
    if self.bannerMaps is not None:
12944 
      oprot.writeFieldBegin('bannerMaps', TType.LIST, 1)
12945 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerMaps))
8590 kshitij.so 12946 
      for iter224 in self.bannerMaps:
12947 
        iter224.write(oprot)
8579 kshitij.so 12948 
      oprot.writeListEnd()
12949 
      oprot.writeFieldEnd()
12950 
    oprot.writeFieldStop()
12951 
    oprot.writeStructEnd()
12952 
 
12953 
  def validate(self):
12954 
    return
12955 
 
12956 
 
12957 
  def __repr__(self):
12958 
    L = ['%s=%r' % (key, value)
12959 
      for key, value in self.__dict__.iteritems()]
12960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12961 
 
12962 
  def __eq__(self, other):
12963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12964 
 
12965 
  def __ne__(self, other):
12966 
    return not (self == other)
12967 
 
12968 
class addBannerMap_result:
12969 
  """
12970 
  Attributes:
12971 
   - success
12972 
  """
12973 
 
12974 
  thrift_spec = (
12975 
    (0, TType.BOOL, 'success', None, None, ), # 0
12976 
  )
12977 
 
12978 
  def __init__(self, success=None,):
12979 
    self.success = success
12980 
 
12981 
  def read(self, iprot):
12982 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12983 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12984 
      return
12985 
    iprot.readStructBegin()
12986 
    while True:
12987 
      (fname, ftype, fid) = iprot.readFieldBegin()
12988 
      if ftype == TType.STOP:
12989 
        break
12990 
      if fid == 0:
12991 
        if ftype == TType.BOOL:
12992 
          self.success = iprot.readBool();
6849 kshitij.so 12993 
        else:
12994 
          iprot.skip(ftype)
8579 kshitij.so 12995 
      else:
12996 
        iprot.skip(ftype)
12997 
      iprot.readFieldEnd()
12998 
    iprot.readStructEnd()
12999 
 
13000 
  def write(self, oprot):
13001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13003 
      return
13004 
    oprot.writeStructBegin('addBannerMap_result')
13005 
    if self.success is not None:
13006 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13007 
      oprot.writeBool(self.success)
13008 
      oprot.writeFieldEnd()
13009 
    oprot.writeFieldStop()
13010 
    oprot.writeStructEnd()
13011 
 
13012 
  def validate(self):
13013 
    return
13014 
 
13015 
 
13016 
  def __repr__(self):
13017 
    L = ['%s=%r' % (key, value)
13018 
      for key, value in self.__dict__.iteritems()]
13019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13020 
 
13021 
  def __eq__(self, other):
13022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13023 
 
13024 
  def __ne__(self, other):
13025 
    return not (self == other)
13026 
 
13027 
class updateBannerMap_args:
13028 
  """
13029 
  Attributes:
13030 
   - bannerMap
13031 
  """
13032 
 
13033 
  thrift_spec = (
13034 
    None, # 0
13035 
    (1, TType.STRUCT, 'bannerMap', (BannerMap, BannerMap.thrift_spec), None, ), # 1
13036 
  )
13037 
 
13038 
  def __init__(self, bannerMap=None,):
13039 
    self.bannerMap = bannerMap
13040 
 
13041 
  def read(self, iprot):
13042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13044 
      return
13045 
    iprot.readStructBegin()
13046 
    while True:
13047 
      (fname, ftype, fid) = iprot.readFieldBegin()
13048 
      if ftype == TType.STOP:
13049 
        break
13050 
      if fid == 1:
13051 
        if ftype == TType.STRUCT:
13052 
          self.bannerMap = BannerMap()
13053 
          self.bannerMap.read(iprot)
6849 kshitij.so 13054 
        else:
13055 
          iprot.skip(ftype)
13056 
      else:
13057 
        iprot.skip(ftype)
13058 
      iprot.readFieldEnd()
13059 
    iprot.readStructEnd()
13060 
 
13061 
  def write(self, oprot):
13062 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13063 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13064 
      return
8579 kshitij.so 13065 
    oprot.writeStructBegin('updateBannerMap_args')
13066 
    if self.bannerMap is not None:
13067 
      oprot.writeFieldBegin('bannerMap', TType.STRUCT, 1)
13068 
      self.bannerMap.write(oprot)
6849 kshitij.so 13069 
      oprot.writeFieldEnd()
13070 
    oprot.writeFieldStop()
13071 
    oprot.writeStructEnd()
13072 
 
13073 
  def validate(self):
13074 
    return
13075 
 
13076 
 
13077 
  def __repr__(self):
13078 
    L = ['%s=%r' % (key, value)
13079 
      for key, value in self.__dict__.iteritems()]
13080 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13081 
 
13082 
  def __eq__(self, other):
13083 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13084 
 
13085 
  def __ne__(self, other):
13086 
    return not (self == other)
13087 
 
8579 kshitij.so 13088 
class updateBannerMap_result:
6849 kshitij.so 13089 
  """
13090 
  Attributes:
13091 
   - success
13092 
  """
13093 
 
13094 
  thrift_spec = (
13095 
    (0, TType.BOOL, 'success', None, None, ), # 0
13096 
  )
13097 
 
13098 
  def __init__(self, success=None,):
13099 
    self.success = success
13100 
 
13101 
  def read(self, iprot):
13102 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13103 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13104 
      return
13105 
    iprot.readStructBegin()
13106 
    while True:
13107 
      (fname, ftype, fid) = iprot.readFieldBegin()
13108 
      if ftype == TType.STOP:
13109 
        break
13110 
      if fid == 0:
13111 
        if ftype == TType.BOOL:
13112 
          self.success = iprot.readBool();
13113 
        else:
13114 
          iprot.skip(ftype)
13115 
      else:
13116 
        iprot.skip(ftype)
13117 
      iprot.readFieldEnd()
13118 
    iprot.readStructEnd()
13119 
 
13120 
  def write(self, oprot):
13121 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13122 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13123 
      return
8579 kshitij.so 13124 
    oprot.writeStructBegin('updateBannerMap_result')
6849 kshitij.so 13125 
    if self.success is not None:
13126 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13127 
      oprot.writeBool(self.success)
13128 
      oprot.writeFieldEnd()
13129 
    oprot.writeFieldStop()
13130 
    oprot.writeStructEnd()
13131 
 
13132 
  def validate(self):
13133 
    return
13134 
 
13135 
 
13136 
  def __repr__(self):
13137 
    L = ['%s=%r' % (key, value)
13138 
      for key, value in self.__dict__.iteritems()]
13139 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13140 
 
13141 
  def __eq__(self, other):
13142 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13143 
 
13144 
  def __ne__(self, other):
13145 
    return not (self == other)
13146 
 
13147 
class deleteBannerMap_args:
13148 
  """
13149 
  Attributes:
13150 
   - bannerName
13151 
  """
13152 
 
13153 
  thrift_spec = (
13154 
    None, # 0
13155 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
13156 
  )
13157 
 
13158 
  def __init__(self, bannerName=None,):
13159 
    self.bannerName = bannerName
13160 
 
13161 
  def read(self, iprot):
13162 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13163 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13164 
      return
13165 
    iprot.readStructBegin()
13166 
    while True:
13167 
      (fname, ftype, fid) = iprot.readFieldBegin()
13168 
      if ftype == TType.STOP:
13169 
        break
13170 
      if fid == 1:
13171 
        if ftype == TType.STRING:
13172 
          self.bannerName = iprot.readString();
13173 
        else:
13174 
          iprot.skip(ftype)
13175 
      else:
13176 
        iprot.skip(ftype)
13177 
      iprot.readFieldEnd()
13178 
    iprot.readStructEnd()
13179 
 
13180 
  def write(self, oprot):
13181 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13182 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13183 
      return
13184 
    oprot.writeStructBegin('deleteBannerMap_args')
13185 
    if self.bannerName is not None:
13186 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
13187 
      oprot.writeString(self.bannerName)
13188 
      oprot.writeFieldEnd()
13189 
    oprot.writeFieldStop()
13190 
    oprot.writeStructEnd()
13191 
 
13192 
  def validate(self):
13193 
    return
13194 
 
13195 
 
13196 
  def __repr__(self):
13197 
    L = ['%s=%r' % (key, value)
13198 
      for key, value in self.__dict__.iteritems()]
13199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13200 
 
13201 
  def __eq__(self, other):
13202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13203 
 
13204 
  def __ne__(self, other):
13205 
    return not (self == other)
13206 
 
13207 
class deleteBannerMap_result:
13208 
  """
13209 
  Attributes:
13210 
   - success
13211 
  """
13212 
 
13213 
  thrift_spec = (
13214 
    (0, TType.BOOL, 'success', None, None, ), # 0
13215 
  )
13216 
 
13217 
  def __init__(self, success=None,):
13218 
    self.success = success
13219 
 
13220 
  def read(self, iprot):
13221 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13222 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13223 
      return
13224 
    iprot.readStructBegin()
13225 
    while True:
13226 
      (fname, ftype, fid) = iprot.readFieldBegin()
13227 
      if ftype == TType.STOP:
13228 
        break
13229 
      if fid == 0:
13230 
        if ftype == TType.BOOL:
13231 
          self.success = iprot.readBool();
13232 
        else:
13233 
          iprot.skip(ftype)
13234 
      else:
13235 
        iprot.skip(ftype)
13236 
      iprot.readFieldEnd()
13237 
    iprot.readStructEnd()
13238 
 
13239 
  def write(self, oprot):
13240 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13241 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13242 
      return
13243 
    oprot.writeStructBegin('deleteBannerMap_result')
13244 
    if self.success is not None:
13245 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13246 
      oprot.writeBool(self.success)
13247 
      oprot.writeFieldEnd()
13248 
    oprot.writeFieldStop()
13249 
    oprot.writeStructEnd()
13250 
 
13251 
  def validate(self):
13252 
    return
13253 
 
13254 
 
13255 
  def __repr__(self):
13256 
    L = ['%s=%r' % (key, value)
13257 
      for key, value in self.__dict__.iteritems()]
13258 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13259 
 
13260 
  def __eq__(self, other):
13261 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13262 
 
13263 
  def __ne__(self, other):
13264 
    return not (self == other)
13265 
 
13266 
class getBannerMapDetails_args:
13267 
  """
13268 
  Attributes:
13269 
   - bannerName
9155 kshitij.so 13270 
   - bannerType
6849 kshitij.so 13271 
  """
13272 
 
13273 
  thrift_spec = (
13274 
    None, # 0
13275 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 13276 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6849 kshitij.so 13277 
  )
13278 
 
9155 kshitij.so 13279 
  def __init__(self, bannerName=None, bannerType=None,):
6849 kshitij.so 13280 
    self.bannerName = bannerName
9155 kshitij.so 13281 
    self.bannerType = bannerType
6849 kshitij.so 13282 
 
13283 
  def read(self, iprot):
13284 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13285 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13286 
      return
13287 
    iprot.readStructBegin()
13288 
    while True:
13289 
      (fname, ftype, fid) = iprot.readFieldBegin()
13290 
      if ftype == TType.STOP:
13291 
        break
13292 
      if fid == 1:
13293 
        if ftype == TType.STRING:
13294 
          self.bannerName = iprot.readString();
13295 
        else:
13296 
          iprot.skip(ftype)
9155 kshitij.so 13297 
      elif fid == 2:
13298 
        if ftype == TType.I32:
13299 
          self.bannerType = iprot.readI32();
13300 
        else:
13301 
          iprot.skip(ftype)
6849 kshitij.so 13302 
      else:
13303 
        iprot.skip(ftype)
13304 
      iprot.readFieldEnd()
13305 
    iprot.readStructEnd()
13306 
 
13307 
  def write(self, oprot):
13308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13310 
      return
13311 
    oprot.writeStructBegin('getBannerMapDetails_args')
13312 
    if self.bannerName is not None:
13313 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
13314 
      oprot.writeString(self.bannerName)
13315 
      oprot.writeFieldEnd()
9155 kshitij.so 13316 
    if self.bannerType is not None:
13317 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
13318 
      oprot.writeI32(self.bannerType)
13319 
      oprot.writeFieldEnd()
6849 kshitij.so 13320 
    oprot.writeFieldStop()
13321 
    oprot.writeStructEnd()
13322 
 
13323 
  def validate(self):
13324 
    return
13325 
 
13326 
 
13327 
  def __repr__(self):
13328 
    L = ['%s=%r' % (key, value)
13329 
      for key, value in self.__dict__.iteritems()]
13330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13331 
 
13332 
  def __eq__(self, other):
13333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13334 
 
13335 
  def __ne__(self, other):
13336 
    return not (self == other)
13337 
 
13338 
class getBannerMapDetails_result:
13339 
  """
13340 
  Attributes:
13341 
   - success
13342 
  """
13343 
 
13344 
  thrift_spec = (
13345 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 0
13346 
  )
13347 
 
13348 
  def __init__(self, success=None,):
13349 
    self.success = success
13350 
 
13351 
  def read(self, iprot):
13352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13354 
      return
13355 
    iprot.readStructBegin()
13356 
    while True:
13357 
      (fname, ftype, fid) = iprot.readFieldBegin()
13358 
      if ftype == TType.STOP:
13359 
        break
13360 
      if fid == 0:
13361 
        if ftype == TType.LIST:
13362 
          self.success = []
8590 kshitij.so 13363 
          (_etype228, _size225) = iprot.readListBegin()
13364 
          for _i229 in xrange(_size225):
13365 
            _elem230 = BannerMap()
13366 
            _elem230.read(iprot)
13367 
            self.success.append(_elem230)
6849 kshitij.so 13368 
          iprot.readListEnd()
13369 
        else:
13370 
          iprot.skip(ftype)
13371 
      else:
13372 
        iprot.skip(ftype)
13373 
      iprot.readFieldEnd()
13374 
    iprot.readStructEnd()
13375 
 
13376 
  def write(self, oprot):
13377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13379 
      return
13380 
    oprot.writeStructBegin('getBannerMapDetails_result')
13381 
    if self.success is not None:
13382 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13383 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 13384 
      for iter231 in self.success:
13385 
        iter231.write(oprot)
6849 kshitij.so 13386 
      oprot.writeListEnd()
13387 
      oprot.writeFieldEnd()
13388 
    oprot.writeFieldStop()
13389 
    oprot.writeStructEnd()
13390 
 
13391 
  def validate(self):
13392 
    return
13393 
 
13394 
 
13395 
  def __repr__(self):
13396 
    L = ['%s=%r' % (key, value)
13397 
      for key, value in self.__dict__.iteritems()]
13398 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13399 
 
13400 
  def __eq__(self, other):
13401 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13402 
 
13403 
  def __ne__(self, other):
13404 
    return not (self == other)
13405 
 
8579 kshitij.so 13406 
class addBannerUri_args:
13407 
  """
13408 
  Attributes:
13409 
   - bannerUriMappings
13410 
  """
13411 
 
13412 
  thrift_spec = (
13413 
    None, # 0
13414 
    (1, TType.LIST, 'bannerUriMappings', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 1
13415 
  )
13416 
 
13417 
  def __init__(self, bannerUriMappings=None,):
13418 
    self.bannerUriMappings = bannerUriMappings
13419 
 
13420 
  def read(self, iprot):
13421 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13422 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13423 
      return
13424 
    iprot.readStructBegin()
13425 
    while True:
13426 
      (fname, ftype, fid) = iprot.readFieldBegin()
13427 
      if ftype == TType.STOP:
13428 
        break
13429 
      if fid == 1:
13430 
        if ftype == TType.LIST:
13431 
          self.bannerUriMappings = []
8590 kshitij.so 13432 
          (_etype235, _size232) = iprot.readListBegin()
13433 
          for _i236 in xrange(_size232):
13434 
            _elem237 = BannerUriMapping()
13435 
            _elem237.read(iprot)
13436 
            self.bannerUriMappings.append(_elem237)
8579 kshitij.so 13437 
          iprot.readListEnd()
13438 
        else:
13439 
          iprot.skip(ftype)
13440 
      else:
13441 
        iprot.skip(ftype)
13442 
      iprot.readFieldEnd()
13443 
    iprot.readStructEnd()
13444 
 
13445 
  def write(self, oprot):
13446 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13447 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13448 
      return
13449 
    oprot.writeStructBegin('addBannerUri_args')
13450 
    if self.bannerUriMappings is not None:
13451 
      oprot.writeFieldBegin('bannerUriMappings', TType.LIST, 1)
13452 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerUriMappings))
8590 kshitij.so 13453 
      for iter238 in self.bannerUriMappings:
13454 
        iter238.write(oprot)
8579 kshitij.so 13455 
      oprot.writeListEnd()
13456 
      oprot.writeFieldEnd()
13457 
    oprot.writeFieldStop()
13458 
    oprot.writeStructEnd()
13459 
 
13460 
  def validate(self):
13461 
    return
13462 
 
13463 
 
13464 
  def __repr__(self):
13465 
    L = ['%s=%r' % (key, value)
13466 
      for key, value in self.__dict__.iteritems()]
13467 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13468 
 
13469 
  def __eq__(self, other):
13470 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13471 
 
13472 
  def __ne__(self, other):
13473 
    return not (self == other)
13474 
 
13475 
class addBannerUri_result:
13476 
 
13477 
  thrift_spec = (
13478 
  )
13479 
 
13480 
  def read(self, iprot):
13481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13483 
      return
13484 
    iprot.readStructBegin()
13485 
    while True:
13486 
      (fname, ftype, fid) = iprot.readFieldBegin()
13487 
      if ftype == TType.STOP:
13488 
        break
13489 
      else:
13490 
        iprot.skip(ftype)
13491 
      iprot.readFieldEnd()
13492 
    iprot.readStructEnd()
13493 
 
13494 
  def write(self, oprot):
13495 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13496 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13497 
      return
13498 
    oprot.writeStructBegin('addBannerUri_result')
13499 
    oprot.writeFieldStop()
13500 
    oprot.writeStructEnd()
13501 
 
13502 
  def validate(self):
13503 
    return
13504 
 
13505 
 
13506 
  def __repr__(self):
13507 
    L = ['%s=%r' % (key, value)
13508 
      for key, value in self.__dict__.iteritems()]
13509 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13510 
 
13511 
  def __eq__(self, other):
13512 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13513 
 
13514 
  def __ne__(self, other):
13515 
    return not (self == other)
13516 
 
13517 
class getUriMapping_args:
13518 
  """
13519 
  Attributes:
13520 
   - bannerName
9155 kshitij.so 13521 
   - bannerType
8579 kshitij.so 13522 
  """
13523 
 
13524 
  thrift_spec = (
13525 
    None, # 0
13526 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 13527 
    (2, TType.I32, 'bannerType', None, None, ), # 2
8579 kshitij.so 13528 
  )
13529 
 
9155 kshitij.so 13530 
  def __init__(self, bannerName=None, bannerType=None,):
8579 kshitij.so 13531 
    self.bannerName = bannerName
9155 kshitij.so 13532 
    self.bannerType = bannerType
8579 kshitij.so 13533 
 
13534 
  def read(self, iprot):
13535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13537 
      return
13538 
    iprot.readStructBegin()
13539 
    while True:
13540 
      (fname, ftype, fid) = iprot.readFieldBegin()
13541 
      if ftype == TType.STOP:
13542 
        break
13543 
      if fid == 1:
13544 
        if ftype == TType.STRING:
13545 
          self.bannerName = iprot.readString();
13546 
        else:
13547 
          iprot.skip(ftype)
9155 kshitij.so 13548 
      elif fid == 2:
13549 
        if ftype == TType.I32:
13550 
          self.bannerType = iprot.readI32();
13551 
        else:
13552 
          iprot.skip(ftype)
8579 kshitij.so 13553 
      else:
13554 
        iprot.skip(ftype)
13555 
      iprot.readFieldEnd()
13556 
    iprot.readStructEnd()
13557 
 
13558 
  def write(self, oprot):
13559 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13560 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13561 
      return
13562 
    oprot.writeStructBegin('getUriMapping_args')
13563 
    if self.bannerName is not None:
13564 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
13565 
      oprot.writeString(self.bannerName)
13566 
      oprot.writeFieldEnd()
9155 kshitij.so 13567 
    if self.bannerType is not None:
13568 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
13569 
      oprot.writeI32(self.bannerType)
13570 
      oprot.writeFieldEnd()
8579 kshitij.so 13571 
    oprot.writeFieldStop()
13572 
    oprot.writeStructEnd()
13573 
 
13574 
  def validate(self):
13575 
    return
13576 
 
13577 
 
13578 
  def __repr__(self):
13579 
    L = ['%s=%r' % (key, value)
13580 
      for key, value in self.__dict__.iteritems()]
13581 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13582 
 
13583 
  def __eq__(self, other):
13584 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13585 
 
13586 
  def __ne__(self, other):
13587 
    return not (self == other)
13588 
 
13589 
class getUriMapping_result:
13590 
  """
13591 
  Attributes:
13592 
   - success
13593 
  """
13594 
 
13595 
  thrift_spec = (
13596 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 0
13597 
  )
13598 
 
13599 
  def __init__(self, success=None,):
13600 
    self.success = success
13601 
 
13602 
  def read(self, iprot):
13603 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13604 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13605 
      return
13606 
    iprot.readStructBegin()
13607 
    while True:
13608 
      (fname, ftype, fid) = iprot.readFieldBegin()
13609 
      if ftype == TType.STOP:
13610 
        break
13611 
      if fid == 0:
13612 
        if ftype == TType.LIST:
13613 
          self.success = []
8590 kshitij.so 13614 
          (_etype242, _size239) = iprot.readListBegin()
13615 
          for _i243 in xrange(_size239):
13616 
            _elem244 = BannerUriMapping()
13617 
            _elem244.read(iprot)
13618 
            self.success.append(_elem244)
8579 kshitij.so 13619 
          iprot.readListEnd()
13620 
        else:
13621 
          iprot.skip(ftype)
13622 
      else:
13623 
        iprot.skip(ftype)
13624 
      iprot.readFieldEnd()
13625 
    iprot.readStructEnd()
13626 
 
13627 
  def write(self, oprot):
13628 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13629 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13630 
      return
13631 
    oprot.writeStructBegin('getUriMapping_result')
13632 
    if self.success is not None:
13633 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13634 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 13635 
      for iter245 in self.success:
13636 
        iter245.write(oprot)
8579 kshitij.so 13637 
      oprot.writeListEnd()
13638 
      oprot.writeFieldEnd()
13639 
    oprot.writeFieldStop()
13640 
    oprot.writeStructEnd()
13641 
 
13642 
  def validate(self):
13643 
    return
13644 
 
13645 
 
13646 
  def __repr__(self):
13647 
    L = ['%s=%r' % (key, value)
13648 
      for key, value in self.__dict__.iteritems()]
13649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13650 
 
13651 
  def __eq__(self, other):
13652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13653 
 
13654 
  def __ne__(self, other):
13655 
    return not (self == other)
13656 
 
13657 
class addCampaign_args:
13658 
  """
13659 
  Attributes:
13660 
   - campaign
13661 
  """
13662 
 
13663 
  thrift_spec = (
13664 
    None, # 0
13665 
    (1, TType.STRUCT, 'campaign', (Campaign, Campaign.thrift_spec), None, ), # 1
13666 
  )
13667 
 
13668 
  def __init__(self, campaign=None,):
13669 
    self.campaign = campaign
13670 
 
13671 
  def read(self, iprot):
13672 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13673 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13674 
      return
13675 
    iprot.readStructBegin()
13676 
    while True:
13677 
      (fname, ftype, fid) = iprot.readFieldBegin()
13678 
      if ftype == TType.STOP:
13679 
        break
13680 
      if fid == 1:
13681 
        if ftype == TType.STRUCT:
13682 
          self.campaign = Campaign()
13683 
          self.campaign.read(iprot)
13684 
        else:
13685 
          iprot.skip(ftype)
13686 
      else:
13687 
        iprot.skip(ftype)
13688 
      iprot.readFieldEnd()
13689 
    iprot.readStructEnd()
13690 
 
13691 
  def write(self, oprot):
13692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13694 
      return
13695 
    oprot.writeStructBegin('addCampaign_args')
13696 
    if self.campaign is not None:
13697 
      oprot.writeFieldBegin('campaign', TType.STRUCT, 1)
13698 
      self.campaign.write(oprot)
13699 
      oprot.writeFieldEnd()
13700 
    oprot.writeFieldStop()
13701 
    oprot.writeStructEnd()
13702 
 
13703 
  def validate(self):
13704 
    return
13705 
 
13706 
 
13707 
  def __repr__(self):
13708 
    L = ['%s=%r' % (key, value)
13709 
      for key, value in self.__dict__.iteritems()]
13710 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13711 
 
13712 
  def __eq__(self, other):
13713 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13714 
 
13715 
  def __ne__(self, other):
13716 
    return not (self == other)
13717 
 
13718 
class addCampaign_result:
13719 
 
13720 
  thrift_spec = (
13721 
  )
13722 
 
13723 
  def read(self, iprot):
13724 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13725 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13726 
      return
13727 
    iprot.readStructBegin()
13728 
    while True:
13729 
      (fname, ftype, fid) = iprot.readFieldBegin()
13730 
      if ftype == TType.STOP:
13731 
        break
13732 
      else:
13733 
        iprot.skip(ftype)
13734 
      iprot.readFieldEnd()
13735 
    iprot.readStructEnd()
13736 
 
13737 
  def write(self, oprot):
13738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13740 
      return
13741 
    oprot.writeStructBegin('addCampaign_result')
13742 
    oprot.writeFieldStop()
13743 
    oprot.writeStructEnd()
13744 
 
13745 
  def validate(self):
13746 
    return
13747 
 
13748 
 
13749 
  def __repr__(self):
13750 
    L = ['%s=%r' % (key, value)
13751 
      for key, value in self.__dict__.iteritems()]
13752 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13753 
 
13754 
  def __eq__(self, other):
13755 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13756 
 
13757 
  def __ne__(self, other):
13758 
    return not (self == other)
13759 
 
13760 
class getCampaigns_args:
13761 
  """
13762 
  Attributes:
13763 
   - campaignName
13764 
  """
13765 
 
13766 
  thrift_spec = (
13767 
    None, # 0
13768 
    (1, TType.STRING, 'campaignName', None, None, ), # 1
13769 
  )
13770 
 
13771 
  def __init__(self, campaignName=None,):
13772 
    self.campaignName = campaignName
13773 
 
13774 
  def read(self, iprot):
13775 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13776 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13777 
      return
13778 
    iprot.readStructBegin()
13779 
    while True:
13780 
      (fname, ftype, fid) = iprot.readFieldBegin()
13781 
      if ftype == TType.STOP:
13782 
        break
13783 
      if fid == 1:
13784 
        if ftype == TType.STRING:
13785 
          self.campaignName = iprot.readString();
13786 
        else:
13787 
          iprot.skip(ftype)
13788 
      else:
13789 
        iprot.skip(ftype)
13790 
      iprot.readFieldEnd()
13791 
    iprot.readStructEnd()
13792 
 
13793 
  def write(self, oprot):
13794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13796 
      return
13797 
    oprot.writeStructBegin('getCampaigns_args')
13798 
    if self.campaignName is not None:
13799 
      oprot.writeFieldBegin('campaignName', TType.STRING, 1)
13800 
      oprot.writeString(self.campaignName)
13801 
      oprot.writeFieldEnd()
13802 
    oprot.writeFieldStop()
13803 
    oprot.writeStructEnd()
13804 
 
13805 
  def validate(self):
13806 
    return
13807 
 
13808 
 
13809 
  def __repr__(self):
13810 
    L = ['%s=%r' % (key, value)
13811 
      for key, value in self.__dict__.iteritems()]
13812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13813 
 
13814 
  def __eq__(self, other):
13815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13816 
 
13817 
  def __ne__(self, other):
13818 
    return not (self == other)
13819 
 
13820 
class getCampaigns_result:
13821 
  """
13822 
  Attributes:
13823 
   - success
13824 
  """
13825 
 
13826 
  thrift_spec = (
13827 
    (0, TType.LIST, 'success', (TType.STRUCT,(Campaign, Campaign.thrift_spec)), None, ), # 0
13828 
  )
13829 
 
13830 
  def __init__(self, success=None,):
13831 
    self.success = success
13832 
 
13833 
  def read(self, iprot):
13834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13836 
      return
13837 
    iprot.readStructBegin()
13838 
    while True:
13839 
      (fname, ftype, fid) = iprot.readFieldBegin()
13840 
      if ftype == TType.STOP:
13841 
        break
13842 
      if fid == 0:
13843 
        if ftype == TType.LIST:
13844 
          self.success = []
8590 kshitij.so 13845 
          (_etype249, _size246) = iprot.readListBegin()
13846 
          for _i250 in xrange(_size246):
13847 
            _elem251 = Campaign()
13848 
            _elem251.read(iprot)
13849 
            self.success.append(_elem251)
8579 kshitij.so 13850 
          iprot.readListEnd()
13851 
        else:
13852 
          iprot.skip(ftype)
13853 
      else:
13854 
        iprot.skip(ftype)
13855 
      iprot.readFieldEnd()
13856 
    iprot.readStructEnd()
13857 
 
13858 
  def write(self, oprot):
13859 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13860 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13861 
      return
13862 
    oprot.writeStructBegin('getCampaigns_result')
13863 
    if self.success is not None:
13864 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13865 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 13866 
      for iter252 in self.success:
13867 
        iter252.write(oprot)
8579 kshitij.so 13868 
      oprot.writeListEnd()
13869 
      oprot.writeFieldEnd()
13870 
    oprot.writeFieldStop()
13871 
    oprot.writeStructEnd()
13872 
 
13873 
  def validate(self):
13874 
    return
13875 
 
13876 
 
13877 
  def __repr__(self):
13878 
    L = ['%s=%r' % (key, value)
13879 
      for key, value in self.__dict__.iteritems()]
13880 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13881 
 
13882 
  def __eq__(self, other):
13883 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13884 
 
13885 
  def __ne__(self, other):
13886 
    return not (self == other)
13887 
 
13888 
class deleteCampaign_args:
13889 
  """
13890 
  Attributes:
13891 
   - campaignId
13892 
  """
13893 
 
13894 
  thrift_spec = (
13895 
    None, # 0
13896 
    (1, TType.I64, 'campaignId', None, None, ), # 1
13897 
  )
13898 
 
13899 
  def __init__(self, campaignId=None,):
13900 
    self.campaignId = campaignId
13901 
 
13902 
  def read(self, iprot):
13903 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13904 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13905 
      return
13906 
    iprot.readStructBegin()
13907 
    while True:
13908 
      (fname, ftype, fid) = iprot.readFieldBegin()
13909 
      if ftype == TType.STOP:
13910 
        break
13911 
      if fid == 1:
13912 
        if ftype == TType.I64:
13913 
          self.campaignId = iprot.readI64();
13914 
        else:
13915 
          iprot.skip(ftype)
13916 
      else:
13917 
        iprot.skip(ftype)
13918 
      iprot.readFieldEnd()
13919 
    iprot.readStructEnd()
13920 
 
13921 
  def write(self, oprot):
13922 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13923 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13924 
      return
13925 
    oprot.writeStructBegin('deleteCampaign_args')
13926 
    if self.campaignId is not None:
13927 
      oprot.writeFieldBegin('campaignId', TType.I64, 1)
13928 
      oprot.writeI64(self.campaignId)
13929 
      oprot.writeFieldEnd()
13930 
    oprot.writeFieldStop()
13931 
    oprot.writeStructEnd()
13932 
 
13933 
  def validate(self):
13934 
    return
13935 
 
13936 
 
13937 
  def __repr__(self):
13938 
    L = ['%s=%r' % (key, value)
13939 
      for key, value in self.__dict__.iteritems()]
13940 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13941 
 
13942 
  def __eq__(self, other):
13943 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13944 
 
13945 
  def __ne__(self, other):
13946 
    return not (self == other)
13947 
 
13948 
class deleteCampaign_result:
13949 
 
13950 
  thrift_spec = (
13951 
  )
13952 
 
13953 
  def read(self, iprot):
13954 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13955 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13956 
      return
13957 
    iprot.readStructBegin()
13958 
    while True:
13959 
      (fname, ftype, fid) = iprot.readFieldBegin()
13960 
      if ftype == TType.STOP:
13961 
        break
13962 
      else:
13963 
        iprot.skip(ftype)
13964 
      iprot.readFieldEnd()
13965 
    iprot.readStructEnd()
13966 
 
13967 
  def write(self, oprot):
13968 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13969 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13970 
      return
13971 
    oprot.writeStructBegin('deleteCampaign_result')
13972 
    oprot.writeFieldStop()
13973 
    oprot.writeStructEnd()
13974 
 
13975 
  def validate(self):
13976 
    return
13977 
 
13978 
 
13979 
  def __repr__(self):
13980 
    L = ['%s=%r' % (key, value)
13981 
      for key, value in self.__dict__.iteritems()]
13982 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13983 
 
13984 
  def __eq__(self, other):
13985 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13986 
 
13987 
  def __ne__(self, other):
13988 
    return not (self == other)
13989 
 
13990 
class getAllCampaigns_args:
13991 
 
13992 
  thrift_spec = (
13993 
  )
13994 
 
13995 
  def read(self, iprot):
13996 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13997 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13998 
      return
13999 
    iprot.readStructBegin()
14000 
    while True:
14001 
      (fname, ftype, fid) = iprot.readFieldBegin()
14002 
      if ftype == TType.STOP:
14003 
        break
14004 
      else:
14005 
        iprot.skip(ftype)
14006 
      iprot.readFieldEnd()
14007 
    iprot.readStructEnd()
14008 
 
14009 
  def write(self, oprot):
14010 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14011 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14012 
      return
14013 
    oprot.writeStructBegin('getAllCampaigns_args')
14014 
    oprot.writeFieldStop()
14015 
    oprot.writeStructEnd()
14016 
 
14017 
  def validate(self):
14018 
    return
14019 
 
14020 
 
14021 
  def __repr__(self):
14022 
    L = ['%s=%r' % (key, value)
14023 
      for key, value in self.__dict__.iteritems()]
14024 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14025 
 
14026 
  def __eq__(self, other):
14027 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14028 
 
14029 
  def __ne__(self, other):
14030 
    return not (self == other)
14031 
 
14032 
class getAllCampaigns_result:
14033 
  """
14034 
  Attributes:
14035 
   - success
14036 
  """
14037 
 
14038 
  thrift_spec = (
14039 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
14040 
  )
14041 
 
14042 
  def __init__(self, success=None,):
14043 
    self.success = success
14044 
 
14045 
  def read(self, iprot):
14046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14048 
      return
14049 
    iprot.readStructBegin()
14050 
    while True:
14051 
      (fname, ftype, fid) = iprot.readFieldBegin()
14052 
      if ftype == TType.STOP:
14053 
        break
14054 
      if fid == 0:
14055 
        if ftype == TType.LIST:
14056 
          self.success = []
8590 kshitij.so 14057 
          (_etype256, _size253) = iprot.readListBegin()
14058 
          for _i257 in xrange(_size253):
14059 
            _elem258 = iprot.readString();
14060 
            self.success.append(_elem258)
8579 kshitij.so 14061 
          iprot.readListEnd()
14062 
        else:
14063 
          iprot.skip(ftype)
14064 
      else:
14065 
        iprot.skip(ftype)
14066 
      iprot.readFieldEnd()
14067 
    iprot.readStructEnd()
14068 
 
14069 
  def write(self, oprot):
14070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14072 
      return
14073 
    oprot.writeStructBegin('getAllCampaigns_result')
14074 
    if self.success is not None:
14075 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14076 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 14077 
      for iter259 in self.success:
14078 
        oprot.writeString(iter259)
8579 kshitij.so 14079 
      oprot.writeListEnd()
14080 
      oprot.writeFieldEnd()
14081 
    oprot.writeFieldStop()
14082 
    oprot.writeStructEnd()
14083 
 
14084 
  def validate(self):
14085 
    return
14086 
 
14087 
 
14088 
  def __repr__(self):
14089 
    L = ['%s=%r' % (key, value)
14090 
      for key, value in self.__dict__.iteritems()]
14091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14092 
 
14093 
  def __eq__(self, other):
14094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14095 
 
14096 
  def __ne__(self, other):
14097 
    return not (self == other)
14098 
 
9155 kshitij.so 14099 
class getActiveBannersForMobileSite_args:
14100 
 
14101 
  thrift_spec = (
14102 
  )
14103 
 
14104 
  def read(self, iprot):
14105 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14106 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14107 
      return
14108 
    iprot.readStructBegin()
14109 
    while True:
14110 
      (fname, ftype, fid) = iprot.readFieldBegin()
14111 
      if ftype == TType.STOP:
14112 
        break
14113 
      else:
14114 
        iprot.skip(ftype)
14115 
      iprot.readFieldEnd()
14116 
    iprot.readStructEnd()
14117 
 
14118 
  def write(self, oprot):
14119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14121 
      return
14122 
    oprot.writeStructBegin('getActiveBannersForMobileSite_args')
14123 
    oprot.writeFieldStop()
14124 
    oprot.writeStructEnd()
14125 
 
14126 
  def validate(self):
14127 
    return
14128 
 
14129 
 
14130 
  def __repr__(self):
14131 
    L = ['%s=%r' % (key, value)
14132 
      for key, value in self.__dict__.iteritems()]
14133 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14134 
 
14135 
  def __eq__(self, other):
14136 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14137 
 
14138 
  def __ne__(self, other):
14139 
    return not (self == other)
14140 
 
14141 
class getActiveBannersForMobileSite_result:
14142 
  """
14143 
  Attributes:
14144 
   - success
14145 
  """
14146 
 
14147 
  thrift_spec = (
14148 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
14149 
  )
14150 
 
14151 
  def __init__(self, success=None,):
14152 
    self.success = success
14153 
 
14154 
  def read(self, iprot):
14155 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14156 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14157 
      return
14158 
    iprot.readStructBegin()
14159 
    while True:
14160 
      (fname, ftype, fid) = iprot.readFieldBegin()
14161 
      if ftype == TType.STOP:
14162 
        break
14163 
      if fid == 0:
14164 
        if ftype == TType.MAP:
14165 
          self.success = {}
14166 
          (_ktype261, _vtype262, _size260 ) = iprot.readMapBegin()
14167 
          for _i264 in xrange(_size260):
14168 
            _key265 = iprot.readString();
14169 
            _val266 = []
14170 
            (_etype270, _size267) = iprot.readListBegin()
14171 
            for _i271 in xrange(_size267):
14172 
              _elem272 = Banner()
14173 
              _elem272.read(iprot)
14174 
              _val266.append(_elem272)
14175 
            iprot.readListEnd()
14176 
            self.success[_key265] = _val266
14177 
          iprot.readMapEnd()
14178 
        else:
14179 
          iprot.skip(ftype)
14180 
      else:
14181 
        iprot.skip(ftype)
14182 
      iprot.readFieldEnd()
14183 
    iprot.readStructEnd()
14184 
 
14185 
  def write(self, oprot):
14186 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14187 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14188 
      return
14189 
    oprot.writeStructBegin('getActiveBannersForMobileSite_result')
14190 
    if self.success is not None:
14191 
      oprot.writeFieldBegin('success', TType.MAP, 0)
14192 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
14193 
      for kiter273,viter274 in self.success.items():
14194 
        oprot.writeString(kiter273)
14195 
        oprot.writeListBegin(TType.STRUCT, len(viter274))
14196 
        for iter275 in viter274:
14197 
          iter275.write(oprot)
14198 
        oprot.writeListEnd()
14199 
      oprot.writeMapEnd()
14200 
      oprot.writeFieldEnd()
14201 
    oprot.writeFieldStop()
14202 
    oprot.writeStructEnd()
14203 
 
14204 
  def validate(self):
14205 
    return
14206 
 
14207 
 
14208 
  def __repr__(self):
14209 
    L = ['%s=%r' % (key, value)
14210 
      for key, value in self.__dict__.iteritems()]
14211 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14212 
 
14213 
  def __eq__(self, other):
14214 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14215 
 
14216 
  def __ne__(self, other):
14217 
    return not (self == other)
14218 
 
5944 mandeep.dh 14219 
class deleteSimilarItem_args:
14220 
  """
14221 
  Attributes:
14222 
   - itemId
14223 
   - catalogItemId
14224 
  """
14225 
 
14226 
  thrift_spec = (
14227 
    None, # 0
14228 
    (1, TType.I64, 'itemId', None, None, ), # 1
14229 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
14230 
  )
14231 
 
14232 
  def __init__(self, itemId=None, catalogItemId=None,):
14233 
    self.itemId = itemId
14234 
    self.catalogItemId = catalogItemId
14235 
 
14236 
  def read(self, iprot):
14237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14239 
      return
14240 
    iprot.readStructBegin()
14241 
    while True:
14242 
      (fname, ftype, fid) = iprot.readFieldBegin()
14243 
      if ftype == TType.STOP:
14244 
        break
14245 
      if fid == 1:
14246 
        if ftype == TType.I64:
14247 
          self.itemId = iprot.readI64();
14248 
        else:
14249 
          iprot.skip(ftype)
14250 
      elif fid == 2:
14251 
        if ftype == TType.I64:
14252 
          self.catalogItemId = iprot.readI64();
14253 
        else:
14254 
          iprot.skip(ftype)
14255 
      else:
14256 
        iprot.skip(ftype)
14257 
      iprot.readFieldEnd()
14258 
    iprot.readStructEnd()
14259 
 
14260 
  def write(self, oprot):
14261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14263 
      return
14264 
    oprot.writeStructBegin('deleteSimilarItem_args')
14265 
    if self.itemId is not None:
14266 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14267 
      oprot.writeI64(self.itemId)
14268 
      oprot.writeFieldEnd()
14269 
    if self.catalogItemId is not None:
14270 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
14271 
      oprot.writeI64(self.catalogItemId)
14272 
      oprot.writeFieldEnd()
14273 
    oprot.writeFieldStop()
14274 
    oprot.writeStructEnd()
14275 
 
14276 
  def validate(self):
14277 
    return
14278 
 
14279 
 
14280 
  def __repr__(self):
14281 
    L = ['%s=%r' % (key, value)
14282 
      for key, value in self.__dict__.iteritems()]
14283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14284 
 
14285 
  def __eq__(self, other):
14286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14287 
 
14288 
  def __ne__(self, other):
14289 
    return not (self == other)
14290 
 
14291 
class deleteSimilarItem_result:
14292 
  """
14293 
  Attributes:
14294 
   - success
14295 
   - cex
14296 
  """
14297 
 
14298 
  thrift_spec = (
14299 
    (0, TType.BOOL, 'success', None, None, ), # 0
14300 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14301 
  )
14302 
 
14303 
  def __init__(self, success=None, cex=None,):
14304 
    self.success = success
14305 
    self.cex = cex
14306 
 
14307 
  def read(self, iprot):
14308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14310 
      return
14311 
    iprot.readStructBegin()
14312 
    while True:
14313 
      (fname, ftype, fid) = iprot.readFieldBegin()
14314 
      if ftype == TType.STOP:
14315 
        break
14316 
      if fid == 0:
14317 
        if ftype == TType.BOOL:
14318 
          self.success = iprot.readBool();
14319 
        else:
14320 
          iprot.skip(ftype)
14321 
      elif fid == 1:
14322 
        if ftype == TType.STRUCT:
14323 
          self.cex = CatalogServiceException()
14324 
          self.cex.read(iprot)
14325 
        else:
14326 
          iprot.skip(ftype)
14327 
      else:
14328 
        iprot.skip(ftype)
14329 
      iprot.readFieldEnd()
14330 
    iprot.readStructEnd()
14331 
 
14332 
  def write(self, oprot):
14333 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14334 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14335 
      return
14336 
    oprot.writeStructBegin('deleteSimilarItem_result')
14337 
    if self.success is not None:
14338 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14339 
      oprot.writeBool(self.success)
14340 
      oprot.writeFieldEnd()
14341 
    if self.cex is not None:
14342 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14343 
      self.cex.write(oprot)
14344 
      oprot.writeFieldEnd()
14345 
    oprot.writeFieldStop()
14346 
    oprot.writeStructEnd()
14347 
 
14348 
  def validate(self):
14349 
    return
14350 
 
14351 
 
14352 
  def __repr__(self):
14353 
    L = ['%s=%r' % (key, value)
14354 
      for key, value in self.__dict__.iteritems()]
14355 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14356 
 
14357 
  def __eq__(self, other):
14358 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14359 
 
14360 
  def __ne__(self, other):
14361 
    return not (self == other)
14362 
 
14363 
class checkSimilarItem_args:
14364 
  """
14365 
  Attributes:
14366 
   - brand
14367 
   - modelNumber
14368 
   - modelName
14369 
   - color
14370 
  """
14371 
 
14372 
  thrift_spec = (
14373 
    None, # 0
14374 
    (1, TType.STRING, 'brand', None, None, ), # 1
14375 
    (2, TType.STRING, 'modelNumber', None, None, ), # 2
14376 
    (3, TType.STRING, 'modelName', None, None, ), # 3
14377 
    (4, TType.STRING, 'color', None, None, ), # 4
14378 
  )
14379 
 
14380 
  def __init__(self, brand=None, modelNumber=None, modelName=None, color=None,):
14381 
    self.brand = brand
14382 
    self.modelNumber = modelNumber
14383 
    self.modelName = modelName
14384 
    self.color = color
14385 
 
14386 
  def read(self, iprot):
14387 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14388 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14389 
      return
14390 
    iprot.readStructBegin()
14391 
    while True:
14392 
      (fname, ftype, fid) = iprot.readFieldBegin()
14393 
      if ftype == TType.STOP:
14394 
        break
14395 
      if fid == 1:
14396 
        if ftype == TType.STRING:
14397 
          self.brand = iprot.readString();
14398 
        else:
14399 
          iprot.skip(ftype)
14400 
      elif fid == 2:
14401 
        if ftype == TType.STRING:
14402 
          self.modelNumber = iprot.readString();
14403 
        else:
14404 
          iprot.skip(ftype)
14405 
      elif fid == 3:
14406 
        if ftype == TType.STRING:
14407 
          self.modelName = iprot.readString();
14408 
        else:
14409 
          iprot.skip(ftype)
14410 
      elif fid == 4:
14411 
        if ftype == TType.STRING:
14412 
          self.color = iprot.readString();
14413 
        else:
14414 
          iprot.skip(ftype)
14415 
      else:
14416 
        iprot.skip(ftype)
14417 
      iprot.readFieldEnd()
14418 
    iprot.readStructEnd()
14419 
 
14420 
  def write(self, oprot):
14421 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14422 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14423 
      return
14424 
    oprot.writeStructBegin('checkSimilarItem_args')
14425 
    if self.brand is not None:
14426 
      oprot.writeFieldBegin('brand', TType.STRING, 1)
14427 
      oprot.writeString(self.brand)
14428 
      oprot.writeFieldEnd()
14429 
    if self.modelNumber is not None:
14430 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 2)
14431 
      oprot.writeString(self.modelNumber)
14432 
      oprot.writeFieldEnd()
14433 
    if self.modelName is not None:
14434 
      oprot.writeFieldBegin('modelName', TType.STRING, 3)
14435 
      oprot.writeString(self.modelName)
14436 
      oprot.writeFieldEnd()
14437 
    if self.color is not None:
14438 
      oprot.writeFieldBegin('color', TType.STRING, 4)
14439 
      oprot.writeString(self.color)
14440 
      oprot.writeFieldEnd()
14441 
    oprot.writeFieldStop()
14442 
    oprot.writeStructEnd()
14443 
 
14444 
  def validate(self):
14445 
    return
14446 
 
14447 
 
14448 
  def __repr__(self):
14449 
    L = ['%s=%r' % (key, value)
14450 
      for key, value in self.__dict__.iteritems()]
14451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14452 
 
14453 
  def __eq__(self, other):
14454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14455 
 
14456 
  def __ne__(self, other):
14457 
    return not (self == other)
14458 
 
14459 
class checkSimilarItem_result:
14460 
  """
14461 
  Attributes:
14462 
   - success
14463 
  """
14464 
 
14465 
  thrift_spec = (
14466 
    (0, TType.I64, 'success', None, None, ), # 0
14467 
  )
14468 
 
14469 
  def __init__(self, success=None,):
14470 
    self.success = success
14471 
 
14472 
  def read(self, iprot):
14473 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14474 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14475 
      return
14476 
    iprot.readStructBegin()
14477 
    while True:
14478 
      (fname, ftype, fid) = iprot.readFieldBegin()
14479 
      if ftype == TType.STOP:
14480 
        break
14481 
      if fid == 0:
14482 
        if ftype == TType.I64:
14483 
          self.success = iprot.readI64();
14484 
        else:
14485 
          iprot.skip(ftype)
14486 
      else:
14487 
        iprot.skip(ftype)
14488 
      iprot.readFieldEnd()
14489 
    iprot.readStructEnd()
14490 
 
14491 
  def write(self, oprot):
14492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14494 
      return
14495 
    oprot.writeStructBegin('checkSimilarItem_result')
14496 
    if self.success is not None:
14497 
      oprot.writeFieldBegin('success', TType.I64, 0)
14498 
      oprot.writeI64(self.success)
14499 
      oprot.writeFieldEnd()
14500 
    oprot.writeFieldStop()
14501 
    oprot.writeStructEnd()
14502 
 
14503 
  def validate(self):
14504 
    return
14505 
 
14506 
 
14507 
  def __repr__(self):
14508 
    L = ['%s=%r' % (key, value)
14509 
      for key, value in self.__dict__.iteritems()]
14510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14511 
 
14512 
  def __eq__(self, other):
14513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14514 
 
14515 
  def __ne__(self, other):
14516 
    return not (self == other)
14517 
 
14518 
class validateRiskyStatus_args:
14519 
  """
14520 
  Attributes:
14521 
   - itemId
14522 
  """
14523 
 
14524 
  thrift_spec = (
14525 
    None, # 0
14526 
    (1, TType.I64, 'itemId', None, None, ), # 1
14527 
  )
14528 
 
14529 
  def __init__(self, itemId=None,):
14530 
    self.itemId = itemId
14531 
 
14532 
  def read(self, iprot):
14533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14535 
      return
14536 
    iprot.readStructBegin()
14537 
    while True:
14538 
      (fname, ftype, fid) = iprot.readFieldBegin()
14539 
      if ftype == TType.STOP:
14540 
        break
14541 
      if fid == 1:
14542 
        if ftype == TType.I64:
14543 
          self.itemId = iprot.readI64();
14544 
        else:
14545 
          iprot.skip(ftype)
14546 
      else:
14547 
        iprot.skip(ftype)
14548 
      iprot.readFieldEnd()
14549 
    iprot.readStructEnd()
14550 
 
14551 
  def write(self, oprot):
14552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14554 
      return
14555 
    oprot.writeStructBegin('validateRiskyStatus_args')
14556 
    if self.itemId is not None:
14557 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14558 
      oprot.writeI64(self.itemId)
14559 
      oprot.writeFieldEnd()
14560 
    oprot.writeFieldStop()
14561 
    oprot.writeStructEnd()
14562 
 
14563 
  def validate(self):
14564 
    return
14565 
 
14566 
 
14567 
  def __repr__(self):
14568 
    L = ['%s=%r' % (key, value)
14569 
      for key, value in self.__dict__.iteritems()]
14570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14571 
 
14572 
  def __eq__(self, other):
14573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14574 
 
14575 
  def __ne__(self, other):
14576 
    return not (self == other)
14577 
 
14578 
class validateRiskyStatus_result:
14579 
 
14580 
  thrift_spec = (
14581 
  )
14582 
 
14583 
  def read(self, iprot):
14584 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14585 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14586 
      return
14587 
    iprot.readStructBegin()
14588 
    while True:
14589 
      (fname, ftype, fid) = iprot.readFieldBegin()
14590 
      if ftype == TType.STOP:
14591 
        break
14592 
      else:
14593 
        iprot.skip(ftype)
14594 
      iprot.readFieldEnd()
14595 
    iprot.readStructEnd()
14596 
 
14597 
  def write(self, oprot):
14598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14600 
      return
14601 
    oprot.writeStructBegin('validateRiskyStatus_result')
14602 
    oprot.writeFieldStop()
14603 
    oprot.writeStructEnd()
14604 
 
14605 
  def validate(self):
14606 
    return
14607 
 
14608 
 
14609 
  def __repr__(self):
14610 
    L = ['%s=%r' % (key, value)
14611 
      for key, value in self.__dict__.iteritems()]
14612 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14613 
 
14614 
  def __eq__(self, other):
14615 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14616 
 
14617 
  def __ne__(self, other):
14618 
    return not (self == other)
14619 
 
14620 
class changeItemRiskyFlag_args:
14621 
  """
14622 
  Attributes:
14623 
   - itemId
14624 
   - risky
14625 
  """
14626 
 
14627 
  thrift_spec = (
14628 
    None, # 0
14629 
    (1, TType.I64, 'itemId', None, None, ), # 1
14630 
    (2, TType.BOOL, 'risky', None, None, ), # 2
14631 
  )
14632 
 
14633 
  def __init__(self, itemId=None, risky=None,):
14634 
    self.itemId = itemId
14635 
    self.risky = risky
14636 
 
14637 
  def read(self, iprot):
14638 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14639 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14640 
      return
14641 
    iprot.readStructBegin()
14642 
    while True:
14643 
      (fname, ftype, fid) = iprot.readFieldBegin()
14644 
      if ftype == TType.STOP:
14645 
        break
14646 
      if fid == 1:
14647 
        if ftype == TType.I64:
14648 
          self.itemId = iprot.readI64();
14649 
        else:
14650 
          iprot.skip(ftype)
14651 
      elif fid == 2:
14652 
        if ftype == TType.BOOL:
14653 
          self.risky = iprot.readBool();
14654 
        else:
14655 
          iprot.skip(ftype)
14656 
      else:
14657 
        iprot.skip(ftype)
14658 
      iprot.readFieldEnd()
14659 
    iprot.readStructEnd()
14660 
 
14661 
  def write(self, oprot):
14662 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14663 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14664 
      return
14665 
    oprot.writeStructBegin('changeItemRiskyFlag_args')
14666 
    if self.itemId is not None:
14667 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14668 
      oprot.writeI64(self.itemId)
14669 
      oprot.writeFieldEnd()
14670 
    if self.risky is not None:
14671 
      oprot.writeFieldBegin('risky', TType.BOOL, 2)
14672 
      oprot.writeBool(self.risky)
14673 
      oprot.writeFieldEnd()
14674 
    oprot.writeFieldStop()
14675 
    oprot.writeStructEnd()
14676 
 
14677 
  def validate(self):
14678 
    return
14679 
 
14680 
 
14681 
  def __repr__(self):
14682 
    L = ['%s=%r' % (key, value)
14683 
      for key, value in self.__dict__.iteritems()]
14684 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14685 
 
14686 
  def __eq__(self, other):
14687 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14688 
 
14689 
  def __ne__(self, other):
14690 
    return not (self == other)
14691 
 
14692 
class changeItemRiskyFlag_result:
14693 
 
14694 
  thrift_spec = (
14695 
  )
14696 
 
14697 
  def read(self, iprot):
14698 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14699 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14700 
      return
14701 
    iprot.readStructBegin()
14702 
    while True:
14703 
      (fname, ftype, fid) = iprot.readFieldBegin()
14704 
      if ftype == TType.STOP:
14705 
        break
14706 
      else:
14707 
        iprot.skip(ftype)
14708 
      iprot.readFieldEnd()
14709 
    iprot.readStructEnd()
14710 
 
14711 
  def write(self, oprot):
14712 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14713 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14714 
      return
14715 
    oprot.writeStructBegin('changeItemRiskyFlag_result')
14716 
    oprot.writeFieldStop()
14717 
    oprot.writeStructEnd()
14718 
 
14719 
  def validate(self):
14720 
    return
14721 
 
14722 
 
14723 
  def __repr__(self):
14724 
    L = ['%s=%r' % (key, value)
14725 
      for key, value in self.__dict__.iteritems()]
14726 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14727 
 
14728 
  def __eq__(self, other):
14729 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14730 
 
14731 
  def __ne__(self, other):
14732 
    return not (self == other)
14733 
 
14734 
class getItemsByRiskyFlag_args:
14735 
 
14736 
  thrift_spec = (
14737 
  )
14738 
 
14739 
  def read(self, iprot):
14740 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14741 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14742 
      return
14743 
    iprot.readStructBegin()
14744 
    while True:
14745 
      (fname, ftype, fid) = iprot.readFieldBegin()
14746 
      if ftype == TType.STOP:
14747 
        break
14748 
      else:
14749 
        iprot.skip(ftype)
14750 
      iprot.readFieldEnd()
14751 
    iprot.readStructEnd()
14752 
 
14753 
  def write(self, oprot):
14754 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14755 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14756 
      return
14757 
    oprot.writeStructBegin('getItemsByRiskyFlag_args')
14758 
    oprot.writeFieldStop()
14759 
    oprot.writeStructEnd()
14760 
 
14761 
  def validate(self):
14762 
    return
14763 
 
14764 
 
14765 
  def __repr__(self):
14766 
    L = ['%s=%r' % (key, value)
14767 
      for key, value in self.__dict__.iteritems()]
14768 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14769 
 
14770 
  def __eq__(self, other):
14771 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14772 
 
14773 
  def __ne__(self, other):
14774 
    return not (self == other)
14775 
 
14776 
class getItemsByRiskyFlag_result:
14777 
  """
14778 
  Attributes:
14779 
   - success
14780 
  """
14781 
 
14782 
  thrift_spec = (
14783 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
14784 
  )
14785 
 
14786 
  def __init__(self, success=None,):
14787 
    self.success = success
14788 
 
14789 
  def read(self, iprot):
14790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14792 
      return
14793 
    iprot.readStructBegin()
14794 
    while True:
14795 
      (fname, ftype, fid) = iprot.readFieldBegin()
14796 
      if ftype == TType.STOP:
14797 
        break
14798 
      if fid == 0:
14799 
        if ftype == TType.LIST:
14800 
          self.success = []
9155 kshitij.so 14801 
          (_etype279, _size276) = iprot.readListBegin()
14802 
          for _i280 in xrange(_size276):
14803 
            _elem281 = Item()
14804 
            _elem281.read(iprot)
14805 
            self.success.append(_elem281)
5944 mandeep.dh 14806 
          iprot.readListEnd()
14807 
        else:
14808 
          iprot.skip(ftype)
14809 
      else:
14810 
        iprot.skip(ftype)
14811 
      iprot.readFieldEnd()
14812 
    iprot.readStructEnd()
14813 
 
14814 
  def write(self, oprot):
14815 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14816 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14817 
      return
14818 
    oprot.writeStructBegin('getItemsByRiskyFlag_result')
14819 
    if self.success is not None:
14820 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14821 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 14822 
      for iter282 in self.success:
14823 
        iter282.write(oprot)
5944 mandeep.dh 14824 
      oprot.writeListEnd()
14825 
      oprot.writeFieldEnd()
14826 
    oprot.writeFieldStop()
14827 
    oprot.writeStructEnd()
14828 
 
14829 
  def validate(self):
14830 
    return
14831 
 
14832 
 
14833 
  def __repr__(self):
14834 
    L = ['%s=%r' % (key, value)
14835 
      for key, value in self.__dict__.iteritems()]
14836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14837 
 
14838 
  def __eq__(self, other):
14839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14840 
 
14841 
  def __ne__(self, other):
14842 
    return not (self == other)
14843 
 
14844 
class getItemsForMasterSheet_args:
14845 
  """
14846 
  Attributes:
14847 
   - category
14848 
   - brand
14849 
  """
14850 
 
14851 
  thrift_spec = (
14852 
    None, # 0
14853 
    (1, TType.STRING, 'category', None, None, ), # 1
14854 
    (2, TType.STRING, 'brand', None, None, ), # 2
14855 
  )
14856 
 
14857 
  def __init__(self, category=None, brand=None,):
14858 
    self.category = category
14859 
    self.brand = brand
14860 
 
14861 
  def read(self, iprot):
14862 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14863 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14864 
      return
14865 
    iprot.readStructBegin()
14866 
    while True:
14867 
      (fname, ftype, fid) = iprot.readFieldBegin()
14868 
      if ftype == TType.STOP:
14869 
        break
14870 
      if fid == 1:
14871 
        if ftype == TType.STRING:
14872 
          self.category = iprot.readString();
14873 
        else:
14874 
          iprot.skip(ftype)
14875 
      elif fid == 2:
14876 
        if ftype == TType.STRING:
14877 
          self.brand = iprot.readString();
14878 
        else:
14879 
          iprot.skip(ftype)
14880 
      else:
14881 
        iprot.skip(ftype)
14882 
      iprot.readFieldEnd()
14883 
    iprot.readStructEnd()
14884 
 
14885 
  def write(self, oprot):
14886 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14887 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14888 
      return
14889 
    oprot.writeStructBegin('getItemsForMasterSheet_args')
14890 
    if self.category is not None:
14891 
      oprot.writeFieldBegin('category', TType.STRING, 1)
14892 
      oprot.writeString(self.category)
14893 
      oprot.writeFieldEnd()
14894 
    if self.brand is not None:
14895 
      oprot.writeFieldBegin('brand', TType.STRING, 2)
14896 
      oprot.writeString(self.brand)
14897 
      oprot.writeFieldEnd()
14898 
    oprot.writeFieldStop()
14899 
    oprot.writeStructEnd()
14900 
 
14901 
  def validate(self):
14902 
    return
14903 
 
14904 
 
14905 
  def __repr__(self):
14906 
    L = ['%s=%r' % (key, value)
14907 
      for key, value in self.__dict__.iteritems()]
14908 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14909 
 
14910 
  def __eq__(self, other):
14911 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14912 
 
14913 
  def __ne__(self, other):
14914 
    return not (self == other)
14915 
 
14916 
class getItemsForMasterSheet_result:
14917 
  """
14918 
  Attributes:
14919 
   - success
14920 
  """
14921 
 
14922 
  thrift_spec = (
14923 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
14924 
  )
14925 
 
14926 
  def __init__(self, success=None,):
14927 
    self.success = success
14928 
 
14929 
  def read(self, iprot):
14930 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14931 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14932 
      return
14933 
    iprot.readStructBegin()
14934 
    while True:
14935 
      (fname, ftype, fid) = iprot.readFieldBegin()
14936 
      if ftype == TType.STOP:
14937 
        break
14938 
      if fid == 0:
14939 
        if ftype == TType.LIST:
14940 
          self.success = []
9155 kshitij.so 14941 
          (_etype286, _size283) = iprot.readListBegin()
14942 
          for _i287 in xrange(_size283):
14943 
            _elem288 = Item()
14944 
            _elem288.read(iprot)
14945 
            self.success.append(_elem288)
5944 mandeep.dh 14946 
          iprot.readListEnd()
14947 
        else:
14948 
          iprot.skip(ftype)
14949 
      else:
14950 
        iprot.skip(ftype)
14951 
      iprot.readFieldEnd()
14952 
    iprot.readStructEnd()
14953 
 
14954 
  def write(self, oprot):
14955 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14956 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14957 
      return
14958 
    oprot.writeStructBegin('getItemsForMasterSheet_result')
14959 
    if self.success is not None:
14960 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14961 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 14962 
      for iter289 in self.success:
14963 
        iter289.write(oprot)
5944 mandeep.dh 14964 
      oprot.writeListEnd()
14965 
      oprot.writeFieldEnd()
14966 
    oprot.writeFieldStop()
14967 
    oprot.writeStructEnd()
14968 
 
14969 
  def validate(self):
14970 
    return
14971 
 
14972 
 
14973 
  def __repr__(self):
14974 
    L = ['%s=%r' % (key, value)
14975 
      for key, value in self.__dict__.iteritems()]
14976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14977 
 
14978 
  def __eq__(self, other):
14979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14980 
 
14981 
  def __ne__(self, other):
14982 
    return not (self == other)
14983 
 
14984 
class getSimilarItemsCatalogIds_args:
14985 
  """
14986 
  Attributes:
14987 
   - beginIndex
14988 
   - totalItems
14989 
   - itemId
14990 
  """
14991 
 
14992 
  thrift_spec = (
14993 
    None, # 0
14994 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
14995 
    (2, TType.I64, 'totalItems', None, None, ), # 2
14996 
    (3, TType.I64, 'itemId', None, None, ), # 3
14997 
  )
14998 
 
14999 
  def __init__(self, beginIndex=None, totalItems=None, itemId=None,):
15000 
    self.beginIndex = beginIndex
15001 
    self.totalItems = totalItems
15002 
    self.itemId = itemId
15003 
 
15004 
  def read(self, iprot):
15005 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15006 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15007 
      return
15008 
    iprot.readStructBegin()
15009 
    while True:
15010 
      (fname, ftype, fid) = iprot.readFieldBegin()
15011 
      if ftype == TType.STOP:
15012 
        break
15013 
      if fid == 1:
15014 
        if ftype == TType.I64:
15015 
          self.beginIndex = iprot.readI64();
15016 
        else:
15017 
          iprot.skip(ftype)
15018 
      elif fid == 2:
15019 
        if ftype == TType.I64:
15020 
          self.totalItems = iprot.readI64();
15021 
        else:
15022 
          iprot.skip(ftype)
15023 
      elif fid == 3:
15024 
        if ftype == TType.I64:
15025 
          self.itemId = iprot.readI64();
15026 
        else:
15027 
          iprot.skip(ftype)
15028 
      else:
15029 
        iprot.skip(ftype)
15030 
      iprot.readFieldEnd()
15031 
    iprot.readStructEnd()
15032 
 
15033 
  def write(self, oprot):
15034 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15035 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15036 
      return
15037 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_args')
15038 
    if self.beginIndex is not None:
15039 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
15040 
      oprot.writeI64(self.beginIndex)
15041 
      oprot.writeFieldEnd()
15042 
    if self.totalItems is not None:
15043 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
15044 
      oprot.writeI64(self.totalItems)
15045 
      oprot.writeFieldEnd()
15046 
    if self.itemId is not None:
15047 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
15048 
      oprot.writeI64(self.itemId)
15049 
      oprot.writeFieldEnd()
15050 
    oprot.writeFieldStop()
15051 
    oprot.writeStructEnd()
15052 
 
15053 
  def validate(self):
15054 
    return
15055 
 
15056 
 
15057 
  def __repr__(self):
15058 
    L = ['%s=%r' % (key, value)
15059 
      for key, value in self.__dict__.iteritems()]
15060 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15061 
 
15062 
  def __eq__(self, other):
15063 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15064 
 
15065 
  def __ne__(self, other):
15066 
    return not (self == other)
15067 
 
15068 
class getSimilarItemsCatalogIds_result:
15069 
  """
15070 
  Attributes:
15071 
   - success
15072 
  """
15073 
 
15074 
  thrift_spec = (
15075 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
15076 
  )
15077 
 
15078 
  def __init__(self, success=None,):
15079 
    self.success = success
15080 
 
15081 
  def read(self, iprot):
15082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15084 
      return
15085 
    iprot.readStructBegin()
15086 
    while True:
15087 
      (fname, ftype, fid) = iprot.readFieldBegin()
15088 
      if ftype == TType.STOP:
15089 
        break
15090 
      if fid == 0:
15091 
        if ftype == TType.LIST:
15092 
          self.success = []
9155 kshitij.so 15093 
          (_etype293, _size290) = iprot.readListBegin()
15094 
          for _i294 in xrange(_size290):
15095 
            _elem295 = iprot.readI64();
15096 
            self.success.append(_elem295)
5944 mandeep.dh 15097 
          iprot.readListEnd()
15098 
        else:
15099 
          iprot.skip(ftype)
15100 
      else:
15101 
        iprot.skip(ftype)
15102 
      iprot.readFieldEnd()
15103 
    iprot.readStructEnd()
15104 
 
15105 
  def write(self, oprot):
15106 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15107 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15108 
      return
15109 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_result')
15110 
    if self.success is not None:
15111 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15112 
      oprot.writeListBegin(TType.I64, len(self.success))
9155 kshitij.so 15113 
      for iter296 in self.success:
15114 
        oprot.writeI64(iter296)
5944 mandeep.dh 15115 
      oprot.writeListEnd()
15116 
      oprot.writeFieldEnd()
15117 
    oprot.writeFieldStop()
15118 
    oprot.writeStructEnd()
15119 
 
15120 
  def validate(self):
15121 
    return
15122 
 
15123 
 
15124 
  def __repr__(self):
15125 
    L = ['%s=%r' % (key, value)
15126 
      for key, value in self.__dict__.iteritems()]
15127 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15128 
 
15129 
  def __eq__(self, other):
15130 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15131 
 
15132 
  def __ne__(self, other):
15133 
    return not (self == other)
15134 
 
15135 
class addProductNotification_args:
15136 
  """
15137 
  Attributes:
15138 
   - itemId
15139 
   - email
15140 
  """
15141 
 
15142 
  thrift_spec = None
15143 
  def __init__(self, itemId=None, email=None,):
15144 
    self.itemId = itemId
15145 
    self.email = email
15146 
 
15147 
  def read(self, iprot):
15148 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15149 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15150 
      return
15151 
    iprot.readStructBegin()
15152 
    while True:
15153 
      (fname, ftype, fid) = iprot.readFieldBegin()
15154 
      if ftype == TType.STOP:
15155 
        break
15156 
      if fid == -1:
15157 
        if ftype == TType.I64:
15158 
          self.itemId = iprot.readI64();
15159 
        else:
15160 
          iprot.skip(ftype)
15161 
      elif fid == -2:
15162 
        if ftype == TType.STRING:
15163 
          self.email = iprot.readString();
15164 
        else:
15165 
          iprot.skip(ftype)
15166 
      else:
15167 
        iprot.skip(ftype)
15168 
      iprot.readFieldEnd()
15169 
    iprot.readStructEnd()
15170 
 
15171 
  def write(self, oprot):
15172 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15173 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15174 
      return
15175 
    oprot.writeStructBegin('addProductNotification_args')
15176 
    if self.email is not None:
15177 
      oprot.writeFieldBegin('email', TType.STRING, -2)
15178 
      oprot.writeString(self.email)
15179 
      oprot.writeFieldEnd()
15180 
    if self.itemId is not None:
15181 
      oprot.writeFieldBegin('itemId', TType.I64, -1)
15182 
      oprot.writeI64(self.itemId)
15183 
      oprot.writeFieldEnd()
15184 
    oprot.writeFieldStop()
15185 
    oprot.writeStructEnd()
15186 
 
15187 
  def validate(self):
15188 
    return
15189 
 
15190 
 
15191 
  def __repr__(self):
15192 
    L = ['%s=%r' % (key, value)
15193 
      for key, value in self.__dict__.iteritems()]
15194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15195 
 
15196 
  def __eq__(self, other):
15197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15198 
 
15199 
  def __ne__(self, other):
15200 
    return not (self == other)
15201 
 
15202 
class addProductNotification_result:
15203 
  """
15204 
  Attributes:
15205 
   - success
15206 
  """
15207 
 
15208 
  thrift_spec = (
15209 
    (0, TType.BOOL, 'success', None, None, ), # 0
15210 
  )
15211 
 
15212 
  def __init__(self, success=None,):
15213 
    self.success = success
15214 
 
15215 
  def read(self, iprot):
15216 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15217 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15218 
      return
15219 
    iprot.readStructBegin()
15220 
    while True:
15221 
      (fname, ftype, fid) = iprot.readFieldBegin()
15222 
      if ftype == TType.STOP:
15223 
        break
15224 
      if fid == 0:
15225 
        if ftype == TType.BOOL:
15226 
          self.success = iprot.readBool();
15227 
        else:
15228 
          iprot.skip(ftype)
15229 
      else:
15230 
        iprot.skip(ftype)
15231 
      iprot.readFieldEnd()
15232 
    iprot.readStructEnd()
15233 
 
15234 
  def write(self, oprot):
15235 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15236 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15237 
      return
15238 
    oprot.writeStructBegin('addProductNotification_result')
15239 
    if self.success is not None:
15240 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15241 
      oprot.writeBool(self.success)
15242 
      oprot.writeFieldEnd()
15243 
    oprot.writeFieldStop()
15244 
    oprot.writeStructEnd()
15245 
 
15246 
  def validate(self):
15247 
    return
15248 
 
15249 
 
15250 
  def __repr__(self):
15251 
    L = ['%s=%r' % (key, value)
15252 
      for key, value in self.__dict__.iteritems()]
15253 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15254 
 
15255 
  def __eq__(self, other):
15256 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15257 
 
15258 
  def __ne__(self, other):
15259 
    return not (self == other)
15260 
 
15261 
class sendProductNotifications_args:
15262 
 
15263 
  thrift_spec = (
15264 
  )
15265 
 
15266 
  def read(self, iprot):
15267 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15268 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15269 
      return
15270 
    iprot.readStructBegin()
15271 
    while True:
15272 
      (fname, ftype, fid) = iprot.readFieldBegin()
15273 
      if ftype == TType.STOP:
15274 
        break
15275 
      else:
15276 
        iprot.skip(ftype)
15277 
      iprot.readFieldEnd()
15278 
    iprot.readStructEnd()
15279 
 
15280 
  def write(self, oprot):
15281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15283 
      return
15284 
    oprot.writeStructBegin('sendProductNotifications_args')
15285 
    oprot.writeFieldStop()
15286 
    oprot.writeStructEnd()
15287 
 
15288 
  def validate(self):
15289 
    return
15290 
 
15291 
 
15292 
  def __repr__(self):
15293 
    L = ['%s=%r' % (key, value)
15294 
      for key, value in self.__dict__.iteritems()]
15295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15296 
 
15297 
  def __eq__(self, other):
15298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15299 
 
15300 
  def __ne__(self, other):
15301 
    return not (self == other)
15302 
 
15303 
class sendProductNotifications_result:
15304 
  """
15305 
  Attributes:
15306 
   - success
15307 
  """
15308 
 
15309 
  thrift_spec = (
15310 
    (0, TType.BOOL, 'success', None, None, ), # 0
15311 
  )
15312 
 
15313 
  def __init__(self, success=None,):
15314 
    self.success = success
15315 
 
15316 
  def read(self, iprot):
15317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15319 
      return
15320 
    iprot.readStructBegin()
15321 
    while True:
15322 
      (fname, ftype, fid) = iprot.readFieldBegin()
15323 
      if ftype == TType.STOP:
15324 
        break
15325 
      if fid == 0:
15326 
        if ftype == TType.BOOL:
15327 
          self.success = iprot.readBool();
15328 
        else:
15329 
          iprot.skip(ftype)
15330 
      else:
15331 
        iprot.skip(ftype)
15332 
      iprot.readFieldEnd()
15333 
    iprot.readStructEnd()
15334 
 
15335 
  def write(self, oprot):
15336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15338 
      return
15339 
    oprot.writeStructBegin('sendProductNotifications_result')
15340 
    if self.success is not None:
15341 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15342 
      oprot.writeBool(self.success)
15343 
      oprot.writeFieldEnd()
15344 
    oprot.writeFieldStop()
15345 
    oprot.writeStructEnd()
15346 
 
15347 
  def validate(self):
15348 
    return
15349 
 
15350 
 
15351 
  def __repr__(self):
15352 
    L = ['%s=%r' % (key, value)
15353 
      for key, value in self.__dict__.iteritems()]
15354 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15355 
 
15356 
  def __eq__(self, other):
15357 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15358 
 
15359 
  def __ne__(self, other):
15360 
    return not (self == other)
15361 
 
15362 
class getAllBrandsByCategory_args:
15363 
  """
15364 
  Attributes:
15365 
   - categoryId
15366 
  """
15367 
 
15368 
  thrift_spec = (
15369 
    None, # 0
15370 
    (1, TType.I64, 'categoryId', None, None, ), # 1
15371 
  )
15372 
 
15373 
  def __init__(self, categoryId=None,):
15374 
    self.categoryId = categoryId
15375 
 
15376 
  def read(self, iprot):
15377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15379 
      return
15380 
    iprot.readStructBegin()
15381 
    while True:
15382 
      (fname, ftype, fid) = iprot.readFieldBegin()
15383 
      if ftype == TType.STOP:
15384 
        break
15385 
      if fid == 1:
15386 
        if ftype == TType.I64:
15387 
          self.categoryId = iprot.readI64();
15388 
        else:
15389 
          iprot.skip(ftype)
15390 
      else:
15391 
        iprot.skip(ftype)
15392 
      iprot.readFieldEnd()
15393 
    iprot.readStructEnd()
15394 
 
15395 
  def write(self, oprot):
15396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15398 
      return
15399 
    oprot.writeStructBegin('getAllBrandsByCategory_args')
15400 
    if self.categoryId is not None:
15401 
      oprot.writeFieldBegin('categoryId', TType.I64, 1)
15402 
      oprot.writeI64(self.categoryId)
15403 
      oprot.writeFieldEnd()
15404 
    oprot.writeFieldStop()
15405 
    oprot.writeStructEnd()
15406 
 
15407 
  def validate(self):
15408 
    return
15409 
 
15410 
 
15411 
  def __repr__(self):
15412 
    L = ['%s=%r' % (key, value)
15413 
      for key, value in self.__dict__.iteritems()]
15414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15415 
 
15416 
  def __eq__(self, other):
15417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15418 
 
15419 
  def __ne__(self, other):
15420 
    return not (self == other)
15421 
 
15422 
class getAllBrandsByCategory_result:
15423 
  """
15424 
  Attributes:
15425 
   - success
15426 
  """
15427 
 
15428 
  thrift_spec = (
15429 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
15430 
  )
15431 
 
15432 
  def __init__(self, success=None,):
15433 
    self.success = success
15434 
 
15435 
  def read(self, iprot):
15436 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15437 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15438 
      return
15439 
    iprot.readStructBegin()
15440 
    while True:
15441 
      (fname, ftype, fid) = iprot.readFieldBegin()
15442 
      if ftype == TType.STOP:
15443 
        break
15444 
      if fid == 0:
15445 
        if ftype == TType.LIST:
15446 
          self.success = []
9155 kshitij.so 15447 
          (_etype300, _size297) = iprot.readListBegin()
15448 
          for _i301 in xrange(_size297):
15449 
            _elem302 = iprot.readString();
15450 
            self.success.append(_elem302)
5944 mandeep.dh 15451 
          iprot.readListEnd()
15452 
        else:
15453 
          iprot.skip(ftype)
15454 
      else:
15455 
        iprot.skip(ftype)
15456 
      iprot.readFieldEnd()
15457 
    iprot.readStructEnd()
15458 
 
15459 
  def write(self, oprot):
15460 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15461 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15462 
      return
15463 
    oprot.writeStructBegin('getAllBrandsByCategory_result')
15464 
    if self.success is not None:
15465 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15466 
      oprot.writeListBegin(TType.STRING, len(self.success))
9155 kshitij.so 15467 
      for iter303 in self.success:
15468 
        oprot.writeString(iter303)
5944 mandeep.dh 15469 
      oprot.writeListEnd()
15470 
      oprot.writeFieldEnd()
15471 
    oprot.writeFieldStop()
15472 
    oprot.writeStructEnd()
15473 
 
15474 
  def validate(self):
15475 
    return
15476 
 
15477 
 
15478 
  def __repr__(self):
15479 
    L = ['%s=%r' % (key, value)
15480 
      for key, value in self.__dict__.iteritems()]
15481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15482 
 
15483 
  def __eq__(self, other):
15484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15485 
 
15486 
  def __ne__(self, other):
15487 
    return not (self == other)
15488 
 
15489 
class getAllBrands_args:
15490 
 
15491 
  thrift_spec = (
15492 
  )
15493 
 
15494 
  def read(self, iprot):
15495 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15496 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15497 
      return
15498 
    iprot.readStructBegin()
15499 
    while True:
15500 
      (fname, ftype, fid) = iprot.readFieldBegin()
15501 
      if ftype == TType.STOP:
15502 
        break
15503 
      else:
15504 
        iprot.skip(ftype)
15505 
      iprot.readFieldEnd()
15506 
    iprot.readStructEnd()
15507 
 
15508 
  def write(self, oprot):
15509 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15510 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15511 
      return
15512 
    oprot.writeStructBegin('getAllBrands_args')
15513 
    oprot.writeFieldStop()
15514 
    oprot.writeStructEnd()
15515 
 
15516 
  def validate(self):
15517 
    return
15518 
 
15519 
 
15520 
  def __repr__(self):
15521 
    L = ['%s=%r' % (key, value)
15522 
      for key, value in self.__dict__.iteritems()]
15523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15524 
 
15525 
  def __eq__(self, other):
15526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15527 
 
15528 
  def __ne__(self, other):
15529 
    return not (self == other)
15530 
 
15531 
class getAllBrands_result:
15532 
  """
15533 
  Attributes:
15534 
   - success
15535 
  """
15536 
 
15537 
  thrift_spec = (
15538 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
15539 
  )
15540 
 
15541 
  def __init__(self, success=None,):
15542 
    self.success = success
15543 
 
15544 
  def read(self, iprot):
15545 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15546 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15547 
      return
15548 
    iprot.readStructBegin()
15549 
    while True:
15550 
      (fname, ftype, fid) = iprot.readFieldBegin()
15551 
      if ftype == TType.STOP:
15552 
        break
15553 
      if fid == 0:
15554 
        if ftype == TType.LIST:
15555 
          self.success = []
9155 kshitij.so 15556 
          (_etype307, _size304) = iprot.readListBegin()
15557 
          for _i308 in xrange(_size304):
15558 
            _elem309 = iprot.readString();
15559 
            self.success.append(_elem309)
5944 mandeep.dh 15560 
          iprot.readListEnd()
15561 
        else:
15562 
          iprot.skip(ftype)
15563 
      else:
15564 
        iprot.skip(ftype)
15565 
      iprot.readFieldEnd()
15566 
    iprot.readStructEnd()
15567 
 
15568 
  def write(self, oprot):
15569 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15570 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15571 
      return
15572 
    oprot.writeStructBegin('getAllBrands_result')
15573 
    if self.success is not None:
15574 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15575 
      oprot.writeListBegin(TType.STRING, len(self.success))
9155 kshitij.so 15576 
      for iter310 in self.success:
15577 
        oprot.writeString(iter310)
5944 mandeep.dh 15578 
      oprot.writeListEnd()
15579 
      oprot.writeFieldEnd()
15580 
    oprot.writeFieldStop()
15581 
    oprot.writeStructEnd()
15582 
 
15583 
  def validate(self):
15584 
    return
15585 
 
15586 
 
15587 
  def __repr__(self):
15588 
    L = ['%s=%r' % (key, value)
15589 
      for key, value in self.__dict__.iteritems()]
15590 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15591 
 
15592 
  def __eq__(self, other):
15593 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15594 
 
15595 
  def __ne__(self, other):
15596 
    return not (self == other)
15597 
 
15598 
class getAllSources_args:
15599 
 
15600 
  thrift_spec = (
15601 
  )
15602 
 
15603 
  def read(self, iprot):
15604 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15605 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15606 
      return
15607 
    iprot.readStructBegin()
15608 
    while True:
15609 
      (fname, ftype, fid) = iprot.readFieldBegin()
15610 
      if ftype == TType.STOP:
15611 
        break
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('getAllSources_args')
15622 
    oprot.writeFieldStop()
15623 
    oprot.writeStructEnd()
15624 
 
15625 
  def validate(self):
15626 
    return
15627 
 
15628 
 
15629 
  def __repr__(self):
15630 
    L = ['%s=%r' % (key, value)
15631 
      for key, value in self.__dict__.iteritems()]
15632 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15633 
 
15634 
  def __eq__(self, other):
15635 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15636 
 
15637 
  def __ne__(self, other):
15638 
    return not (self == other)
15639 
 
15640 
class getAllSources_result:
15641 
  """
15642 
  Attributes:
15643 
   - success
15644 
  """
15645 
 
15646 
  thrift_spec = (
15647 
    (0, TType.LIST, 'success', (TType.STRUCT,(Source, Source.thrift_spec)), None, ), # 0
15648 
  )
15649 
 
15650 
  def __init__(self, success=None,):
15651 
    self.success = success
15652 
 
15653 
  def read(self, iprot):
15654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15656 
      return
15657 
    iprot.readStructBegin()
15658 
    while True:
15659 
      (fname, ftype, fid) = iprot.readFieldBegin()
15660 
      if ftype == TType.STOP:
15661 
        break
15662 
      if fid == 0:
15663 
        if ftype == TType.LIST:
15664 
          self.success = []
9155 kshitij.so 15665 
          (_etype314, _size311) = iprot.readListBegin()
15666 
          for _i315 in xrange(_size311):
15667 
            _elem316 = Source()
15668 
            _elem316.read(iprot)
15669 
            self.success.append(_elem316)
5944 mandeep.dh 15670 
          iprot.readListEnd()
15671 
        else:
15672 
          iprot.skip(ftype)
15673 
      else:
15674 
        iprot.skip(ftype)
15675 
      iprot.readFieldEnd()
15676 
    iprot.readStructEnd()
15677 
 
15678 
  def write(self, oprot):
15679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15681 
      return
15682 
    oprot.writeStructBegin('getAllSources_result')
15683 
    if self.success is not None:
15684 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15685 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 15686 
      for iter317 in self.success:
15687 
        iter317.write(oprot)
5944 mandeep.dh 15688 
      oprot.writeListEnd()
15689 
      oprot.writeFieldEnd()
15690 
    oprot.writeFieldStop()
15691 
    oprot.writeStructEnd()
15692 
 
15693 
  def validate(self):
15694 
    return
15695 
 
15696 
 
15697 
  def __repr__(self):
15698 
    L = ['%s=%r' % (key, value)
15699 
      for key, value in self.__dict__.iteritems()]
15700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15701 
 
15702 
  def __eq__(self, other):
15703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15704 
 
15705 
  def __ne__(self, other):
15706 
    return not (self == other)
15707 
 
15708 
class getItemPricingBySource_args:
15709 
  """
15710 
  Attributes:
15711 
   - itemId
15712 
   - sourceId
15713 
  """
15714 
 
15715 
  thrift_spec = (
15716 
    None, # 0
15717 
    (1, TType.I64, 'itemId', None, None, ), # 1
15718 
    (2, TType.I64, 'sourceId', None, None, ), # 2
15719 
  )
15720 
 
15721 
  def __init__(self, itemId=None, sourceId=None,):
15722 
    self.itemId = itemId
15723 
    self.sourceId = sourceId
15724 
 
15725 
  def read(self, iprot):
15726 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15727 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15728 
      return
15729 
    iprot.readStructBegin()
15730 
    while True:
15731 
      (fname, ftype, fid) = iprot.readFieldBegin()
15732 
      if ftype == TType.STOP:
15733 
        break
15734 
      if fid == 1:
15735 
        if ftype == TType.I64:
15736 
          self.itemId = iprot.readI64();
15737 
        else:
15738 
          iprot.skip(ftype)
15739 
      elif fid == 2:
15740 
        if ftype == TType.I64:
15741 
          self.sourceId = iprot.readI64();
15742 
        else:
15743 
          iprot.skip(ftype)
15744 
      else:
15745 
        iprot.skip(ftype)
15746 
      iprot.readFieldEnd()
15747 
    iprot.readStructEnd()
15748 
 
15749 
  def write(self, oprot):
15750 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15751 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15752 
      return
15753 
    oprot.writeStructBegin('getItemPricingBySource_args')
15754 
    if self.itemId is not None:
15755 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15756 
      oprot.writeI64(self.itemId)
15757 
      oprot.writeFieldEnd()
15758 
    if self.sourceId is not None:
15759 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
15760 
      oprot.writeI64(self.sourceId)
15761 
      oprot.writeFieldEnd()
15762 
    oprot.writeFieldStop()
15763 
    oprot.writeStructEnd()
15764 
 
15765 
  def validate(self):
15766 
    return
15767 
 
15768 
 
15769 
  def __repr__(self):
15770 
    L = ['%s=%r' % (key, value)
15771 
      for key, value in self.__dict__.iteritems()]
15772 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15773 
 
15774 
  def __eq__(self, other):
15775 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15776 
 
15777 
  def __ne__(self, other):
15778 
    return not (self == other)
15779 
 
15780 
class getItemPricingBySource_result:
15781 
  """
15782 
  Attributes:
15783 
   - success
15784 
   - cex
15785 
  """
15786 
 
15787 
  thrift_spec = (
15788 
    (0, TType.STRUCT, 'success', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 0
15789 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
15790 
  )
15791 
 
15792 
  def __init__(self, success=None, cex=None,):
15793 
    self.success = success
15794 
    self.cex = cex
15795 
 
15796 
  def read(self, iprot):
15797 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15798 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15799 
      return
15800 
    iprot.readStructBegin()
15801 
    while True:
15802 
      (fname, ftype, fid) = iprot.readFieldBegin()
15803 
      if ftype == TType.STOP:
15804 
        break
15805 
      if fid == 0:
15806 
        if ftype == TType.STRUCT:
15807 
          self.success = SourceItemPricing()
15808 
          self.success.read(iprot)
15809 
        else:
15810 
          iprot.skip(ftype)
15811 
      elif fid == 1:
15812 
        if ftype == TType.STRUCT:
15813 
          self.cex = CatalogServiceException()
15814 
          self.cex.read(iprot)
15815 
        else:
15816 
          iprot.skip(ftype)
15817 
      else:
15818 
        iprot.skip(ftype)
15819 
      iprot.readFieldEnd()
15820 
    iprot.readStructEnd()
15821 
 
15822 
  def write(self, oprot):
15823 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15824 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15825 
      return
15826 
    oprot.writeStructBegin('getItemPricingBySource_result')
15827 
    if self.success is not None:
15828 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15829 
      self.success.write(oprot)
15830 
      oprot.writeFieldEnd()
15831 
    if self.cex is not None:
15832 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15833 
      self.cex.write(oprot)
15834 
      oprot.writeFieldEnd()
15835 
    oprot.writeFieldStop()
15836 
    oprot.writeStructEnd()
15837 
 
15838 
  def validate(self):
15839 
    return
15840 
 
15841 
 
15842 
  def __repr__(self):
15843 
    L = ['%s=%r' % (key, value)
15844 
      for key, value in self.__dict__.iteritems()]
15845 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15846 
 
15847 
  def __eq__(self, other):
15848 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15849 
 
15850 
  def __ne__(self, other):
15851 
    return not (self == other)
15852 
 
15853 
class addSourceItemPricing_args:
15854 
  """
15855 
  Attributes:
15856 
   - sourceItemPricing
15857 
  """
15858 
 
15859 
  thrift_spec = (
15860 
    None, # 0
15861 
    (1, TType.STRUCT, 'sourceItemPricing', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 1
15862 
  )
15863 
 
15864 
  def __init__(self, sourceItemPricing=None,):
15865 
    self.sourceItemPricing = sourceItemPricing
15866 
 
15867 
  def read(self, iprot):
15868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15870 
      return
15871 
    iprot.readStructBegin()
15872 
    while True:
15873 
      (fname, ftype, fid) = iprot.readFieldBegin()
15874 
      if ftype == TType.STOP:
15875 
        break
15876 
      if fid == 1:
15877 
        if ftype == TType.STRUCT:
15878 
          self.sourceItemPricing = SourceItemPricing()
15879 
          self.sourceItemPricing.read(iprot)
15880 
        else:
15881 
          iprot.skip(ftype)
15882 
      else:
15883 
        iprot.skip(ftype)
15884 
      iprot.readFieldEnd()
15885 
    iprot.readStructEnd()
15886 
 
15887 
  def write(self, oprot):
15888 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15889 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15890 
      return
15891 
    oprot.writeStructBegin('addSourceItemPricing_args')
15892 
    if self.sourceItemPricing is not None:
15893 
      oprot.writeFieldBegin('sourceItemPricing', TType.STRUCT, 1)
15894 
      self.sourceItemPricing.write(oprot)
15895 
      oprot.writeFieldEnd()
15896 
    oprot.writeFieldStop()
15897 
    oprot.writeStructEnd()
15898 
 
15899 
  def validate(self):
15900 
    return
15901 
 
15902 
 
15903 
  def __repr__(self):
15904 
    L = ['%s=%r' % (key, value)
15905 
      for key, value in self.__dict__.iteritems()]
15906 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15907 
 
15908 
  def __eq__(self, other):
15909 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15910 
 
15911 
  def __ne__(self, other):
15912 
    return not (self == other)
15913 
 
15914 
class addSourceItemPricing_result:
15915 
  """
15916 
  Attributes:
15917 
   - cex
15918 
  """
15919 
 
15920 
  thrift_spec = (
15921 
    None, # 0
15922 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
15923 
  )
15924 
 
15925 
  def __init__(self, cex=None,):
15926 
    self.cex = cex
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.STRUCT:
15939 
          self.cex = CatalogServiceException()
15940 
          self.cex.read(iprot)
15941 
        else:
15942 
          iprot.skip(ftype)
15943 
      else:
15944 
        iprot.skip(ftype)
15945 
      iprot.readFieldEnd()
15946 
    iprot.readStructEnd()
15947 
 
15948 
  def write(self, oprot):
15949 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15950 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15951 
      return
15952 
    oprot.writeStructBegin('addSourceItemPricing_result')
15953 
    if self.cex is not None:
15954 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15955 
      self.cex.write(oprot)
15956 
      oprot.writeFieldEnd()
15957 
    oprot.writeFieldStop()
15958 
    oprot.writeStructEnd()
15959 
 
15960 
  def validate(self):
15961 
    return
15962 
 
15963 
 
15964 
  def __repr__(self):
15965 
    L = ['%s=%r' % (key, value)
15966 
      for key, value in self.__dict__.iteritems()]
15967 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15968 
 
15969 
  def __eq__(self, other):
15970 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15971 
 
15972 
  def __ne__(self, other):
15973 
    return not (self == other)
15974 
 
15975 
class getAllSourcePricing_args:
15976 
  """
15977 
  Attributes:
15978 
   - itemId
15979 
  """
15980 
 
15981 
  thrift_spec = (
15982 
    None, # 0
15983 
    (1, TType.I64, 'itemId', None, None, ), # 1
15984 
  )
15985 
 
15986 
  def __init__(self, itemId=None,):
15987 
    self.itemId = itemId
15988 
 
15989 
  def read(self, iprot):
15990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15992 
      return
15993 
    iprot.readStructBegin()
15994 
    while True:
15995 
      (fname, ftype, fid) = iprot.readFieldBegin()
15996 
      if ftype == TType.STOP:
15997 
        break
15998 
      if fid == 1:
15999 
        if ftype == TType.I64:
16000 
          self.itemId = iprot.readI64();
16001 
        else:
16002 
          iprot.skip(ftype)
16003 
      else:
16004 
        iprot.skip(ftype)
16005 
      iprot.readFieldEnd()
16006 
    iprot.readStructEnd()
16007 
 
16008 
  def write(self, oprot):
16009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16011 
      return
16012 
    oprot.writeStructBegin('getAllSourcePricing_args')
16013 
    if self.itemId is not None:
16014 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16015 
      oprot.writeI64(self.itemId)
16016 
      oprot.writeFieldEnd()
16017 
    oprot.writeFieldStop()
16018 
    oprot.writeStructEnd()
16019 
 
16020 
  def validate(self):
16021 
    return
16022 
 
16023 
 
16024 
  def __repr__(self):
16025 
    L = ['%s=%r' % (key, value)
16026 
      for key, value in self.__dict__.iteritems()]
16027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16028 
 
16029 
  def __eq__(self, other):
16030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16031 
 
16032 
  def __ne__(self, other):
16033 
    return not (self == other)
16034 
 
16035 
class getAllSourcePricing_result:
16036 
  """
16037 
  Attributes:
16038 
   - success
16039 
   - cex
16040 
  """
16041 
 
16042 
  thrift_spec = (
16043 
    (0, TType.LIST, 'success', (TType.STRUCT,(SourceItemPricing, SourceItemPricing.thrift_spec)), None, ), # 0
16044 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16045 
  )
16046 
 
16047 
  def __init__(self, success=None, cex=None,):
16048 
    self.success = success
16049 
    self.cex = cex
16050 
 
16051 
  def read(self, iprot):
16052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16054 
      return
16055 
    iprot.readStructBegin()
16056 
    while True:
16057 
      (fname, ftype, fid) = iprot.readFieldBegin()
16058 
      if ftype == TType.STOP:
16059 
        break
16060 
      if fid == 0:
16061 
        if ftype == TType.LIST:
16062 
          self.success = []
9155 kshitij.so 16063 
          (_etype321, _size318) = iprot.readListBegin()
16064 
          for _i322 in xrange(_size318):
16065 
            _elem323 = SourceItemPricing()
16066 
            _elem323.read(iprot)
16067 
            self.success.append(_elem323)
5944 mandeep.dh 16068 
          iprot.readListEnd()
16069 
        else:
16070 
          iprot.skip(ftype)
16071 
      elif fid == 1:
16072 
        if ftype == TType.STRUCT:
16073 
          self.cex = CatalogServiceException()
16074 
          self.cex.read(iprot)
16075 
        else:
16076 
          iprot.skip(ftype)
16077 
      else:
16078 
        iprot.skip(ftype)
16079 
      iprot.readFieldEnd()
16080 
    iprot.readStructEnd()
16081 
 
16082 
  def write(self, oprot):
16083 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16084 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16085 
      return
16086 
    oprot.writeStructBegin('getAllSourcePricing_result')
16087 
    if self.success is not None:
16088 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16089 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16090 
      for iter324 in self.success:
16091 
        iter324.write(oprot)
5944 mandeep.dh 16092 
      oprot.writeListEnd()
16093 
      oprot.writeFieldEnd()
16094 
    if self.cex is not None:
16095 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16096 
      self.cex.write(oprot)
16097 
      oprot.writeFieldEnd()
16098 
    oprot.writeFieldStop()
16099 
    oprot.writeStructEnd()
16100 
 
16101 
  def validate(self):
16102 
    return
16103 
 
16104 
 
16105 
  def __repr__(self):
16106 
    L = ['%s=%r' % (key, value)
16107 
      for key, value in self.__dict__.iteritems()]
16108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16109 
 
16110 
  def __eq__(self, other):
16111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16112 
 
16113 
  def __ne__(self, other):
16114 
    return not (self == other)
16115 
 
16116 
class getItemForSource_args:
16117 
  """
16118 
  Attributes:
16119 
   - item_id
16120 
   - sourceId
16121 
  """
16122 
 
16123 
  thrift_spec = (
16124 
    None, # 0
16125 
    (1, TType.I64, 'item_id', None, None, ), # 1
16126 
    (2, TType.I64, 'sourceId', None, None, ), # 2
16127 
  )
16128 
 
16129 
  def __init__(self, item_id=None, sourceId=None,):
16130 
    self.item_id = item_id
16131 
    self.sourceId = sourceId
16132 
 
16133 
  def read(self, iprot):
16134 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16135 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16136 
      return
16137 
    iprot.readStructBegin()
16138 
    while True:
16139 
      (fname, ftype, fid) = iprot.readFieldBegin()
16140 
      if ftype == TType.STOP:
16141 
        break
16142 
      if fid == 1:
16143 
        if ftype == TType.I64:
16144 
          self.item_id = iprot.readI64();
16145 
        else:
16146 
          iprot.skip(ftype)
16147 
      elif fid == 2:
16148 
        if ftype == TType.I64:
16149 
          self.sourceId = iprot.readI64();
16150 
        else:
16151 
          iprot.skip(ftype)
16152 
      else:
16153 
        iprot.skip(ftype)
16154 
      iprot.readFieldEnd()
16155 
    iprot.readStructEnd()
16156 
 
16157 
  def write(self, oprot):
16158 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16159 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16160 
      return
16161 
    oprot.writeStructBegin('getItemForSource_args')
16162 
    if self.item_id is not None:
16163 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
16164 
      oprot.writeI64(self.item_id)
16165 
      oprot.writeFieldEnd()
16166 
    if self.sourceId is not None:
16167 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
16168 
      oprot.writeI64(self.sourceId)
16169 
      oprot.writeFieldEnd()
16170 
    oprot.writeFieldStop()
16171 
    oprot.writeStructEnd()
16172 
 
16173 
  def validate(self):
16174 
    return
16175 
 
16176 
 
16177 
  def __repr__(self):
16178 
    L = ['%s=%r' % (key, value)
16179 
      for key, value in self.__dict__.iteritems()]
16180 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16181 
 
16182 
  def __eq__(self, other):
16183 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16184 
 
16185 
  def __ne__(self, other):
16186 
    return not (self == other)
16187 
 
16188 
class getItemForSource_result:
16189 
  """
16190 
  Attributes:
16191 
   - success
16192 
   - cex
16193 
  """
16194 
 
16195 
  thrift_spec = (
16196 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
16197 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16198 
  )
16199 
 
16200 
  def __init__(self, success=None, cex=None,):
16201 
    self.success = success
16202 
    self.cex = cex
16203 
 
16204 
  def read(self, iprot):
16205 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16206 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16207 
      return
16208 
    iprot.readStructBegin()
16209 
    while True:
16210 
      (fname, ftype, fid) = iprot.readFieldBegin()
16211 
      if ftype == TType.STOP:
16212 
        break
16213 
      if fid == 0:
16214 
        if ftype == TType.STRUCT:
16215 
          self.success = Item()
16216 
          self.success.read(iprot)
16217 
        else:
16218 
          iprot.skip(ftype)
16219 
      elif fid == 1:
16220 
        if ftype == TType.STRUCT:
16221 
          self.cex = CatalogServiceException()
16222 
          self.cex.read(iprot)
16223 
        else:
16224 
          iprot.skip(ftype)
16225 
      else:
16226 
        iprot.skip(ftype)
16227 
      iprot.readFieldEnd()
16228 
    iprot.readStructEnd()
16229 
 
16230 
  def write(self, oprot):
16231 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16232 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16233 
      return
16234 
    oprot.writeStructBegin('getItemForSource_result')
16235 
    if self.success is not None:
16236 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16237 
      self.success.write(oprot)
16238 
      oprot.writeFieldEnd()
16239 
    if self.cex is not None:
16240 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16241 
      self.cex.write(oprot)
16242 
      oprot.writeFieldEnd()
16243 
    oprot.writeFieldStop()
16244 
    oprot.writeStructEnd()
16245 
 
16246 
  def validate(self):
16247 
    return
16248 
 
16249 
 
16250 
  def __repr__(self):
16251 
    L = ['%s=%r' % (key, value)
16252 
      for key, value in self.__dict__.iteritems()]
16253 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16254 
 
16255 
  def __eq__(self, other):
16256 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16257 
 
16258 
  def __ne__(self, other):
16259 
    return not (self == other)
16260 
 
16261 
class searchItemsInRange_args:
16262 
  """
16263 
  Attributes:
16264 
   - searchTerms
16265 
   - offset
16266 
   - limit
16267 
  """
16268 
 
16269 
  thrift_spec = (
16270 
    None, # 0
16271 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
16272 
    (2, TType.I64, 'offset', None, None, ), # 2
16273 
    (3, TType.I64, 'limit', None, None, ), # 3
16274 
  )
16275 
 
16276 
  def __init__(self, searchTerms=None, offset=None, limit=None,):
16277 
    self.searchTerms = searchTerms
16278 
    self.offset = offset
16279 
    self.limit = limit
16280 
 
16281 
  def read(self, iprot):
16282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16284 
      return
16285 
    iprot.readStructBegin()
16286 
    while True:
16287 
      (fname, ftype, fid) = iprot.readFieldBegin()
16288 
      if ftype == TType.STOP:
16289 
        break
16290 
      if fid == 1:
16291 
        if ftype == TType.LIST:
16292 
          self.searchTerms = []
9155 kshitij.so 16293 
          (_etype328, _size325) = iprot.readListBegin()
16294 
          for _i329 in xrange(_size325):
16295 
            _elem330 = iprot.readString();
16296 
            self.searchTerms.append(_elem330)
5944 mandeep.dh 16297 
          iprot.readListEnd()
16298 
        else:
16299 
          iprot.skip(ftype)
16300 
      elif fid == 2:
16301 
        if ftype == TType.I64:
16302 
          self.offset = iprot.readI64();
16303 
        else:
16304 
          iprot.skip(ftype)
16305 
      elif fid == 3:
16306 
        if ftype == TType.I64:
16307 
          self.limit = iprot.readI64();
16308 
        else:
16309 
          iprot.skip(ftype)
16310 
      else:
16311 
        iprot.skip(ftype)
16312 
      iprot.readFieldEnd()
16313 
    iprot.readStructEnd()
16314 
 
16315 
  def write(self, oprot):
16316 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16317 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16318 
      return
16319 
    oprot.writeStructBegin('searchItemsInRange_args')
16320 
    if self.searchTerms is not None:
16321 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
16322 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
9155 kshitij.so 16323 
      for iter331 in self.searchTerms:
16324 
        oprot.writeString(iter331)
5944 mandeep.dh 16325 
      oprot.writeListEnd()
16326 
      oprot.writeFieldEnd()
16327 
    if self.offset is not None:
16328 
      oprot.writeFieldBegin('offset', TType.I64, 2)
16329 
      oprot.writeI64(self.offset)
16330 
      oprot.writeFieldEnd()
16331 
    if self.limit is not None:
16332 
      oprot.writeFieldBegin('limit', TType.I64, 3)
16333 
      oprot.writeI64(self.limit)
16334 
      oprot.writeFieldEnd()
16335 
    oprot.writeFieldStop()
16336 
    oprot.writeStructEnd()
16337 
 
16338 
  def validate(self):
16339 
    return
16340 
 
16341 
 
16342 
  def __repr__(self):
16343 
    L = ['%s=%r' % (key, value)
16344 
      for key, value in self.__dict__.iteritems()]
16345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16346 
 
16347 
  def __eq__(self, other):
16348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16349 
 
16350 
  def __ne__(self, other):
16351 
    return not (self == other)
16352 
 
16353 
class searchItemsInRange_result:
16354 
  """
16355 
  Attributes:
16356 
   - success
16357 
  """
16358 
 
16359 
  thrift_spec = (
16360 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
16361 
  )
16362 
 
16363 
  def __init__(self, success=None,):
16364 
    self.success = success
16365 
 
16366 
  def read(self, iprot):
16367 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16368 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16369 
      return
16370 
    iprot.readStructBegin()
16371 
    while True:
16372 
      (fname, ftype, fid) = iprot.readFieldBegin()
16373 
      if ftype == TType.STOP:
16374 
        break
16375 
      if fid == 0:
16376 
        if ftype == TType.LIST:
16377 
          self.success = []
9155 kshitij.so 16378 
          (_etype335, _size332) = iprot.readListBegin()
16379 
          for _i336 in xrange(_size332):
16380 
            _elem337 = Item()
16381 
            _elem337.read(iprot)
16382 
            self.success.append(_elem337)
5944 mandeep.dh 16383 
          iprot.readListEnd()
16384 
        else:
16385 
          iprot.skip(ftype)
16386 
      else:
16387 
        iprot.skip(ftype)
16388 
      iprot.readFieldEnd()
16389 
    iprot.readStructEnd()
16390 
 
16391 
  def write(self, oprot):
16392 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16393 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16394 
      return
16395 
    oprot.writeStructBegin('searchItemsInRange_result')
16396 
    if self.success is not None:
16397 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16398 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16399 
      for iter338 in self.success:
16400 
        iter338.write(oprot)
5944 mandeep.dh 16401 
      oprot.writeListEnd()
16402 
      oprot.writeFieldEnd()
16403 
    oprot.writeFieldStop()
16404 
    oprot.writeStructEnd()
16405 
 
16406 
  def validate(self):
16407 
    return
16408 
 
16409 
 
16410 
  def __repr__(self):
16411 
    L = ['%s=%r' % (key, value)
16412 
      for key, value in self.__dict__.iteritems()]
16413 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16414 
 
16415 
  def __eq__(self, other):
16416 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16417 
 
16418 
  def __ne__(self, other):
16419 
    return not (self == other)
16420 
 
16421 
class getSearchResultCount_args:
16422 
  """
16423 
  Attributes:
16424 
   - searchTerms
16425 
  """
16426 
 
16427 
  thrift_spec = (
16428 
    None, # 0
16429 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
16430 
  )
16431 
 
16432 
  def __init__(self, searchTerms=None,):
16433 
    self.searchTerms = searchTerms
16434 
 
16435 
  def read(self, iprot):
16436 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16437 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16438 
      return
16439 
    iprot.readStructBegin()
16440 
    while True:
16441 
      (fname, ftype, fid) = iprot.readFieldBegin()
16442 
      if ftype == TType.STOP:
16443 
        break
16444 
      if fid == 1:
16445 
        if ftype == TType.LIST:
16446 
          self.searchTerms = []
9155 kshitij.so 16447 
          (_etype342, _size339) = iprot.readListBegin()
16448 
          for _i343 in xrange(_size339):
16449 
            _elem344 = iprot.readString();
16450 
            self.searchTerms.append(_elem344)
5944 mandeep.dh 16451 
          iprot.readListEnd()
16452 
        else:
16453 
          iprot.skip(ftype)
16454 
      else:
16455 
        iprot.skip(ftype)
16456 
      iprot.readFieldEnd()
16457 
    iprot.readStructEnd()
16458 
 
16459 
  def write(self, oprot):
16460 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16461 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16462 
      return
16463 
    oprot.writeStructBegin('getSearchResultCount_args')
16464 
    if self.searchTerms is not None:
16465 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
16466 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
9155 kshitij.so 16467 
      for iter345 in self.searchTerms:
16468 
        oprot.writeString(iter345)
5944 mandeep.dh 16469 
      oprot.writeListEnd()
16470 
      oprot.writeFieldEnd()
16471 
    oprot.writeFieldStop()
16472 
    oprot.writeStructEnd()
16473 
 
16474 
  def validate(self):
16475 
    return
16476 
 
16477 
 
16478 
  def __repr__(self):
16479 
    L = ['%s=%r' % (key, value)
16480 
      for key, value in self.__dict__.iteritems()]
16481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16482 
 
16483 
  def __eq__(self, other):
16484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16485 
 
16486 
  def __ne__(self, other):
16487 
    return not (self == other)
16488 
 
16489 
class getSearchResultCount_result:
16490 
  """
16491 
  Attributes:
16492 
   - success
16493 
  """
16494 
 
16495 
  thrift_spec = (
16496 
    (0, TType.I32, 'success', None, None, ), # 0
16497 
  )
16498 
 
16499 
  def __init__(self, success=None,):
16500 
    self.success = success
16501 
 
16502 
  def read(self, iprot):
16503 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16504 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16505 
      return
16506 
    iprot.readStructBegin()
16507 
    while True:
16508 
      (fname, ftype, fid) = iprot.readFieldBegin()
16509 
      if ftype == TType.STOP:
16510 
        break
16511 
      if fid == 0:
16512 
        if ftype == TType.I32:
16513 
          self.success = iprot.readI32();
16514 
        else:
16515 
          iprot.skip(ftype)
16516 
      else:
16517 
        iprot.skip(ftype)
16518 
      iprot.readFieldEnd()
16519 
    iprot.readStructEnd()
16520 
 
16521 
  def write(self, oprot):
16522 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16523 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16524 
      return
16525 
    oprot.writeStructBegin('getSearchResultCount_result')
16526 
    if self.success is not None:
16527 
      oprot.writeFieldBegin('success', TType.I32, 0)
16528 
      oprot.writeI32(self.success)
16529 
      oprot.writeFieldEnd()
16530 
    oprot.writeFieldStop()
16531 
    oprot.writeStructEnd()
16532 
 
16533 
  def validate(self):
16534 
    return
16535 
 
16536 
 
16537 
  def __repr__(self):
16538 
    L = ['%s=%r' % (key, value)
16539 
      for key, value in self.__dict__.iteritems()]
16540 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16541 
 
16542 
  def __eq__(self, other):
16543 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16544 
 
16545 
  def __ne__(self, other):
16546 
    return not (self == other)
16547 
 
16548 
class getProductNotifications_args:
16549 
  """
16550 
  Attributes:
16551 
   - startDateTime
16552 
  """
16553 
 
16554 
  thrift_spec = (
16555 
    None, # 0
16556 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
16557 
  )
16558 
 
16559 
  def __init__(self, startDateTime=None,):
16560 
    self.startDateTime = startDateTime
16561 
 
16562 
  def read(self, iprot):
16563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16565 
      return
16566 
    iprot.readStructBegin()
16567 
    while True:
16568 
      (fname, ftype, fid) = iprot.readFieldBegin()
16569 
      if ftype == TType.STOP:
16570 
        break
16571 
      if fid == 1:
16572 
        if ftype == TType.I64:
16573 
          self.startDateTime = iprot.readI64();
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('getProductNotifications_args')
16586 
    if self.startDateTime is not None:
16587 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
16588 
      oprot.writeI64(self.startDateTime)
16589 
      oprot.writeFieldEnd()
16590 
    oprot.writeFieldStop()
16591 
    oprot.writeStructEnd()
16592 
 
16593 
  def validate(self):
16594 
    return
16595 
 
16596 
 
16597 
  def __repr__(self):
16598 
    L = ['%s=%r' % (key, value)
16599 
      for key, value in self.__dict__.iteritems()]
16600 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16601 
 
16602 
  def __eq__(self, other):
16603 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16604 
 
16605 
  def __ne__(self, other):
16606 
    return not (self == other)
16607 
 
16608 
class getProductNotifications_result:
16609 
  """
16610 
  Attributes:
16611 
   - success
16612 
  """
16613 
 
16614 
  thrift_spec = (
16615 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequest, ProductNotificationRequest.thrift_spec)), None, ), # 0
16616 
  )
16617 
 
16618 
  def __init__(self, success=None,):
16619 
    self.success = success
16620 
 
16621 
  def read(self, iprot):
16622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16624 
      return
16625 
    iprot.readStructBegin()
16626 
    while True:
16627 
      (fname, ftype, fid) = iprot.readFieldBegin()
16628 
      if ftype == TType.STOP:
16629 
        break
16630 
      if fid == 0:
16631 
        if ftype == TType.LIST:
16632 
          self.success = []
9155 kshitij.so 16633 
          (_etype349, _size346) = iprot.readListBegin()
16634 
          for _i350 in xrange(_size346):
16635 
            _elem351 = ProductNotificationRequest()
16636 
            _elem351.read(iprot)
16637 
            self.success.append(_elem351)
5944 mandeep.dh 16638 
          iprot.readListEnd()
16639 
        else:
16640 
          iprot.skip(ftype)
16641 
      else:
16642 
        iprot.skip(ftype)
16643 
      iprot.readFieldEnd()
16644 
    iprot.readStructEnd()
16645 
 
16646 
  def write(self, oprot):
16647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16649 
      return
16650 
    oprot.writeStructBegin('getProductNotifications_result')
16651 
    if self.success is not None:
16652 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16653 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16654 
      for iter352 in self.success:
16655 
        iter352.write(oprot)
5944 mandeep.dh 16656 
      oprot.writeListEnd()
16657 
      oprot.writeFieldEnd()
16658 
    oprot.writeFieldStop()
16659 
    oprot.writeStructEnd()
16660 
 
16661 
  def validate(self):
16662 
    return
16663 
 
16664 
 
16665 
  def __repr__(self):
16666 
    L = ['%s=%r' % (key, value)
16667 
      for key, value in self.__dict__.iteritems()]
16668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16669 
 
16670 
  def __eq__(self, other):
16671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16672 
 
16673 
  def __ne__(self, other):
16674 
    return not (self == other)
16675 
 
16676 
class getProductNotificationRequestCount_args:
16677 
  """
16678 
  Attributes:
16679 
   - startDateTime
7897 amar.kumar 16680 
   - categoryId
5944 mandeep.dh 16681 
  """
16682 
 
16683 
  thrift_spec = (
16684 
    None, # 0
16685 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
7897 amar.kumar 16686 
    (2, TType.I64, 'categoryId', None, None, ), # 2
5944 mandeep.dh 16687 
  )
16688 
 
7897 amar.kumar 16689 
  def __init__(self, startDateTime=None, categoryId=None,):
5944 mandeep.dh 16690 
    self.startDateTime = startDateTime
7897 amar.kumar 16691 
    self.categoryId = categoryId
5944 mandeep.dh 16692 
 
16693 
  def read(self, iprot):
16694 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16695 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16696 
      return
16697 
    iprot.readStructBegin()
16698 
    while True:
16699 
      (fname, ftype, fid) = iprot.readFieldBegin()
16700 
      if ftype == TType.STOP:
16701 
        break
16702 
      if fid == 1:
16703 
        if ftype == TType.I64:
16704 
          self.startDateTime = iprot.readI64();
16705 
        else:
16706 
          iprot.skip(ftype)
7897 amar.kumar 16707 
      elif fid == 2:
16708 
        if ftype == TType.I64:
16709 
          self.categoryId = iprot.readI64();
16710 
        else:
16711 
          iprot.skip(ftype)
5944 mandeep.dh 16712 
      else:
16713 
        iprot.skip(ftype)
16714 
      iprot.readFieldEnd()
16715 
    iprot.readStructEnd()
16716 
 
16717 
  def write(self, oprot):
16718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16720 
      return
16721 
    oprot.writeStructBegin('getProductNotificationRequestCount_args')
16722 
    if self.startDateTime is not None:
16723 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
16724 
      oprot.writeI64(self.startDateTime)
16725 
      oprot.writeFieldEnd()
7897 amar.kumar 16726 
    if self.categoryId is not None:
16727 
      oprot.writeFieldBegin('categoryId', TType.I64, 2)
16728 
      oprot.writeI64(self.categoryId)
16729 
      oprot.writeFieldEnd()
5944 mandeep.dh 16730 
    oprot.writeFieldStop()
16731 
    oprot.writeStructEnd()
16732 
 
16733 
  def validate(self):
16734 
    return
16735 
 
16736 
 
16737 
  def __repr__(self):
16738 
    L = ['%s=%r' % (key, value)
16739 
      for key, value in self.__dict__.iteritems()]
16740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16741 
 
16742 
  def __eq__(self, other):
16743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16744 
 
16745 
  def __ne__(self, other):
16746 
    return not (self == other)
16747 
 
16748 
class getProductNotificationRequestCount_result:
16749 
  """
16750 
  Attributes:
16751 
   - success
16752 
  """
16753 
 
16754 
  thrift_spec = (
16755 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequestCount, ProductNotificationRequestCount.thrift_spec)), None, ), # 0
16756 
  )
16757 
 
16758 
  def __init__(self, success=None,):
16759 
    self.success = success
16760 
 
16761 
  def read(self, iprot):
16762 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16763 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16764 
      return
16765 
    iprot.readStructBegin()
16766 
    while True:
16767 
      (fname, ftype, fid) = iprot.readFieldBegin()
16768 
      if ftype == TType.STOP:
16769 
        break
16770 
      if fid == 0:
16771 
        if ftype == TType.LIST:
16772 
          self.success = []
9155 kshitij.so 16773 
          (_etype356, _size353) = iprot.readListBegin()
16774 
          for _i357 in xrange(_size353):
16775 
            _elem358 = ProductNotificationRequestCount()
16776 
            _elem358.read(iprot)
16777 
            self.success.append(_elem358)
5944 mandeep.dh 16778 
          iprot.readListEnd()
16779 
        else:
16780 
          iprot.skip(ftype)
16781 
      else:
16782 
        iprot.skip(ftype)
16783 
      iprot.readFieldEnd()
16784 
    iprot.readStructEnd()
16785 
 
16786 
  def write(self, oprot):
16787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16789 
      return
16790 
    oprot.writeStructBegin('getProductNotificationRequestCount_result')
16791 
    if self.success is not None:
16792 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16793 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16794 
      for iter359 in self.success:
16795 
        iter359.write(oprot)
5944 mandeep.dh 16796 
      oprot.writeListEnd()
16797 
      oprot.writeFieldEnd()
16798 
    oprot.writeFieldStop()
16799 
    oprot.writeStructEnd()
16800 
 
16801 
  def validate(self):
16802 
    return
16803 
 
16804 
 
16805 
  def __repr__(self):
16806 
    L = ['%s=%r' % (key, value)
16807 
      for key, value in self.__dict__.iteritems()]
16808 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16809 
 
16810 
  def __eq__(self, other):
16811 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16812 
 
16813 
  def __ne__(self, other):
16814 
    return not (self == other)
16815 
 
16816 
class addAuthorizationLog_args:
16817 
  """
16818 
  Attributes:
16819 
   - itemId
16820 
   - username
16821 
   - reason
16822 
  """
16823 
 
16824 
  thrift_spec = (
16825 
    None, # 0
16826 
    (1, TType.I64, 'itemId', None, None, ), # 1
16827 
    (2, TType.STRING, 'username', None, None, ), # 2
16828 
    (3, TType.STRING, 'reason', None, None, ), # 3
16829 
  )
16830 
 
16831 
  def __init__(self, itemId=None, username=None, reason=None,):
16832 
    self.itemId = itemId
16833 
    self.username = username
16834 
    self.reason = reason
16835 
 
16836 
  def read(self, iprot):
16837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16839 
      return
16840 
    iprot.readStructBegin()
16841 
    while True:
16842 
      (fname, ftype, fid) = iprot.readFieldBegin()
16843 
      if ftype == TType.STOP:
16844 
        break
16845 
      if fid == 1:
16846 
        if ftype == TType.I64:
16847 
          self.itemId = iprot.readI64();
16848 
        else:
16849 
          iprot.skip(ftype)
16850 
      elif fid == 2:
16851 
        if ftype == TType.STRING:
16852 
          self.username = iprot.readString();
16853 
        else:
16854 
          iprot.skip(ftype)
16855 
      elif fid == 3:
16856 
        if ftype == TType.STRING:
16857 
          self.reason = iprot.readString();
16858 
        else:
16859 
          iprot.skip(ftype)
16860 
      else:
16861 
        iprot.skip(ftype)
16862 
      iprot.readFieldEnd()
16863 
    iprot.readStructEnd()
16864 
 
16865 
  def write(self, oprot):
16866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16868 
      return
16869 
    oprot.writeStructBegin('addAuthorizationLog_args')
16870 
    if self.itemId is not None:
16871 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16872 
      oprot.writeI64(self.itemId)
16873 
      oprot.writeFieldEnd()
16874 
    if self.username is not None:
16875 
      oprot.writeFieldBegin('username', TType.STRING, 2)
16876 
      oprot.writeString(self.username)
16877 
      oprot.writeFieldEnd()
16878 
    if self.reason is not None:
16879 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
16880 
      oprot.writeString(self.reason)
16881 
      oprot.writeFieldEnd()
16882 
    oprot.writeFieldStop()
16883 
    oprot.writeStructEnd()
16884 
 
16885 
  def validate(self):
16886 
    return
16887 
 
16888 
 
16889 
  def __repr__(self):
16890 
    L = ['%s=%r' % (key, value)
16891 
      for key, value in self.__dict__.iteritems()]
16892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16893 
 
16894 
  def __eq__(self, other):
16895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16896 
 
16897 
  def __ne__(self, other):
16898 
    return not (self == other)
16899 
 
16900 
class addAuthorizationLog_result:
16901 
  """
16902 
  Attributes:
16903 
   - success
16904 
   - cex
16905 
  """
16906 
 
16907 
  thrift_spec = (
16908 
    (0, TType.BOOL, 'success', None, None, ), # 0
16909 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16910 
  )
16911 
 
16912 
  def __init__(self, success=None, cex=None,):
16913 
    self.success = success
16914 
    self.cex = cex
16915 
 
16916 
  def read(self, iprot):
16917 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16918 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16919 
      return
16920 
    iprot.readStructBegin()
16921 
    while True:
16922 
      (fname, ftype, fid) = iprot.readFieldBegin()
16923 
      if ftype == TType.STOP:
16924 
        break
16925 
      if fid == 0:
16926 
        if ftype == TType.BOOL:
16927 
          self.success = iprot.readBool();
16928 
        else:
16929 
          iprot.skip(ftype)
16930 
      elif fid == 1:
16931 
        if ftype == TType.STRUCT:
16932 
          self.cex = CatalogServiceException()
16933 
          self.cex.read(iprot)
16934 
        else:
16935 
          iprot.skip(ftype)
16936 
      else:
16937 
        iprot.skip(ftype)
16938 
      iprot.readFieldEnd()
16939 
    iprot.readStructEnd()
16940 
 
16941 
  def write(self, oprot):
16942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16944 
      return
16945 
    oprot.writeStructBegin('addAuthorizationLog_result')
16946 
    if self.success is not None:
16947 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16948 
      oprot.writeBool(self.success)
16949 
      oprot.writeFieldEnd()
16950 
    if self.cex is not None:
16951 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16952 
      self.cex.write(oprot)
16953 
      oprot.writeFieldEnd()
16954 
    oprot.writeFieldStop()
16955 
    oprot.writeStructEnd()
16956 
 
16957 
  def validate(self):
16958 
    return
16959 
 
16960 
 
16961 
  def __repr__(self):
16962 
    L = ['%s=%r' % (key, value)
16963 
      for key, value in self.__dict__.iteritems()]
16964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16965 
 
16966 
  def __eq__(self, other):
16967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16968 
 
16969 
  def __ne__(self, other):
16970 
    return not (self == other)
16971 
 
16972 
class addupdateVoucherForItem_args:
16973 
  """
16974 
  Attributes:
16975 
   - catalog_item_id
16976 
   - voucherType
16977 
   - voucherAmount
16978 
  """
16979 
 
16980 
  thrift_spec = (
16981 
    None, # 0
16982 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
16983 
    (2, TType.I64, 'voucherType', None, None, ), # 2
16984 
    (3, TType.I64, 'voucherAmount', None, None, ), # 3
16985 
  )
16986 
 
16987 
  def __init__(self, catalog_item_id=None, voucherType=None, voucherAmount=None,):
16988 
    self.catalog_item_id = catalog_item_id
16989 
    self.voucherType = voucherType
16990 
    self.voucherAmount = voucherAmount
16991 
 
16992 
  def read(self, iprot):
16993 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16994 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16995 
      return
16996 
    iprot.readStructBegin()
16997 
    while True:
16998 
      (fname, ftype, fid) = iprot.readFieldBegin()
16999 
      if ftype == TType.STOP:
17000 
        break
17001 
      if fid == 1:
17002 
        if ftype == TType.I64:
17003 
          self.catalog_item_id = iprot.readI64();
17004 
        else:
17005 
          iprot.skip(ftype)
17006 
      elif fid == 2:
17007 
        if ftype == TType.I64:
17008 
          self.voucherType = iprot.readI64();
17009 
        else:
17010 
          iprot.skip(ftype)
17011 
      elif fid == 3:
17012 
        if ftype == TType.I64:
17013 
          self.voucherAmount = iprot.readI64();
17014 
        else:
17015 
          iprot.skip(ftype)
17016 
      else:
17017 
        iprot.skip(ftype)
17018 
      iprot.readFieldEnd()
17019 
    iprot.readStructEnd()
17020 
 
17021 
  def write(self, oprot):
17022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17024 
      return
17025 
    oprot.writeStructBegin('addupdateVoucherForItem_args')
17026 
    if self.catalog_item_id is not None:
17027 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
17028 
      oprot.writeI64(self.catalog_item_id)
17029 
      oprot.writeFieldEnd()
17030 
    if self.voucherType is not None:
17031 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
17032 
      oprot.writeI64(self.voucherType)
17033 
      oprot.writeFieldEnd()
17034 
    if self.voucherAmount is not None:
17035 
      oprot.writeFieldBegin('voucherAmount', TType.I64, 3)
17036 
      oprot.writeI64(self.voucherAmount)
17037 
      oprot.writeFieldEnd()
17038 
    oprot.writeFieldStop()
17039 
    oprot.writeStructEnd()
17040 
 
17041 
  def validate(self):
17042 
    return
17043 
 
17044 
 
17045 
  def __repr__(self):
17046 
    L = ['%s=%r' % (key, value)
17047 
      for key, value in self.__dict__.iteritems()]
17048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17049 
 
17050 
  def __eq__(self, other):
17051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17052 
 
17053 
  def __ne__(self, other):
17054 
    return not (self == other)
17055 
 
17056 
class addupdateVoucherForItem_result:
17057 
  """
17058 
  Attributes:
17059 
   - success
17060 
   - cex
17061 
  """
17062 
 
17063 
  thrift_spec = (
17064 
    (0, TType.BOOL, 'success', None, None, ), # 0
17065 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17066 
  )
17067 
 
17068 
  def __init__(self, success=None, cex=None,):
17069 
    self.success = success
17070 
    self.cex = cex
17071 
 
17072 
  def read(self, iprot):
17073 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17074 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17075 
      return
17076 
    iprot.readStructBegin()
17077 
    while True:
17078 
      (fname, ftype, fid) = iprot.readFieldBegin()
17079 
      if ftype == TType.STOP:
17080 
        break
17081 
      if fid == 0:
17082 
        if ftype == TType.BOOL:
17083 
          self.success = iprot.readBool();
17084 
        else:
17085 
          iprot.skip(ftype)
17086 
      elif fid == 1:
17087 
        if ftype == TType.STRUCT:
17088 
          self.cex = CatalogServiceException()
17089 
          self.cex.read(iprot)
17090 
        else:
17091 
          iprot.skip(ftype)
17092 
      else:
17093 
        iprot.skip(ftype)
17094 
      iprot.readFieldEnd()
17095 
    iprot.readStructEnd()
17096 
 
17097 
  def write(self, oprot):
17098 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17099 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17100 
      return
17101 
    oprot.writeStructBegin('addupdateVoucherForItem_result')
17102 
    if self.success is not None:
17103 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17104 
      oprot.writeBool(self.success)
17105 
      oprot.writeFieldEnd()
17106 
    if self.cex is not None:
17107 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17108 
      self.cex.write(oprot)
17109 
      oprot.writeFieldEnd()
17110 
    oprot.writeFieldStop()
17111 
    oprot.writeStructEnd()
17112 
 
17113 
  def validate(self):
17114 
    return
17115 
 
17116 
 
17117 
  def __repr__(self):
17118 
    L = ['%s=%r' % (key, value)
17119 
      for key, value in self.__dict__.iteritems()]
17120 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17121 
 
17122 
  def __eq__(self, other):
17123 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17124 
 
17125 
  def __ne__(self, other):
17126 
    return not (self == other)
17127 
 
17128 
class deleteVoucherForItem_args:
17129 
  """
17130 
  Attributes:
17131 
   - catalog_item_id
17132 
   - voucherType
17133 
  """
17134 
 
17135 
  thrift_spec = (
17136 
    None, # 0
17137 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
17138 
    (2, TType.I64, 'voucherType', None, None, ), # 2
17139 
  )
17140 
 
17141 
  def __init__(self, catalog_item_id=None, voucherType=None,):
17142 
    self.catalog_item_id = catalog_item_id
17143 
    self.voucherType = voucherType
17144 
 
17145 
  def read(self, iprot):
17146 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17147 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17148 
      return
17149 
    iprot.readStructBegin()
17150 
    while True:
17151 
      (fname, ftype, fid) = iprot.readFieldBegin()
17152 
      if ftype == TType.STOP:
17153 
        break
17154 
      if fid == 1:
17155 
        if ftype == TType.I64:
17156 
          self.catalog_item_id = iprot.readI64();
17157 
        else:
17158 
          iprot.skip(ftype)
17159 
      elif fid == 2:
17160 
        if ftype == TType.I64:
17161 
          self.voucherType = iprot.readI64();
17162 
        else:
17163 
          iprot.skip(ftype)
17164 
      else:
17165 
        iprot.skip(ftype)
17166 
      iprot.readFieldEnd()
17167 
    iprot.readStructEnd()
17168 
 
17169 
  def write(self, oprot):
17170 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17171 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17172 
      return
17173 
    oprot.writeStructBegin('deleteVoucherForItem_args')
17174 
    if self.catalog_item_id is not None:
17175 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
17176 
      oprot.writeI64(self.catalog_item_id)
17177 
      oprot.writeFieldEnd()
17178 
    if self.voucherType is not None:
17179 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
17180 
      oprot.writeI64(self.voucherType)
17181 
      oprot.writeFieldEnd()
17182 
    oprot.writeFieldStop()
17183 
    oprot.writeStructEnd()
17184 
 
17185 
  def validate(self):
17186 
    return
17187 
 
17188 
 
17189 
  def __repr__(self):
17190 
    L = ['%s=%r' % (key, value)
17191 
      for key, value in self.__dict__.iteritems()]
17192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17193 
 
17194 
  def __eq__(self, other):
17195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17196 
 
17197 
  def __ne__(self, other):
17198 
    return not (self == other)
17199 
 
17200 
class deleteVoucherForItem_result:
17201 
  """
17202 
  Attributes:
17203 
   - success
17204 
   - cex
17205 
  """
17206 
 
17207 
  thrift_spec = (
17208 
    (0, TType.BOOL, 'success', None, None, ), # 0
17209 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17210 
  )
17211 
 
17212 
  def __init__(self, success=None, cex=None,):
17213 
    self.success = success
17214 
    self.cex = cex
17215 
 
17216 
  def read(self, iprot):
17217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17219 
      return
17220 
    iprot.readStructBegin()
17221 
    while True:
17222 
      (fname, ftype, fid) = iprot.readFieldBegin()
17223 
      if ftype == TType.STOP:
17224 
        break
17225 
      if fid == 0:
17226 
        if ftype == TType.BOOL:
17227 
          self.success = iprot.readBool();
17228 
        else:
17229 
          iprot.skip(ftype)
17230 
      elif fid == 1:
17231 
        if ftype == TType.STRUCT:
17232 
          self.cex = CatalogServiceException()
17233 
          self.cex.read(iprot)
17234 
        else:
17235 
          iprot.skip(ftype)
17236 
      else:
17237 
        iprot.skip(ftype)
17238 
      iprot.readFieldEnd()
17239 
    iprot.readStructEnd()
17240 
 
17241 
  def write(self, oprot):
17242 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17243 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17244 
      return
17245 
    oprot.writeStructBegin('deleteVoucherForItem_result')
17246 
    if self.success is not None:
17247 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17248 
      oprot.writeBool(self.success)
17249 
      oprot.writeFieldEnd()
17250 
    if self.cex is not None:
17251 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17252 
      self.cex.write(oprot)
17253 
      oprot.writeFieldEnd()
17254 
    oprot.writeFieldStop()
17255 
    oprot.writeStructEnd()
17256 
 
17257 
  def validate(self):
17258 
    return
17259 
 
17260 
 
17261 
  def __repr__(self):
17262 
    L = ['%s=%r' % (key, value)
17263 
      for key, value in self.__dict__.iteritems()]
17264 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17265 
 
17266 
  def __eq__(self, other):
17267 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17268 
 
17269 
  def __ne__(self, other):
17270 
    return not (self == other)
17271 
 
17272 
class getVoucherAmount_args:
17273 
  """
17274 
  Attributes:
17275 
   - itemId
17276 
   - voucherType
17277 
  """
17278 
 
17279 
  thrift_spec = (
17280 
    None, # 0
17281 
    (1, TType.I64, 'itemId', None, None, ), # 1
17282 
    (2, TType.I64, 'voucherType', None, None, ), # 2
17283 
  )
17284 
 
17285 
  def __init__(self, itemId=None, voucherType=None,):
17286 
    self.itemId = itemId
17287 
    self.voucherType = voucherType
17288 
 
17289 
  def read(self, iprot):
17290 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17291 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17292 
      return
17293 
    iprot.readStructBegin()
17294 
    while True:
17295 
      (fname, ftype, fid) = iprot.readFieldBegin()
17296 
      if ftype == TType.STOP:
17297 
        break
17298 
      if fid == 1:
17299 
        if ftype == TType.I64:
17300 
          self.itemId = iprot.readI64();
17301 
        else:
17302 
          iprot.skip(ftype)
17303 
      elif fid == 2:
17304 
        if ftype == TType.I64:
17305 
          self.voucherType = iprot.readI64();
17306 
        else:
17307 
          iprot.skip(ftype)
17308 
      else:
17309 
        iprot.skip(ftype)
17310 
      iprot.readFieldEnd()
17311 
    iprot.readStructEnd()
17312 
 
17313 
  def write(self, oprot):
17314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17316 
      return
17317 
    oprot.writeStructBegin('getVoucherAmount_args')
17318 
    if self.itemId is not None:
17319 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17320 
      oprot.writeI64(self.itemId)
17321 
      oprot.writeFieldEnd()
17322 
    if self.voucherType is not None:
17323 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
17324 
      oprot.writeI64(self.voucherType)
17325 
      oprot.writeFieldEnd()
17326 
    oprot.writeFieldStop()
17327 
    oprot.writeStructEnd()
17328 
 
17329 
  def validate(self):
17330 
    return
17331 
 
17332 
 
17333 
  def __repr__(self):
17334 
    L = ['%s=%r' % (key, value)
17335 
      for key, value in self.__dict__.iteritems()]
17336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17337 
 
17338 
  def __eq__(self, other):
17339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17340 
 
17341 
  def __ne__(self, other):
17342 
    return not (self == other)
17343 
 
17344 
class getVoucherAmount_result:
17345 
  """
17346 
  Attributes:
17347 
   - success
17348 
  """
17349 
 
17350 
  thrift_spec = (
17351 
    (0, TType.I64, 'success', None, None, ), # 0
17352 
  )
17353 
 
17354 
  def __init__(self, success=None,):
17355 
    self.success = success
17356 
 
17357 
  def read(self, iprot):
17358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17360 
      return
17361 
    iprot.readStructBegin()
17362 
    while True:
17363 
      (fname, ftype, fid) = iprot.readFieldBegin()
17364 
      if ftype == TType.STOP:
17365 
        break
17366 
      if fid == 0:
17367 
        if ftype == TType.I64:
17368 
          self.success = iprot.readI64();
17369 
        else:
17370 
          iprot.skip(ftype)
17371 
      else:
17372 
        iprot.skip(ftype)
17373 
      iprot.readFieldEnd()
17374 
    iprot.readStructEnd()
17375 
 
17376 
  def write(self, oprot):
17377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17379 
      return
17380 
    oprot.writeStructBegin('getVoucherAmount_result')
17381 
    if self.success is not None:
17382 
      oprot.writeFieldBegin('success', TType.I64, 0)
17383 
      oprot.writeI64(self.success)
17384 
      oprot.writeFieldEnd()
17385 
    oprot.writeFieldStop()
17386 
    oprot.writeStructEnd()
17387 
 
17388 
  def validate(self):
17389 
    return
17390 
 
17391 
 
17392 
  def __repr__(self):
17393 
    L = ['%s=%r' % (key, value)
17394 
      for key, value in self.__dict__.iteritems()]
17395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17396 
 
17397 
  def __eq__(self, other):
17398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17399 
 
17400 
  def __ne__(self, other):
17401 
    return not (self == other)
17402 
 
17403 
class getAllItemVouchers_args:
17404 
  """
17405 
  Attributes:
17406 
   - itemId
17407 
  """
17408 
 
17409 
  thrift_spec = (
17410 
    None, # 0
17411 
    (1, TType.I64, 'itemId', None, None, ), # 1
17412 
  )
17413 
 
17414 
  def __init__(self, itemId=None,):
17415 
    self.itemId = itemId
17416 
 
17417 
  def read(self, iprot):
17418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17420 
      return
17421 
    iprot.readStructBegin()
17422 
    while True:
17423 
      (fname, ftype, fid) = iprot.readFieldBegin()
17424 
      if ftype == TType.STOP:
17425 
        break
17426 
      if fid == 1:
17427 
        if ftype == TType.I64:
17428 
          self.itemId = iprot.readI64();
17429 
        else:
17430 
          iprot.skip(ftype)
17431 
      else:
17432 
        iprot.skip(ftype)
17433 
      iprot.readFieldEnd()
17434 
    iprot.readStructEnd()
17435 
 
17436 
  def write(self, oprot):
17437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17439 
      return
17440 
    oprot.writeStructBegin('getAllItemVouchers_args')
17441 
    if self.itemId is not None:
17442 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17443 
      oprot.writeI64(self.itemId)
17444 
      oprot.writeFieldEnd()
17445 
    oprot.writeFieldStop()
17446 
    oprot.writeStructEnd()
17447 
 
17448 
  def validate(self):
17449 
    return
17450 
 
17451 
 
17452 
  def __repr__(self):
17453 
    L = ['%s=%r' % (key, value)
17454 
      for key, value in self.__dict__.iteritems()]
17455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17456 
 
17457 
  def __eq__(self, other):
17458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17459 
 
17460 
  def __ne__(self, other):
17461 
    return not (self == other)
17462 
 
17463 
class getAllItemVouchers_result:
17464 
  """
17465 
  Attributes:
17466 
   - success
17467 
  """
17468 
 
17469 
  thrift_spec = (
17470 
    (0, TType.LIST, 'success', (TType.STRUCT,(VoucherItemMapping, VoucherItemMapping.thrift_spec)), None, ), # 0
17471 
  )
17472 
 
17473 
  def __init__(self, success=None,):
17474 
    self.success = success
17475 
 
17476 
  def read(self, iprot):
17477 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17478 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17479 
      return
17480 
    iprot.readStructBegin()
17481 
    while True:
17482 
      (fname, ftype, fid) = iprot.readFieldBegin()
17483 
      if ftype == TType.STOP:
17484 
        break
17485 
      if fid == 0:
17486 
        if ftype == TType.LIST:
17487 
          self.success = []
9155 kshitij.so 17488 
          (_etype363, _size360) = iprot.readListBegin()
17489 
          for _i364 in xrange(_size360):
17490 
            _elem365 = VoucherItemMapping()
17491 
            _elem365.read(iprot)
17492 
            self.success.append(_elem365)
5944 mandeep.dh 17493 
          iprot.readListEnd()
17494 
        else:
17495 
          iprot.skip(ftype)
17496 
      else:
17497 
        iprot.skip(ftype)
17498 
      iprot.readFieldEnd()
17499 
    iprot.readStructEnd()
17500 
 
17501 
  def write(self, oprot):
17502 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17503 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17504 
      return
17505 
    oprot.writeStructBegin('getAllItemVouchers_result')
17506 
    if self.success is not None:
17507 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17508 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 17509 
      for iter366 in self.success:
17510 
        iter366.write(oprot)
5944 mandeep.dh 17511 
      oprot.writeListEnd()
17512 
      oprot.writeFieldEnd()
17513 
    oprot.writeFieldStop()
17514 
    oprot.writeStructEnd()
17515 
 
17516 
  def validate(self):
17517 
    return
17518 
 
17519 
 
17520 
  def __repr__(self):
17521 
    L = ['%s=%r' % (key, value)
17522 
      for key, value in self.__dict__.iteritems()]
17523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17524 
 
17525 
  def __eq__(self, other):
17526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17527 
 
17528 
  def __ne__(self, other):
17529 
    return not (self == other)
17530 
 
17531 
class isValidCatalogItemId_args:
17532 
  """
17533 
  Attributes:
17534 
   - catalog_item_id
17535 
  """
17536 
 
17537 
  thrift_spec = (
17538 
    None, # 0
17539 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
17540 
  )
17541 
 
17542 
  def __init__(self, catalog_item_id=None,):
17543 
    self.catalog_item_id = catalog_item_id
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 == 1:
17555 
        if ftype == TType.I64:
17556 
          self.catalog_item_id = iprot.readI64();
17557 
        else:
17558 
          iprot.skip(ftype)
17559 
      else:
17560 
        iprot.skip(ftype)
17561 
      iprot.readFieldEnd()
17562 
    iprot.readStructEnd()
17563 
 
17564 
  def write(self, oprot):
17565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17567 
      return
17568 
    oprot.writeStructBegin('isValidCatalogItemId_args')
17569 
    if self.catalog_item_id is not None:
17570 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
17571 
      oprot.writeI64(self.catalog_item_id)
17572 
      oprot.writeFieldEnd()
17573 
    oprot.writeFieldStop()
17574 
    oprot.writeStructEnd()
17575 
 
17576 
  def validate(self):
17577 
    return
17578 
 
17579 
 
17580 
  def __repr__(self):
17581 
    L = ['%s=%r' % (key, value)
17582 
      for key, value in self.__dict__.iteritems()]
17583 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17584 
 
17585 
  def __eq__(self, other):
17586 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17587 
 
17588 
  def __ne__(self, other):
17589 
    return not (self == other)
17590 
 
17591 
class isValidCatalogItemId_result:
17592 
  """
17593 
  Attributes:
17594 
   - success
17595 
  """
17596 
 
17597 
  thrift_spec = (
17598 
    (0, TType.BOOL, 'success', None, None, ), # 0
17599 
  )
17600 
 
17601 
  def __init__(self, success=None,):
17602 
    self.success = success
17603 
 
17604 
  def read(self, iprot):
17605 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17606 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17607 
      return
17608 
    iprot.readStructBegin()
17609 
    while True:
17610 
      (fname, ftype, fid) = iprot.readFieldBegin()
17611 
      if ftype == TType.STOP:
17612 
        break
17613 
      if fid == 0:
17614 
        if ftype == TType.BOOL:
17615 
          self.success = iprot.readBool();
17616 
        else:
17617 
          iprot.skip(ftype)
17618 
      else:
17619 
        iprot.skip(ftype)
17620 
      iprot.readFieldEnd()
17621 
    iprot.readStructEnd()
17622 
 
17623 
  def write(self, oprot):
17624 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17625 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17626 
      return
17627 
    oprot.writeStructBegin('isValidCatalogItemId_result')
17628 
    if self.success is not None:
17629 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17630 
      oprot.writeBool(self.success)
17631 
      oprot.writeFieldEnd()
17632 
    oprot.writeFieldStop()
17633 
    oprot.writeStructEnd()
17634 
 
17635 
  def validate(self):
17636 
    return
17637 
 
17638 
 
17639 
  def __repr__(self):
17640 
    L = ['%s=%r' % (key, value)
17641 
      for key, value in self.__dict__.iteritems()]
17642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17643 
 
17644 
  def __eq__(self, other):
17645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17646 
 
17647 
  def __ne__(self, other):
17648 
    return not (self == other)
6039 amit.gupta 17649 
 
17650 
class getVatPercentageForItem_args:
17651 
  """
17652 
  Attributes:
17653 
   - itemId
7330 amit.gupta 17654 
   - stateId
6039 amit.gupta 17655 
   - price
17656 
  """
17657 
 
17658 
  thrift_spec = (
17659 
    None, # 0
17660 
    (1, TType.I64, 'itemId', None, None, ), # 1
7330 amit.gupta 17661 
    (2, TType.I64, 'stateId', None, None, ), # 2
17662 
    (3, TType.DOUBLE, 'price', None, None, ), # 3
6039 amit.gupta 17663 
  )
17664 
 
7330 amit.gupta 17665 
  def __init__(self, itemId=None, stateId=None, price=None,):
6039 amit.gupta 17666 
    self.itemId = itemId
7330 amit.gupta 17667 
    self.stateId = stateId
6039 amit.gupta 17668 
    self.price = price
17669 
 
17670 
  def read(self, iprot):
17671 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17672 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17673 
      return
17674 
    iprot.readStructBegin()
17675 
    while True:
17676 
      (fname, ftype, fid) = iprot.readFieldBegin()
17677 
      if ftype == TType.STOP:
17678 
        break
17679 
      if fid == 1:
17680 
        if ftype == TType.I64:
17681 
          self.itemId = iprot.readI64();
17682 
        else:
17683 
          iprot.skip(ftype)
17684 
      elif fid == 2:
7330 amit.gupta 17685 
        if ftype == TType.I64:
17686 
          self.stateId = iprot.readI64();
17687 
        else:
17688 
          iprot.skip(ftype)
17689 
      elif fid == 3:
6039 amit.gupta 17690 
        if ftype == TType.DOUBLE:
17691 
          self.price = iprot.readDouble();
17692 
        else:
17693 
          iprot.skip(ftype)
17694 
      else:
17695 
        iprot.skip(ftype)
17696 
      iprot.readFieldEnd()
17697 
    iprot.readStructEnd()
17698 
 
17699 
  def write(self, oprot):
17700 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17701 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17702 
      return
17703 
    oprot.writeStructBegin('getVatPercentageForItem_args')
17704 
    if self.itemId is not None:
17705 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17706 
      oprot.writeI64(self.itemId)
17707 
      oprot.writeFieldEnd()
7330 amit.gupta 17708 
    if self.stateId is not None:
17709 
      oprot.writeFieldBegin('stateId', TType.I64, 2)
17710 
      oprot.writeI64(self.stateId)
17711 
      oprot.writeFieldEnd()
6039 amit.gupta 17712 
    if self.price is not None:
7330 amit.gupta 17713 
      oprot.writeFieldBegin('price', TType.DOUBLE, 3)
6039 amit.gupta 17714 
      oprot.writeDouble(self.price)
17715 
      oprot.writeFieldEnd()
17716 
    oprot.writeFieldStop()
17717 
    oprot.writeStructEnd()
17718 
 
17719 
  def validate(self):
17720 
    return
17721 
 
17722 
 
17723 
  def __repr__(self):
17724 
    L = ['%s=%r' % (key, value)
17725 
      for key, value in self.__dict__.iteritems()]
17726 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17727 
 
17728 
  def __eq__(self, other):
17729 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17730 
 
17731 
  def __ne__(self, other):
17732 
    return not (self == other)
17733 
 
17734 
class getVatPercentageForItem_result:
17735 
  """
17736 
  Attributes:
17737 
   - success
7340 amit.gupta 17738 
   - cex
6039 amit.gupta 17739 
  """
17740 
 
17741 
  thrift_spec = (
17742 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
7340 amit.gupta 17743 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6039 amit.gupta 17744 
  )
17745 
 
7340 amit.gupta 17746 
  def __init__(self, success=None, cex=None,):
6039 amit.gupta 17747 
    self.success = success
7340 amit.gupta 17748 
    self.cex = cex
6039 amit.gupta 17749 
 
17750 
  def read(self, iprot):
17751 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17752 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17753 
      return
17754 
    iprot.readStructBegin()
17755 
    while True:
17756 
      (fname, ftype, fid) = iprot.readFieldBegin()
17757 
      if ftype == TType.STOP:
17758 
        break
17759 
      if fid == 0:
17760 
        if ftype == TType.DOUBLE:
17761 
          self.success = iprot.readDouble();
17762 
        else:
17763 
          iprot.skip(ftype)
7340 amit.gupta 17764 
      elif fid == 1:
17765 
        if ftype == TType.STRUCT:
17766 
          self.cex = CatalogServiceException()
17767 
          self.cex.read(iprot)
17768 
        else:
17769 
          iprot.skip(ftype)
6039 amit.gupta 17770 
      else:
17771 
        iprot.skip(ftype)
17772 
      iprot.readFieldEnd()
17773 
    iprot.readStructEnd()
17774 
 
17775 
  def write(self, oprot):
17776 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17777 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17778 
      return
17779 
    oprot.writeStructBegin('getVatPercentageForItem_result')
17780 
    if self.success is not None:
17781 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
17782 
      oprot.writeDouble(self.success)
17783 
      oprot.writeFieldEnd()
7340 amit.gupta 17784 
    if self.cex is not None:
17785 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17786 
      self.cex.write(oprot)
17787 
      oprot.writeFieldEnd()
6039 amit.gupta 17788 
    oprot.writeFieldStop()
17789 
    oprot.writeStructEnd()
17790 
 
17791 
  def validate(self):
17792 
    return
17793 
 
17794 
 
17795 
  def __repr__(self):
17796 
    L = ['%s=%r' % (key, value)
17797 
      for key, value in self.__dict__.iteritems()]
17798 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17799 
 
17800 
  def __eq__(self, other):
17801 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17802 
 
17803 
  def __ne__(self, other):
17804 
    return not (self == other)
17805 
 
17806 
class getVatAmountForItem_args:
17807 
  """
17808 
  Attributes:
17809 
   - itemId
17810 
   - price
17811 
  """
17812 
 
17813 
  thrift_spec = (
17814 
    None, # 0
17815 
    (1, TType.I64, 'itemId', None, None, ), # 1
17816 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
17817 
  )
17818 
 
17819 
  def __init__(self, itemId=None, price=None,):
17820 
    self.itemId = itemId
17821 
    self.price = price
17822 
 
17823 
  def read(self, iprot):
17824 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17825 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17826 
      return
17827 
    iprot.readStructBegin()
17828 
    while True:
17829 
      (fname, ftype, fid) = iprot.readFieldBegin()
17830 
      if ftype == TType.STOP:
17831 
        break
17832 
      if fid == 1:
17833 
        if ftype == TType.I64:
17834 
          self.itemId = iprot.readI64();
17835 
        else:
17836 
          iprot.skip(ftype)
17837 
      elif fid == 2:
17838 
        if ftype == TType.DOUBLE:
17839 
          self.price = iprot.readDouble();
17840 
        else:
17841 
          iprot.skip(ftype)
17842 
      else:
17843 
        iprot.skip(ftype)
17844 
      iprot.readFieldEnd()
17845 
    iprot.readStructEnd()
17846 
 
17847 
  def write(self, oprot):
17848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17850 
      return
17851 
    oprot.writeStructBegin('getVatAmountForItem_args')
17852 
    if self.itemId is not None:
17853 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17854 
      oprot.writeI64(self.itemId)
17855 
      oprot.writeFieldEnd()
17856 
    if self.price is not None:
17857 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
17858 
      oprot.writeDouble(self.price)
17859 
      oprot.writeFieldEnd()
17860 
    oprot.writeFieldStop()
17861 
    oprot.writeStructEnd()
17862 
 
17863 
  def validate(self):
17864 
    return
17865 
 
17866 
 
17867 
  def __repr__(self):
17868 
    L = ['%s=%r' % (key, value)
17869 
      for key, value in self.__dict__.iteritems()]
17870 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17871 
 
17872 
  def __eq__(self, other):
17873 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17874 
 
17875 
  def __ne__(self, other):
17876 
    return not (self == other)
17877 
 
17878 
class getVatAmountForItem_result:
17879 
  """
17880 
  Attributes:
17881 
   - success
17882 
  """
17883 
 
17884 
  thrift_spec = (
17885 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
17886 
  )
17887 
 
17888 
  def __init__(self, success=None,):
17889 
    self.success = success
17890 
 
17891 
  def read(self, iprot):
17892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17894 
      return
17895 
    iprot.readStructBegin()
17896 
    while True:
17897 
      (fname, ftype, fid) = iprot.readFieldBegin()
17898 
      if ftype == TType.STOP:
17899 
        break
17900 
      if fid == 0:
17901 
        if ftype == TType.DOUBLE:
17902 
          self.success = iprot.readDouble();
17903 
        else:
17904 
          iprot.skip(ftype)
17905 
      else:
17906 
        iprot.skip(ftype)
17907 
      iprot.readFieldEnd()
17908 
    iprot.readStructEnd()
17909 
 
17910 
  def write(self, oprot):
17911 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17912 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17913 
      return
17914 
    oprot.writeStructBegin('getVatAmountForItem_result')
17915 
    if self.success is not None:
17916 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
17917 
      oprot.writeDouble(self.success)
17918 
      oprot.writeFieldEnd()
17919 
    oprot.writeFieldStop()
17920 
    oprot.writeStructEnd()
17921 
 
17922 
  def validate(self):
17923 
    return
17924 
 
17925 
 
17926 
  def __repr__(self):
17927 
    L = ['%s=%r' % (key, value)
17928 
      for key, value in self.__dict__.iteritems()]
17929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17930 
 
17931 
  def __eq__(self, other):
17932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17933 
 
17934 
  def __ne__(self, other):
17935 
    return not (self == other)
6531 vikram.rag 17936 
 
17937 
class getAllIgnoredInventoryUpdateItemsList_args:
17938 
  """
17939 
  Attributes:
17940 
   - offset
17941 
   - limit
17942 
  """
17943 
 
17944 
  thrift_spec = (
17945 
    None, # 0
17946 
    (1, TType.I32, 'offset', None, None, ), # 1
17947 
    (2, TType.I32, 'limit', None, None, ), # 2
17948 
  )
17949 
 
17950 
  def __init__(self, offset=None, limit=None,):
17951 
    self.offset = offset
17952 
    self.limit = limit
17953 
 
17954 
  def read(self, iprot):
17955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17957 
      return
17958 
    iprot.readStructBegin()
17959 
    while True:
17960 
      (fname, ftype, fid) = iprot.readFieldBegin()
17961 
      if ftype == TType.STOP:
17962 
        break
17963 
      if fid == 1:
17964 
        if ftype == TType.I32:
17965 
          self.offset = iprot.readI32();
17966 
        else:
17967 
          iprot.skip(ftype)
17968 
      elif fid == 2:
17969 
        if ftype == TType.I32:
17970 
          self.limit = iprot.readI32();
17971 
        else:
17972 
          iprot.skip(ftype)
17973 
      else:
17974 
        iprot.skip(ftype)
17975 
      iprot.readFieldEnd()
17976 
    iprot.readStructEnd()
17977 
 
17978 
  def write(self, oprot):
17979 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17980 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17981 
      return
17982 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_args')
17983 
    if self.offset is not None:
17984 
      oprot.writeFieldBegin('offset', TType.I32, 1)
17985 
      oprot.writeI32(self.offset)
17986 
      oprot.writeFieldEnd()
17987 
    if self.limit is not None:
17988 
      oprot.writeFieldBegin('limit', TType.I32, 2)
17989 
      oprot.writeI32(self.limit)
17990 
      oprot.writeFieldEnd()
17991 
    oprot.writeFieldStop()
17992 
    oprot.writeStructEnd()
17993 
 
17994 
  def validate(self):
17995 
    return
17996 
 
17997 
 
17998 
  def __repr__(self):
17999 
    L = ['%s=%r' % (key, value)
18000 
      for key, value in self.__dict__.iteritems()]
18001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18002 
 
18003 
  def __eq__(self, other):
18004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18005 
 
18006 
  def __ne__(self, other):
18007 
    return not (self == other)
18008 
 
18009 
class getAllIgnoredInventoryUpdateItemsList_result:
18010 
  """
18011 
  Attributes:
18012 
   - success
18013 
  """
18014 
 
18015 
  thrift_spec = (
18016 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
18017 
  )
18018 
 
18019 
  def __init__(self, success=None,):
18020 
    self.success = success
18021 
 
18022 
  def read(self, iprot):
18023 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18024 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18025 
      return
18026 
    iprot.readStructBegin()
18027 
    while True:
18028 
      (fname, ftype, fid) = iprot.readFieldBegin()
18029 
      if ftype == TType.STOP:
18030 
        break
18031 
      if fid == 0:
18032 
        if ftype == TType.LIST:
18033 
          self.success = []
9155 kshitij.so 18034 
          (_etype370, _size367) = iprot.readListBegin()
18035 
          for _i371 in xrange(_size367):
18036 
            _elem372 = Item()
18037 
            _elem372.read(iprot)
18038 
            self.success.append(_elem372)
6531 vikram.rag 18039 
          iprot.readListEnd()
18040 
        else:
18041 
          iprot.skip(ftype)
18042 
      else:
18043 
        iprot.skip(ftype)
18044 
      iprot.readFieldEnd()
18045 
    iprot.readStructEnd()
18046 
 
18047 
  def write(self, oprot):
18048 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18049 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18050 
      return
18051 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_result')
18052 
    if self.success is not None:
18053 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18054 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18055 
      for iter373 in self.success:
18056 
        iter373.write(oprot)
6531 vikram.rag 18057 
      oprot.writeListEnd()
18058 
      oprot.writeFieldEnd()
18059 
    oprot.writeFieldStop()
18060 
    oprot.writeStructEnd()
18061 
 
18062 
  def validate(self):
18063 
    return
18064 
 
18065 
 
18066 
  def __repr__(self):
18067 
    L = ['%s=%r' % (key, value)
18068 
      for key, value in self.__dict__.iteritems()]
18069 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18070 
 
18071 
  def __eq__(self, other):
18072 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18073 
 
18074 
  def __ne__(self, other):
18075 
    return not (self == other)
6805 anupam.sin 18076 
 
6821 amar.kumar 18077 
class getAllAliveItems_args:
18078 
 
18079 
  thrift_spec = (
18080 
  )
18081 
 
18082 
  def read(self, iprot):
18083 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18084 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18085 
      return
18086 
    iprot.readStructBegin()
18087 
    while True:
18088 
      (fname, ftype, fid) = iprot.readFieldBegin()
18089 
      if ftype == TType.STOP:
18090 
        break
18091 
      else:
18092 
        iprot.skip(ftype)
18093 
      iprot.readFieldEnd()
18094 
    iprot.readStructEnd()
18095 
 
18096 
  def write(self, oprot):
18097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18099 
      return
18100 
    oprot.writeStructBegin('getAllAliveItems_args')
18101 
    oprot.writeFieldStop()
18102 
    oprot.writeStructEnd()
18103 
 
18104 
  def validate(self):
18105 
    return
18106 
 
18107 
 
18108 
  def __repr__(self):
18109 
    L = ['%s=%r' % (key, value)
18110 
      for key, value in self.__dict__.iteritems()]
18111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18112 
 
18113 
  def __eq__(self, other):
18114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18115 
 
18116 
  def __ne__(self, other):
18117 
    return not (self == other)
18118 
 
18119 
class getAllAliveItems_result:
18120 
  """
18121 
  Attributes:
18122 
   - success
18123 
  """
18124 
 
18125 
  thrift_spec = (
18126 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
18127 
  )
18128 
 
18129 
  def __init__(self, success=None,):
18130 
    self.success = success
18131 
 
18132 
  def read(self, iprot):
18133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18135 
      return
18136 
    iprot.readStructBegin()
18137 
    while True:
18138 
      (fname, ftype, fid) = iprot.readFieldBegin()
18139 
      if ftype == TType.STOP:
18140 
        break
18141 
      if fid == 0:
18142 
        if ftype == TType.LIST:
18143 
          self.success = []
9155 kshitij.so 18144 
          (_etype377, _size374) = iprot.readListBegin()
18145 
          for _i378 in xrange(_size374):
18146 
            _elem379 = Item()
18147 
            _elem379.read(iprot)
18148 
            self.success.append(_elem379)
6821 amar.kumar 18149 
          iprot.readListEnd()
18150 
        else:
18151 
          iprot.skip(ftype)
18152 
      else:
18153 
        iprot.skip(ftype)
18154 
      iprot.readFieldEnd()
18155 
    iprot.readStructEnd()
18156 
 
18157 
  def write(self, oprot):
18158 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18159 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18160 
      return
18161 
    oprot.writeStructBegin('getAllAliveItems_result')
18162 
    if self.success is not None:
18163 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18164 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18165 
      for iter380 in self.success:
18166 
        iter380.write(oprot)
6821 amar.kumar 18167 
      oprot.writeListEnd()
18168 
      oprot.writeFieldEnd()
18169 
    oprot.writeFieldStop()
18170 
    oprot.writeStructEnd()
18171 
 
18172 
  def validate(self):
18173 
    return
18174 
 
18175 
 
18176 
  def __repr__(self):
18177 
    L = ['%s=%r' % (key, value)
18178 
      for key, value in self.__dict__.iteritems()]
18179 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18180 
 
18181 
  def __eq__(self, other):
18182 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18183 
 
18184 
  def __ne__(self, other):
18185 
    return not (self == other)
18186 
 
6805 anupam.sin 18187 
class getInsuranceAmount_args:
18188 
  """
18189 
  Attributes:
18190 
   - itemId
6921 anupam.sin 18191 
   - price
6805 anupam.sin 18192 
   - insurerId
18193 
   - quantity
18194 
  """
18195 
 
18196 
  thrift_spec = (
18197 
    None, # 0
18198 
    (1, TType.I64, 'itemId', None, None, ), # 1
6921 anupam.sin 18199 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
18200 
    (3, TType.I64, 'insurerId', None, None, ), # 3
18201 
    (4, TType.I64, 'quantity', None, None, ), # 4
6805 anupam.sin 18202 
  )
18203 
 
6921 anupam.sin 18204 
  def __init__(self, itemId=None, price=None, insurerId=None, quantity=None,):
6805 anupam.sin 18205 
    self.itemId = itemId
6921 anupam.sin 18206 
    self.price = price
6805 anupam.sin 18207 
    self.insurerId = insurerId
18208 
    self.quantity = quantity
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 == 1:
18220 
        if ftype == TType.I64:
18221 
          self.itemId = iprot.readI64();
18222 
        else:
18223 
          iprot.skip(ftype)
18224 
      elif fid == 2:
6921 anupam.sin 18225 
        if ftype == TType.DOUBLE:
18226 
          self.price = iprot.readDouble();
18227 
        else:
18228 
          iprot.skip(ftype)
18229 
      elif fid == 3:
6805 anupam.sin 18230 
        if ftype == TType.I64:
18231 
          self.insurerId = iprot.readI64();
18232 
        else:
18233 
          iprot.skip(ftype)
6921 anupam.sin 18234 
      elif fid == 4:
6805 anupam.sin 18235 
        if ftype == TType.I64:
18236 
          self.quantity = iprot.readI64();
18237 
        else:
18238 
          iprot.skip(ftype)
18239 
      else:
18240 
        iprot.skip(ftype)
18241 
      iprot.readFieldEnd()
18242 
    iprot.readStructEnd()
18243 
 
18244 
  def write(self, oprot):
18245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18247 
      return
18248 
    oprot.writeStructBegin('getInsuranceAmount_args')
18249 
    if self.itemId is not None:
18250 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18251 
      oprot.writeI64(self.itemId)
18252 
      oprot.writeFieldEnd()
6921 anupam.sin 18253 
    if self.price is not None:
18254 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
18255 
      oprot.writeDouble(self.price)
18256 
      oprot.writeFieldEnd()
6805 anupam.sin 18257 
    if self.insurerId is not None:
6921 anupam.sin 18258 
      oprot.writeFieldBegin('insurerId', TType.I64, 3)
6805 anupam.sin 18259 
      oprot.writeI64(self.insurerId)
18260 
      oprot.writeFieldEnd()
18261 
    if self.quantity is not None:
6921 anupam.sin 18262 
      oprot.writeFieldBegin('quantity', TType.I64, 4)
6805 anupam.sin 18263 
      oprot.writeI64(self.quantity)
18264 
      oprot.writeFieldEnd()
18265 
    oprot.writeFieldStop()
18266 
    oprot.writeStructEnd()
18267 
 
18268 
  def validate(self):
18269 
    return
18270 
 
18271 
 
18272 
  def __repr__(self):
18273 
    L = ['%s=%r' % (key, value)
18274 
      for key, value in self.__dict__.iteritems()]
18275 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18276 
 
18277 
  def __eq__(self, other):
18278 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18279 
 
18280 
  def __ne__(self, other):
18281 
    return not (self == other)
18282 
 
18283 
class getInsuranceAmount_result:
18284 
  """
18285 
  Attributes:
18286 
   - success
18287 
  """
18288 
 
18289 
  thrift_spec = (
18290 
    (0, TType.I64, 'success', None, None, ), # 0
18291 
  )
18292 
 
18293 
  def __init__(self, success=None,):
18294 
    self.success = success
18295 
 
18296 
  def read(self, iprot):
18297 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18298 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18299 
      return
18300 
    iprot.readStructBegin()
18301 
    while True:
18302 
      (fname, ftype, fid) = iprot.readFieldBegin()
18303 
      if ftype == TType.STOP:
18304 
        break
18305 
      if fid == 0:
18306 
        if ftype == TType.I64:
18307 
          self.success = iprot.readI64();
18308 
        else:
18309 
          iprot.skip(ftype)
18310 
      else:
18311 
        iprot.skip(ftype)
18312 
      iprot.readFieldEnd()
18313 
    iprot.readStructEnd()
18314 
 
18315 
  def write(self, oprot):
18316 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18317 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18318 
      return
18319 
    oprot.writeStructBegin('getInsuranceAmount_result')
18320 
    if self.success is not None:
18321 
      oprot.writeFieldBegin('success', TType.I64, 0)
18322 
      oprot.writeI64(self.success)
18323 
      oprot.writeFieldEnd()
18324 
    oprot.writeFieldStop()
18325 
    oprot.writeStructEnd()
18326 
 
18327 
  def validate(self):
18328 
    return
18329 
 
18330 
 
18331 
  def __repr__(self):
18332 
    L = ['%s=%r' % (key, value)
18333 
      for key, value in self.__dict__.iteritems()]
18334 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18335 
 
18336 
  def __eq__(self, other):
18337 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18338 
 
18339 
  def __ne__(self, other):
18340 
    return not (self == other)
18341 
 
18342 
class getInsurer_args:
18343 
  """
18344 
  Attributes:
18345 
   - insurerId
18346 
  """
18347 
 
18348 
  thrift_spec = (
18349 
    None, # 0
18350 
    (1, TType.I64, 'insurerId', None, None, ), # 1
18351 
  )
18352 
 
18353 
  def __init__(self, insurerId=None,):
18354 
    self.insurerId = insurerId
18355 
 
18356 
  def read(self, iprot):
18357 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18358 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18359 
      return
18360 
    iprot.readStructBegin()
18361 
    while True:
18362 
      (fname, ftype, fid) = iprot.readFieldBegin()
18363 
      if ftype == TType.STOP:
18364 
        break
18365 
      if fid == 1:
18366 
        if ftype == TType.I64:
18367 
          self.insurerId = iprot.readI64();
18368 
        else:
18369 
          iprot.skip(ftype)
18370 
      else:
18371 
        iprot.skip(ftype)
18372 
      iprot.readFieldEnd()
18373 
    iprot.readStructEnd()
18374 
 
18375 
  def write(self, oprot):
18376 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18377 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18378 
      return
18379 
    oprot.writeStructBegin('getInsurer_args')
18380 
    if self.insurerId is not None:
18381 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
18382 
      oprot.writeI64(self.insurerId)
18383 
      oprot.writeFieldEnd()
18384 
    oprot.writeFieldStop()
18385 
    oprot.writeStructEnd()
18386 
 
18387 
  def validate(self):
18388 
    return
18389 
 
18390 
 
18391 
  def __repr__(self):
18392 
    L = ['%s=%r' % (key, value)
18393 
      for key, value in self.__dict__.iteritems()]
18394 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18395 
 
18396 
  def __eq__(self, other):
18397 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18398 
 
18399 
  def __ne__(self, other):
18400 
    return not (self == other)
18401 
 
18402 
class getInsurer_result:
18403 
  """
18404 
  Attributes:
18405 
   - success
18406 
  """
18407 
 
18408 
  thrift_spec = (
18409 
    (0, TType.STRUCT, 'success', (Insurer, Insurer.thrift_spec), None, ), # 0
18410 
  )
18411 
 
18412 
  def __init__(self, success=None,):
18413 
    self.success = success
18414 
 
18415 
  def read(self, iprot):
18416 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18417 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18418 
      return
18419 
    iprot.readStructBegin()
18420 
    while True:
18421 
      (fname, ftype, fid) = iprot.readFieldBegin()
18422 
      if ftype == TType.STOP:
18423 
        break
18424 
      if fid == 0:
18425 
        if ftype == TType.STRUCT:
18426 
          self.success = Insurer()
18427 
          self.success.read(iprot)
18428 
        else:
18429 
          iprot.skip(ftype)
18430 
      else:
18431 
        iprot.skip(ftype)
18432 
      iprot.readFieldEnd()
18433 
    iprot.readStructEnd()
18434 
 
18435 
  def write(self, oprot):
18436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18438 
      return
18439 
    oprot.writeStructBegin('getInsurer_result')
18440 
    if self.success is not None:
18441 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18442 
      self.success.write(oprot)
18443 
      oprot.writeFieldEnd()
18444 
    oprot.writeFieldStop()
18445 
    oprot.writeStructEnd()
18446 
 
18447 
  def validate(self):
18448 
    return
18449 
 
18450 
 
18451 
  def __repr__(self):
18452 
    L = ['%s=%r' % (key, value)
18453 
      for key, value in self.__dict__.iteritems()]
18454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18455 
 
18456 
  def __eq__(self, other):
18457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18458 
 
18459 
  def __ne__(self, other):
18460 
    return not (self == other)
6838 vikram.rag 18461 
 
18462 
class getAllInsurers_args:
18463 
 
18464 
  thrift_spec = (
18465 
  )
18466 
 
18467 
  def read(self, iprot):
18468 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18469 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18470 
      return
18471 
    iprot.readStructBegin()
18472 
    while True:
18473 
      (fname, ftype, fid) = iprot.readFieldBegin()
18474 
      if ftype == TType.STOP:
18475 
        break
18476 
      else:
18477 
        iprot.skip(ftype)
18478 
      iprot.readFieldEnd()
18479 
    iprot.readStructEnd()
18480 
 
18481 
  def write(self, oprot):
18482 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18483 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18484 
      return
18485 
    oprot.writeStructBegin('getAllInsurers_args')
18486 
    oprot.writeFieldStop()
18487 
    oprot.writeStructEnd()
18488 
 
18489 
  def validate(self):
18490 
    return
18491 
 
18492 
 
18493 
  def __repr__(self):
18494 
    L = ['%s=%r' % (key, value)
18495 
      for key, value in self.__dict__.iteritems()]
18496 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18497 
 
18498 
  def __eq__(self, other):
18499 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18500 
 
18501 
  def __ne__(self, other):
18502 
    return not (self == other)
18503 
 
18504 
class getAllInsurers_result:
18505 
  """
18506 
  Attributes:
18507 
   - success
18508 
  """
18509 
 
18510 
  thrift_spec = (
18511 
    (0, TType.LIST, 'success', (TType.STRUCT,(Insurer, Insurer.thrift_spec)), None, ), # 0
18512 
  )
18513 
 
18514 
  def __init__(self, success=None,):
18515 
    self.success = success
18516 
 
18517 
  def read(self, iprot):
18518 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18519 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18520 
      return
18521 
    iprot.readStructBegin()
18522 
    while True:
18523 
      (fname, ftype, fid) = iprot.readFieldBegin()
18524 
      if ftype == TType.STOP:
18525 
        break
18526 
      if fid == 0:
18527 
        if ftype == TType.LIST:
18528 
          self.success = []
9155 kshitij.so 18529 
          (_etype384, _size381) = iprot.readListBegin()
18530 
          for _i385 in xrange(_size381):
18531 
            _elem386 = Insurer()
18532 
            _elem386.read(iprot)
18533 
            self.success.append(_elem386)
6838 vikram.rag 18534 
          iprot.readListEnd()
18535 
        else:
18536 
          iprot.skip(ftype)
18537 
      else:
18538 
        iprot.skip(ftype)
18539 
      iprot.readFieldEnd()
18540 
    iprot.readStructEnd()
18541 
 
18542 
  def write(self, oprot):
18543 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18544 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18545 
      return
18546 
    oprot.writeStructBegin('getAllInsurers_result')
18547 
    if self.success is not None:
18548 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18549 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18550 
      for iter387 in self.success:
18551 
        iter387.write(oprot)
6838 vikram.rag 18552 
      oprot.writeListEnd()
18553 
      oprot.writeFieldEnd()
18554 
    oprot.writeFieldStop()
18555 
    oprot.writeStructEnd()
18556 
 
18557 
  def validate(self):
18558 
    return
18559 
 
18560 
 
18561 
  def __repr__(self):
18562 
    L = ['%s=%r' % (key, value)
18563 
      for key, value in self.__dict__.iteritems()]
18564 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18565 
 
18566 
  def __eq__(self, other):
18567 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18568 
 
18569 
  def __ne__(self, other):
18570 
    return not (self == other)
6962 rajveer 18571 
 
18572 
class updateInsuranceDeclaredAmount_args:
18573 
  """
18574 
  Attributes:
18575 
   - insurerId
18576 
   - amount
18577 
  """
18578 
 
18579 
  thrift_spec = (
18580 
    None, # 0
18581 
    (1, TType.I64, 'insurerId', None, None, ), # 1
18582 
    (2, TType.DOUBLE, 'amount', None, None, ), # 2
18583 
  )
18584 
 
18585 
  def __init__(self, insurerId=None, amount=None,):
18586 
    self.insurerId = insurerId
18587 
    self.amount = amount
18588 
 
18589 
  def read(self, iprot):
18590 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18591 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18592 
      return
18593 
    iprot.readStructBegin()
18594 
    while True:
18595 
      (fname, ftype, fid) = iprot.readFieldBegin()
18596 
      if ftype == TType.STOP:
18597 
        break
18598 
      if fid == 1:
18599 
        if ftype == TType.I64:
18600 
          self.insurerId = iprot.readI64();
18601 
        else:
18602 
          iprot.skip(ftype)
18603 
      elif fid == 2:
18604 
        if ftype == TType.DOUBLE:
18605 
          self.amount = iprot.readDouble();
18606 
        else:
18607 
          iprot.skip(ftype)
18608 
      else:
18609 
        iprot.skip(ftype)
18610 
      iprot.readFieldEnd()
18611 
    iprot.readStructEnd()
18612 
 
18613 
  def write(self, oprot):
18614 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18615 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18616 
      return
18617 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_args')
18618 
    if self.insurerId is not None:
18619 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
18620 
      oprot.writeI64(self.insurerId)
18621 
      oprot.writeFieldEnd()
18622 
    if self.amount is not None:
18623 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 2)
18624 
      oprot.writeDouble(self.amount)
18625 
      oprot.writeFieldEnd()
18626 
    oprot.writeFieldStop()
18627 
    oprot.writeStructEnd()
18628 
 
18629 
  def validate(self):
18630 
    return
18631 
 
18632 
 
18633 
  def __repr__(self):
18634 
    L = ['%s=%r' % (key, value)
18635 
      for key, value in self.__dict__.iteritems()]
18636 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18637 
 
18638 
  def __eq__(self, other):
18639 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18640 
 
18641 
  def __ne__(self, other):
18642 
    return not (self == other)
18643 
 
18644 
class updateInsuranceDeclaredAmount_result:
18645 
 
18646 
  thrift_spec = (
18647 
  )
18648 
 
18649 
  def read(self, iprot):
18650 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18651 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18652 
      return
18653 
    iprot.readStructBegin()
18654 
    while True:
18655 
      (fname, ftype, fid) = iprot.readFieldBegin()
18656 
      if ftype == TType.STOP:
18657 
        break
18658 
      else:
18659 
        iprot.skip(ftype)
18660 
      iprot.readFieldEnd()
18661 
    iprot.readStructEnd()
18662 
 
18663 
  def write(self, oprot):
18664 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18665 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18666 
      return
18667 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_result')
18668 
    oprot.writeFieldStop()
18669 
    oprot.writeStructEnd()
18670 
 
18671 
  def validate(self):
18672 
    return
18673 
 
18674 
 
18675 
  def __repr__(self):
18676 
    L = ['%s=%r' % (key, value)
18677 
      for key, value in self.__dict__.iteritems()]
18678 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18679 
 
18680 
  def __eq__(self, other):
18681 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18682 
 
18683 
  def __ne__(self, other):
18684 
    return not (self == other)
7190 amar.kumar 18685 
 
18686 
class getFreebieForItem_args:
18687 
  """
18688 
  Attributes:
18689 
   - itemId
18690 
  """
18691 
 
18692 
  thrift_spec = (
18693 
    None, # 0
18694 
    (1, TType.I64, 'itemId', None, None, ), # 1
18695 
  )
18696 
 
18697 
  def __init__(self, itemId=None,):
18698 
    self.itemId = itemId
18699 
 
18700 
  def read(self, iprot):
18701 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18702 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18703 
      return
18704 
    iprot.readStructBegin()
18705 
    while True:
18706 
      (fname, ftype, fid) = iprot.readFieldBegin()
18707 
      if ftype == TType.STOP:
18708 
        break
18709 
      if fid == 1:
18710 
        if ftype == TType.I64:
18711 
          self.itemId = iprot.readI64();
18712 
        else:
18713 
          iprot.skip(ftype)
18714 
      else:
18715 
        iprot.skip(ftype)
18716 
      iprot.readFieldEnd()
18717 
    iprot.readStructEnd()
18718 
 
18719 
  def write(self, oprot):
18720 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18721 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18722 
      return
18723 
    oprot.writeStructBegin('getFreebieForItem_args')
18724 
    if self.itemId is not None:
18725 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18726 
      oprot.writeI64(self.itemId)
18727 
      oprot.writeFieldEnd()
18728 
    oprot.writeFieldStop()
18729 
    oprot.writeStructEnd()
18730 
 
18731 
  def validate(self):
18732 
    return
18733 
 
18734 
 
18735 
  def __repr__(self):
18736 
    L = ['%s=%r' % (key, value)
18737 
      for key, value in self.__dict__.iteritems()]
18738 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18739 
 
18740 
  def __eq__(self, other):
18741 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18742 
 
18743 
  def __ne__(self, other):
18744 
    return not (self == other)
18745 
 
18746 
class getFreebieForItem_result:
18747 
  """
18748 
  Attributes:
18749 
   - success
18750 
  """
18751 
 
18752 
  thrift_spec = (
18753 
    (0, TType.I64, 'success', None, None, ), # 0
18754 
  )
18755 
 
18756 
  def __init__(self, success=None,):
18757 
    self.success = success
18758 
 
18759 
  def read(self, iprot):
18760 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18761 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18762 
      return
18763 
    iprot.readStructBegin()
18764 
    while True:
18765 
      (fname, ftype, fid) = iprot.readFieldBegin()
18766 
      if ftype == TType.STOP:
18767 
        break
18768 
      if fid == 0:
18769 
        if ftype == TType.I64:
18770 
          self.success = iprot.readI64();
18771 
        else:
18772 
          iprot.skip(ftype)
18773 
      else:
18774 
        iprot.skip(ftype)
18775 
      iprot.readFieldEnd()
18776 
    iprot.readStructEnd()
18777 
 
18778 
  def write(self, oprot):
18779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18781 
      return
18782 
    oprot.writeStructBegin('getFreebieForItem_result')
18783 
    if self.success is not None:
18784 
      oprot.writeFieldBegin('success', TType.I64, 0)
18785 
      oprot.writeI64(self.success)
18786 
      oprot.writeFieldEnd()
18787 
    oprot.writeFieldStop()
18788 
    oprot.writeStructEnd()
18789 
 
18790 
  def validate(self):
18791 
    return
18792 
 
18793 
 
18794 
  def __repr__(self):
18795 
    L = ['%s=%r' % (key, value)
18796 
      for key, value in self.__dict__.iteritems()]
18797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18798 
 
18799 
  def __eq__(self, other):
18800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18801 
 
18802 
  def __ne__(self, other):
18803 
    return not (self == other)
18804 
 
18805 
class addOrUpdateFreebieForItem_args:
18806 
  """
18807 
  Attributes:
18808 
   - freebieItem
18809 
  """
18810 
 
18811 
  thrift_spec = (
18812 
    None, # 0
18813 
    (1, TType.STRUCT, 'freebieItem', (FreebieItem, FreebieItem.thrift_spec), None, ), # 1
18814 
  )
18815 
 
18816 
  def __init__(self, freebieItem=None,):
18817 
    self.freebieItem = freebieItem
18818 
 
18819 
  def read(self, iprot):
18820 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18821 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18822 
      return
18823 
    iprot.readStructBegin()
18824 
    while True:
18825 
      (fname, ftype, fid) = iprot.readFieldBegin()
18826 
      if ftype == TType.STOP:
18827 
        break
18828 
      if fid == 1:
18829 
        if ftype == TType.STRUCT:
18830 
          self.freebieItem = FreebieItem()
18831 
          self.freebieItem.read(iprot)
18832 
        else:
18833 
          iprot.skip(ftype)
18834 
      else:
18835 
        iprot.skip(ftype)
18836 
      iprot.readFieldEnd()
18837 
    iprot.readStructEnd()
18838 
 
18839 
  def write(self, oprot):
18840 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18841 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18842 
      return
18843 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_args')
18844 
    if self.freebieItem is not None:
18845 
      oprot.writeFieldBegin('freebieItem', TType.STRUCT, 1)
18846 
      self.freebieItem.write(oprot)
18847 
      oprot.writeFieldEnd()
18848 
    oprot.writeFieldStop()
18849 
    oprot.writeStructEnd()
18850 
 
18851 
  def validate(self):
18852 
    return
18853 
 
18854 
 
18855 
  def __repr__(self):
18856 
    L = ['%s=%r' % (key, value)
18857 
      for key, value in self.__dict__.iteritems()]
18858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18859 
 
18860 
  def __eq__(self, other):
18861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18862 
 
18863 
  def __ne__(self, other):
18864 
    return not (self == other)
18865 
 
18866 
class addOrUpdateFreebieForItem_result:
18867 
 
18868 
  thrift_spec = (
18869 
  )
18870 
 
18871 
  def read(self, iprot):
18872 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18873 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18874 
      return
18875 
    iprot.readStructBegin()
18876 
    while True:
18877 
      (fname, ftype, fid) = iprot.readFieldBegin()
18878 
      if ftype == TType.STOP:
18879 
        break
18880 
      else:
18881 
        iprot.skip(ftype)
18882 
      iprot.readFieldEnd()
18883 
    iprot.readStructEnd()
18884 
 
18885 
  def write(self, oprot):
18886 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18887 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18888 
      return
18889 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_result')
18890 
    oprot.writeFieldStop()
18891 
    oprot.writeStructEnd()
18892 
 
18893 
  def validate(self):
18894 
    return
18895 
 
18896 
 
18897 
  def __repr__(self):
18898 
    L = ['%s=%r' % (key, value)
18899 
      for key, value in self.__dict__.iteritems()]
18900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18901 
 
18902 
  def __eq__(self, other):
18903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18904 
 
18905 
  def __ne__(self, other):
18906 
    return not (self == other)
7256 rajveer 18907 
 
7272 amit.gupta 18908 
class addOrUpdateBrandInfo_args:
18909 
  """
18910 
  Attributes:
18911 
   - brandInfo
18912 
  """
18913 
 
18914 
  thrift_spec = (
18915 
    None, # 0
18916 
    (1, TType.STRUCT, 'brandInfo', (BrandInfo, BrandInfo.thrift_spec), None, ), # 1
18917 
  )
18918 
 
18919 
  def __init__(self, brandInfo=None,):
18920 
    self.brandInfo = brandInfo
18921 
 
18922 
  def read(self, iprot):
18923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18925 
      return
18926 
    iprot.readStructBegin()
18927 
    while True:
18928 
      (fname, ftype, fid) = iprot.readFieldBegin()
18929 
      if ftype == TType.STOP:
18930 
        break
18931 
      if fid == 1:
18932 
        if ftype == TType.STRUCT:
18933 
          self.brandInfo = BrandInfo()
18934 
          self.brandInfo.read(iprot)
18935 
        else:
18936 
          iprot.skip(ftype)
18937 
      else:
18938 
        iprot.skip(ftype)
18939 
      iprot.readFieldEnd()
18940 
    iprot.readStructEnd()
18941 
 
18942 
  def write(self, oprot):
18943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18945 
      return
18946 
    oprot.writeStructBegin('addOrUpdateBrandInfo_args')
18947 
    if self.brandInfo is not None:
18948 
      oprot.writeFieldBegin('brandInfo', TType.STRUCT, 1)
18949 
      self.brandInfo.write(oprot)
18950 
      oprot.writeFieldEnd()
18951 
    oprot.writeFieldStop()
18952 
    oprot.writeStructEnd()
18953 
 
18954 
  def validate(self):
18955 
    return
18956 
 
18957 
 
18958 
  def __repr__(self):
18959 
    L = ['%s=%r' % (key, value)
18960 
      for key, value in self.__dict__.iteritems()]
18961 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18962 
 
18963 
  def __eq__(self, other):
18964 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18965 
 
18966 
  def __ne__(self, other):
18967 
    return not (self == other)
18968 
 
18969 
class addOrUpdateBrandInfo_result:
18970 
 
18971 
  thrift_spec = (
18972 
  )
18973 
 
18974 
  def read(self, iprot):
18975 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18976 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18977 
      return
18978 
    iprot.readStructBegin()
18979 
    while True:
18980 
      (fname, ftype, fid) = iprot.readFieldBegin()
18981 
      if ftype == TType.STOP:
18982 
        break
18983 
      else:
18984 
        iprot.skip(ftype)
18985 
      iprot.readFieldEnd()
18986 
    iprot.readStructEnd()
18987 
 
18988 
  def write(self, oprot):
18989 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18990 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18991 
      return
18992 
    oprot.writeStructBegin('addOrUpdateBrandInfo_result')
18993 
    oprot.writeFieldStop()
18994 
    oprot.writeStructEnd()
18995 
 
18996 
  def validate(self):
18997 
    return
18998 
 
18999 
 
19000 
  def __repr__(self):
19001 
    L = ['%s=%r' % (key, value)
19002 
      for key, value in self.__dict__.iteritems()]
19003 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19004 
 
19005 
  def __eq__(self, other):
19006 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19007 
 
19008 
  def __ne__(self, other):
19009 
    return not (self == other)
19010 
 
19011 
class getBrandInfo_args:
19012 
 
19013 
  thrift_spec = (
19014 
  )
19015 
 
19016 
  def read(self, iprot):
19017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19019 
      return
19020 
    iprot.readStructBegin()
19021 
    while True:
19022 
      (fname, ftype, fid) = iprot.readFieldBegin()
19023 
      if ftype == TType.STOP:
19024 
        break
19025 
      else:
19026 
        iprot.skip(ftype)
19027 
      iprot.readFieldEnd()
19028 
    iprot.readStructEnd()
19029 
 
19030 
  def write(self, oprot):
19031 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19032 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19033 
      return
19034 
    oprot.writeStructBegin('getBrandInfo_args')
19035 
    oprot.writeFieldStop()
19036 
    oprot.writeStructEnd()
19037 
 
19038 
  def validate(self):
19039 
    return
19040 
 
19041 
 
19042 
  def __repr__(self):
19043 
    L = ['%s=%r' % (key, value)
19044 
      for key, value in self.__dict__.iteritems()]
19045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19046 
 
19047 
  def __eq__(self, other):
19048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19049 
 
19050 
  def __ne__(self, other):
19051 
    return not (self == other)
19052 
 
19053 
class getBrandInfo_result:
19054 
  """
19055 
  Attributes:
19056 
   - success
19057 
  """
19058 
 
19059 
  thrift_spec = (
19060 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(BrandInfo, BrandInfo.thrift_spec)), None, ), # 0
19061 
  )
19062 
 
19063 
  def __init__(self, success=None,):
19064 
    self.success = success
19065 
 
19066 
  def read(self, iprot):
19067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19069 
      return
19070 
    iprot.readStructBegin()
19071 
    while True:
19072 
      (fname, ftype, fid) = iprot.readFieldBegin()
19073 
      if ftype == TType.STOP:
19074 
        break
19075 
      if fid == 0:
19076 
        if ftype == TType.MAP:
19077 
          self.success = {}
9155 kshitij.so 19078 
          (_ktype389, _vtype390, _size388 ) = iprot.readMapBegin()
19079 
          for _i392 in xrange(_size388):
19080 
            _key393 = iprot.readString();
19081 
            _val394 = BrandInfo()
19082 
            _val394.read(iprot)
19083 
            self.success[_key393] = _val394
7272 amit.gupta 19084 
          iprot.readMapEnd()
19085 
        else:
19086 
          iprot.skip(ftype)
19087 
      else:
19088 
        iprot.skip(ftype)
19089 
      iprot.readFieldEnd()
19090 
    iprot.readStructEnd()
19091 
 
19092 
  def write(self, oprot):
19093 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19094 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19095 
      return
19096 
    oprot.writeStructBegin('getBrandInfo_result')
19097 
    if self.success is not None:
19098 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19099 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
9155 kshitij.so 19100 
      for kiter395,viter396 in self.success.items():
19101 
        oprot.writeString(kiter395)
19102 
        viter396.write(oprot)
7272 amit.gupta 19103 
      oprot.writeMapEnd()
19104 
      oprot.writeFieldEnd()
19105 
    oprot.writeFieldStop()
19106 
    oprot.writeStructEnd()
19107 
 
19108 
  def validate(self):
19109 
    return
19110 
 
19111 
 
19112 
  def __repr__(self):
19113 
    L = ['%s=%r' % (key, value)
19114 
      for key, value in self.__dict__.iteritems()]
19115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19116 
 
19117 
  def __eq__(self, other):
19118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19119 
 
19120 
  def __ne__(self, other):
19121 
    return not (self == other)
19122 
 
7256 rajveer 19123 
class getStorePricing_args:
19124 
  """
19125 
  Attributes:
19126 
   - itemId
19127 
  """
19128 
 
19129 
  thrift_spec = (
19130 
    None, # 0
19131 
    (1, TType.I64, 'itemId', None, None, ), # 1
19132 
  )
19133 
 
19134 
  def __init__(self, itemId=None,):
19135 
    self.itemId = itemId
19136 
 
19137 
  def read(self, iprot):
19138 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19139 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19140 
      return
19141 
    iprot.readStructBegin()
19142 
    while True:
19143 
      (fname, ftype, fid) = iprot.readFieldBegin()
19144 
      if ftype == TType.STOP:
19145 
        break
19146 
      if fid == 1:
19147 
        if ftype == TType.I64:
19148 
          self.itemId = iprot.readI64();
19149 
        else:
19150 
          iprot.skip(ftype)
19151 
      else:
19152 
        iprot.skip(ftype)
19153 
      iprot.readFieldEnd()
19154 
    iprot.readStructEnd()
19155 
 
19156 
  def write(self, oprot):
19157 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19158 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19159 
      return
19160 
    oprot.writeStructBegin('getStorePricing_args')
19161 
    if self.itemId is not None:
19162 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19163 
      oprot.writeI64(self.itemId)
19164 
      oprot.writeFieldEnd()
19165 
    oprot.writeFieldStop()
19166 
    oprot.writeStructEnd()
19167 
 
19168 
  def validate(self):
19169 
    return
19170 
 
19171 
 
19172 
  def __repr__(self):
19173 
    L = ['%s=%r' % (key, value)
19174 
      for key, value in self.__dict__.iteritems()]
19175 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19176 
 
19177 
  def __eq__(self, other):
19178 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19179 
 
19180 
  def __ne__(self, other):
19181 
    return not (self == other)
19182 
 
19183 
class getStorePricing_result:
19184 
  """
19185 
  Attributes:
19186 
   - success
19187 
  """
19188 
 
19189 
  thrift_spec = (
19190 
    (0, TType.STRUCT, 'success', (StorePricing, StorePricing.thrift_spec), None, ), # 0
19191 
  )
19192 
 
19193 
  def __init__(self, success=None,):
19194 
    self.success = success
19195 
 
19196 
  def read(self, iprot):
19197 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19198 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19199 
      return
19200 
    iprot.readStructBegin()
19201 
    while True:
19202 
      (fname, ftype, fid) = iprot.readFieldBegin()
19203 
      if ftype == TType.STOP:
19204 
        break
19205 
      if fid == 0:
19206 
        if ftype == TType.STRUCT:
19207 
          self.success = StorePricing()
19208 
          self.success.read(iprot)
19209 
        else:
19210 
          iprot.skip(ftype)
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('getStorePricing_result')
19221 
    if self.success is not None:
19222 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19223 
      self.success.write(oprot)
19224 
      oprot.writeFieldEnd()
19225 
    oprot.writeFieldStop()
19226 
    oprot.writeStructEnd()
19227 
 
19228 
  def validate(self):
19229 
    return
19230 
 
19231 
 
19232 
  def __repr__(self):
19233 
    L = ['%s=%r' % (key, value)
19234 
      for key, value in self.__dict__.iteritems()]
19235 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19236 
 
19237 
  def __eq__(self, other):
19238 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19239 
 
19240 
  def __ne__(self, other):
19241 
    return not (self == other)
7265 rajveer 19242 
 
7306 rajveer 19243 
class getStorePricings_args:
19244 
  """
19245 
  Attributes:
19246 
   - itemIds
19247 
  """
19248 
 
19249 
  thrift_spec = (
19250 
    None, # 0
19251 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
19252 
  )
19253 
 
19254 
  def __init__(self, itemIds=None,):
19255 
    self.itemIds = itemIds
19256 
 
19257 
  def read(self, iprot):
19258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19260 
      return
19261 
    iprot.readStructBegin()
19262 
    while True:
19263 
      (fname, ftype, fid) = iprot.readFieldBegin()
19264 
      if ftype == TType.STOP:
19265 
        break
19266 
      if fid == 1:
19267 
        if ftype == TType.LIST:
19268 
          self.itemIds = []
9155 kshitij.so 19269 
          (_etype400, _size397) = iprot.readListBegin()
19270 
          for _i401 in xrange(_size397):
19271 
            _elem402 = iprot.readI64();
19272 
            self.itemIds.append(_elem402)
7306 rajveer 19273 
          iprot.readListEnd()
19274 
        else:
19275 
          iprot.skip(ftype)
19276 
      else:
19277 
        iprot.skip(ftype)
19278 
      iprot.readFieldEnd()
19279 
    iprot.readStructEnd()
19280 
 
19281 
  def write(self, oprot):
19282 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19283 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19284 
      return
19285 
    oprot.writeStructBegin('getStorePricings_args')
19286 
    if self.itemIds is not None:
19287 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
19288 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
9155 kshitij.so 19289 
      for iter403 in self.itemIds:
19290 
        oprot.writeI64(iter403)
7306 rajveer 19291 
      oprot.writeListEnd()
19292 
      oprot.writeFieldEnd()
19293 
    oprot.writeFieldStop()
19294 
    oprot.writeStructEnd()
19295 
 
19296 
  def validate(self):
19297 
    return
19298 
 
19299 
 
19300 
  def __repr__(self):
19301 
    L = ['%s=%r' % (key, value)
19302 
      for key, value in self.__dict__.iteritems()]
19303 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19304 
 
19305 
  def __eq__(self, other):
19306 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19307 
 
19308 
  def __ne__(self, other):
19309 
    return not (self == other)
19310 
 
19311 
class getStorePricings_result:
19312 
  """
19313 
  Attributes:
19314 
   - success
19315 
  """
19316 
 
19317 
  thrift_spec = (
19318 
    (0, TType.LIST, 'success', (TType.STRUCT,(StorePricing, StorePricing.thrift_spec)), None, ), # 0
19319 
  )
19320 
 
19321 
  def __init__(self, success=None,):
19322 
    self.success = success
19323 
 
19324 
  def read(self, iprot):
19325 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19326 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19327 
      return
19328 
    iprot.readStructBegin()
19329 
    while True:
19330 
      (fname, ftype, fid) = iprot.readFieldBegin()
19331 
      if ftype == TType.STOP:
19332 
        break
19333 
      if fid == 0:
19334 
        if ftype == TType.LIST:
19335 
          self.success = []
9155 kshitij.so 19336 
          (_etype407, _size404) = iprot.readListBegin()
19337 
          for _i408 in xrange(_size404):
19338 
            _elem409 = StorePricing()
19339 
            _elem409.read(iprot)
19340 
            self.success.append(_elem409)
7306 rajveer 19341 
          iprot.readListEnd()
19342 
        else:
19343 
          iprot.skip(ftype)
19344 
      else:
19345 
        iprot.skip(ftype)
19346 
      iprot.readFieldEnd()
19347 
    iprot.readStructEnd()
19348 
 
19349 
  def write(self, oprot):
19350 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19351 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19352 
      return
19353 
    oprot.writeStructBegin('getStorePricings_result')
19354 
    if self.success is not None:
19355 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19356 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 19357 
      for iter410 in self.success:
19358 
        iter410.write(oprot)
7306 rajveer 19359 
      oprot.writeListEnd()
19360 
      oprot.writeFieldEnd()
19361 
    oprot.writeFieldStop()
19362 
    oprot.writeStructEnd()
19363 
 
19364 
  def validate(self):
19365 
    return
19366 
 
19367 
 
19368 
  def __repr__(self):
19369 
    L = ['%s=%r' % (key, value)
19370 
      for key, value in self.__dict__.iteritems()]
19371 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19372 
 
19373 
  def __eq__(self, other):
19374 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19375 
 
19376 
  def __ne__(self, other):
19377 
    return not (self == other)
19378 
 
7265 rajveer 19379 
class updateStorePricing_args:
19380 
  """
19381 
  Attributes:
19382 
   - sp
7382 rajveer 19383 
   - allColors
7265 rajveer 19384 
  """
19385 
 
19386 
  thrift_spec = (
19387 
    None, # 0
19388 
    (1, TType.STRUCT, 'sp', (StorePricing, StorePricing.thrift_spec), None, ), # 1
7382 rajveer 19389 
    (2, TType.BOOL, 'allColors', None, None, ), # 2
7265 rajveer 19390 
  )
19391 
 
7382 rajveer 19392 
  def __init__(self, sp=None, allColors=None,):
7265 rajveer 19393 
    self.sp = sp
7382 rajveer 19394 
    self.allColors = allColors
7265 rajveer 19395 
 
19396 
  def read(self, iprot):
19397 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19398 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19399 
      return
19400 
    iprot.readStructBegin()
19401 
    while True:
19402 
      (fname, ftype, fid) = iprot.readFieldBegin()
19403 
      if ftype == TType.STOP:
19404 
        break
19405 
      if fid == 1:
19406 
        if ftype == TType.STRUCT:
19407 
          self.sp = StorePricing()
19408 
          self.sp.read(iprot)
19409 
        else:
19410 
          iprot.skip(ftype)
7382 rajveer 19411 
      elif fid == 2:
19412 
        if ftype == TType.BOOL:
19413 
          self.allColors = iprot.readBool();
19414 
        else:
19415 
          iprot.skip(ftype)
7265 rajveer 19416 
      else:
19417 
        iprot.skip(ftype)
19418 
      iprot.readFieldEnd()
19419 
    iprot.readStructEnd()
19420 
 
19421 
  def write(self, oprot):
19422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19424 
      return
19425 
    oprot.writeStructBegin('updateStorePricing_args')
19426 
    if self.sp is not None:
19427 
      oprot.writeFieldBegin('sp', TType.STRUCT, 1)
19428 
      self.sp.write(oprot)
19429 
      oprot.writeFieldEnd()
7382 rajveer 19430 
    if self.allColors is not None:
19431 
      oprot.writeFieldBegin('allColors', TType.BOOL, 2)
19432 
      oprot.writeBool(self.allColors)
19433 
      oprot.writeFieldEnd()
7265 rajveer 19434 
    oprot.writeFieldStop()
19435 
    oprot.writeStructEnd()
19436 
 
19437 
  def validate(self):
19438 
    return
19439 
 
19440 
 
19441 
  def __repr__(self):
19442 
    L = ['%s=%r' % (key, value)
19443 
      for key, value in self.__dict__.iteritems()]
19444 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19445 
 
19446 
  def __eq__(self, other):
19447 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19448 
 
19449 
  def __ne__(self, other):
19450 
    return not (self == other)
19451 
 
19452 
class updateStorePricing_result:
19453 
 
19454 
  thrift_spec = (
19455 
  )
19456 
 
19457 
  def read(self, iprot):
19458 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19459 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19460 
      return
19461 
    iprot.readStructBegin()
19462 
    while True:
19463 
      (fname, ftype, fid) = iprot.readFieldBegin()
19464 
      if ftype == TType.STOP:
19465 
        break
19466 
      else:
19467 
        iprot.skip(ftype)
19468 
      iprot.readFieldEnd()
19469 
    iprot.readStructEnd()
19470 
 
19471 
  def write(self, oprot):
19472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19474 
      return
19475 
    oprot.writeStructBegin('updateStorePricing_result')
19476 
    oprot.writeFieldStop()
19477 
    oprot.writeStructEnd()
19478 
 
19479 
  def validate(self):
19480 
    return
19481 
 
19482 
 
19483 
  def __repr__(self):
19484 
    L = ['%s=%r' % (key, value)
19485 
      for key, value in self.__dict__.iteritems()]
19486 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19487 
 
19488 
  def __eq__(self, other):
19489 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19490 
 
19491 
  def __ne__(self, other):
19492 
    return not (self == other)
7281 kshitij.so 19493 
 
19494 
class getAllAmazonListedItems_args:
19495 
 
19496 
  thrift_spec = (
19497 
  )
19498 
 
19499 
  def read(self, iprot):
19500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19502 
      return
19503 
    iprot.readStructBegin()
19504 
    while True:
19505 
      (fname, ftype, fid) = iprot.readFieldBegin()
19506 
      if ftype == TType.STOP:
19507 
        break
19508 
      else:
19509 
        iprot.skip(ftype)
19510 
      iprot.readFieldEnd()
19511 
    iprot.readStructEnd()
19512 
 
19513 
  def write(self, oprot):
19514 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19515 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19516 
      return
19517 
    oprot.writeStructBegin('getAllAmazonListedItems_args')
19518 
    oprot.writeFieldStop()
19519 
    oprot.writeStructEnd()
19520 
 
19521 
  def validate(self):
19522 
    return
19523 
 
19524 
 
19525 
  def __repr__(self):
19526 
    L = ['%s=%r' % (key, value)
19527 
      for key, value in self.__dict__.iteritems()]
19528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19529 
 
19530 
  def __eq__(self, other):
19531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19532 
 
19533 
  def __ne__(self, other):
19534 
    return not (self == other)
19535 
 
19536 
class getAllAmazonListedItems_result:
19537 
  """
19538 
  Attributes:
19539 
   - success
19540 
  """
19541 
 
19542 
  thrift_spec = (
19543 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
19544 
  )
19545 
 
19546 
  def __init__(self, success=None,):
19547 
    self.success = success
19548 
 
19549 
  def read(self, iprot):
19550 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19551 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19552 
      return
19553 
    iprot.readStructBegin()
19554 
    while True:
19555 
      (fname, ftype, fid) = iprot.readFieldBegin()
19556 
      if ftype == TType.STOP:
19557 
        break
19558 
      if fid == 0:
19559 
        if ftype == TType.LIST:
19560 
          self.success = []
9155 kshitij.so 19561 
          (_etype414, _size411) = iprot.readListBegin()
19562 
          for _i415 in xrange(_size411):
19563 
            _elem416 = Amazonlisted()
19564 
            _elem416.read(iprot)
19565 
            self.success.append(_elem416)
7281 kshitij.so 19566 
          iprot.readListEnd()
19567 
        else:
19568 
          iprot.skip(ftype)
19569 
      else:
19570 
        iprot.skip(ftype)
19571 
      iprot.readFieldEnd()
19572 
    iprot.readStructEnd()
19573 
 
19574 
  def write(self, oprot):
19575 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19576 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19577 
      return
19578 
    oprot.writeStructBegin('getAllAmazonListedItems_result')
19579 
    if self.success is not None:
19580 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19581 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 19582 
      for iter417 in self.success:
19583 
        iter417.write(oprot)
7281 kshitij.so 19584 
      oprot.writeListEnd()
19585 
      oprot.writeFieldEnd()
19586 
    oprot.writeFieldStop()
19587 
    oprot.writeStructEnd()
19588 
 
19589 
  def validate(self):
19590 
    return
19591 
 
19592 
 
19593 
  def __repr__(self):
19594 
    L = ['%s=%r' % (key, value)
19595 
      for key, value in self.__dict__.iteritems()]
19596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19597 
 
19598 
  def __eq__(self, other):
19599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19600 
 
19601 
  def __ne__(self, other):
19602 
    return not (self == other)
19603 
 
8619 kshitij.so 19604 
class searchAmazonItems_args:
19605 
  """
19606 
  Attributes:
19607 
   - searchTerm
19608 
   - offset
19609 
   - limit
19610 
  """
19611 
 
19612 
  thrift_spec = (
19613 
    None, # 0
19614 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
19615 
    (2, TType.I64, 'offset', None, None, ), # 2
19616 
    (3, TType.I64, 'limit', None, None, ), # 3
19617 
  )
19618 
 
19619 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
19620 
    self.searchTerm = searchTerm
19621 
    self.offset = offset
19622 
    self.limit = limit
19623 
 
19624 
  def read(self, iprot):
19625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19627 
      return
19628 
    iprot.readStructBegin()
19629 
    while True:
19630 
      (fname, ftype, fid) = iprot.readFieldBegin()
19631 
      if ftype == TType.STOP:
19632 
        break
19633 
      if fid == 1:
19634 
        if ftype == TType.LIST:
19635 
          self.searchTerm = []
9155 kshitij.so 19636 
          (_etype421, _size418) = iprot.readListBegin()
19637 
          for _i422 in xrange(_size418):
19638 
            _elem423 = iprot.readString();
19639 
            self.searchTerm.append(_elem423)
8619 kshitij.so 19640 
          iprot.readListEnd()
19641 
        else:
19642 
          iprot.skip(ftype)
19643 
      elif fid == 2:
19644 
        if ftype == TType.I64:
19645 
          self.offset = iprot.readI64();
19646 
        else:
19647 
          iprot.skip(ftype)
19648 
      elif fid == 3:
19649 
        if ftype == TType.I64:
19650 
          self.limit = iprot.readI64();
19651 
        else:
19652 
          iprot.skip(ftype)
19653 
      else:
19654 
        iprot.skip(ftype)
19655 
      iprot.readFieldEnd()
19656 
    iprot.readStructEnd()
19657 
 
19658 
  def write(self, oprot):
19659 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19660 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19661 
      return
19662 
    oprot.writeStructBegin('searchAmazonItems_args')
19663 
    if self.searchTerm is not None:
19664 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
19665 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
9155 kshitij.so 19666 
      for iter424 in self.searchTerm:
19667 
        oprot.writeString(iter424)
8619 kshitij.so 19668 
      oprot.writeListEnd()
19669 
      oprot.writeFieldEnd()
19670 
    if self.offset is not None:
19671 
      oprot.writeFieldBegin('offset', TType.I64, 2)
19672 
      oprot.writeI64(self.offset)
19673 
      oprot.writeFieldEnd()
19674 
    if self.limit is not None:
19675 
      oprot.writeFieldBegin('limit', TType.I64, 3)
19676 
      oprot.writeI64(self.limit)
19677 
      oprot.writeFieldEnd()
19678 
    oprot.writeFieldStop()
19679 
    oprot.writeStructEnd()
19680 
 
19681 
  def validate(self):
19682 
    return
19683 
 
19684 
 
19685 
  def __repr__(self):
19686 
    L = ['%s=%r' % (key, value)
19687 
      for key, value in self.__dict__.iteritems()]
19688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19689 
 
19690 
  def __eq__(self, other):
19691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19692 
 
19693 
  def __ne__(self, other):
19694 
    return not (self == other)
19695 
 
19696 
class searchAmazonItems_result:
19697 
  """
19698 
  Attributes:
19699 
   - success
19700 
  """
19701 
 
19702 
  thrift_spec = (
19703 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
19704 
  )
19705 
 
19706 
  def __init__(self, success=None,):
19707 
    self.success = success
19708 
 
19709 
  def read(self, iprot):
19710 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19711 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19712 
      return
19713 
    iprot.readStructBegin()
19714 
    while True:
19715 
      (fname, ftype, fid) = iprot.readFieldBegin()
19716 
      if ftype == TType.STOP:
19717 
        break
19718 
      if fid == 0:
19719 
        if ftype == TType.LIST:
19720 
          self.success = []
9155 kshitij.so 19721 
          (_etype428, _size425) = iprot.readListBegin()
19722 
          for _i429 in xrange(_size425):
19723 
            _elem430 = Amazonlisted()
19724 
            _elem430.read(iprot)
19725 
            self.success.append(_elem430)
8619 kshitij.so 19726 
          iprot.readListEnd()
19727 
        else:
19728 
          iprot.skip(ftype)
19729 
      else:
19730 
        iprot.skip(ftype)
19731 
      iprot.readFieldEnd()
19732 
    iprot.readStructEnd()
19733 
 
19734 
  def write(self, oprot):
19735 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19736 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19737 
      return
19738 
    oprot.writeStructBegin('searchAmazonItems_result')
19739 
    if self.success is not None:
19740 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19741 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 19742 
      for iter431 in self.success:
19743 
        iter431.write(oprot)
8619 kshitij.so 19744 
      oprot.writeListEnd()
19745 
      oprot.writeFieldEnd()
19746 
    oprot.writeFieldStop()
19747 
    oprot.writeStructEnd()
19748 
 
19749 
  def validate(self):
19750 
    return
19751 
 
19752 
 
19753 
  def __repr__(self):
19754 
    L = ['%s=%r' % (key, value)
19755 
      for key, value in self.__dict__.iteritems()]
19756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19757 
 
19758 
  def __eq__(self, other):
19759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19760 
 
19761 
  def __ne__(self, other):
19762 
    return not (self == other)
19763 
 
19764 
class getAmazonSearchResultCount_args:
19765 
  """
19766 
  Attributes:
19767 
   - searchTerm
19768 
  """
19769 
 
19770 
  thrift_spec = (
19771 
    None, # 0
19772 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
19773 
  )
19774 
 
19775 
  def __init__(self, searchTerm=None,):
19776 
    self.searchTerm = searchTerm
19777 
 
19778 
  def read(self, iprot):
19779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19781 
      return
19782 
    iprot.readStructBegin()
19783 
    while True:
19784 
      (fname, ftype, fid) = iprot.readFieldBegin()
19785 
      if ftype == TType.STOP:
19786 
        break
19787 
      if fid == 1:
19788 
        if ftype == TType.LIST:
19789 
          self.searchTerm = []
9155 kshitij.so 19790 
          (_etype435, _size432) = iprot.readListBegin()
19791 
          for _i436 in xrange(_size432):
19792 
            _elem437 = iprot.readString();
19793 
            self.searchTerm.append(_elem437)
8619 kshitij.so 19794 
          iprot.readListEnd()
19795 
        else:
19796 
          iprot.skip(ftype)
19797 
      else:
19798 
        iprot.skip(ftype)
19799 
      iprot.readFieldEnd()
19800 
    iprot.readStructEnd()
19801 
 
19802 
  def write(self, oprot):
19803 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19804 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19805 
      return
19806 
    oprot.writeStructBegin('getAmazonSearchResultCount_args')
19807 
    if self.searchTerm is not None:
19808 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
19809 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
9155 kshitij.so 19810 
      for iter438 in self.searchTerm:
19811 
        oprot.writeString(iter438)
8619 kshitij.so 19812 
      oprot.writeListEnd()
19813 
      oprot.writeFieldEnd()
19814 
    oprot.writeFieldStop()
19815 
    oprot.writeStructEnd()
19816 
 
19817 
  def validate(self):
19818 
    return
19819 
 
19820 
 
19821 
  def __repr__(self):
19822 
    L = ['%s=%r' % (key, value)
19823 
      for key, value in self.__dict__.iteritems()]
19824 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19825 
 
19826 
  def __eq__(self, other):
19827 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19828 
 
19829 
  def __ne__(self, other):
19830 
    return not (self == other)
19831 
 
19832 
class getAmazonSearchResultCount_result:
19833 
  """
19834 
  Attributes:
19835 
   - success
19836 
  """
19837 
 
19838 
  thrift_spec = (
19839 
    (0, TType.I64, 'success', None, None, ), # 0
19840 
  )
19841 
 
19842 
  def __init__(self, success=None,):
19843 
    self.success = success
19844 
 
19845 
  def read(self, iprot):
19846 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19847 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19848 
      return
19849 
    iprot.readStructBegin()
19850 
    while True:
19851 
      (fname, ftype, fid) = iprot.readFieldBegin()
19852 
      if ftype == TType.STOP:
19853 
        break
19854 
      if fid == 0:
19855 
        if ftype == TType.I64:
19856 
          self.success = iprot.readI64();
19857 
        else:
19858 
          iprot.skip(ftype)
19859 
      else:
19860 
        iprot.skip(ftype)
19861 
      iprot.readFieldEnd()
19862 
    iprot.readStructEnd()
19863 
 
19864 
  def write(self, oprot):
19865 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19866 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19867 
      return
19868 
    oprot.writeStructBegin('getAmazonSearchResultCount_result')
19869 
    if self.success is not None:
19870 
      oprot.writeFieldBegin('success', TType.I64, 0)
19871 
      oprot.writeI64(self.success)
19872 
      oprot.writeFieldEnd()
19873 
    oprot.writeFieldStop()
19874 
    oprot.writeStructEnd()
19875 
 
19876 
  def validate(self):
19877 
    return
19878 
 
19879 
 
19880 
  def __repr__(self):
19881 
    L = ['%s=%r' % (key, value)
19882 
      for key, value in self.__dict__.iteritems()]
19883 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19884 
 
19885 
  def __eq__(self, other):
19886 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19887 
 
19888 
  def __ne__(self, other):
19889 
    return not (self == other)
19890 
 
19891 
class getCountForAmazonlistedItems_args:
19892 
 
19893 
  thrift_spec = (
19894 
  )
19895 
 
19896 
  def read(self, iprot):
19897 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19898 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19899 
      return
19900 
    iprot.readStructBegin()
19901 
    while True:
19902 
      (fname, ftype, fid) = iprot.readFieldBegin()
19903 
      if ftype == TType.STOP:
19904 
        break
19905 
      else:
19906 
        iprot.skip(ftype)
19907 
      iprot.readFieldEnd()
19908 
    iprot.readStructEnd()
19909 
 
19910 
  def write(self, oprot):
19911 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19912 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19913 
      return
19914 
    oprot.writeStructBegin('getCountForAmazonlistedItems_args')
19915 
    oprot.writeFieldStop()
19916 
    oprot.writeStructEnd()
19917 
 
19918 
  def validate(self):
19919 
    return
19920 
 
19921 
 
19922 
  def __repr__(self):
19923 
    L = ['%s=%r' % (key, value)
19924 
      for key, value in self.__dict__.iteritems()]
19925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19926 
 
19927 
  def __eq__(self, other):
19928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19929 
 
19930 
  def __ne__(self, other):
19931 
    return not (self == other)
19932 
 
19933 
class getCountForAmazonlistedItems_result:
19934 
  """
19935 
  Attributes:
19936 
   - success
19937 
  """
19938 
 
19939 
  thrift_spec = (
19940 
    (0, TType.I64, 'success', None, None, ), # 0
19941 
  )
19942 
 
19943 
  def __init__(self, success=None,):
19944 
    self.success = success
19945 
 
19946 
  def read(self, iprot):
19947 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19948 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19949 
      return
19950 
    iprot.readStructBegin()
19951 
    while True:
19952 
      (fname, ftype, fid) = iprot.readFieldBegin()
19953 
      if ftype == TType.STOP:
19954 
        break
19955 
      if fid == 0:
19956 
        if ftype == TType.I64:
19957 
          self.success = iprot.readI64();
19958 
        else:
19959 
          iprot.skip(ftype)
19960 
      else:
19961 
        iprot.skip(ftype)
19962 
      iprot.readFieldEnd()
19963 
    iprot.readStructEnd()
19964 
 
19965 
  def write(self, oprot):
19966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19968 
      return
19969 
    oprot.writeStructBegin('getCountForAmazonlistedItems_result')
19970 
    if self.success is not None:
19971 
      oprot.writeFieldBegin('success', TType.I64, 0)
19972 
      oprot.writeI64(self.success)
19973 
      oprot.writeFieldEnd()
19974 
    oprot.writeFieldStop()
19975 
    oprot.writeStructEnd()
19976 
 
19977 
  def validate(self):
19978 
    return
19979 
 
19980 
 
19981 
  def __repr__(self):
19982 
    L = ['%s=%r' % (key, value)
19983 
      for key, value in self.__dict__.iteritems()]
19984 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19985 
 
19986 
  def __eq__(self, other):
19987 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19988 
 
19989 
  def __ne__(self, other):
19990 
    return not (self == other)
19991 
 
7281 kshitij.so 19992 
class getAmazonItemDetails_args:
19993 
  """
19994 
  Attributes:
19995 
   - itemId
19996 
  """
19997 
 
19998 
  thrift_spec = (
19999 
    None, # 0
20000 
    (1, TType.I64, 'itemId', None, None, ), # 1
20001 
  )
20002 
 
20003 
  def __init__(self, itemId=None,):
20004 
    self.itemId = itemId
20005 
 
20006 
  def read(self, iprot):
20007 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20008 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20009 
      return
20010 
    iprot.readStructBegin()
20011 
    while True:
20012 
      (fname, ftype, fid) = iprot.readFieldBegin()
20013 
      if ftype == TType.STOP:
20014 
        break
20015 
      if fid == 1:
20016 
        if ftype == TType.I64:
20017 
          self.itemId = iprot.readI64();
20018 
        else:
20019 
          iprot.skip(ftype)
20020 
      else:
20021 
        iprot.skip(ftype)
20022 
      iprot.readFieldEnd()
20023 
    iprot.readStructEnd()
20024 
 
20025 
  def write(self, oprot):
20026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20028 
      return
20029 
    oprot.writeStructBegin('getAmazonItemDetails_args')
20030 
    if self.itemId is not None:
20031 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20032 
      oprot.writeI64(self.itemId)
20033 
      oprot.writeFieldEnd()
20034 
    oprot.writeFieldStop()
20035 
    oprot.writeStructEnd()
20036 
 
20037 
  def validate(self):
20038 
    return
20039 
 
20040 
 
20041 
  def __repr__(self):
20042 
    L = ['%s=%r' % (key, value)
20043 
      for key, value in self.__dict__.iteritems()]
20044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20045 
 
20046 
  def __eq__(self, other):
20047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20048 
 
20049 
  def __ne__(self, other):
20050 
    return not (self == other)
20051 
 
20052 
class getAmazonItemDetails_result:
20053 
  """
20054 
  Attributes:
20055 
   - success
20056 
  """
20057 
 
20058 
  thrift_spec = (
20059 
    (0, TType.STRUCT, 'success', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 0
20060 
  )
20061 
 
20062 
  def __init__(self, success=None,):
20063 
    self.success = success
20064 
 
20065 
  def read(self, iprot):
20066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20068 
      return
20069 
    iprot.readStructBegin()
20070 
    while True:
20071 
      (fname, ftype, fid) = iprot.readFieldBegin()
20072 
      if ftype == TType.STOP:
20073 
        break
20074 
      if fid == 0:
20075 
        if ftype == TType.STRUCT:
20076 
          self.success = Amazonlisted()
20077 
          self.success.read(iprot)
20078 
        else:
20079 
          iprot.skip(ftype)
20080 
      else:
20081 
        iprot.skip(ftype)
20082 
      iprot.readFieldEnd()
20083 
    iprot.readStructEnd()
20084 
 
20085 
  def write(self, oprot):
20086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20088 
      return
20089 
    oprot.writeStructBegin('getAmazonItemDetails_result')
20090 
    if self.success is not None:
20091 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20092 
      self.success.write(oprot)
20093 
      oprot.writeFieldEnd()
20094 
    oprot.writeFieldStop()
20095 
    oprot.writeStructEnd()
20096 
 
20097 
  def validate(self):
20098 
    return
20099 
 
20100 
 
20101 
  def __repr__(self):
20102 
    L = ['%s=%r' % (key, value)
20103 
      for key, value in self.__dict__.iteritems()]
20104 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20105 
 
20106 
  def __eq__(self, other):
20107 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20108 
 
20109 
  def __ne__(self, other):
20110 
    return not (self == other)
20111 
 
20112 
class updateAmazonItemDetails_args:
20113 
  """
20114 
  Attributes:
8168 kshitij.so 20115 
   - amazonlisted
7281 kshitij.so 20116 
  """
20117 
 
20118 
  thrift_spec = (
20119 
    None, # 0
8168 kshitij.so 20120 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
7281 kshitij.so 20121 
  )
20122 
 
8168 kshitij.so 20123 
  def __init__(self, amazonlisted=None,):
20124 
    self.amazonlisted = amazonlisted
7281 kshitij.so 20125 
 
20126 
  def read(self, iprot):
20127 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20128 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20129 
      return
20130 
    iprot.readStructBegin()
20131 
    while True:
20132 
      (fname, ftype, fid) = iprot.readFieldBegin()
20133 
      if ftype == TType.STOP:
20134 
        break
20135 
      if fid == 1:
8168 kshitij.so 20136 
        if ftype == TType.STRUCT:
20137 
          self.amazonlisted = Amazonlisted()
20138 
          self.amazonlisted.read(iprot)
7281 kshitij.so 20139 
        else:
20140 
          iprot.skip(ftype)
20141 
      else:
20142 
        iprot.skip(ftype)
20143 
      iprot.readFieldEnd()
20144 
    iprot.readStructEnd()
20145 
 
20146 
  def write(self, oprot):
20147 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20148 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20149 
      return
20150 
    oprot.writeStructBegin('updateAmazonItemDetails_args')
8168 kshitij.so 20151 
    if self.amazonlisted is not None:
20152 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
20153 
      self.amazonlisted.write(oprot)
7281 kshitij.so 20154 
      oprot.writeFieldEnd()
20155 
    oprot.writeFieldStop()
20156 
    oprot.writeStructEnd()
20157 
 
20158 
  def validate(self):
20159 
    return
20160 
 
20161 
 
20162 
  def __repr__(self):
20163 
    L = ['%s=%r' % (key, value)
20164 
      for key, value in self.__dict__.iteritems()]
20165 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20166 
 
20167 
  def __eq__(self, other):
20168 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20169 
 
20170 
  def __ne__(self, other):
20171 
    return not (self == other)
20172 
 
20173 
class updateAmazonItemDetails_result:
20174 
 
20175 
  thrift_spec = (
20176 
  )
20177 
 
20178 
  def read(self, iprot):
20179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20181 
      return
20182 
    iprot.readStructBegin()
20183 
    while True:
20184 
      (fname, ftype, fid) = iprot.readFieldBegin()
20185 
      if ftype == TType.STOP:
20186 
        break
20187 
      else:
20188 
        iprot.skip(ftype)
20189 
      iprot.readFieldEnd()
20190 
    iprot.readStructEnd()
20191 
 
20192 
  def write(self, oprot):
20193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20195 
      return
20196 
    oprot.writeStructBegin('updateAmazonItemDetails_result')
20197 
    oprot.writeFieldStop()
20198 
    oprot.writeStructEnd()
20199 
 
20200 
  def validate(self):
20201 
    return
20202 
 
20203 
 
20204 
  def __repr__(self):
20205 
    L = ['%s=%r' % (key, value)
20206 
      for key, value in self.__dict__.iteritems()]
20207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20208 
 
20209 
  def __eq__(self, other):
20210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20211 
 
20212 
  def __ne__(self, other):
20213 
    return not (self == other)
20214 
 
20215 
class addAmazonItem_args:
20216 
  """
20217 
  Attributes:
20218 
   - amazonlisted
20219 
  """
20220 
 
20221 
  thrift_spec = (
20222 
    None, # 0
20223 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
20224 
  )
20225 
 
20226 
  def __init__(self, amazonlisted=None,):
20227 
    self.amazonlisted = amazonlisted
20228 
 
20229 
  def read(self, iprot):
20230 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20231 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20232 
      return
20233 
    iprot.readStructBegin()
20234 
    while True:
20235 
      (fname, ftype, fid) = iprot.readFieldBegin()
20236 
      if ftype == TType.STOP:
20237 
        break
20238 
      if fid == 1:
20239 
        if ftype == TType.STRUCT:
20240 
          self.amazonlisted = Amazonlisted()
20241 
          self.amazonlisted.read(iprot)
20242 
        else:
20243 
          iprot.skip(ftype)
20244 
      else:
20245 
        iprot.skip(ftype)
20246 
      iprot.readFieldEnd()
20247 
    iprot.readStructEnd()
20248 
 
20249 
  def write(self, oprot):
20250 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20251 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20252 
      return
20253 
    oprot.writeStructBegin('addAmazonItem_args')
20254 
    if self.amazonlisted is not None:
20255 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
20256 
      self.amazonlisted.write(oprot)
20257 
      oprot.writeFieldEnd()
20258 
    oprot.writeFieldStop()
20259 
    oprot.writeStructEnd()
20260 
 
20261 
  def validate(self):
20262 
    return
20263 
 
20264 
 
20265 
  def __repr__(self):
20266 
    L = ['%s=%r' % (key, value)
20267 
      for key, value in self.__dict__.iteritems()]
20268 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20269 
 
20270 
  def __eq__(self, other):
20271 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20272 
 
20273 
  def __ne__(self, other):
20274 
    return not (self == other)
20275 
 
20276 
class addAmazonItem_result:
20277 
 
20278 
  thrift_spec = (
20279 
  )
20280 
 
20281 
  def read(self, iprot):
20282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20284 
      return
20285 
    iprot.readStructBegin()
20286 
    while True:
20287 
      (fname, ftype, fid) = iprot.readFieldBegin()
20288 
      if ftype == TType.STOP:
20289 
        break
20290 
      else:
20291 
        iprot.skip(ftype)
20292 
      iprot.readFieldEnd()
20293 
    iprot.readStructEnd()
20294 
 
20295 
  def write(self, oprot):
20296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20298 
      return
20299 
    oprot.writeStructBegin('addAmazonItem_result')
20300 
    oprot.writeFieldStop()
20301 
    oprot.writeStructEnd()
20302 
 
20303 
  def validate(self):
20304 
    return
20305 
 
20306 
 
20307 
  def __repr__(self):
20308 
    L = ['%s=%r' % (key, value)
20309 
      for key, value in self.__dict__.iteritems()]
20310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20311 
 
20312 
  def __eq__(self, other):
20313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20314 
 
20315 
  def __ne__(self, other):
20316 
    return not (self == other)
7291 vikram.rag 20317 
 
20318 
class getAsinItems_args:
20319 
 
20320 
  thrift_spec = (
20321 
  )
20322 
 
20323 
  def read(self, iprot):
20324 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20325 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20326 
      return
20327 
    iprot.readStructBegin()
20328 
    while True:
20329 
      (fname, ftype, fid) = iprot.readFieldBegin()
20330 
      if ftype == TType.STOP:
20331 
        break
20332 
      else:
20333 
        iprot.skip(ftype)
20334 
      iprot.readFieldEnd()
20335 
    iprot.readStructEnd()
20336 
 
20337 
  def write(self, oprot):
20338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20340 
      return
20341 
    oprot.writeStructBegin('getAsinItems_args')
20342 
    oprot.writeFieldStop()
20343 
    oprot.writeStructEnd()
20344 
 
20345 
  def validate(self):
20346 
    return
20347 
 
20348 
 
20349 
  def __repr__(self):
20350 
    L = ['%s=%r' % (key, value)
20351 
      for key, value in self.__dict__.iteritems()]
20352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20353 
 
20354 
  def __eq__(self, other):
20355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20356 
 
20357 
  def __ne__(self, other):
20358 
    return not (self == other)
20359 
 
20360 
class getAsinItems_result:
20361 
  """
20362 
  Attributes:
20363 
   - success
20364 
  """
20365 
 
20366 
  thrift_spec = (
20367 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
20368 
  )
20369 
 
20370 
  def __init__(self, success=None,):
20371 
    self.success = success
20372 
 
20373 
  def read(self, iprot):
20374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20376 
      return
20377 
    iprot.readStructBegin()
20378 
    while True:
20379 
      (fname, ftype, fid) = iprot.readFieldBegin()
20380 
      if ftype == TType.STOP:
20381 
        break
20382 
      if fid == 0:
20383 
        if ftype == TType.LIST:
20384 
          self.success = []
9155 kshitij.so 20385 
          (_etype442, _size439) = iprot.readListBegin()
20386 
          for _i443 in xrange(_size439):
20387 
            _elem444 = Item()
20388 
            _elem444.read(iprot)
20389 
            self.success.append(_elem444)
7291 vikram.rag 20390 
          iprot.readListEnd()
20391 
        else:
20392 
          iprot.skip(ftype)
20393 
      else:
20394 
        iprot.skip(ftype)
20395 
      iprot.readFieldEnd()
20396 
    iprot.readStructEnd()
20397 
 
20398 
  def write(self, oprot):
20399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20401 
      return
20402 
    oprot.writeStructBegin('getAsinItems_result')
20403 
    if self.success is not None:
20404 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20405 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 20406 
      for iter445 in self.success:
20407 
        iter445.write(oprot)
7291 vikram.rag 20408 
      oprot.writeListEnd()
20409 
      oprot.writeFieldEnd()
20410 
    oprot.writeFieldStop()
20411 
    oprot.writeStructEnd()
20412 
 
20413 
  def validate(self):
20414 
    return
20415 
 
20416 
 
20417 
  def __repr__(self):
20418 
    L = ['%s=%r' % (key, value)
20419 
      for key, value in self.__dict__.iteritems()]
20420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20421 
 
20422 
  def __eq__(self, other):
20423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20424 
 
20425 
  def __ne__(self, other):
20426 
    return not (self == other)
20427 
 
20428 
class getAllFbaListedItems_args:
20429 
 
20430 
  thrift_spec = (
20431 
  )
20432 
 
20433 
  def read(self, iprot):
20434 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20435 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20436 
      return
20437 
    iprot.readStructBegin()
20438 
    while True:
20439 
      (fname, ftype, fid) = iprot.readFieldBegin()
20440 
      if ftype == TType.STOP:
20441 
        break
20442 
      else:
20443 
        iprot.skip(ftype)
20444 
      iprot.readFieldEnd()
20445 
    iprot.readStructEnd()
20446 
 
20447 
  def write(self, oprot):
20448 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20449 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20450 
      return
20451 
    oprot.writeStructBegin('getAllFbaListedItems_args')
20452 
    oprot.writeFieldStop()
20453 
    oprot.writeStructEnd()
20454 
 
20455 
  def validate(self):
20456 
    return
20457 
 
20458 
 
20459 
  def __repr__(self):
20460 
    L = ['%s=%r' % (key, value)
20461 
      for key, value in self.__dict__.iteritems()]
20462 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20463 
 
20464 
  def __eq__(self, other):
20465 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20466 
 
20467 
  def __ne__(self, other):
20468 
    return not (self == other)
20469 
 
20470 
class getAllFbaListedItems_result:
20471 
  """
20472 
  Attributes:
20473 
   - success
20474 
  """
20475 
 
20476 
  thrift_spec = (
20477 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
20478 
  )
20479 
 
20480 
  def __init__(self, success=None,):
20481 
    self.success = success
20482 
 
20483 
  def read(self, iprot):
20484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20486 
      return
20487 
    iprot.readStructBegin()
20488 
    while True:
20489 
      (fname, ftype, fid) = iprot.readFieldBegin()
20490 
      if ftype == TType.STOP:
20491 
        break
20492 
      if fid == 0:
20493 
        if ftype == TType.LIST:
20494 
          self.success = []
9155 kshitij.so 20495 
          (_etype449, _size446) = iprot.readListBegin()
20496 
          for _i450 in xrange(_size446):
20497 
            _elem451 = Amazonlisted()
20498 
            _elem451.read(iprot)
20499 
            self.success.append(_elem451)
7291 vikram.rag 20500 
          iprot.readListEnd()
20501 
        else:
20502 
          iprot.skip(ftype)
20503 
      else:
20504 
        iprot.skip(ftype)
20505 
      iprot.readFieldEnd()
20506 
    iprot.readStructEnd()
20507 
 
20508 
  def write(self, oprot):
20509 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20510 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20511 
      return
20512 
    oprot.writeStructBegin('getAllFbaListedItems_result')
20513 
    if self.success is not None:
20514 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20515 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 20516 
      for iter452 in self.success:
20517 
        iter452.write(oprot)
7291 vikram.rag 20518 
      oprot.writeListEnd()
20519 
      oprot.writeFieldEnd()
20520 
    oprot.writeFieldStop()
20521 
    oprot.writeStructEnd()
20522 
 
20523 
  def validate(self):
20524 
    return
20525 
 
20526 
 
20527 
  def __repr__(self):
20528 
    L = ['%s=%r' % (key, value)
20529 
      for key, value in self.__dict__.iteritems()]
20530 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20531 
 
20532 
  def __eq__(self, other):
20533 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20534 
 
20535 
  def __ne__(self, other):
20536 
    return not (self == other)
20537 
 
20538 
class getAllNonFbaListedItems_args:
20539 
 
20540 
  thrift_spec = (
20541 
  )
20542 
 
20543 
  def read(self, iprot):
20544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20546 
      return
20547 
    iprot.readStructBegin()
20548 
    while True:
20549 
      (fname, ftype, fid) = iprot.readFieldBegin()
20550 
      if ftype == TType.STOP:
20551 
        break
20552 
      else:
20553 
        iprot.skip(ftype)
20554 
      iprot.readFieldEnd()
20555 
    iprot.readStructEnd()
20556 
 
20557 
  def write(self, oprot):
20558 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20559 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20560 
      return
20561 
    oprot.writeStructBegin('getAllNonFbaListedItems_args')
20562 
    oprot.writeFieldStop()
20563 
    oprot.writeStructEnd()
20564 
 
20565 
  def validate(self):
20566 
    return
20567 
 
20568 
 
20569 
  def __repr__(self):
20570 
    L = ['%s=%r' % (key, value)
20571 
      for key, value in self.__dict__.iteritems()]
20572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20573 
 
20574 
  def __eq__(self, other):
20575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20576 
 
20577 
  def __ne__(self, other):
20578 
    return not (self == other)
20579 
 
20580 
class getAllNonFbaListedItems_result:
20581 
  """
20582 
  Attributes:
20583 
   - success
20584 
  """
20585 
 
20586 
  thrift_spec = (
20587 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
20588 
  )
20589 
 
20590 
  def __init__(self, success=None,):
20591 
    self.success = success
20592 
 
20593 
  def read(self, iprot):
20594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20596 
      return
20597 
    iprot.readStructBegin()
20598 
    while True:
20599 
      (fname, ftype, fid) = iprot.readFieldBegin()
20600 
      if ftype == TType.STOP:
20601 
        break
20602 
      if fid == 0:
20603 
        if ftype == TType.LIST:
20604 
          self.success = []
9155 kshitij.so 20605 
          (_etype456, _size453) = iprot.readListBegin()
20606 
          for _i457 in xrange(_size453):
20607 
            _elem458 = Amazonlisted()
20608 
            _elem458.read(iprot)
20609 
            self.success.append(_elem458)
7291 vikram.rag 20610 
          iprot.readListEnd()
20611 
        else:
20612 
          iprot.skip(ftype)
20613 
      else:
20614 
        iprot.skip(ftype)
20615 
      iprot.readFieldEnd()
20616 
    iprot.readStructEnd()
20617 
 
20618 
  def write(self, oprot):
20619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20621 
      return
20622 
    oprot.writeStructBegin('getAllNonFbaListedItems_result')
20623 
    if self.success is not None:
20624 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20625 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 20626 
      for iter459 in self.success:
20627 
        iter459.write(oprot)
7291 vikram.rag 20628 
      oprot.writeListEnd()
20629 
      oprot.writeFieldEnd()
20630 
    oprot.writeFieldStop()
20631 
    oprot.writeStructEnd()
20632 
 
20633 
  def validate(self):
20634 
    return
20635 
 
20636 
 
20637 
  def __repr__(self):
20638 
    L = ['%s=%r' % (key, value)
20639 
      for key, value in self.__dict__.iteritems()]
20640 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20641 
 
20642 
  def __eq__(self, other):
20643 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20644 
 
20645 
  def __ne__(self, other):
20646 
    return not (self == other)
7460 kshitij.so 20647 
 
20648 
class updateItemInventory_args:
20649 
  """
20650 
  Attributes:
20651 
   - itemId
20652 
   - holdInventory
20653 
   - defaultInventory
20654 
  """
20655 
 
20656 
  thrift_spec = (
20657 
    None, # 0
20658 
    (1, TType.I64, 'itemId', None, None, ), # 1
20659 
    (2, TType.I64, 'holdInventory', None, None, ), # 2
20660 
    (3, TType.I64, 'defaultInventory', None, None, ), # 3
20661 
  )
20662 
 
20663 
  def __init__(self, itemId=None, holdInventory=None, defaultInventory=None,):
20664 
    self.itemId = itemId
20665 
    self.holdInventory = holdInventory
20666 
    self.defaultInventory = defaultInventory
20667 
 
20668 
  def read(self, iprot):
20669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20671 
      return
20672 
    iprot.readStructBegin()
20673 
    while True:
20674 
      (fname, ftype, fid) = iprot.readFieldBegin()
20675 
      if ftype == TType.STOP:
20676 
        break
20677 
      if fid == 1:
20678 
        if ftype == TType.I64:
20679 
          self.itemId = iprot.readI64();
20680 
        else:
20681 
          iprot.skip(ftype)
20682 
      elif fid == 2:
20683 
        if ftype == TType.I64:
20684 
          self.holdInventory = iprot.readI64();
20685 
        else:
20686 
          iprot.skip(ftype)
20687 
      elif fid == 3:
20688 
        if ftype == TType.I64:
20689 
          self.defaultInventory = iprot.readI64();
20690 
        else:
20691 
          iprot.skip(ftype)
20692 
      else:
20693 
        iprot.skip(ftype)
20694 
      iprot.readFieldEnd()
20695 
    iprot.readStructEnd()
20696 
 
20697 
  def write(self, oprot):
20698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20700 
      return
20701 
    oprot.writeStructBegin('updateItemInventory_args')
20702 
    if self.itemId is not None:
20703 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20704 
      oprot.writeI64(self.itemId)
20705 
      oprot.writeFieldEnd()
20706 
    if self.holdInventory is not None:
20707 
      oprot.writeFieldBegin('holdInventory', TType.I64, 2)
20708 
      oprot.writeI64(self.holdInventory)
20709 
      oprot.writeFieldEnd()
20710 
    if self.defaultInventory is not None:
20711 
      oprot.writeFieldBegin('defaultInventory', TType.I64, 3)
20712 
      oprot.writeI64(self.defaultInventory)
20713 
      oprot.writeFieldEnd()
20714 
    oprot.writeFieldStop()
20715 
    oprot.writeStructEnd()
20716 
 
20717 
  def validate(self):
20718 
    return
20719 
 
20720 
 
20721 
  def __repr__(self):
20722 
    L = ['%s=%r' % (key, value)
20723 
      for key, value in self.__dict__.iteritems()]
20724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20725 
 
20726 
  def __eq__(self, other):
20727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20728 
 
20729 
  def __ne__(self, other):
20730 
    return not (self == other)
20731 
 
20732 
class updateItemInventory_result:
20733 
  """
20734 
  Attributes:
20735 
   - success
20736 
  """
20737 
 
20738 
  thrift_spec = (
20739 
    (0, TType.BOOL, 'success', None, None, ), # 0
20740 
  )
20741 
 
20742 
  def __init__(self, success=None,):
20743 
    self.success = success
20744 
 
20745 
  def read(self, iprot):
20746 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20747 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20748 
      return
20749 
    iprot.readStructBegin()
20750 
    while True:
20751 
      (fname, ftype, fid) = iprot.readFieldBegin()
20752 
      if ftype == TType.STOP:
20753 
        break
20754 
      if fid == 0:
20755 
        if ftype == TType.BOOL:
20756 
          self.success = iprot.readBool();
20757 
        else:
20758 
          iprot.skip(ftype)
20759 
      else:
20760 
        iprot.skip(ftype)
20761 
      iprot.readFieldEnd()
20762 
    iprot.readStructEnd()
20763 
 
20764 
  def write(self, oprot):
20765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20767 
      return
20768 
    oprot.writeStructBegin('updateItemInventory_result')
20769 
    if self.success is not None:
20770 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20771 
      oprot.writeBool(self.success)
20772 
      oprot.writeFieldEnd()
20773 
    oprot.writeFieldStop()
20774 
    oprot.writeStructEnd()
20775 
 
20776 
  def validate(self):
20777 
    return
20778 
 
20779 
 
20780 
  def __repr__(self):
20781 
    L = ['%s=%r' % (key, value)
20782 
      for key, value in self.__dict__.iteritems()]
20783 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20784 
 
20785 
  def __eq__(self, other):
20786 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20787 
 
20788 
  def __ne__(self, other):
20789 
    return not (self == other)
7770 kshitij.so 20790 
 
20791 
class updateTimestampForAmazonFeeds_args:
20792 
  """
20793 
  Attributes:
20794 
   - type
20795 
   - sku
20796 
   - timestamp
20797 
  """
20798 
 
20799 
  thrift_spec = (
20800 
    None, # 0
20801 
    (1, TType.STRING, 'type', None, None, ), # 1
20802 
    (2, TType.LIST, 'sku', (TType.I64,None), None, ), # 2
20803 
    (3, TType.I64, 'timestamp', None, None, ), # 3
20804 
  )
20805 
 
20806 
  def __init__(self, type=None, sku=None, timestamp=None,):
20807 
    self.type = type
20808 
    self.sku = sku
20809 
    self.timestamp = timestamp
20810 
 
20811 
  def read(self, iprot):
20812 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20813 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20814 
      return
20815 
    iprot.readStructBegin()
20816 
    while True:
20817 
      (fname, ftype, fid) = iprot.readFieldBegin()
20818 
      if ftype == TType.STOP:
20819 
        break
20820 
      if fid == 1:
20821 
        if ftype == TType.STRING:
20822 
          self.type = iprot.readString();
20823 
        else:
20824 
          iprot.skip(ftype)
20825 
      elif fid == 2:
20826 
        if ftype == TType.LIST:
20827 
          self.sku = []
9155 kshitij.so 20828 
          (_etype463, _size460) = iprot.readListBegin()
20829 
          for _i464 in xrange(_size460):
20830 
            _elem465 = iprot.readI64();
20831 
            self.sku.append(_elem465)
7770 kshitij.so 20832 
          iprot.readListEnd()
20833 
        else:
20834 
          iprot.skip(ftype)
20835 
      elif fid == 3:
20836 
        if ftype == TType.I64:
20837 
          self.timestamp = iprot.readI64();
20838 
        else:
20839 
          iprot.skip(ftype)
20840 
      else:
20841 
        iprot.skip(ftype)
20842 
      iprot.readFieldEnd()
20843 
    iprot.readStructEnd()
20844 
 
20845 
  def write(self, oprot):
20846 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20847 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20848 
      return
20849 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_args')
20850 
    if self.type is not None:
20851 
      oprot.writeFieldBegin('type', TType.STRING, 1)
20852 
      oprot.writeString(self.type)
20853 
      oprot.writeFieldEnd()
20854 
    if self.sku is not None:
20855 
      oprot.writeFieldBegin('sku', TType.LIST, 2)
20856 
      oprot.writeListBegin(TType.I64, len(self.sku))
9155 kshitij.so 20857 
      for iter466 in self.sku:
20858 
        oprot.writeI64(iter466)
7770 kshitij.so 20859 
      oprot.writeListEnd()
20860 
      oprot.writeFieldEnd()
20861 
    if self.timestamp is not None:
20862 
      oprot.writeFieldBegin('timestamp', TType.I64, 3)
20863 
      oprot.writeI64(self.timestamp)
20864 
      oprot.writeFieldEnd()
20865 
    oprot.writeFieldStop()
20866 
    oprot.writeStructEnd()
20867 
 
20868 
  def validate(self):
20869 
    return
20870 
 
20871 
 
20872 
  def __repr__(self):
20873 
    L = ['%s=%r' % (key, value)
20874 
      for key, value in self.__dict__.iteritems()]
20875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20876 
 
20877 
  def __eq__(self, other):
20878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20879 
 
20880 
  def __ne__(self, other):
20881 
    return not (self == other)
20882 
 
20883 
class updateTimestampForAmazonFeeds_result:
20884 
  """
20885 
  Attributes:
20886 
   - success
20887 
  """
20888 
 
20889 
  thrift_spec = (
20890 
    (0, TType.BOOL, 'success', None, None, ), # 0
20891 
  )
20892 
 
20893 
  def __init__(self, success=None,):
20894 
    self.success = success
20895 
 
20896 
  def read(self, iprot):
20897 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20898 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20899 
      return
20900 
    iprot.readStructBegin()
20901 
    while True:
20902 
      (fname, ftype, fid) = iprot.readFieldBegin()
20903 
      if ftype == TType.STOP:
20904 
        break
20905 
      if fid == 0:
20906 
        if ftype == TType.BOOL:
20907 
          self.success = iprot.readBool();
20908 
        else:
20909 
          iprot.skip(ftype)
20910 
      else:
20911 
        iprot.skip(ftype)
20912 
      iprot.readFieldEnd()
20913 
    iprot.readStructEnd()
20914 
 
20915 
  def write(self, oprot):
20916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20918 
      return
20919 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_result')
20920 
    if self.success is not None:
20921 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20922 
      oprot.writeBool(self.success)
20923 
      oprot.writeFieldEnd()
20924 
    oprot.writeFieldStop()
20925 
    oprot.writeStructEnd()
20926 
 
20927 
  def validate(self):
20928 
    return
20929 
 
20930 
 
20931 
  def __repr__(self):
20932 
    L = ['%s=%r' % (key, value)
20933 
      for key, value in self.__dict__.iteritems()]
20934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20935 
 
20936 
  def __eq__(self, other):
20937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20938 
 
20939 
  def __ne__(self, other):
20940 
    return not (self == other)
7897 amar.kumar 20941 
 
20942 
class getAllParentCategories_args:
20943 
 
20944 
  thrift_spec = (
20945 
  )
20946 
 
20947 
  def read(self, iprot):
20948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20950 
      return
20951 
    iprot.readStructBegin()
20952 
    while True:
20953 
      (fname, ftype, fid) = iprot.readFieldBegin()
20954 
      if ftype == TType.STOP:
20955 
        break
20956 
      else:
20957 
        iprot.skip(ftype)
20958 
      iprot.readFieldEnd()
20959 
    iprot.readStructEnd()
20960 
 
20961 
  def write(self, oprot):
20962 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20963 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20964 
      return
20965 
    oprot.writeStructBegin('getAllParentCategories_args')
20966 
    oprot.writeFieldStop()
20967 
    oprot.writeStructEnd()
20968 
 
20969 
  def validate(self):
20970 
    return
20971 
 
20972 
 
20973 
  def __repr__(self):
20974 
    L = ['%s=%r' % (key, value)
20975 
      for key, value in self.__dict__.iteritems()]
20976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20977 
 
20978 
  def __eq__(self, other):
20979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20980 
 
20981 
  def __ne__(self, other):
20982 
    return not (self == other)
20983 
 
20984 
class getAllParentCategories_result:
20985 
  """
20986 
  Attributes:
20987 
   - success
20988 
  """
20989 
 
20990 
  thrift_spec = (
20991 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
20992 
  )
20993 
 
20994 
  def __init__(self, success=None,):
20995 
    self.success = success
20996 
 
20997 
  def read(self, iprot):
20998 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20999 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21000 
      return
21001 
    iprot.readStructBegin()
21002 
    while True:
21003 
      (fname, ftype, fid) = iprot.readFieldBegin()
21004 
      if ftype == TType.STOP:
21005 
        break
21006 
      if fid == 0:
21007 
        if ftype == TType.LIST:
21008 
          self.success = []
9155 kshitij.so 21009 
          (_etype470, _size467) = iprot.readListBegin()
21010 
          for _i471 in xrange(_size467):
21011 
            _elem472 = Category()
21012 
            _elem472.read(iprot)
21013 
            self.success.append(_elem472)
7897 amar.kumar 21014 
          iprot.readListEnd()
21015 
        else:
21016 
          iprot.skip(ftype)
21017 
      else:
21018 
        iprot.skip(ftype)
21019 
      iprot.readFieldEnd()
21020 
    iprot.readStructEnd()
21021 
 
21022 
  def write(self, oprot):
21023 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21024 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21025 
      return
21026 
    oprot.writeStructBegin('getAllParentCategories_result')
21027 
    if self.success is not None:
21028 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21029 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21030 
      for iter473 in self.success:
21031 
        iter473.write(oprot)
7897 amar.kumar 21032 
      oprot.writeListEnd()
21033 
      oprot.writeFieldEnd()
21034 
    oprot.writeFieldStop()
21035 
    oprot.writeStructEnd()
21036 
 
21037 
  def validate(self):
21038 
    return
21039 
 
21040 
 
21041 
  def __repr__(self):
21042 
    L = ['%s=%r' % (key, value)
21043 
      for key, value in self.__dict__.iteritems()]
21044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21045 
 
21046 
  def __eq__(self, other):
21047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21048 
 
21049 
  def __ne__(self, other):
21050 
    return not (self == other)
7977 kshitij.so 21051 
 
21052 
class addPageViewEvent_args:
21053 
  """
21054 
  Attributes:
21055 
   - pageViewEvents
21056 
  """
21057 
 
21058 
  thrift_spec = (
21059 
    None, # 0
21060 
    (1, TType.STRUCT, 'pageViewEvents', (PageViewEvents, PageViewEvents.thrift_spec), None, ), # 1
21061 
  )
21062 
 
21063 
  def __init__(self, pageViewEvents=None,):
21064 
    self.pageViewEvents = pageViewEvents
21065 
 
21066 
  def read(self, iprot):
21067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21069 
      return
21070 
    iprot.readStructBegin()
21071 
    while True:
21072 
      (fname, ftype, fid) = iprot.readFieldBegin()
21073 
      if ftype == TType.STOP:
21074 
        break
21075 
      if fid == 1:
21076 
        if ftype == TType.STRUCT:
21077 
          self.pageViewEvents = PageViewEvents()
21078 
          self.pageViewEvents.read(iprot)
21079 
        else:
21080 
          iprot.skip(ftype)
21081 
      else:
21082 
        iprot.skip(ftype)
21083 
      iprot.readFieldEnd()
21084 
    iprot.readStructEnd()
21085 
 
21086 
  def write(self, oprot):
21087 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21088 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21089 
      return
21090 
    oprot.writeStructBegin('addPageViewEvent_args')
21091 
    if self.pageViewEvents is not None:
21092 
      oprot.writeFieldBegin('pageViewEvents', TType.STRUCT, 1)
21093 
      self.pageViewEvents.write(oprot)
21094 
      oprot.writeFieldEnd()
21095 
    oprot.writeFieldStop()
21096 
    oprot.writeStructEnd()
21097 
 
21098 
  def validate(self):
21099 
    return
21100 
 
21101 
 
21102 
  def __repr__(self):
21103 
    L = ['%s=%r' % (key, value)
21104 
      for key, value in self.__dict__.iteritems()]
21105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21106 
 
21107 
  def __eq__(self, other):
21108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21109 
 
21110 
  def __ne__(self, other):
21111 
    return not (self == other)
21112 
 
21113 
class addPageViewEvent_result:
21114 
 
21115 
  thrift_spec = (
21116 
  )
21117 
 
21118 
  def read(self, iprot):
21119 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21120 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21121 
      return
21122 
    iprot.readStructBegin()
21123 
    while True:
21124 
      (fname, ftype, fid) = iprot.readFieldBegin()
21125 
      if ftype == TType.STOP:
21126 
        break
21127 
      else:
21128 
        iprot.skip(ftype)
21129 
      iprot.readFieldEnd()
21130 
    iprot.readStructEnd()
21131 
 
21132 
  def write(self, oprot):
21133 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21134 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21135 
      return
21136 
    oprot.writeStructBegin('addPageViewEvent_result')
21137 
    oprot.writeFieldStop()
21138 
    oprot.writeStructEnd()
21139 
 
21140 
  def validate(self):
21141 
    return
21142 
 
21143 
 
21144 
  def __repr__(self):
21145 
    L = ['%s=%r' % (key, value)
21146 
      for key, value in self.__dict__.iteritems()]
21147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21148 
 
21149 
  def __eq__(self, other):
21150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21151 
 
21152 
  def __ne__(self, other):
21153 
    return not (self == other)
21154 
 
21155 
class addCartEvent_args:
21156 
  """
21157 
  Attributes:
21158 
   - cartEvents
21159 
  """
21160 
 
21161 
  thrift_spec = (
21162 
    None, # 0
21163 
    (1, TType.STRUCT, 'cartEvents', (CartEvents, CartEvents.thrift_spec), None, ), # 1
21164 
  )
21165 
 
21166 
  def __init__(self, cartEvents=None,):
21167 
    self.cartEvents = cartEvents
21168 
 
21169 
  def read(self, iprot):
21170 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21171 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21172 
      return
21173 
    iprot.readStructBegin()
21174 
    while True:
21175 
      (fname, ftype, fid) = iprot.readFieldBegin()
21176 
      if ftype == TType.STOP:
21177 
        break
21178 
      if fid == 1:
21179 
        if ftype == TType.STRUCT:
21180 
          self.cartEvents = CartEvents()
21181 
          self.cartEvents.read(iprot)
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('addCartEvent_args')
21194 
    if self.cartEvents is not None:
21195 
      oprot.writeFieldBegin('cartEvents', TType.STRUCT, 1)
21196 
      self.cartEvents.write(oprot)
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 addCartEvent_result:
21217 
 
21218 
  thrift_spec = (
21219 
  )
21220 
 
21221 
  def read(self, iprot):
21222 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21223 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21224 
      return
21225 
    iprot.readStructBegin()
21226 
    while True:
21227 
      (fname, ftype, fid) = iprot.readFieldBegin()
21228 
      if ftype == TType.STOP:
21229 
        break
21230 
      else:
21231 
        iprot.skip(ftype)
21232 
      iprot.readFieldEnd()
21233 
    iprot.readStructEnd()
21234 
 
21235 
  def write(self, oprot):
21236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21238 
      return
21239 
    oprot.writeStructBegin('addCartEvent_result')
21240 
    oprot.writeFieldStop()
21241 
    oprot.writeStructEnd()
21242 
 
21243 
  def validate(self):
21244 
    return
21245 
 
21246 
 
21247 
  def __repr__(self):
21248 
    L = ['%s=%r' % (key, value)
21249 
      for key, value in self.__dict__.iteritems()]
21250 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21251 
 
21252 
  def __eq__(self, other):
21253 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21254 
 
21255 
  def __ne__(self, other):
21256 
    return not (self == other)
8139 kshitij.so 21257 
 
8182 amar.kumar 21258 
class addEbayItem_args:
21259 
  """
21260 
  Attributes:
21261 
   - ebayItem
21262 
  """
21263 
 
21264 
  thrift_spec = (
21265 
    None, # 0
21266 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
21267 
  )
21268 
 
21269 
  def __init__(self, ebayItem=None,):
21270 
    self.ebayItem = ebayItem
21271 
 
21272 
  def read(self, iprot):
21273 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21274 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21275 
      return
21276 
    iprot.readStructBegin()
21277 
    while True:
21278 
      (fname, ftype, fid) = iprot.readFieldBegin()
21279 
      if ftype == TType.STOP:
21280 
        break
21281 
      if fid == 1:
21282 
        if ftype == TType.STRUCT:
21283 
          self.ebayItem = EbayItem()
21284 
          self.ebayItem.read(iprot)
21285 
        else:
21286 
          iprot.skip(ftype)
21287 
      else:
21288 
        iprot.skip(ftype)
21289 
      iprot.readFieldEnd()
21290 
    iprot.readStructEnd()
21291 
 
21292 
  def write(self, oprot):
21293 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21294 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21295 
      return
21296 
    oprot.writeStructBegin('addEbayItem_args')
21297 
    if self.ebayItem is not None:
21298 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
21299 
      self.ebayItem.write(oprot)
21300 
      oprot.writeFieldEnd()
21301 
    oprot.writeFieldStop()
21302 
    oprot.writeStructEnd()
21303 
 
21304 
  def validate(self):
21305 
    return
21306 
 
21307 
 
21308 
  def __repr__(self):
21309 
    L = ['%s=%r' % (key, value)
21310 
      for key, value in self.__dict__.iteritems()]
21311 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21312 
 
21313 
  def __eq__(self, other):
21314 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21315 
 
21316 
  def __ne__(self, other):
21317 
    return not (self == other)
21318 
 
21319 
class addEbayItem_result:
21320 
 
21321 
  thrift_spec = (
21322 
  )
21323 
 
21324 
  def read(self, iprot):
21325 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21326 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21327 
      return
21328 
    iprot.readStructBegin()
21329 
    while True:
21330 
      (fname, ftype, fid) = iprot.readFieldBegin()
21331 
      if ftype == TType.STOP:
21332 
        break
21333 
      else:
21334 
        iprot.skip(ftype)
21335 
      iprot.readFieldEnd()
21336 
    iprot.readStructEnd()
21337 
 
21338 
  def write(self, oprot):
21339 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21340 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21341 
      return
21342 
    oprot.writeStructBegin('addEbayItem_result')
21343 
    oprot.writeFieldStop()
21344 
    oprot.writeStructEnd()
21345 
 
21346 
  def validate(self):
21347 
    return
21348 
 
21349 
 
21350 
  def __repr__(self):
21351 
    L = ['%s=%r' % (key, value)
21352 
      for key, value in self.__dict__.iteritems()]
21353 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21354 
 
21355 
  def __eq__(self, other):
21356 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21357 
 
21358 
  def __ne__(self, other):
21359 
    return not (self == other)
21360 
 
21361 
class getEbayItem_args:
21362 
  """
21363 
  Attributes:
21364 
   - listingId
21365 
  """
21366 
 
21367 
  thrift_spec = (
21368 
    None, # 0
21369 
    (1, TType.STRING, 'listingId', None, None, ), # 1
21370 
  )
21371 
 
21372 
  def __init__(self, listingId=None,):
21373 
    self.listingId = listingId
21374 
 
21375 
  def read(self, iprot):
21376 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21377 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21378 
      return
21379 
    iprot.readStructBegin()
21380 
    while True:
21381 
      (fname, ftype, fid) = iprot.readFieldBegin()
21382 
      if ftype == TType.STOP:
21383 
        break
21384 
      if fid == 1:
21385 
        if ftype == TType.STRING:
21386 
          self.listingId = iprot.readString();
21387 
        else:
21388 
          iprot.skip(ftype)
21389 
      else:
21390 
        iprot.skip(ftype)
21391 
      iprot.readFieldEnd()
21392 
    iprot.readStructEnd()
21393 
 
21394 
  def write(self, oprot):
21395 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21396 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21397 
      return
21398 
    oprot.writeStructBegin('getEbayItem_args')
21399 
    if self.listingId is not None:
21400 
      oprot.writeFieldBegin('listingId', TType.STRING, 1)
21401 
      oprot.writeString(self.listingId)
21402 
      oprot.writeFieldEnd()
21403 
    oprot.writeFieldStop()
21404 
    oprot.writeStructEnd()
21405 
 
21406 
  def validate(self):
21407 
    return
21408 
 
21409 
 
21410 
  def __repr__(self):
21411 
    L = ['%s=%r' % (key, value)
21412 
      for key, value in self.__dict__.iteritems()]
21413 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21414 
 
21415 
  def __eq__(self, other):
21416 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21417 
 
21418 
  def __ne__(self, other):
21419 
    return not (self == other)
21420 
 
21421 
class getEbayItem_result:
21422 
  """
21423 
  Attributes:
21424 
   - success
21425 
  """
21426 
 
21427 
  thrift_spec = (
21428 
    (0, TType.STRUCT, 'success', (EbayItem, EbayItem.thrift_spec), None, ), # 0
21429 
  )
21430 
 
21431 
  def __init__(self, success=None,):
21432 
    self.success = success
21433 
 
21434 
  def read(self, iprot):
21435 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21436 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21437 
      return
21438 
    iprot.readStructBegin()
21439 
    while True:
21440 
      (fname, ftype, fid) = iprot.readFieldBegin()
21441 
      if ftype == TType.STOP:
21442 
        break
21443 
      if fid == 0:
21444 
        if ftype == TType.STRUCT:
21445 
          self.success = EbayItem()
21446 
          self.success.read(iprot)
21447 
        else:
21448 
          iprot.skip(ftype)
21449 
      else:
21450 
        iprot.skip(ftype)
21451 
      iprot.readFieldEnd()
21452 
    iprot.readStructEnd()
21453 
 
21454 
  def write(self, oprot):
21455 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21456 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21457 
      return
21458 
    oprot.writeStructBegin('getEbayItem_result')
21459 
    if self.success is not None:
21460 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21461 
      self.success.write(oprot)
21462 
      oprot.writeFieldEnd()
21463 
    oprot.writeFieldStop()
21464 
    oprot.writeStructEnd()
21465 
 
21466 
  def validate(self):
21467 
    return
21468 
 
21469 
 
21470 
  def __repr__(self):
21471 
    L = ['%s=%r' % (key, value)
21472 
      for key, value in self.__dict__.iteritems()]
21473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21474 
 
21475 
  def __eq__(self, other):
21476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21477 
 
21478 
  def __ne__(self, other):
21479 
    return not (self == other)
21480 
 
21481 
class updateEbayItem_args:
21482 
  """
21483 
  Attributes:
21484 
   - ebayItem
21485 
  """
21486 
 
21487 
  thrift_spec = (
21488 
    None, # 0
21489 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
21490 
  )
21491 
 
21492 
  def __init__(self, ebayItem=None,):
21493 
    self.ebayItem = ebayItem
21494 
 
21495 
  def read(self, iprot):
21496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21498 
      return
21499 
    iprot.readStructBegin()
21500 
    while True:
21501 
      (fname, ftype, fid) = iprot.readFieldBegin()
21502 
      if ftype == TType.STOP:
21503 
        break
21504 
      if fid == 1:
21505 
        if ftype == TType.STRUCT:
21506 
          self.ebayItem = EbayItem()
21507 
          self.ebayItem.read(iprot)
21508 
        else:
21509 
          iprot.skip(ftype)
21510 
      else:
21511 
        iprot.skip(ftype)
21512 
      iprot.readFieldEnd()
21513 
    iprot.readStructEnd()
21514 
 
21515 
  def write(self, oprot):
21516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21518 
      return
21519 
    oprot.writeStructBegin('updateEbayItem_args')
21520 
    if self.ebayItem is not None:
21521 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
21522 
      self.ebayItem.write(oprot)
21523 
      oprot.writeFieldEnd()
21524 
    oprot.writeFieldStop()
21525 
    oprot.writeStructEnd()
21526 
 
21527 
  def validate(self):
21528 
    return
21529 
 
21530 
 
21531 
  def __repr__(self):
21532 
    L = ['%s=%r' % (key, value)
21533 
      for key, value in self.__dict__.iteritems()]
21534 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21535 
 
21536 
  def __eq__(self, other):
21537 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21538 
 
21539 
  def __ne__(self, other):
21540 
    return not (self == other)
21541 
 
21542 
class updateEbayItem_result:
21543 
 
21544 
  thrift_spec = (
21545 
  )
21546 
 
21547 
  def read(self, iprot):
21548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21550 
      return
21551 
    iprot.readStructBegin()
21552 
    while True:
21553 
      (fname, ftype, fid) = iprot.readFieldBegin()
21554 
      if ftype == TType.STOP:
21555 
        break
21556 
      else:
21557 
        iprot.skip(ftype)
21558 
      iprot.readFieldEnd()
21559 
    iprot.readStructEnd()
21560 
 
21561 
  def write(self, oprot):
21562 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21563 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21564 
      return
21565 
    oprot.writeStructBegin('updateEbayItem_result')
21566 
    oprot.writeFieldStop()
21567 
    oprot.writeStructEnd()
21568 
 
21569 
  def validate(self):
21570 
    return
21571 
 
21572 
 
21573 
  def __repr__(self):
21574 
    L = ['%s=%r' % (key, value)
21575 
      for key, value in self.__dict__.iteritems()]
21576 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21577 
 
21578 
  def __eq__(self, other):
21579 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21580 
 
21581 
  def __ne__(self, other):
21582 
    return not (self == other)
21583 
 
8139 kshitij.so 21584 
class getAmazonListedItems_args:
21585 
  """
21586 
  Attributes:
21587 
   - offset
21588 
   - limit
21589 
  """
21590 
 
21591 
  thrift_spec = (
21592 
    None, # 0
21593 
    (1, TType.I64, 'offset', None, None, ), # 1
21594 
    (2, TType.I64, 'limit', None, None, ), # 2
21595 
  )
21596 
 
21597 
  def __init__(self, offset=None, limit=None,):
21598 
    self.offset = offset
21599 
    self.limit = limit
21600 
 
21601 
  def read(self, iprot):
21602 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21603 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21604 
      return
21605 
    iprot.readStructBegin()
21606 
    while True:
21607 
      (fname, ftype, fid) = iprot.readFieldBegin()
21608 
      if ftype == TType.STOP:
21609 
        break
21610 
      if fid == 1:
21611 
        if ftype == TType.I64:
21612 
          self.offset = iprot.readI64();
21613 
        else:
21614 
          iprot.skip(ftype)
21615 
      elif fid == 2:
21616 
        if ftype == TType.I64:
21617 
          self.limit = iprot.readI64();
21618 
        else:
21619 
          iprot.skip(ftype)
21620 
      else:
21621 
        iprot.skip(ftype)
21622 
      iprot.readFieldEnd()
21623 
    iprot.readStructEnd()
21624 
 
21625 
  def write(self, oprot):
21626 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21627 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21628 
      return
21629 
    oprot.writeStructBegin('getAmazonListedItems_args')
21630 
    if self.offset is not None:
21631 
      oprot.writeFieldBegin('offset', TType.I64, 1)
21632 
      oprot.writeI64(self.offset)
21633 
      oprot.writeFieldEnd()
21634 
    if self.limit is not None:
21635 
      oprot.writeFieldBegin('limit', TType.I64, 2)
21636 
      oprot.writeI64(self.limit)
21637 
      oprot.writeFieldEnd()
21638 
    oprot.writeFieldStop()
21639 
    oprot.writeStructEnd()
21640 
 
21641 
  def validate(self):
21642 
    return
21643 
 
21644 
 
21645 
  def __repr__(self):
21646 
    L = ['%s=%r' % (key, value)
21647 
      for key, value in self.__dict__.iteritems()]
21648 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21649 
 
21650 
  def __eq__(self, other):
21651 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21652 
 
21653 
  def __ne__(self, other):
21654 
    return not (self == other)
21655 
 
21656 
class getAmazonListedItems_result:
21657 
  """
21658 
  Attributes:
21659 
   - success
21660 
  """
21661 
 
21662 
  thrift_spec = (
21663 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
21664 
  )
21665 
 
21666 
  def __init__(self, success=None,):
21667 
    self.success = success
21668 
 
21669 
  def read(self, iprot):
21670 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21671 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21672 
      return
21673 
    iprot.readStructBegin()
21674 
    while True:
21675 
      (fname, ftype, fid) = iprot.readFieldBegin()
21676 
      if ftype == TType.STOP:
21677 
        break
21678 
      if fid == 0:
21679 
        if ftype == TType.LIST:
21680 
          self.success = []
9155 kshitij.so 21681 
          (_etype477, _size474) = iprot.readListBegin()
21682 
          for _i478 in xrange(_size474):
21683 
            _elem479 = Amazonlisted()
21684 
            _elem479.read(iprot)
21685 
            self.success.append(_elem479)
8139 kshitij.so 21686 
          iprot.readListEnd()
21687 
        else:
21688 
          iprot.skip(ftype)
21689 
      else:
21690 
        iprot.skip(ftype)
21691 
      iprot.readFieldEnd()
21692 
    iprot.readStructEnd()
21693 
 
21694 
  def write(self, oprot):
21695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21697 
      return
21698 
    oprot.writeStructBegin('getAmazonListedItems_result')
21699 
    if self.success is not None:
21700 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21701 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21702 
      for iter480 in self.success:
21703 
        iter480.write(oprot)
8139 kshitij.so 21704 
      oprot.writeListEnd()
21705 
      oprot.writeFieldEnd()
21706 
    oprot.writeFieldStop()
21707 
    oprot.writeStructEnd()
21708 
 
21709 
  def validate(self):
21710 
    return
21711 
 
21712 
 
21713 
  def __repr__(self):
21714 
    L = ['%s=%r' % (key, value)
21715 
      for key, value in self.__dict__.iteritems()]
21716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21717 
 
21718 
  def __eq__(self, other):
21719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21720 
 
21721 
  def __ne__(self, other):
21722 
    return not (self == other)
8168 kshitij.so 21723 
 
21724 
class updateAmazonAttributesInBulk_args:
21725 
  """
21726 
  Attributes:
21727 
   - amazonlisted
21728 
  """
21729 
 
21730 
  thrift_spec = (
21731 
    None, # 0
21732 
    (1, TType.MAP, 'amazonlisted', (TType.I64,None,TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 1
21733 
  )
21734 
 
21735 
  def __init__(self, amazonlisted=None,):
21736 
    self.amazonlisted = amazonlisted
21737 
 
21738 
  def read(self, iprot):
21739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21741 
      return
21742 
    iprot.readStructBegin()
21743 
    while True:
21744 
      (fname, ftype, fid) = iprot.readFieldBegin()
21745 
      if ftype == TType.STOP:
21746 
        break
21747 
      if fid == 1:
21748 
        if ftype == TType.MAP:
21749 
          self.amazonlisted = {}
9155 kshitij.so 21750 
          (_ktype482, _vtype483, _size481 ) = iprot.readMapBegin()
21751 
          for _i485 in xrange(_size481):
21752 
            _key486 = iprot.readI64();
21753 
            _val487 = Amazonlisted()
21754 
            _val487.read(iprot)
21755 
            self.amazonlisted[_key486] = _val487
8168 kshitij.so 21756 
          iprot.readMapEnd()
21757 
        else:
21758 
          iprot.skip(ftype)
21759 
      else:
21760 
        iprot.skip(ftype)
21761 
      iprot.readFieldEnd()
21762 
    iprot.readStructEnd()
21763 
 
21764 
  def write(self, oprot):
21765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21767 
      return
21768 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_args')
21769 
    if self.amazonlisted is not None:
21770 
      oprot.writeFieldBegin('amazonlisted', TType.MAP, 1)
21771 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.amazonlisted))
9155 kshitij.so 21772 
      for kiter488,viter489 in self.amazonlisted.items():
21773 
        oprot.writeI64(kiter488)
21774 
        viter489.write(oprot)
8168 kshitij.so 21775 
      oprot.writeMapEnd()
21776 
      oprot.writeFieldEnd()
21777 
    oprot.writeFieldStop()
21778 
    oprot.writeStructEnd()
21779 
 
21780 
  def validate(self):
21781 
    return
21782 
 
21783 
 
21784 
  def __repr__(self):
21785 
    L = ['%s=%r' % (key, value)
21786 
      for key, value in self.__dict__.iteritems()]
21787 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21788 
 
21789 
  def __eq__(self, other):
21790 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21791 
 
21792 
  def __ne__(self, other):
21793 
    return not (self == other)
21794 
 
21795 
class updateAmazonAttributesInBulk_result:
21796 
  """
21797 
  Attributes:
21798 
   - success
21799 
  """
21800 
 
21801 
  thrift_spec = (
21802 
    (0, TType.BOOL, 'success', None, None, ), # 0
21803 
  )
21804 
 
21805 
  def __init__(self, success=None,):
21806 
    self.success = success
21807 
 
21808 
  def read(self, iprot):
21809 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21810 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21811 
      return
21812 
    iprot.readStructBegin()
21813 
    while True:
21814 
      (fname, ftype, fid) = iprot.readFieldBegin()
21815 
      if ftype == TType.STOP:
21816 
        break
21817 
      if fid == 0:
21818 
        if ftype == TType.BOOL:
21819 
          self.success = iprot.readBool();
21820 
        else:
21821 
          iprot.skip(ftype)
21822 
      else:
21823 
        iprot.skip(ftype)
21824 
      iprot.readFieldEnd()
21825 
    iprot.readStructEnd()
21826 
 
21827 
  def write(self, oprot):
21828 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21829 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21830 
      return
21831 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_result')
21832 
    if self.success is not None:
21833 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21834 
      oprot.writeBool(self.success)
21835 
      oprot.writeFieldEnd()
21836 
    oprot.writeFieldStop()
21837 
    oprot.writeStructEnd()
21838 
 
21839 
  def validate(self):
21840 
    return
21841 
 
21842 
 
21843 
  def __repr__(self):
21844 
    L = ['%s=%r' % (key, value)
21845 
      for key, value in self.__dict__.iteritems()]
21846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21847 
 
21848 
  def __eq__(self, other):
21849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21850 
 
21851 
  def __ne__(self, other):
21852 
    return not (self == other)
8379 vikram.rag 21853 
 
21854 
class getAllItemstoListOnFba_args:
21855 
 
21856 
  thrift_spec = (
21857 
  )
21858 
 
21859 
  def read(self, iprot):
21860 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21861 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21862 
      return
21863 
    iprot.readStructBegin()
21864 
    while True:
21865 
      (fname, ftype, fid) = iprot.readFieldBegin()
21866 
      if ftype == TType.STOP:
21867 
        break
21868 
      else:
21869 
        iprot.skip(ftype)
21870 
      iprot.readFieldEnd()
21871 
    iprot.readStructEnd()
21872 
 
21873 
  def write(self, oprot):
21874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21876 
      return
21877 
    oprot.writeStructBegin('getAllItemstoListOnFba_args')
21878 
    oprot.writeFieldStop()
21879 
    oprot.writeStructEnd()
21880 
 
21881 
  def validate(self):
21882 
    return
21883 
 
21884 
 
21885 
  def __repr__(self):
21886 
    L = ['%s=%r' % (key, value)
21887 
      for key, value in self.__dict__.iteritems()]
21888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21889 
 
21890 
  def __eq__(self, other):
21891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21892 
 
21893 
  def __ne__(self, other):
21894 
    return not (self == other)
21895 
 
21896 
class getAllItemstoListOnFba_result:
21897 
  """
21898 
  Attributes:
21899 
   - success
21900 
  """
21901 
 
21902 
  thrift_spec = (
21903 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
21904 
  )
21905 
 
21906 
  def __init__(self, success=None,):
21907 
    self.success = success
21908 
 
21909 
  def read(self, iprot):
21910 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21911 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21912 
      return
21913 
    iprot.readStructBegin()
21914 
    while True:
21915 
      (fname, ftype, fid) = iprot.readFieldBegin()
21916 
      if ftype == TType.STOP:
21917 
        break
21918 
      if fid == 0:
21919 
        if ftype == TType.LIST:
21920 
          self.success = []
9155 kshitij.so 21921 
          (_etype493, _size490) = iprot.readListBegin()
21922 
          for _i494 in xrange(_size490):
21923 
            _elem495 = Amazonlisted()
21924 
            _elem495.read(iprot)
21925 
            self.success.append(_elem495)
8379 vikram.rag 21926 
          iprot.readListEnd()
21927 
        else:
21928 
          iprot.skip(ftype)
21929 
      else:
21930 
        iprot.skip(ftype)
21931 
      iprot.readFieldEnd()
21932 
    iprot.readStructEnd()
21933 
 
21934 
  def write(self, oprot):
21935 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21936 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21937 
      return
21938 
    oprot.writeStructBegin('getAllItemstoListOnFba_result')
21939 
    if self.success is not None:
21940 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21941 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21942 
      for iter496 in self.success:
21943 
        iter496.write(oprot)
8379 vikram.rag 21944 
      oprot.writeListEnd()
21945 
      oprot.writeFieldEnd()
21946 
    oprot.writeFieldStop()
21947 
    oprot.writeStructEnd()
21948 
 
21949 
  def validate(self):
21950 
    return
21951 
 
21952 
 
21953 
  def __repr__(self):
21954 
    L = ['%s=%r' % (key, value)
21955 
      for key, value in self.__dict__.iteritems()]
21956 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21957 
 
21958 
  def __eq__(self, other):
21959 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21960 
 
21961 
  def __ne__(self, other):
21962 
    return not (self == other)
21963 
 
21964 
class getAllItemstoListOnNonFba_args:
21965 
 
21966 
  thrift_spec = (
21967 
  )
21968 
 
21969 
  def read(self, iprot):
21970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21972 
      return
21973 
    iprot.readStructBegin()
21974 
    while True:
21975 
      (fname, ftype, fid) = iprot.readFieldBegin()
21976 
      if ftype == TType.STOP:
21977 
        break
21978 
      else:
21979 
        iprot.skip(ftype)
21980 
      iprot.readFieldEnd()
21981 
    iprot.readStructEnd()
21982 
 
21983 
  def write(self, oprot):
21984 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21985 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21986 
      return
21987 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_args')
21988 
    oprot.writeFieldStop()
21989 
    oprot.writeStructEnd()
21990 
 
21991 
  def validate(self):
21992 
    return
21993 
 
21994 
 
21995 
  def __repr__(self):
21996 
    L = ['%s=%r' % (key, value)
21997 
      for key, value in self.__dict__.iteritems()]
21998 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21999 
 
22000 
  def __eq__(self, other):
22001 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22002 
 
22003 
  def __ne__(self, other):
22004 
    return not (self == other)
22005 
 
22006 
class getAllItemstoListOnNonFba_result:
22007 
  """
22008 
  Attributes:
22009 
   - success
22010 
  """
22011 
 
22012 
  thrift_spec = (
22013 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
22014 
  )
22015 
 
22016 
  def __init__(self, success=None,):
22017 
    self.success = success
22018 
 
22019 
  def read(self, iprot):
22020 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22021 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22022 
      return
22023 
    iprot.readStructBegin()
22024 
    while True:
22025 
      (fname, ftype, fid) = iprot.readFieldBegin()
22026 
      if ftype == TType.STOP:
22027 
        break
22028 
      if fid == 0:
22029 
        if ftype == TType.LIST:
22030 
          self.success = []
9155 kshitij.so 22031 
          (_etype500, _size497) = iprot.readListBegin()
22032 
          for _i501 in xrange(_size497):
22033 
            _elem502 = Amazonlisted()
22034 
            _elem502.read(iprot)
22035 
            self.success.append(_elem502)
8379 vikram.rag 22036 
          iprot.readListEnd()
22037 
        else:
22038 
          iprot.skip(ftype)
22039 
      else:
22040 
        iprot.skip(ftype)
22041 
      iprot.readFieldEnd()
22042 
    iprot.readStructEnd()
22043 
 
22044 
  def write(self, oprot):
22045 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22046 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22047 
      return
22048 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_result')
22049 
    if self.success is not None:
22050 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22051 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22052 
      for iter503 in self.success:
22053 
        iter503.write(oprot)
8379 vikram.rag 22054 
      oprot.writeListEnd()
22055 
      oprot.writeFieldEnd()
22056 
    oprot.writeFieldStop()
22057 
    oprot.writeStructEnd()
22058 
 
22059 
  def validate(self):
22060 
    return
22061 
 
22062 
 
22063 
  def __repr__(self):
22064 
    L = ['%s=%r' % (key, value)
22065 
      for key, value in self.__dict__.iteritems()]
22066 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22067 
 
22068 
  def __eq__(self, other):
22069 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22070 
 
22071 
  def __ne__(self, other):
22072 
    return not (self == other)
8616 vikram.rag 22073 
 
9242 kshitij.so 22074 
class updateAsin_args:
22075 
  """
22076 
  Attributes:
22077 
   - item
22078 
  """
8616 vikram.rag 22079 
 
22080 
  thrift_spec = (
9242 kshitij.so 22081 
    None, # 0
22082 
    (1, TType.MAP, 'item', (TType.I64,None,TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 1
8616 vikram.rag 22083 
  )
22084 
 
9242 kshitij.so 22085 
  def __init__(self, item=None,):
22086 
    self.item = item
22087 
 
8616 vikram.rag 22088 
  def read(self, iprot):
22089 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22090 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22091 
      return
22092 
    iprot.readStructBegin()
22093 
    while True:
22094 
      (fname, ftype, fid) = iprot.readFieldBegin()
22095 
      if ftype == TType.STOP:
22096 
        break
9242 kshitij.so 22097 
      if fid == 1:
22098 
        if ftype == TType.MAP:
22099 
          self.item = {}
22100 
          (_ktype505, _vtype506, _size504 ) = iprot.readMapBegin()
22101 
          for _i508 in xrange(_size504):
22102 
            _key509 = iprot.readI64();
22103 
            _val510 = Item()
22104 
            _val510.read(iprot)
22105 
            self.item[_key509] = _val510
22106 
          iprot.readMapEnd()
22107 
        else:
22108 
          iprot.skip(ftype)
8616 vikram.rag 22109 
      else:
22110 
        iprot.skip(ftype)
22111 
      iprot.readFieldEnd()
22112 
    iprot.readStructEnd()
22113 
 
22114 
  def write(self, oprot):
22115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22117 
      return
9242 kshitij.so 22118 
    oprot.writeStructBegin('updateAsin_args')
22119 
    if self.item is not None:
22120 
      oprot.writeFieldBegin('item', TType.MAP, 1)
22121 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.item))
22122 
      for kiter511,viter512 in self.item.items():
22123 
        oprot.writeI64(kiter511)
22124 
        viter512.write(oprot)
22125 
      oprot.writeMapEnd()
22126 
      oprot.writeFieldEnd()
8616 vikram.rag 22127 
    oprot.writeFieldStop()
22128 
    oprot.writeStructEnd()
22129 
 
22130 
  def validate(self):
22131 
    return
22132 
 
22133 
 
22134 
  def __repr__(self):
22135 
    L = ['%s=%r' % (key, value)
22136 
      for key, value in self.__dict__.iteritems()]
22137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22138 
 
22139 
  def __eq__(self, other):
22140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22141 
 
22142 
  def __ne__(self, other):
22143 
    return not (self == other)
22144 
 
9242 kshitij.so 22145 
class updateAsin_result:
8616 vikram.rag 22146 
 
22147 
  thrift_spec = (
22148 
  )
22149 
 
22150 
  def read(self, iprot):
22151 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22152 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22153 
      return
22154 
    iprot.readStructBegin()
22155 
    while True:
22156 
      (fname, ftype, fid) = iprot.readFieldBegin()
22157 
      if ftype == TType.STOP:
22158 
        break
22159 
      else:
22160 
        iprot.skip(ftype)
22161 
      iprot.readFieldEnd()
22162 
    iprot.readStructEnd()
22163 
 
22164 
  def write(self, oprot):
22165 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22166 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22167 
      return
9242 kshitij.so 22168 
    oprot.writeStructBegin('updateAsin_result')
8616 vikram.rag 22169 
    oprot.writeFieldStop()
22170 
    oprot.writeStructEnd()
22171 
 
22172 
  def validate(self):
22173 
    return
22174 
 
22175 
 
22176 
  def __repr__(self):
22177 
    L = ['%s=%r' % (key, value)
22178 
      for key, value in self.__dict__.iteritems()]
22179 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22180 
 
22181 
  def __eq__(self, other):
22182 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22183 
 
22184 
  def __ne__(self, other):
22185 
    return not (self == other)
8619 kshitij.so 22186 
 
9242 kshitij.so 22187 
class addOrUpdateSnapdealItem_args:
8619 kshitij.so 22188 
  """
22189 
  Attributes:
9242 kshitij.so 22190 
   - snapdealitem
8619 kshitij.so 22191 
  """
22192 
 
9242 kshitij.so 22193 
  thrift_spec = None
22194 
  def __init__(self, snapdealitem=None,):
22195 
    self.snapdealitem = snapdealitem
8619 kshitij.so 22196 
 
22197 
  def read(self, iprot):
22198 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22199 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22200 
      return
22201 
    iprot.readStructBegin()
22202 
    while True:
22203 
      (fname, ftype, fid) = iprot.readFieldBegin()
22204 
      if ftype == TType.STOP:
22205 
        break
9242 kshitij.so 22206 
      if fid == -1:
22207 
        if ftype == TType.STRUCT:
22208 
          self.snapdealitem = SnapdealItem()
22209 
          self.snapdealitem.read(iprot)
8619 kshitij.so 22210 
        else:
22211 
          iprot.skip(ftype)
22212 
      else:
22213 
        iprot.skip(ftype)
22214 
      iprot.readFieldEnd()
22215 
    iprot.readStructEnd()
22216 
 
22217 
  def write(self, oprot):
22218 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22219 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22220 
      return
9242 kshitij.so 22221 
    oprot.writeStructBegin('addOrUpdateSnapdealItem_args')
22222 
    if self.snapdealitem is not None:
22223 
      oprot.writeFieldBegin('snapdealitem', TType.STRUCT, -1)
22224 
      self.snapdealitem.write(oprot)
8619 kshitij.so 22225 
      oprot.writeFieldEnd()
22226 
    oprot.writeFieldStop()
22227 
    oprot.writeStructEnd()
22228 
 
22229 
  def validate(self):
22230 
    return
22231 
 
22232 
 
22233 
  def __repr__(self):
22234 
    L = ['%s=%r' % (key, value)
22235 
      for key, value in self.__dict__.iteritems()]
22236 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22237 
 
22238 
  def __eq__(self, other):
22239 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22240 
 
22241 
  def __ne__(self, other):
22242 
    return not (self == other)
22243 
 
9242 kshitij.so 22244 
class addOrUpdateSnapdealItem_result:
22245 
  """
22246 
  Attributes:
22247 
   - success
22248 
  """
8619 kshitij.so 22249 
 
22250 
  thrift_spec = (
9242 kshitij.so 22251 
    (0, TType.BOOL, 'success', None, None, ), # 0
8619 kshitij.so 22252 
  )
22253 
 
9242 kshitij.so 22254 
  def __init__(self, success=None,):
22255 
    self.success = success
22256 
 
8619 kshitij.so 22257 
  def read(self, iprot):
22258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22260 
      return
22261 
    iprot.readStructBegin()
22262 
    while True:
22263 
      (fname, ftype, fid) = iprot.readFieldBegin()
22264 
      if ftype == TType.STOP:
22265 
        break
9242 kshitij.so 22266 
      if fid == 0:
22267 
        if ftype == TType.BOOL:
22268 
          self.success = iprot.readBool();
22269 
        else:
22270 
          iprot.skip(ftype)
8619 kshitij.so 22271 
      else:
22272 
        iprot.skip(ftype)
22273 
      iprot.readFieldEnd()
22274 
    iprot.readStructEnd()
22275 
 
22276 
  def write(self, oprot):
22277 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22278 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22279 
      return
9242 kshitij.so 22280 
    oprot.writeStructBegin('addOrUpdateSnapdealItem_result')
22281 
    if self.success is not None:
22282 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22283 
      oprot.writeBool(self.success)
22284 
      oprot.writeFieldEnd()
8619 kshitij.so 22285 
    oprot.writeFieldStop()
22286 
    oprot.writeStructEnd()
22287 
 
22288 
  def validate(self):
22289 
    return
22290 
 
22291 
 
22292 
  def __repr__(self):
22293 
    L = ['%s=%r' % (key, value)
22294 
      for key, value in self.__dict__.iteritems()]
22295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22296 
 
22297 
  def __eq__(self, other):
22298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22299 
 
22300 
  def __ne__(self, other):
22301 
    return not (self == other)
8739 vikram.rag 22302 
 
9242 kshitij.so 22303 
class getSnapdealItem_args:
8739 vikram.rag 22304 
  """
22305 
  Attributes:
9242 kshitij.so 22306 
   - item_id
8739 vikram.rag 22307 
  """
22308 
 
9242 kshitij.so 22309 
  thrift_spec = (
22310 
    None, # 0
22311 
    (1, TType.I64, 'item_id', None, None, ), # 1
22312 
  )
8739 vikram.rag 22313 
 
9242 kshitij.so 22314 
  def __init__(self, item_id=None,):
22315 
    self.item_id = item_id
22316 
 
8739 vikram.rag 22317 
  def read(self, iprot):
22318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22320 
      return
22321 
    iprot.readStructBegin()
22322 
    while True:
22323 
      (fname, ftype, fid) = iprot.readFieldBegin()
22324 
      if ftype == TType.STOP:
22325 
        break
9242 kshitij.so 22326 
      if fid == 1:
22327 
        if ftype == TType.I64:
22328 
          self.item_id = iprot.readI64();
8739 vikram.rag 22329 
        else:
22330 
          iprot.skip(ftype)
22331 
      else:
22332 
        iprot.skip(ftype)
22333 
      iprot.readFieldEnd()
22334 
    iprot.readStructEnd()
22335 
 
22336 
  def write(self, oprot):
22337 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22338 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22339 
      return
9242 kshitij.so 22340 
    oprot.writeStructBegin('getSnapdealItem_args')
22341 
    if self.item_id is not None:
22342 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
22343 
      oprot.writeI64(self.item_id)
8739 vikram.rag 22344 
      oprot.writeFieldEnd()
22345 
    oprot.writeFieldStop()
22346 
    oprot.writeStructEnd()
22347 
 
22348 
  def validate(self):
22349 
    return
22350 
 
22351 
 
22352 
  def __repr__(self):
22353 
    L = ['%s=%r' % (key, value)
22354 
      for key, value in self.__dict__.iteritems()]
22355 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22356 
 
22357 
  def __eq__(self, other):
22358 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22359 
 
22360 
  def __ne__(self, other):
22361 
    return not (self == other)
22362 
 
9242 kshitij.so 22363 
class getSnapdealItem_result:
8739 vikram.rag 22364 
  """
22365 
  Attributes:
22366 
   - success
22367 
  """
22368 
 
22369 
  thrift_spec = (
9242 kshitij.so 22370 
    (0, TType.STRUCT, 'success', (SnapdealItem, SnapdealItem.thrift_spec), None, ), # 0
8739 vikram.rag 22371 
  )
22372 
 
22373 
  def __init__(self, success=None,):
22374 
    self.success = success
22375 
 
22376 
  def read(self, iprot):
22377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22379 
      return
22380 
    iprot.readStructBegin()
22381 
    while True:
22382 
      (fname, ftype, fid) = iprot.readFieldBegin()
22383 
      if ftype == TType.STOP:
22384 
        break
22385 
      if fid == 0:
9242 kshitij.so 22386 
        if ftype == TType.STRUCT:
22387 
          self.success = SnapdealItem()
22388 
          self.success.read(iprot)
8739 vikram.rag 22389 
        else:
22390 
          iprot.skip(ftype)
22391 
      else:
22392 
        iprot.skip(ftype)
22393 
      iprot.readFieldEnd()
22394 
    iprot.readStructEnd()
22395 
 
22396 
  def write(self, oprot):
22397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22399 
      return
9242 kshitij.so 22400 
    oprot.writeStructBegin('getSnapdealItem_result')
8739 vikram.rag 22401 
    if self.success is not None:
9242 kshitij.so 22402 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22403 
      self.success.write(oprot)
8739 vikram.rag 22404 
      oprot.writeFieldEnd()
22405 
    oprot.writeFieldStop()
22406 
    oprot.writeStructEnd()
22407 
 
22408 
  def validate(self):
22409 
    return
22410 
 
22411 
 
22412 
  def __repr__(self):
22413 
    L = ['%s=%r' % (key, value)
22414 
      for key, value in self.__dict__.iteritems()]
22415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22416 
 
22417 
  def __eq__(self, other):
22418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22419 
 
22420 
  def __ne__(self, other):
22421 
    return not (self == other)
22422 
 
9242 kshitij.so 22423 
class getSnapdealItemDetails_args:
8739 vikram.rag 22424 
  """
22425 
  Attributes:
22426 
   - item_id
22427 
  """
22428 
 
22429 
  thrift_spec = (
22430 
    None, # 0
22431 
    (1, TType.I64, 'item_id', None, None, ), # 1
22432 
  )
22433 
 
22434 
  def __init__(self, item_id=None,):
22435 
    self.item_id = item_id
22436 
 
22437 
  def read(self, iprot):
22438 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22439 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22440 
      return
22441 
    iprot.readStructBegin()
22442 
    while True:
22443 
      (fname, ftype, fid) = iprot.readFieldBegin()
22444 
      if ftype == TType.STOP:
22445 
        break
22446 
      if fid == 1:
22447 
        if ftype == TType.I64:
22448 
          self.item_id = iprot.readI64();
22449 
        else:
22450 
          iprot.skip(ftype)
22451 
      else:
22452 
        iprot.skip(ftype)
22453 
      iprot.readFieldEnd()
22454 
    iprot.readStructEnd()
22455 
 
22456 
  def write(self, oprot):
22457 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22458 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22459 
      return
9242 kshitij.so 22460 
    oprot.writeStructBegin('getSnapdealItemDetails_args')
8739 vikram.rag 22461 
    if self.item_id is not None:
22462 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
22463 
      oprot.writeI64(self.item_id)
22464 
      oprot.writeFieldEnd()
22465 
    oprot.writeFieldStop()
22466 
    oprot.writeStructEnd()
22467 
 
22468 
  def validate(self):
22469 
    return
22470 
 
22471 
 
22472 
  def __repr__(self):
22473 
    L = ['%s=%r' % (key, value)
22474 
      for key, value in self.__dict__.iteritems()]
22475 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22476 
 
22477 
  def __eq__(self, other):
22478 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22479 
 
22480 
  def __ne__(self, other):
22481 
    return not (self == other)
22482 
 
9242 kshitij.so 22483 
class getSnapdealItemDetails_result:
8739 vikram.rag 22484 
  """
22485 
  Attributes:
22486 
   - success
22487 
  """
22488 
 
22489 
  thrift_spec = (
9242 kshitij.so 22490 
    (0, TType.STRUCT, 'success', (SnapdealItemDetails, SnapdealItemDetails.thrift_spec), None, ), # 0
8739 vikram.rag 22491 
  )
22492 
 
22493 
  def __init__(self, success=None,):
22494 
    self.success = success
22495 
 
22496 
  def read(self, iprot):
22497 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22498 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22499 
      return
22500 
    iprot.readStructBegin()
22501 
    while True:
22502 
      (fname, ftype, fid) = iprot.readFieldBegin()
22503 
      if ftype == TType.STOP:
22504 
        break
22505 
      if fid == 0:
22506 
        if ftype == TType.STRUCT:
9242 kshitij.so 22507 
          self.success = SnapdealItemDetails()
8739 vikram.rag 22508 
          self.success.read(iprot)
22509 
        else:
22510 
          iprot.skip(ftype)
22511 
      else:
22512 
        iprot.skip(ftype)
22513 
      iprot.readFieldEnd()
22514 
    iprot.readStructEnd()
22515 
 
22516 
  def write(self, oprot):
22517 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22518 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22519 
      return
9242 kshitij.so 22520 
    oprot.writeStructBegin('getSnapdealItemDetails_result')
8739 vikram.rag 22521 
    if self.success is not None:
22522 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22523 
      self.success.write(oprot)
22524 
      oprot.writeFieldEnd()
22525 
    oprot.writeFieldStop()
22526 
    oprot.writeStructEnd()
22527 
 
22528 
  def validate(self):
22529 
    return
22530 
 
22531 
 
22532 
  def __repr__(self):
22533 
    L = ['%s=%r' % (key, value)
22534 
      for key, value in self.__dict__.iteritems()]
22535 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22536 
 
22537 
  def __eq__(self, other):
22538 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22539 
 
22540 
  def __ne__(self, other):
22541 
    return not (self == other)
22542 
 
22543 
class getAllSnapdealItems_args:
22544 
 
22545 
  thrift_spec = (
22546 
  )
22547 
 
22548 
  def read(self, iprot):
22549 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22550 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22551 
      return
22552 
    iprot.readStructBegin()
22553 
    while True:
22554 
      (fname, ftype, fid) = iprot.readFieldBegin()
22555 
      if ftype == TType.STOP:
22556 
        break
22557 
      else:
22558 
        iprot.skip(ftype)
22559 
      iprot.readFieldEnd()
22560 
    iprot.readStructEnd()
22561 
 
22562 
  def write(self, oprot):
22563 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22564 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22565 
      return
22566 
    oprot.writeStructBegin('getAllSnapdealItems_args')
22567 
    oprot.writeFieldStop()
22568 
    oprot.writeStructEnd()
22569 
 
22570 
  def validate(self):
22571 
    return
22572 
 
22573 
 
22574 
  def __repr__(self):
22575 
    L = ['%s=%r' % (key, value)
22576 
      for key, value in self.__dict__.iteritems()]
22577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22578 
 
22579 
  def __eq__(self, other):
22580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22581 
 
22582 
  def __ne__(self, other):
22583 
    return not (self == other)
22584 
 
22585 
class getAllSnapdealItems_result:
22586 
  """
22587 
  Attributes:
22588 
   - success
22589 
  """
22590 
 
22591 
  thrift_spec = (
9242 kshitij.so 22592 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
8739 vikram.rag 22593 
  )
22594 
 
22595 
  def __init__(self, success=None,):
22596 
    self.success = success
22597 
 
22598 
  def read(self, iprot):
22599 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22600 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22601 
      return
22602 
    iprot.readStructBegin()
22603 
    while True:
22604 
      (fname, ftype, fid) = iprot.readFieldBegin()
22605 
      if ftype == TType.STOP:
22606 
        break
22607 
      if fid == 0:
22608 
        if ftype == TType.LIST:
22609 
          self.success = []
9242 kshitij.so 22610 
          (_etype516, _size513) = iprot.readListBegin()
22611 
          for _i517 in xrange(_size513):
22612 
            _elem518 = SnapdealItemDetails()
22613 
            _elem518.read(iprot)
22614 
            self.success.append(_elem518)
22615 
          iprot.readListEnd()
22616 
        else:
22617 
          iprot.skip(ftype)
22618 
      else:
22619 
        iprot.skip(ftype)
22620 
      iprot.readFieldEnd()
22621 
    iprot.readStructEnd()
22622 
 
22623 
  def write(self, oprot):
22624 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22625 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22626 
      return
22627 
    oprot.writeStructBegin('getAllSnapdealItems_result')
22628 
    if self.success is not None:
22629 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22630 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
22631 
      for iter519 in self.success:
22632 
        iter519.write(oprot)
22633 
      oprot.writeListEnd()
22634 
      oprot.writeFieldEnd()
22635 
    oprot.writeFieldStop()
22636 
    oprot.writeStructEnd()
22637 
 
22638 
  def validate(self):
22639 
    return
22640 
 
22641 
 
22642 
  def __repr__(self):
22643 
    L = ['%s=%r' % (key, value)
22644 
      for key, value in self.__dict__.iteritems()]
22645 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22646 
 
22647 
  def __eq__(self, other):
22648 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22649 
 
22650 
  def __ne__(self, other):
22651 
    return not (self == other)
22652 
 
22653 
class getSnapdealItems_args:
22654 
  """
22655 
  Attributes:
22656 
   - offset
22657 
   - limit
22658 
  """
22659 
 
22660 
  thrift_spec = (
22661 
    None, # 0
22662 
    (1, TType.I64, 'offset', None, None, ), # 1
22663 
    (2, TType.I64, 'limit', None, None, ), # 2
22664 
  )
22665 
 
22666 
  def __init__(self, offset=None, limit=None,):
22667 
    self.offset = offset
22668 
    self.limit = limit
22669 
 
22670 
  def read(self, iprot):
22671 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22672 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22673 
      return
22674 
    iprot.readStructBegin()
22675 
    while True:
22676 
      (fname, ftype, fid) = iprot.readFieldBegin()
22677 
      if ftype == TType.STOP:
22678 
        break
22679 
      if fid == 1:
22680 
        if ftype == TType.I64:
22681 
          self.offset = iprot.readI64();
22682 
        else:
22683 
          iprot.skip(ftype)
22684 
      elif fid == 2:
22685 
        if ftype == TType.I64:
22686 
          self.limit = iprot.readI64();
22687 
        else:
22688 
          iprot.skip(ftype)
22689 
      else:
22690 
        iprot.skip(ftype)
22691 
      iprot.readFieldEnd()
22692 
    iprot.readStructEnd()
22693 
 
22694 
  def write(self, oprot):
22695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22697 
      return
22698 
    oprot.writeStructBegin('getSnapdealItems_args')
22699 
    if self.offset is not None:
22700 
      oprot.writeFieldBegin('offset', TType.I64, 1)
22701 
      oprot.writeI64(self.offset)
22702 
      oprot.writeFieldEnd()
22703 
    if self.limit is not None:
22704 
      oprot.writeFieldBegin('limit', TType.I64, 2)
22705 
      oprot.writeI64(self.limit)
22706 
      oprot.writeFieldEnd()
22707 
    oprot.writeFieldStop()
22708 
    oprot.writeStructEnd()
22709 
 
22710 
  def validate(self):
22711 
    return
22712 
 
22713 
 
22714 
  def __repr__(self):
22715 
    L = ['%s=%r' % (key, value)
22716 
      for key, value in self.__dict__.iteritems()]
22717 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22718 
 
22719 
  def __eq__(self, other):
22720 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22721 
 
22722 
  def __ne__(self, other):
22723 
    return not (self == other)
22724 
 
22725 
class getSnapdealItems_result:
22726 
  """
22727 
  Attributes:
22728 
   - success
22729 
  """
22730 
 
22731 
  thrift_spec = (
22732 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
22733 
  )
22734 
 
22735 
  def __init__(self, success=None,):
22736 
    self.success = success
22737 
 
22738 
  def read(self, iprot):
22739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22741 
      return
22742 
    iprot.readStructBegin()
22743 
    while True:
22744 
      (fname, ftype, fid) = iprot.readFieldBegin()
22745 
      if ftype == TType.STOP:
22746 
        break
22747 
      if fid == 0:
22748 
        if ftype == TType.LIST:
22749 
          self.success = []
9155 kshitij.so 22750 
          (_etype523, _size520) = iprot.readListBegin()
22751 
          for _i524 in xrange(_size520):
9242 kshitij.so 22752 
            _elem525 = SnapdealItemDetails()
9155 kshitij.so 22753 
            _elem525.read(iprot)
22754 
            self.success.append(_elem525)
8739 vikram.rag 22755 
          iprot.readListEnd()
22756 
        else:
22757 
          iprot.skip(ftype)
22758 
      else:
22759 
        iprot.skip(ftype)
22760 
      iprot.readFieldEnd()
22761 
    iprot.readStructEnd()
22762 
 
22763 
  def write(self, oprot):
22764 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22765 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22766 
      return
9242 kshitij.so 22767 
    oprot.writeStructBegin('getSnapdealItems_result')
8739 vikram.rag 22768 
    if self.success is not None:
22769 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22770 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22771 
      for iter526 in self.success:
22772 
        iter526.write(oprot)
8739 vikram.rag 22773 
      oprot.writeListEnd()
22774 
      oprot.writeFieldEnd()
22775 
    oprot.writeFieldStop()
22776 
    oprot.writeStructEnd()
22777 
 
22778 
  def validate(self):
22779 
    return
22780 
 
22781 
 
22782 
  def __repr__(self):
22783 
    L = ['%s=%r' % (key, value)
22784 
      for key, value in self.__dict__.iteritems()]
22785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22786 
 
22787 
  def __eq__(self, other):
22788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22789 
 
22790 
  def __ne__(self, other):
22791 
    return not (self == other)
9242 kshitij.so 22792 
 
22793 
class searchSnapdealItems_args:
22794 
  """
22795 
  Attributes:
22796 
   - searchTerm
22797 
   - offset
22798 
   - limit
22799 
  """
22800 
 
22801 
  thrift_spec = (
22802 
    None, # 0
22803 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
22804 
    (2, TType.I64, 'offset', None, None, ), # 2
22805 
    (3, TType.I64, 'limit', None, None, ), # 3
22806 
  )
22807 
 
22808 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
22809 
    self.searchTerm = searchTerm
22810 
    self.offset = offset
22811 
    self.limit = limit
22812 
 
22813 
  def read(self, iprot):
22814 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22815 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22816 
      return
22817 
    iprot.readStructBegin()
22818 
    while True:
22819 
      (fname, ftype, fid) = iprot.readFieldBegin()
22820 
      if ftype == TType.STOP:
22821 
        break
22822 
      if fid == 1:
22823 
        if ftype == TType.LIST:
22824 
          self.searchTerm = []
22825 
          (_etype530, _size527) = iprot.readListBegin()
22826 
          for _i531 in xrange(_size527):
22827 
            _elem532 = iprot.readString();
22828 
            self.searchTerm.append(_elem532)
22829 
          iprot.readListEnd()
22830 
        else:
22831 
          iprot.skip(ftype)
22832 
      elif fid == 2:
22833 
        if ftype == TType.I64:
22834 
          self.offset = iprot.readI64();
22835 
        else:
22836 
          iprot.skip(ftype)
22837 
      elif fid == 3:
22838 
        if ftype == TType.I64:
22839 
          self.limit = iprot.readI64();
22840 
        else:
22841 
          iprot.skip(ftype)
22842 
      else:
22843 
        iprot.skip(ftype)
22844 
      iprot.readFieldEnd()
22845 
    iprot.readStructEnd()
22846 
 
22847 
  def write(self, oprot):
22848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22850 
      return
22851 
    oprot.writeStructBegin('searchSnapdealItems_args')
22852 
    if self.searchTerm is not None:
22853 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
22854 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
22855 
      for iter533 in self.searchTerm:
22856 
        oprot.writeString(iter533)
22857 
      oprot.writeListEnd()
22858 
      oprot.writeFieldEnd()
22859 
    if self.offset is not None:
22860 
      oprot.writeFieldBegin('offset', TType.I64, 2)
22861 
      oprot.writeI64(self.offset)
22862 
      oprot.writeFieldEnd()
22863 
    if self.limit is not None:
22864 
      oprot.writeFieldBegin('limit', TType.I64, 3)
22865 
      oprot.writeI64(self.limit)
22866 
      oprot.writeFieldEnd()
22867 
    oprot.writeFieldStop()
22868 
    oprot.writeStructEnd()
22869 
 
22870 
  def validate(self):
22871 
    return
22872 
 
22873 
 
22874 
  def __repr__(self):
22875 
    L = ['%s=%r' % (key, value)
22876 
      for key, value in self.__dict__.iteritems()]
22877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22878 
 
22879 
  def __eq__(self, other):
22880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22881 
 
22882 
  def __ne__(self, other):
22883 
    return not (self == other)
22884 
 
22885 
class searchSnapdealItems_result:
22886 
  """
22887 
  Attributes:
22888 
   - success
22889 
  """
22890 
 
22891 
  thrift_spec = (
22892 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
22893 
  )
22894 
 
22895 
  def __init__(self, success=None,):
22896 
    self.success = success
22897 
 
22898 
  def read(self, iprot):
22899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22901 
      return
22902 
    iprot.readStructBegin()
22903 
    while True:
22904 
      (fname, ftype, fid) = iprot.readFieldBegin()
22905 
      if ftype == TType.STOP:
22906 
        break
22907 
      if fid == 0:
22908 
        if ftype == TType.LIST:
22909 
          self.success = []
22910 
          (_etype537, _size534) = iprot.readListBegin()
22911 
          for _i538 in xrange(_size534):
22912 
            _elem539 = SnapdealItemDetails()
22913 
            _elem539.read(iprot)
22914 
            self.success.append(_elem539)
22915 
          iprot.readListEnd()
22916 
        else:
22917 
          iprot.skip(ftype)
22918 
      else:
22919 
        iprot.skip(ftype)
22920 
      iprot.readFieldEnd()
22921 
    iprot.readStructEnd()
22922 
 
22923 
  def write(self, oprot):
22924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22926 
      return
22927 
    oprot.writeStructBegin('searchSnapdealItems_result')
22928 
    if self.success is not None:
22929 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22930 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
22931 
      for iter540 in self.success:
22932 
        iter540.write(oprot)
22933 
      oprot.writeListEnd()
22934 
      oprot.writeFieldEnd()
22935 
    oprot.writeFieldStop()
22936 
    oprot.writeStructEnd()
22937 
 
22938 
  def validate(self):
22939 
    return
22940 
 
22941 
 
22942 
  def __repr__(self):
22943 
    L = ['%s=%r' % (key, value)
22944 
      for key, value in self.__dict__.iteritems()]
22945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22946 
 
22947 
  def __eq__(self, other):
22948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22949 
 
22950 
  def __ne__(self, other):
22951 
    return not (self == other)
22952 
 
22953 
class getCountForSnapdealItems_args:
22954 
 
22955 
  thrift_spec = (
22956 
  )
22957 
 
22958 
  def read(self, iprot):
22959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22961 
      return
22962 
    iprot.readStructBegin()
22963 
    while True:
22964 
      (fname, ftype, fid) = iprot.readFieldBegin()
22965 
      if ftype == TType.STOP:
22966 
        break
22967 
      else:
22968 
        iprot.skip(ftype)
22969 
      iprot.readFieldEnd()
22970 
    iprot.readStructEnd()
22971 
 
22972 
  def write(self, oprot):
22973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22975 
      return
22976 
    oprot.writeStructBegin('getCountForSnapdealItems_args')
22977 
    oprot.writeFieldStop()
22978 
    oprot.writeStructEnd()
22979 
 
22980 
  def validate(self):
22981 
    return
22982 
 
22983 
 
22984 
  def __repr__(self):
22985 
    L = ['%s=%r' % (key, value)
22986 
      for key, value in self.__dict__.iteritems()]
22987 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22988 
 
22989 
  def __eq__(self, other):
22990 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22991 
 
22992 
  def __ne__(self, other):
22993 
    return not (self == other)
22994 
 
22995 
class getCountForSnapdealItems_result:
22996 
  """
22997 
  Attributes:
22998 
   - success
22999 
  """
23000 
 
23001 
  thrift_spec = (
23002 
    (0, TType.I64, 'success', None, None, ), # 0
23003 
  )
23004 
 
23005 
  def __init__(self, success=None,):
23006 
    self.success = success
23007 
 
23008 
  def read(self, iprot):
23009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23011 
      return
23012 
    iprot.readStructBegin()
23013 
    while True:
23014 
      (fname, ftype, fid) = iprot.readFieldBegin()
23015 
      if ftype == TType.STOP:
23016 
        break
23017 
      if fid == 0:
23018 
        if ftype == TType.I64:
23019 
          self.success = iprot.readI64();
23020 
        else:
23021 
          iprot.skip(ftype)
23022 
      else:
23023 
        iprot.skip(ftype)
23024 
      iprot.readFieldEnd()
23025 
    iprot.readStructEnd()
23026 
 
23027 
  def write(self, oprot):
23028 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23029 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23030 
      return
23031 
    oprot.writeStructBegin('getCountForSnapdealItems_result')
23032 
    if self.success is not None:
23033 
      oprot.writeFieldBegin('success', TType.I64, 0)
23034 
      oprot.writeI64(self.success)
23035 
      oprot.writeFieldEnd()
23036 
    oprot.writeFieldStop()
23037 
    oprot.writeStructEnd()
23038 
 
23039 
  def validate(self):
23040 
    return
23041 
 
23042 
 
23043 
  def __repr__(self):
23044 
    L = ['%s=%r' % (key, value)
23045 
      for key, value in self.__dict__.iteritems()]
23046 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23047 
 
23048 
  def __eq__(self, other):
23049 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23050 
 
23051 
  def __ne__(self, other):
23052 
    return not (self == other)
23053 
 
23054 
class getSnapdealSearchResultCount_args:
23055 
  """
23056 
  Attributes:
23057 
   - searchTerm
23058 
  """
23059 
 
23060 
  thrift_spec = (
23061 
    None, # 0
23062 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
23063 
  )
23064 
 
23065 
  def __init__(self, searchTerm=None,):
23066 
    self.searchTerm = searchTerm
23067 
 
23068 
  def read(self, iprot):
23069 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23070 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23071 
      return
23072 
    iprot.readStructBegin()
23073 
    while True:
23074 
      (fname, ftype, fid) = iprot.readFieldBegin()
23075 
      if ftype == TType.STOP:
23076 
        break
23077 
      if fid == 1:
23078 
        if ftype == TType.LIST:
23079 
          self.searchTerm = []
23080 
          (_etype544, _size541) = iprot.readListBegin()
23081 
          for _i545 in xrange(_size541):
23082 
            _elem546 = iprot.readString();
23083 
            self.searchTerm.append(_elem546)
23084 
          iprot.readListEnd()
23085 
        else:
23086 
          iprot.skip(ftype)
23087 
      else:
23088 
        iprot.skip(ftype)
23089 
      iprot.readFieldEnd()
23090 
    iprot.readStructEnd()
23091 
 
23092 
  def write(self, oprot):
23093 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23094 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23095 
      return
23096 
    oprot.writeStructBegin('getSnapdealSearchResultCount_args')
23097 
    if self.searchTerm is not None:
23098 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
23099 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
23100 
      for iter547 in self.searchTerm:
23101 
        oprot.writeString(iter547)
23102 
      oprot.writeListEnd()
23103 
      oprot.writeFieldEnd()
23104 
    oprot.writeFieldStop()
23105 
    oprot.writeStructEnd()
23106 
 
23107 
  def validate(self):
23108 
    return
23109 
 
23110 
 
23111 
  def __repr__(self):
23112 
    L = ['%s=%r' % (key, value)
23113 
      for key, value in self.__dict__.iteritems()]
23114 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23115 
 
23116 
  def __eq__(self, other):
23117 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23118 
 
23119 
  def __ne__(self, other):
23120 
    return not (self == other)
23121 
 
23122 
class getSnapdealSearchResultCount_result:
23123 
  """
23124 
  Attributes:
23125 
   - success
23126 
  """
23127 
 
23128 
  thrift_spec = (
23129 
    (0, TType.I64, 'success', None, None, ), # 0
23130 
  )
23131 
 
23132 
  def __init__(self, success=None,):
23133 
    self.success = success
23134 
 
23135 
  def read(self, iprot):
23136 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23137 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23138 
      return
23139 
    iprot.readStructBegin()
23140 
    while True:
23141 
      (fname, ftype, fid) = iprot.readFieldBegin()
23142 
      if ftype == TType.STOP:
23143 
        break
23144 
      if fid == 0:
23145 
        if ftype == TType.I64:
23146 
          self.success = iprot.readI64();
23147 
        else:
23148 
          iprot.skip(ftype)
23149 
      else:
23150 
        iprot.skip(ftype)
23151 
      iprot.readFieldEnd()
23152 
    iprot.readStructEnd()
23153 
 
23154 
  def write(self, oprot):
23155 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23156 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23157 
      return
23158 
    oprot.writeStructBegin('getSnapdealSearchResultCount_result')
23159 
    if self.success is not None:
23160 
      oprot.writeFieldBegin('success', TType.I64, 0)
23161 
      oprot.writeI64(self.success)
23162 
      oprot.writeFieldEnd()
23163 
    oprot.writeFieldStop()
23164 
    oprot.writeStructEnd()
23165 
 
23166 
  def validate(self):
23167 
    return
23168 
 
23169 
 
23170 
  def __repr__(self):
23171 
    L = ['%s=%r' % (key, value)
23172 
      for key, value in self.__dict__.iteritems()]
23173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23174 
 
23175 
  def __eq__(self, other):
23176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23177 
 
23178 
  def __ne__(self, other):
23179 
    return not (self == other)