Subversion Repositories SmartDukaan

Rev

Rev 19413 | Rev 22717 | 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 addWarehouse(self, warehouse):
21 
    """
22 
    Parameters:
23 
     - warehouse
24 
    """
25 
    pass
26 
 
27 
  def addVendor(self, vendor):
28 
    """
29 
    add a new vendor
30 
 
31 
    Parameters:
32 
     - vendor
33 
    """
34 
    pass
35 
 
36 
  def updateInventoryHistory(self, warehouse_id, timestamp, availability):
37 
    """
38 
    Stores the incremental warehouse updates of items.
39 
 
40 
    Parameters:
41 
     - warehouse_id
42 
     - timestamp
43 
     - availability
44 
    """
45 
    pass
46 
 
47 
  def updateInventory(self, warehouse_id, timestamp, availability):
48 
    """
49 
    Stores the final inventory stocks of items.
50 
 
51 
    Parameters:
52 
     - warehouse_id
53 
     - timestamp
54 
     - availability
55 
    """
56 
    pass
57 
 
58 
  def addInventory(self, itemId, warehouseId, quantity):
59 
    """
60 
    Add the inventory to existing stock.
61 
 
62 
    Parameters:
63 
     - itemId
64 
     - warehouseId
65 
     - quantity
66 
    """
67 
    pass
68 
 
69 
  def retireWarehouse(self, warehouse_id):
70 
    """
71 
    Parameters:
72 
     - warehouse_id
73 
    """
74 
    pass
75 
 
76 
  def getItemInventoryByItemId(self, item_id):
77 
    """
78 
    Parameters:
79 
     - item_id
80 
    """
81 
    pass
82 
 
83 
  def getItemAvailibilityAtWarehouse(self, warehouse_id, item_id):
84 
    """
85 
    Parameters:
86 
     - warehouse_id
87 
     - item_id
88 
    """
89 
    pass
90 
 
5978 rajveer 91 
  def getItemAvailabilityAtLocation(self, itemId, sourceId):
5944 mandeep.dh 92 
    """
93 
    Determines the warehouse that should be used to fulfil an order for the given item.
94 
    It first checks all the warehouses which are in the logistics location given by the
95 
    warehouse_loc parameter. If none of the warehouses there have any inventory, then the
96 
    preferred warehouse for the item is used.
97 
 
98 
    Returns an ordered list of size 4 with following elements in the given order:
99 
    1. Id of the fulfillment warehouse which was finally picked up.
100 
    2. Expected delay added by the category manager.
101 
    3. Id of the billing warehouse which was finally picked up.
102 
 
103 
    Parameters:
104 
     - itemId
5978 rajveer 105 
     - sourceId
5944 mandeep.dh 106 
    """
107 
    pass
108 
 
109 
  def getAllWarehouses(self, isActive):
110 
    """
111 
    Parameters:
112 
     - isActive
113 
    """
114 
    pass
115 
 
116 
  def getWarehouse(self, warehouse_id):
117 
    """
118 
    Returns the warehouse with the given id.
119 
 
120 
    Parameters:
121 
     - warehouse_id
122 
    """
123 
    pass
124 
 
125 
  def getAllItemsForWarehouse(self, warehouse_id):
126 
    """
127 
    Parameters:
128 
     - warehouse_id
129 
    """
130 
    pass
131 
 
5966 rajveer 132 
  def isOrderBillable(self, itemId, warehouseId, sourceId, orderId):
5944 mandeep.dh 133 
    """
5966 rajveer 134 
    Depending on reservation in the table, verify if we can bill this order or not.
135 
 
136 
    Parameters:
137 
     - itemId
138 
     - warehouseId
139 
     - sourceId
140 
     - orderId
141 
    """
142 
    pass
143 
 
144 
  def reserveItemInWarehouse(self, itemId, warehouseId, sourceId, orderId, createdTimestamp, promisedShippingTimestamp, quantity):
145 
    """
5944 mandeep.dh 146 
    Increases the reservation count for an item in a warehouse. Should always succeed normally.
147 
 
148 
    Parameters:
149 
     - itemId
150 
     - warehouseId
5966 rajveer 151 
     - sourceId
152 
     - orderId
153 
     - createdTimestamp
154 
     - promisedShippingTimestamp
5944 mandeep.dh 155 
     - quantity
156 
    """
157 
    pass
158 
 
7968 amar.kumar 159 
  def updateReservationForOrder(self, itemId, warehouseId, sourceId, orderId, createdTimestamp, promisedShippingTimestamp, quantity):
160 
    """
161 
    Updates the reservation for Order
162 
 
163 
    Parameters:
164 
     - itemId
165 
     - warehouseId
166 
     - sourceId
167 
     - orderId
168 
     - createdTimestamp
169 
     - promisedShippingTimestamp
170 
     - quantity
171 
    """
172 
    pass
173 
 
5966 rajveer 174 
  def reduceReservationCount(self, itemId, warehouseId, sourceId, orderId, quantity):
5944 mandeep.dh 175 
    """
176 
    Decreases the reservation count for an item in a warehouse. Should always succeed normally.
177 
 
178 
    Parameters:
179 
     - itemId
180 
     - warehouseId
5966 rajveer 181 
     - sourceId
182 
     - orderId
5944 mandeep.dh 183 
     - quantity
184 
    """
185 
    pass
186 
 
187 
  def getItemPricing(self, itemId, vendorId):
188 
    """
189 
    Returns the pricing information of an item associated with the vendor of the given warehouse.
190 
    Raises an exception if either the item, vendor or the associated pricing information can't be found.
191 
 
192 
    Parameters:
193 
     - itemId
194 
     - vendorId
195 
    """
196 
    pass
197 
 
198 
  def getAllItemPricing(self, itemId):
199 
    """
200 
    Returns the list of vendor pricing information of an item.
201 
    Raises an exception if item not found corresponding to itemId
202 
 
203 
    Parameters:
204 
     - itemId
205 
    """
206 
    pass
207 
 
208 
  def addVendorItemPricing(self, vendorItemPricing):
209 
    """
210 
    Adds vendor prices corresponding to the item. If pricing already exists then updates the prices.
211 
    Raises an exception if either the item or vendor can't be found corresponding to their ids.
212 
 
213 
    Parameters:
214 
     - vendorItemPricing
215 
    """
216 
    pass
217 
 
218 
  def getVendor(self, vendorId):
219 
    """
220 
    Returns a vendor given its id
221 
 
222 
    Parameters:
223 
     - vendorId
224 
    """
225 
    pass
226 
 
227 
  def getAllVendors(self, ):
228 
    """
229 
    Return list of all vendors
230 
    """
231 
    pass
232 
 
233 
  def addVendorItemMapping(self, key, vendorItemMapping):
234 
    """
235 
    Adds VendorItemMapping. Updates VendorItemMapping if exists corresponding to the item key.
236 
 
237 
    Parameters:
238 
     - key
239 
     - vendorItemMapping
240 
    """
241 
    pass
242 
 
243 
  def getVendorItemMappings(self, itemId):
244 
    """
245 
    Returns the list of vendor item mapping corresponding to itemId passed as parameter.
246 
    Raises an exception if item not found corresponding to itemId
247 
 
248 
    Parameters:
249 
     - itemId
250 
    """
251 
    pass
252 
 
253 
  def getPendingOrdersInventory(self, vendorid):
254 
    """
255 
    Returns a list of inventory stock for items for which there are pending orders for the given vendor.
256 
 
257 
    Parameters:
258 
     - vendorid
259 
    """
260 
    pass
261 
 
262 
  def getWarehouses(self, warehouseType, inventoryType, vendorId, billingWarehouseId, shippingWarehouseId):
263 
    """
264 
    This method returns all warehouses for a given warehosueType, inventoryType, vendor, billingWarehouse and shippingWarehouse.
265 
    getWarehouses(WarehouseType.OURS, InventoryType.GOOD, 3, 7, 7) would return ours warehouse with GOOD type inventory for vendor 1 for billing warehouse 7 and shipping warehouse 7
266 
    getWarehouses(WarehouseType.OURS, InventoryType.GOOD, 3, 7, 7) would return ours warehouse with GOOD type inventory for vendor 3 for billing warehouse 7 and shipping warehouse 7
267 
       getWarehouses(null, null, 3, 7, 7) would return all type warehouses with all type inventory for vendor 3 for billing warehouse 7 and shipping warehouse 7
268 
       getWarehouses(null, null, 0, 0, 7) would return all type warehouses with all type inventory for all vendors for all billing warehouses at shipping warehouse 7
269 
 
270 
    Parameters:
271 
     - warehouseType
272 
     - inventoryType
273 
     - vendorId
274 
     - billingWarehouseId
275 
     - shippingWarehouseId
276 
    """
277 
    pass
278 
 
279 
  def resetAvailability(self, itemKey, vendorId, quantity, warehouseId):
280 
    """
281 
    Resets availability of an item to the quantity mentioned in a warehouse.
282 
 
283 
    Parameters:
284 
     - itemKey
285 
     - vendorId
286 
     - quantity
287 
     - warehouseId
288 
    """
289 
    pass
290 
 
291 
  def resetAvailabilityForWarehouse(self, warehouseId):
292 
    """
293 
    Resets availability of a warehouse to zero.
294 
 
295 
    Parameters:
296 
     - warehouseId
297 
    """
298 
    pass
299 
 
300 
  def getItemKeysToBeProcessed(self, warehouseId):
301 
    """
302 
    Returns the list of item keys which need to be processed for a given warehouse.
303 
    This is currently used by Support application to send item keys whose inventory needs
304 
    to be updated from PLB
305 
 
306 
    Parameters:
307 
     - warehouseId
308 
    """
309 
    pass
310 
 
311 
  def markMissedInventoryUpdatesAsProcessed(self, itemKey, warehouseId):
312 
    """
313 
    Marks/Deletes missed inventory updates for a given key and warehouse.
314 
    This generally happens when updates from PLB are applied on the currentinventorysnapshot for an item
315 
 
316 
    Parameters:
317 
     - itemKey
318 
     - warehouseId
319 
    """
320 
    pass
321 
 
322 
  def getIgnoredItemKeys(self, ):
323 
    """
324 
    Returns all the item key mappings that have been ignored until date. Value of map has the warehouse id
325 
    and the timestamp from where alert was raised.
326 
    """
327 
    pass
328 
 
329 
  def addBadInventory(self, itemId, warehouseId, quantity):
330 
    """
331 
    Add the BAD type inventory to existing stock.
332 
 
333 
    Parameters:
334 
     - itemId
335 
     - warehouseId
336 
     - quantity
337 
    """
338 
    pass
339 
 
340 
  def getShippingLocations(self, ):
341 
    """
342 
    Returns all shipping locations
343 
    """
344 
    pass
345 
 
346 
  def getAllVendorItemMappings(self, ):
347 
    """
348 
    Fetches all the vendor item mappings present.
349 
    """
350 
    pass
351 
 
352 
  def getInventorySnapshot(self, warehouseId):
353 
    """
354 
    Gets items' inventory for a warehouse
355 
    If warehouse is passed as zero, items' inventory across all warehouses is sent
356 
 
357 
    Parameters:
358 
     - warehouseId
359 
    """
360 
    pass
361 
 
362 
  def clearItemAvailabilityCache(self, ):
363 
    """
364 
    Clear item availability cache.
365 
    """
366 
    pass
367 
 
368 
  def updateVendorString(self, warehouseId, vendorString):
369 
    """
370 
    Parameters:
371 
     - warehouseId
372 
     - vendorString
373 
    """
374 
    pass
375 
 
6096 amit.gupta 376 
  def clearItemAvailabilityCacheForItem(self, item_id):
377 
    """
378 
    Parameters:
379 
     - item_id
380 
    """
381 
    pass
5944 mandeep.dh 382 
 
7718 amar.kumar 383 
  def getOurWarehouseIdForVendor(self, vendorId, billingWarehouseId):
6467 amar.kumar 384 
    """
385 
    Parameters:
386 
     - vendorId
7718 amar.kumar 387 
     - billingWarehouseId
6467 amar.kumar 388 
    """
389 
    pass
6096 amit.gupta 390 
 
6484 amar.kumar 391 
  def getItemAvailabilitiesAtOurWarehouses(self, item_ids):
392 
    """
393 
    Parameters:
394 
     - item_ids
395 
    """
396 
    pass
6467 amar.kumar 397 
 
6531 vikram.rag 398 
  def getMonitoredWarehouseForVendors(self, vendorIds):
399 
    """
400 
    Parameters:
401 
     - vendorIds
402 
    """
403 
    pass
6484 amar.kumar 404 
 
6531 vikram.rag 405 
  def getIgnoredWarehouseidsAndItemids(self, ):
406 
    pass
407 
 
408 
  def insertItemtoIgnoreInventoryUpdatelist(self, item_id, warehouse_id):
409 
    """
410 
    Parameters:
411 
     - item_id
412 
     - warehouse_id
413 
    """
414 
    pass
415 
 
416 
  def deleteItemFromIgnoredInventoryUpdateList(self, item_id, warehouse_id):
417 
    """
418 
    Parameters:
419 
     - item_id
420 
     - warehouse_id
421 
    """
422 
    pass
423 
 
424 
  def getAllIgnoredInventoryupdateItemsCount(self, ):
425 
    pass
426 
 
427 
  def getIgnoredInventoryUpdateItemids(self, offset, limit):
428 
    """
429 
    Parameters:
430 
     - offset
431 
     - limit
432 
    """
433 
    pass
434 
 
6821 amar.kumar 435 
  def updateItemStockPurchaseParams(self, item_id, numOfDaysStock, minStockLevel):
436 
    """
437 
    Parameters:
438 
     - item_id
439 
     - numOfDaysStock
440 
     - minStockLevel
441 
    """
442 
    pass
6531 vikram.rag 443 
 
6821 amar.kumar 444 
  def getItemStockPurchaseParams(self, itemId):
445 
    """
446 
    Parameters:
447 
     - itemId
448 
    """
449 
    pass
450 
 
451 
  def addOosStatusForItem(self, oosStatusMap, date):
452 
    """
453 
    Parameters:
454 
     - oosStatusMap
455 
     - date
456 
    """
457 
    pass
458 
 
9762 amar.kumar 459 
  def getOosStatusesForXDaysForItem(self, itemId, sourceId, days):
6832 amar.kumar 460 
    """
461 
    Parameters:
462 
     - itemId
9762 amar.kumar 463 
     - sourceId
6832 amar.kumar 464 
     - days
465 
    """
466 
    pass
6821 amar.kumar 467 
 
10126 amar.kumar 468 
  def getOosStatusesForXDays(self, sourceId, days):
469 
    """
470 
    Parameters:
471 
     - sourceId
472 
     - days
473 
    """
474 
    pass
475 
 
476 
  def getAllVendorItemPricing(self, itemId, vendorId):
477 
    """
478 
    Parameters:
479 
     - itemId
480 
     - vendorId
481 
    """
482 
    pass
483 
 
6857 amar.kumar 484 
  def getNonZeroItemStockPurchaseParams(self, ):
485 
    pass
6832 amar.kumar 486 
 
7149 amar.kumar 487 
  def getBillableInventoryAndPendingOrders(self, ):
488 
    """
489 
    Returns a list of inventory stock for items for which there are pending orders or have billable inventory.
490 
    """
491 
    pass
6857 amar.kumar 492 
 
7281 kshitij.so 493 
  def getWarehouseName(self, warehouse_id):
494 
    """
495 
    Parameters:
496 
     - warehouse_id
497 
    """
498 
    pass
7149 amar.kumar 499 
 
7281 kshitij.so 500 
  def getAmazonInventoryForItem(self, item_id):
501 
    """
502 
    Parameters:
503 
     - item_id
504 
    """
505 
    pass
506 
 
507 
  def getAllAmazonInventory(self, ):
508 
    pass
509 
 
10450 vikram.rag 510 
  def addOrUpdateAmazonInventoryForItem(self, amazonInventorySnapshot, time):
7281 kshitij.so 511 
    """
512 
    Parameters:
513 
     - amazonInventorySnapshot
10450 vikram.rag 514 
     - time
7281 kshitij.so 515 
    """
516 
    pass
517 
 
7972 amar.kumar 518 
  def getLastNdaySaleForItem(self, itemId, numberOfDays):
519 
    """
520 
    Parameters:
521 
     - itemId
522 
     - numberOfDays
523 
    """
524 
    pass
7281 kshitij.so 525 
 
8282 kshitij.so 526 
  def addOrUpdateAmazonFbaInventory(self, amazonfbainventorysnapshot):
527 
    """
528 
    Parameters:
529 
     - amazonfbainventorysnapshot
530 
    """
531 
    pass
532 
 
8182 amar.kumar 533 
  def addUpdateHoldInventory(self, itemId, warehouseId, holdQuantity, source):
534 
    """
535 
    Parameters:
536 
     - itemId
537 
     - warehouseId
538 
     - holdQuantity
539 
     - source
540 
    """
541 
    pass
7972 amar.kumar 542 
 
8282 kshitij.so 543 
  def getAmazonFbaItemInventory(self, itemId):
544 
    """
545 
    Parameters:
546 
     - itemId
547 
    """
548 
    pass
8182 amar.kumar 549 
 
8363 vikram.rag 550 
  def getAllAmazonFbaItemInventory(self, ):
8282 kshitij.so 551 
    pass
552 
 
8363 vikram.rag 553 
  def getOursGoodWarehouseIdsForLocation(self, state_id):
554 
    """
555 
    Parameters:
556 
     - state_id
557 
    """
558 
    pass
8282 kshitij.so 559 
 
8955 vikram.rag 560 
  def getHoldInventoryDetailForItemForWarehouseIdExceptSource(self, id, warehouse_id, source):
561 
    """
562 
    Parameters:
563 
     - id
564 
     - warehouse_id
565 
     - source
566 
    """
567 
    pass
8363 vikram.rag 568 
 
9404 vikram.rag 569 
  def getSnapdealInventoryForItem(self, item_id):
570 
    """
571 
    Parameters:
572 
     - item_id
573 
    """
574 
    pass
8955 vikram.rag 575 
 
9404 vikram.rag 576 
  def addOrUpdateSnapdealInventoryForItem(self, snapdealinventoryitem):
577 
    """
578 
    Parameters:
579 
     - snapdealinventoryitem
580 
    """
581 
    pass
582 
 
583 
  def getNlcForWarehouse(self, warehouse_id, item_id):
584 
    """
585 
    Parameters:
586 
     - warehouse_id
587 
     - item_id
588 
    """
589 
    pass
590 
 
9640 amar.kumar 591 
  def getHeldInventoryMapForItem(self, item_id, warehouse_id):
592 
    """
593 
    Parameters:
594 
     - item_id
595 
     - warehouse_id
596 
    """
597 
    pass
598 
 
9482 vikram.rag 599 
  def addOrUpdateAllAmazonFbaInventory(self, allamazonfbainventorysnapshot):
600 
    """
601 
    Parameters:
602 
     - allamazonfbainventorysnapshot
603 
    """
604 
    pass
9456 vikram.rag 605 
 
9495 vikram.rag 606 
  def addOrUpdateAllSnapdealInventory(self, allsnapdealinventorysnapshot):
607 
    """
608 
    Parameters:
609 
     - allsnapdealinventorysnapshot
610 
    """
611 
    pass
9482 vikram.rag 612 
 
9495 vikram.rag 613 
  def getSnapdealInventorySnapshot(self, ):
614 
    pass
615 
 
9761 amar.kumar 616 
  def getHoldInventoryDetails(self, itemId, warehouseId, source):
617 
    """
618 
    Parameters:
619 
     - itemId
620 
     - warehouseId
621 
     - source
622 
    """
623 
    pass
9495 vikram.rag 624 
 
10450 vikram.rag 625 
  def addOrUpdateFlipkartInventorySnapshot(self, flipkartInventorySnapshot, time):
10050 vikram.rag 626 
    """
627 
    Parameters:
628 
     - flipkartInventorySnapshot
10450 vikram.rag 629 
     - time
10050 vikram.rag 630 
    """
631 
    pass
9761 amar.kumar 632 
 
10050 vikram.rag 633 
  def getFlipkartInventorySnapshot(self, ):
634 
    pass
635 
 
10097 kshitij.so 636 
  def getFlipkartlInventoryForItem(self, item_id):
637 
    """
638 
    Parameters:
639 
     - item_id
640 
    """
641 
    pass
10050 vikram.rag 642 
 
10485 vikram.rag 643 
  def getStateMaster(self, ):
644 
    pass
10097 kshitij.so 645 
 
10544 vikram.rag 646 
  def updateSnapdealStockAtEOD(self, allsnapdealstock):
647 
    """
648 
    Parameters:
649 
     - allsnapdealstock
650 
    """
651 
    pass
10485 vikram.rag 652 
 
10544 vikram.rag 653 
  def updateFlipkartStockAtEOD(self, allflipkartstock):
654 
    """
655 
    Parameters:
656 
     - allflipkartstock
657 
    """
658 
    pass
659 
 
12363 kshitij.so 660 
  def getWanNlcForSource(self, item_id, source):
661 
    """
662 
    Parameters:
663 
     - item_id
664 
     - source
665 
    """
666 
    pass
10544 vikram.rag 667 
 
12363 kshitij.so 668 
  def getAllAvailableAmazonFbaItemInventory(self, ):
669 
    pass
670 
 
17990 kshitij.so 671 
  def updateItemAvailabilityForItemIds(self, itemIds):
672 
    """
673 
    Parameters:
674 
     - itemIds
675 
    """
676 
    pass
12363 kshitij.so 677 
 
19247 kshitij.so 678 
  def addVendorItemPricingInBulk(self, vendorItemPricingList):
679 
    """
680 
    Parameters:
681 
     - vendorItemPricingList
682 
    """
683 
    pass
17990 kshitij.so 684 
 
19247 kshitij.so 685 
  def addInventoryInBulk(self, bulkInventoryList):
686 
    """
687 
    Parameters:
688 
     - bulkInventoryList
689 
    """
690 
    pass
691 
 
19413 amit.gupta 692 
  def getItemLocationAvailabilityCache(self, itemLocations):
693 
    """
694 
    Parameters:
695 
     - itemLocations
696 
    """
697 
    pass
19247 kshitij.so 698 
 
19413 amit.gupta 699 
  def getItemLocationAvailabilityCacheByItemId(self, itemIds):
700 
    """
701 
    Parameters:
702 
     - itemIds
703 
    """
704 
    pass
705 
 
19416 amit.gupta 706 
  def getItemPincodeAvailability(self, itempricing, pincode):
19413 amit.gupta 707 
    """
708 
    Parameters:
19416 amit.gupta 709 
     - itempricing
19413 amit.gupta 710 
     - pincode
711 
    """
712 
    pass
713 
 
714 
 
5944 mandeep.dh 715 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
716 
  def __init__(self, iprot, oprot=None):
717 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
718 
 
719 
  def addWarehouse(self, warehouse):
720 
    """
721 
    Parameters:
722 
     - warehouse
723 
    """
724 
    self.send_addWarehouse(warehouse)
725 
    return self.recv_addWarehouse()
726 
 
727 
  def send_addWarehouse(self, warehouse):
728 
    self._oprot.writeMessageBegin('addWarehouse', TMessageType.CALL, self._seqid)
729 
    args = addWarehouse_args()
730 
    args.warehouse = warehouse
731 
    args.write(self._oprot)
732 
    self._oprot.writeMessageEnd()
733 
    self._oprot.trans.flush()
734 
 
735 
  def recv_addWarehouse(self, ):
736 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
737 
    if mtype == TMessageType.EXCEPTION:
738 
      x = TApplicationException()
739 
      x.read(self._iprot)
740 
      self._iprot.readMessageEnd()
741 
      raise x
742 
    result = addWarehouse_result()
743 
    result.read(self._iprot)
744 
    self._iprot.readMessageEnd()
745 
    if result.success is not None:
746 
      return result.success
747 
    if result.cex is not None:
748 
      raise result.cex
749 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addWarehouse failed: unknown result");
750 
 
751 
  def addVendor(self, vendor):
752 
    """
753 
    add a new vendor
754 
 
755 
    Parameters:
756 
     - vendor
757 
    """
758 
    self.send_addVendor(vendor)
759 
    return self.recv_addVendor()
760 
 
761 
  def send_addVendor(self, vendor):
762 
    self._oprot.writeMessageBegin('addVendor', TMessageType.CALL, self._seqid)
763 
    args = addVendor_args()
764 
    args.vendor = vendor
765 
    args.write(self._oprot)
766 
    self._oprot.writeMessageEnd()
767 
    self._oprot.trans.flush()
768 
 
769 
  def recv_addVendor(self, ):
770 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
771 
    if mtype == TMessageType.EXCEPTION:
772 
      x = TApplicationException()
773 
      x.read(self._iprot)
774 
      self._iprot.readMessageEnd()
775 
      raise x
776 
    result = addVendor_result()
777 
    result.read(self._iprot)
778 
    self._iprot.readMessageEnd()
779 
    if result.success is not None:
780 
      return result.success
781 
    if result.cex is not None:
782 
      raise result.cex
783 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addVendor failed: unknown result");
784 
 
785 
  def updateInventoryHistory(self, warehouse_id, timestamp, availability):
786 
    """
787 
    Stores the incremental warehouse updates of items.
788 
 
789 
    Parameters:
790 
     - warehouse_id
791 
     - timestamp
792 
     - availability
793 
    """
794 
    self.send_updateInventoryHistory(warehouse_id, timestamp, availability)
795 
    self.recv_updateInventoryHistory()
796 
 
797 
  def send_updateInventoryHistory(self, warehouse_id, timestamp, availability):
798 
    self._oprot.writeMessageBegin('updateInventoryHistory', TMessageType.CALL, self._seqid)
799 
    args = updateInventoryHistory_args()
800 
    args.warehouse_id = warehouse_id
801 
    args.timestamp = timestamp
802 
    args.availability = availability
803 
    args.write(self._oprot)
804 
    self._oprot.writeMessageEnd()
805 
    self._oprot.trans.flush()
806 
 
807 
  def recv_updateInventoryHistory(self, ):
808 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
809 
    if mtype == TMessageType.EXCEPTION:
810 
      x = TApplicationException()
811 
      x.read(self._iprot)
812 
      self._iprot.readMessageEnd()
813 
      raise x
814 
    result = updateInventoryHistory_result()
815 
    result.read(self._iprot)
816 
    self._iprot.readMessageEnd()
817 
    if result.cex is not None:
818 
      raise result.cex
819 
    return
820 
 
821 
  def updateInventory(self, warehouse_id, timestamp, availability):
822 
    """
823 
    Stores the final inventory stocks of items.
824 
 
825 
    Parameters:
826 
     - warehouse_id
827 
     - timestamp
828 
     - availability
829 
    """
830 
    self.send_updateInventory(warehouse_id, timestamp, availability)
831 
    self.recv_updateInventory()
832 
 
833 
  def send_updateInventory(self, warehouse_id, timestamp, availability):
834 
    self._oprot.writeMessageBegin('updateInventory', TMessageType.CALL, self._seqid)
835 
    args = updateInventory_args()
836 
    args.warehouse_id = warehouse_id
837 
    args.timestamp = timestamp
838 
    args.availability = availability
839 
    args.write(self._oprot)
840 
    self._oprot.writeMessageEnd()
841 
    self._oprot.trans.flush()
842 
 
843 
  def recv_updateInventory(self, ):
844 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
845 
    if mtype == TMessageType.EXCEPTION:
846 
      x = TApplicationException()
847 
      x.read(self._iprot)
848 
      self._iprot.readMessageEnd()
849 
      raise x
850 
    result = updateInventory_result()
851 
    result.read(self._iprot)
852 
    self._iprot.readMessageEnd()
853 
    if result.cex is not None:
854 
      raise result.cex
855 
    return
856 
 
857 
  def addInventory(self, itemId, warehouseId, quantity):
858 
    """
859 
    Add the inventory to existing stock.
860 
 
861 
    Parameters:
862 
     - itemId
863 
     - warehouseId
864 
     - quantity
865 
    """
866 
    self.send_addInventory(itemId, warehouseId, quantity)
867 
    self.recv_addInventory()
868 
 
869 
  def send_addInventory(self, itemId, warehouseId, quantity):
870 
    self._oprot.writeMessageBegin('addInventory', TMessageType.CALL, self._seqid)
871 
    args = addInventory_args()
872 
    args.itemId = itemId
873 
    args.warehouseId = warehouseId
874 
    args.quantity = quantity
875 
    args.write(self._oprot)
876 
    self._oprot.writeMessageEnd()
877 
    self._oprot.trans.flush()
878 
 
879 
  def recv_addInventory(self, ):
880 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
881 
    if mtype == TMessageType.EXCEPTION:
882 
      x = TApplicationException()
883 
      x.read(self._iprot)
884 
      self._iprot.readMessageEnd()
885 
      raise x
886 
    result = addInventory_result()
887 
    result.read(self._iprot)
888 
    self._iprot.readMessageEnd()
889 
    if result.cex is not None:
890 
      raise result.cex
891 
    return
892 
 
893 
  def retireWarehouse(self, warehouse_id):
894 
    """
895 
    Parameters:
896 
     - warehouse_id
897 
    """
898 
    self.send_retireWarehouse(warehouse_id)
899 
    self.recv_retireWarehouse()
900 
 
901 
  def send_retireWarehouse(self, warehouse_id):
902 
    self._oprot.writeMessageBegin('retireWarehouse', TMessageType.CALL, self._seqid)
903 
    args = retireWarehouse_args()
904 
    args.warehouse_id = warehouse_id
905 
    args.write(self._oprot)
906 
    self._oprot.writeMessageEnd()
907 
    self._oprot.trans.flush()
908 
 
909 
  def recv_retireWarehouse(self, ):
910 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
911 
    if mtype == TMessageType.EXCEPTION:
912 
      x = TApplicationException()
913 
      x.read(self._iprot)
914 
      self._iprot.readMessageEnd()
915 
      raise x
916 
    result = retireWarehouse_result()
917 
    result.read(self._iprot)
918 
    self._iprot.readMessageEnd()
919 
    if result.cex is not None:
920 
      raise result.cex
921 
    return
922 
 
923 
  def getItemInventoryByItemId(self, item_id):
924 
    """
925 
    Parameters:
926 
     - item_id
927 
    """
928 
    self.send_getItemInventoryByItemId(item_id)
929 
    return self.recv_getItemInventoryByItemId()
930 
 
931 
  def send_getItemInventoryByItemId(self, item_id):
932 
    self._oprot.writeMessageBegin('getItemInventoryByItemId', TMessageType.CALL, self._seqid)
933 
    args = getItemInventoryByItemId_args()
934 
    args.item_id = item_id
935 
    args.write(self._oprot)
936 
    self._oprot.writeMessageEnd()
937 
    self._oprot.trans.flush()
938 
 
939 
  def recv_getItemInventoryByItemId(self, ):
940 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
941 
    if mtype == TMessageType.EXCEPTION:
942 
      x = TApplicationException()
943 
      x.read(self._iprot)
944 
      self._iprot.readMessageEnd()
945 
      raise x
946 
    result = getItemInventoryByItemId_result()
947 
    result.read(self._iprot)
948 
    self._iprot.readMessageEnd()
949 
    if result.success is not None:
950 
      return result.success
951 
    if result.cex is not None:
952 
      raise result.cex
953 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemInventoryByItemId failed: unknown result");
954 
 
955 
  def getItemAvailibilityAtWarehouse(self, warehouse_id, item_id):
956 
    """
957 
    Parameters:
958 
     - warehouse_id
959 
     - item_id
960 
    """
961 
    self.send_getItemAvailibilityAtWarehouse(warehouse_id, item_id)
962 
    return self.recv_getItemAvailibilityAtWarehouse()
963 
 
964 
  def send_getItemAvailibilityAtWarehouse(self, warehouse_id, item_id):
965 
    self._oprot.writeMessageBegin('getItemAvailibilityAtWarehouse', TMessageType.CALL, self._seqid)
966 
    args = getItemAvailibilityAtWarehouse_args()
967 
    args.warehouse_id = warehouse_id
968 
    args.item_id = item_id
969 
    args.write(self._oprot)
970 
    self._oprot.writeMessageEnd()
971 
    self._oprot.trans.flush()
972 
 
973 
  def recv_getItemAvailibilityAtWarehouse(self, ):
974 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
975 
    if mtype == TMessageType.EXCEPTION:
976 
      x = TApplicationException()
977 
      x.read(self._iprot)
978 
      self._iprot.readMessageEnd()
979 
      raise x
980 
    result = getItemAvailibilityAtWarehouse_result()
981 
    result.read(self._iprot)
982 
    self._iprot.readMessageEnd()
983 
    if result.success is not None:
984 
      return result.success
985 
    if result.cex is not None:
986 
      raise result.cex
987 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemAvailibilityAtWarehouse failed: unknown result");
988 
 
5978 rajveer 989 
  def getItemAvailabilityAtLocation(self, itemId, sourceId):
5944 mandeep.dh 990 
    """
991 
    Determines the warehouse that should be used to fulfil an order for the given item.
992 
    It first checks all the warehouses which are in the logistics location given by the
993 
    warehouse_loc parameter. If none of the warehouses there have any inventory, then the
994 
    preferred warehouse for the item is used.
995 
 
996 
    Returns an ordered list of size 4 with following elements in the given order:
997 
    1. Id of the fulfillment warehouse which was finally picked up.
998 
    2. Expected delay added by the category manager.
999 
    3. Id of the billing warehouse which was finally picked up.
1000 
 
1001 
    Parameters:
1002 
     - itemId
5978 rajveer 1003 
     - sourceId
5944 mandeep.dh 1004 
    """
5978 rajveer 1005 
    self.send_getItemAvailabilityAtLocation(itemId, sourceId)
5944 mandeep.dh 1006 
    return self.recv_getItemAvailabilityAtLocation()
1007 
 
5978 rajveer 1008 
  def send_getItemAvailabilityAtLocation(self, itemId, sourceId):
5944 mandeep.dh 1009 
    self._oprot.writeMessageBegin('getItemAvailabilityAtLocation', TMessageType.CALL, self._seqid)
1010 
    args = getItemAvailabilityAtLocation_args()
1011 
    args.itemId = itemId
5978 rajveer 1012 
    args.sourceId = sourceId
5944 mandeep.dh 1013 
    args.write(self._oprot)
1014 
    self._oprot.writeMessageEnd()
1015 
    self._oprot.trans.flush()
1016 
 
1017 
  def recv_getItemAvailabilityAtLocation(self, ):
1018 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1019 
    if mtype == TMessageType.EXCEPTION:
1020 
      x = TApplicationException()
1021 
      x.read(self._iprot)
1022 
      self._iprot.readMessageEnd()
1023 
      raise x
1024 
    result = getItemAvailabilityAtLocation_result()
1025 
    result.read(self._iprot)
1026 
    self._iprot.readMessageEnd()
1027 
    if result.success is not None:
1028 
      return result.success
1029 
    if result.isex is not None:
1030 
      raise result.isex
1031 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemAvailabilityAtLocation failed: unknown result");
1032 
 
1033 
  def getAllWarehouses(self, isActive):
1034 
    """
1035 
    Parameters:
1036 
     - isActive
1037 
    """
1038 
    self.send_getAllWarehouses(isActive)
1039 
    return self.recv_getAllWarehouses()
1040 
 
1041 
  def send_getAllWarehouses(self, isActive):
1042 
    self._oprot.writeMessageBegin('getAllWarehouses', TMessageType.CALL, self._seqid)
1043 
    args = getAllWarehouses_args()
1044 
    args.isActive = isActive
1045 
    args.write(self._oprot)
1046 
    self._oprot.writeMessageEnd()
1047 
    self._oprot.trans.flush()
1048 
 
1049 
  def recv_getAllWarehouses(self, ):
1050 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1051 
    if mtype == TMessageType.EXCEPTION:
1052 
      x = TApplicationException()
1053 
      x.read(self._iprot)
1054 
      self._iprot.readMessageEnd()
1055 
      raise x
1056 
    result = getAllWarehouses_result()
1057 
    result.read(self._iprot)
1058 
    self._iprot.readMessageEnd()
1059 
    if result.success is not None:
1060 
      return result.success
1061 
    if result.cex is not None:
1062 
      raise result.cex
1063 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllWarehouses failed: unknown result");
1064 
 
1065 
  def getWarehouse(self, warehouse_id):
1066 
    """
1067 
    Returns the warehouse with the given id.
1068 
 
1069 
    Parameters:
1070 
     - warehouse_id
1071 
    """
1072 
    self.send_getWarehouse(warehouse_id)
1073 
    return self.recv_getWarehouse()
1074 
 
1075 
  def send_getWarehouse(self, warehouse_id):
1076 
    self._oprot.writeMessageBegin('getWarehouse', TMessageType.CALL, self._seqid)
1077 
    args = getWarehouse_args()
1078 
    args.warehouse_id = warehouse_id
1079 
    args.write(self._oprot)
1080 
    self._oprot.writeMessageEnd()
1081 
    self._oprot.trans.flush()
1082 
 
1083 
  def recv_getWarehouse(self, ):
1084 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1085 
    if mtype == TMessageType.EXCEPTION:
1086 
      x = TApplicationException()
1087 
      x.read(self._iprot)
1088 
      self._iprot.readMessageEnd()
1089 
      raise x
1090 
    result = getWarehouse_result()
1091 
    result.read(self._iprot)
1092 
    self._iprot.readMessageEnd()
1093 
    if result.success is not None:
1094 
      return result.success
1095 
    if result.cex is not None:
1096 
      raise result.cex
1097 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getWarehouse failed: unknown result");
1098 
 
1099 
  def getAllItemsForWarehouse(self, warehouse_id):
1100 
    """
1101 
    Parameters:
1102 
     - warehouse_id
1103 
    """
1104 
    self.send_getAllItemsForWarehouse(warehouse_id)
1105 
    return self.recv_getAllItemsForWarehouse()
1106 
 
1107 
  def send_getAllItemsForWarehouse(self, warehouse_id):
1108 
    self._oprot.writeMessageBegin('getAllItemsForWarehouse', TMessageType.CALL, self._seqid)
1109 
    args = getAllItemsForWarehouse_args()
1110 
    args.warehouse_id = warehouse_id
1111 
    args.write(self._oprot)
1112 
    self._oprot.writeMessageEnd()
1113 
    self._oprot.trans.flush()
1114 
 
1115 
  def recv_getAllItemsForWarehouse(self, ):
1116 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1117 
    if mtype == TMessageType.EXCEPTION:
1118 
      x = TApplicationException()
1119 
      x.read(self._iprot)
1120 
      self._iprot.readMessageEnd()
1121 
      raise x
1122 
    result = getAllItemsForWarehouse_result()
1123 
    result.read(self._iprot)
1124 
    self._iprot.readMessageEnd()
1125 
    if result.success is not None:
1126 
      return result.success
1127 
    if result.cex is not None:
1128 
      raise result.cex
1129 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsForWarehouse failed: unknown result");
1130 
 
5966 rajveer 1131 
  def isOrderBillable(self, itemId, warehouseId, sourceId, orderId):
5944 mandeep.dh 1132 
    """
5978 rajveer 1133 
    Depending on reservation in the table, verify if we can bill this order or not.
5966 rajveer 1134 
 
1135 
    Parameters:
1136 
     - itemId
1137 
     - warehouseId
1138 
     - sourceId
1139 
     - orderId
1140 
    """
1141 
    self.send_isOrderBillable(itemId, warehouseId, sourceId, orderId)
1142 
    return self.recv_isOrderBillable()
1143 
 
1144 
  def send_isOrderBillable(self, itemId, warehouseId, sourceId, orderId):
1145 
    self._oprot.writeMessageBegin('isOrderBillable', TMessageType.CALL, self._seqid)
1146 
    args = isOrderBillable_args()
1147 
    args.itemId = itemId
1148 
    args.warehouseId = warehouseId
1149 
    args.sourceId = sourceId
1150 
    args.orderId = orderId
1151 
    args.write(self._oprot)
1152 
    self._oprot.writeMessageEnd()
1153 
    self._oprot.trans.flush()
1154 
 
1155 
  def recv_isOrderBillable(self, ):
1156 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1157 
    if mtype == TMessageType.EXCEPTION:
1158 
      x = TApplicationException()
1159 
      x.read(self._iprot)
1160 
      self._iprot.readMessageEnd()
1161 
      raise x
1162 
    result = isOrderBillable_result()
1163 
    result.read(self._iprot)
1164 
    self._iprot.readMessageEnd()
1165 
    if result.success is not None:
1166 
      return result.success
1167 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isOrderBillable failed: unknown result");
1168 
 
1169 
  def reserveItemInWarehouse(self, itemId, warehouseId, sourceId, orderId, createdTimestamp, promisedShippingTimestamp, quantity):
1170 
    """
5944 mandeep.dh 1171 
    Increases the reservation count for an item in a warehouse. Should always succeed normally.
1172 
 
1173 
    Parameters:
1174 
     - itemId
1175 
     - warehouseId
5966 rajveer 1176 
     - sourceId
1177 
     - orderId
1178 
     - createdTimestamp
1179 
     - promisedShippingTimestamp
5944 mandeep.dh 1180 
     - quantity
1181 
    """
5966 rajveer 1182 
    self.send_reserveItemInWarehouse(itemId, warehouseId, sourceId, orderId, createdTimestamp, promisedShippingTimestamp, quantity)
5944 mandeep.dh 1183 
    return self.recv_reserveItemInWarehouse()
1184 
 
5966 rajveer 1185 
  def send_reserveItemInWarehouse(self, itemId, warehouseId, sourceId, orderId, createdTimestamp, promisedShippingTimestamp, quantity):
5944 mandeep.dh 1186 
    self._oprot.writeMessageBegin('reserveItemInWarehouse', TMessageType.CALL, self._seqid)
1187 
    args = reserveItemInWarehouse_args()
1188 
    args.itemId = itemId
1189 
    args.warehouseId = warehouseId
5966 rajveer 1190 
    args.sourceId = sourceId
1191 
    args.orderId = orderId
1192 
    args.createdTimestamp = createdTimestamp
1193 
    args.promisedShippingTimestamp = promisedShippingTimestamp
5944 mandeep.dh 1194 
    args.quantity = quantity
1195 
    args.write(self._oprot)
1196 
    self._oprot.writeMessageEnd()
1197 
    self._oprot.trans.flush()
1198 
 
1199 
  def recv_reserveItemInWarehouse(self, ):
1200 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1201 
    if mtype == TMessageType.EXCEPTION:
1202 
      x = TApplicationException()
1203 
      x.read(self._iprot)
1204 
      self._iprot.readMessageEnd()
1205 
      raise x
1206 
    result = reserveItemInWarehouse_result()
1207 
    result.read(self._iprot)
1208 
    self._iprot.readMessageEnd()
1209 
    if result.success is not None:
1210 
      return result.success
1211 
    if result.cex is not None:
1212 
      raise result.cex
1213 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reserveItemInWarehouse failed: unknown result");
1214 
 
7968 amar.kumar 1215 
  def updateReservationForOrder(self, itemId, warehouseId, sourceId, orderId, createdTimestamp, promisedShippingTimestamp, quantity):
1216 
    """
1217 
    Updates the reservation for Order
1218 
 
1219 
    Parameters:
1220 
     - itemId
1221 
     - warehouseId
1222 
     - sourceId
1223 
     - orderId
1224 
     - createdTimestamp
1225 
     - promisedShippingTimestamp
1226 
     - quantity
1227 
    """
1228 
    self.send_updateReservationForOrder(itemId, warehouseId, sourceId, orderId, createdTimestamp, promisedShippingTimestamp, quantity)
1229 
    return self.recv_updateReservationForOrder()
1230 
 
1231 
  def send_updateReservationForOrder(self, itemId, warehouseId, sourceId, orderId, createdTimestamp, promisedShippingTimestamp, quantity):
1232 
    self._oprot.writeMessageBegin('updateReservationForOrder', TMessageType.CALL, self._seqid)
1233 
    args = updateReservationForOrder_args()
1234 
    args.itemId = itemId
1235 
    args.warehouseId = warehouseId
1236 
    args.sourceId = sourceId
1237 
    args.orderId = orderId
1238 
    args.createdTimestamp = createdTimestamp
1239 
    args.promisedShippingTimestamp = promisedShippingTimestamp
1240 
    args.quantity = quantity
1241 
    args.write(self._oprot)
1242 
    self._oprot.writeMessageEnd()
1243 
    self._oprot.trans.flush()
1244 
 
1245 
  def recv_updateReservationForOrder(self, ):
1246 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1247 
    if mtype == TMessageType.EXCEPTION:
1248 
      x = TApplicationException()
1249 
      x.read(self._iprot)
1250 
      self._iprot.readMessageEnd()
1251 
      raise x
1252 
    result = updateReservationForOrder_result()
1253 
    result.read(self._iprot)
1254 
    self._iprot.readMessageEnd()
1255 
    if result.success is not None:
1256 
      return result.success
1257 
    if result.cex is not None:
1258 
      raise result.cex
1259 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateReservationForOrder failed: unknown result");
1260 
 
5966 rajveer 1261 
  def reduceReservationCount(self, itemId, warehouseId, sourceId, orderId, quantity):
5944 mandeep.dh 1262 
    """
1263 
    Decreases the reservation count for an item in a warehouse. Should always succeed normally.
1264 
 
1265 
    Parameters:
1266 
     - itemId
1267 
     - warehouseId
5966 rajveer 1268 
     - sourceId
1269 
     - orderId
5944 mandeep.dh 1270 
     - quantity
1271 
    """
5966 rajveer 1272 
    self.send_reduceReservationCount(itemId, warehouseId, sourceId, orderId, quantity)
5944 mandeep.dh 1273 
    return self.recv_reduceReservationCount()
1274 
 
5966 rajveer 1275 
  def send_reduceReservationCount(self, itemId, warehouseId, sourceId, orderId, quantity):
5944 mandeep.dh 1276 
    self._oprot.writeMessageBegin('reduceReservationCount', TMessageType.CALL, self._seqid)
1277 
    args = reduceReservationCount_args()
1278 
    args.itemId = itemId
1279 
    args.warehouseId = warehouseId
5966 rajveer 1280 
    args.sourceId = sourceId
1281 
    args.orderId = orderId
5944 mandeep.dh 1282 
    args.quantity = quantity
1283 
    args.write(self._oprot)
1284 
    self._oprot.writeMessageEnd()
1285 
    self._oprot.trans.flush()
1286 
 
1287 
  def recv_reduceReservationCount(self, ):
1288 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1289 
    if mtype == TMessageType.EXCEPTION:
1290 
      x = TApplicationException()
1291 
      x.read(self._iprot)
1292 
      self._iprot.readMessageEnd()
1293 
      raise x
1294 
    result = reduceReservationCount_result()
1295 
    result.read(self._iprot)
1296 
    self._iprot.readMessageEnd()
1297 
    if result.success is not None:
1298 
      return result.success
1299 
    if result.cex is not None:
1300 
      raise result.cex
1301 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reduceReservationCount failed: unknown result");
1302 
 
1303 
  def getItemPricing(self, itemId, vendorId):
1304 
    """
1305 
    Returns the pricing information of an item associated with the vendor of the given warehouse.
1306 
    Raises an exception if either the item, vendor or the associated pricing information can't be found.
1307 
 
1308 
    Parameters:
1309 
     - itemId
1310 
     - vendorId
1311 
    """
1312 
    self.send_getItemPricing(itemId, vendorId)
1313 
    return self.recv_getItemPricing()
1314 
 
1315 
  def send_getItemPricing(self, itemId, vendorId):
1316 
    self._oprot.writeMessageBegin('getItemPricing', TMessageType.CALL, self._seqid)
1317 
    args = getItemPricing_args()
1318 
    args.itemId = itemId
1319 
    args.vendorId = vendorId
1320 
    args.write(self._oprot)
1321 
    self._oprot.writeMessageEnd()
1322 
    self._oprot.trans.flush()
1323 
 
1324 
  def recv_getItemPricing(self, ):
1325 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1326 
    if mtype == TMessageType.EXCEPTION:
1327 
      x = TApplicationException()
1328 
      x.read(self._iprot)
1329 
      self._iprot.readMessageEnd()
1330 
      raise x
1331 
    result = getItemPricing_result()
1332 
    result.read(self._iprot)
1333 
    self._iprot.readMessageEnd()
1334 
    if result.success is not None:
1335 
      return result.success
1336 
    if result.cex is not None:
1337 
      raise result.cex
1338 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricing failed: unknown result");
1339 
 
1340 
  def getAllItemPricing(self, itemId):
1341 
    """
1342 
    Returns the list of vendor pricing information of an item.
1343 
    Raises an exception if item not found corresponding to itemId
1344 
 
1345 
    Parameters:
1346 
     - itemId
1347 
    """
1348 
    self.send_getAllItemPricing(itemId)
1349 
    return self.recv_getAllItemPricing()
1350 
 
1351 
  def send_getAllItemPricing(self, itemId):
1352 
    self._oprot.writeMessageBegin('getAllItemPricing', TMessageType.CALL, self._seqid)
1353 
    args = getAllItemPricing_args()
1354 
    args.itemId = itemId
1355 
    args.write(self._oprot)
1356 
    self._oprot.writeMessageEnd()
1357 
    self._oprot.trans.flush()
1358 
 
1359 
  def recv_getAllItemPricing(self, ):
1360 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1361 
    if mtype == TMessageType.EXCEPTION:
1362 
      x = TApplicationException()
1363 
      x.read(self._iprot)
1364 
      self._iprot.readMessageEnd()
1365 
      raise x
1366 
    result = getAllItemPricing_result()
1367 
    result.read(self._iprot)
1368 
    self._iprot.readMessageEnd()
1369 
    if result.success is not None:
1370 
      return result.success
1371 
    if result.cex is not None:
1372 
      raise result.cex
1373 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemPricing failed: unknown result");
1374 
 
1375 
  def addVendorItemPricing(self, vendorItemPricing):
1376 
    """
1377 
    Adds vendor prices corresponding to the item. If pricing already exists then updates the prices.
1378 
    Raises an exception if either the item or vendor can't be found corresponding to their ids.
1379 
 
1380 
    Parameters:
1381 
     - vendorItemPricing
1382 
    """
1383 
    self.send_addVendorItemPricing(vendorItemPricing)
1384 
    self.recv_addVendorItemPricing()
1385 
 
1386 
  def send_addVendorItemPricing(self, vendorItemPricing):
1387 
    self._oprot.writeMessageBegin('addVendorItemPricing', TMessageType.CALL, self._seqid)
1388 
    args = addVendorItemPricing_args()
1389 
    args.vendorItemPricing = vendorItemPricing
1390 
    args.write(self._oprot)
1391 
    self._oprot.writeMessageEnd()
1392 
    self._oprot.trans.flush()
1393 
 
1394 
  def recv_addVendorItemPricing(self, ):
1395 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1396 
    if mtype == TMessageType.EXCEPTION:
1397 
      x = TApplicationException()
1398 
      x.read(self._iprot)
1399 
      self._iprot.readMessageEnd()
1400 
      raise x
1401 
    result = addVendorItemPricing_result()
1402 
    result.read(self._iprot)
1403 
    self._iprot.readMessageEnd()
1404 
    if result.cex is not None:
1405 
      raise result.cex
1406 
    return
1407 
 
1408 
  def getVendor(self, vendorId):
1409 
    """
1410 
    Returns a vendor given its id
1411 
 
1412 
    Parameters:
1413 
     - vendorId
1414 
    """
1415 
    self.send_getVendor(vendorId)
1416 
    return self.recv_getVendor()
1417 
 
1418 
  def send_getVendor(self, vendorId):
1419 
    self._oprot.writeMessageBegin('getVendor', TMessageType.CALL, self._seqid)
1420 
    args = getVendor_args()
1421 
    args.vendorId = vendorId
1422 
    args.write(self._oprot)
1423 
    self._oprot.writeMessageEnd()
1424 
    self._oprot.trans.flush()
1425 
 
1426 
  def recv_getVendor(self, ):
1427 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1428 
    if mtype == TMessageType.EXCEPTION:
1429 
      x = TApplicationException()
1430 
      x.read(self._iprot)
1431 
      self._iprot.readMessageEnd()
1432 
      raise x
1433 
    result = getVendor_result()
1434 
    result.read(self._iprot)
1435 
    self._iprot.readMessageEnd()
1436 
    if result.success is not None:
1437 
      return result.success
1438 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVendor failed: unknown result");
1439 
 
1440 
  def getAllVendors(self, ):
1441 
    """
1442 
    Return list of all vendors
1443 
    """
1444 
    self.send_getAllVendors()
1445 
    return self.recv_getAllVendors()
1446 
 
1447 
  def send_getAllVendors(self, ):
1448 
    self._oprot.writeMessageBegin('getAllVendors', TMessageType.CALL, self._seqid)
1449 
    args = getAllVendors_args()
1450 
    args.write(self._oprot)
1451 
    self._oprot.writeMessageEnd()
1452 
    self._oprot.trans.flush()
1453 
 
1454 
  def recv_getAllVendors(self, ):
1455 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1456 
    if mtype == TMessageType.EXCEPTION:
1457 
      x = TApplicationException()
1458 
      x.read(self._iprot)
1459 
      self._iprot.readMessageEnd()
1460 
      raise x
1461 
    result = getAllVendors_result()
1462 
    result.read(self._iprot)
1463 
    self._iprot.readMessageEnd()
1464 
    if result.success is not None:
1465 
      return result.success
1466 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVendors failed: unknown result");
1467 
 
1468 
  def addVendorItemMapping(self, key, vendorItemMapping):
1469 
    """
1470 
    Adds VendorItemMapping. Updates VendorItemMapping if exists corresponding to the item key.
1471 
 
1472 
    Parameters:
1473 
     - key
1474 
     - vendorItemMapping
1475 
    """
1476 
    self.send_addVendorItemMapping(key, vendorItemMapping)
1477 
    self.recv_addVendorItemMapping()
1478 
 
1479 
  def send_addVendorItemMapping(self, key, vendorItemMapping):
1480 
    self._oprot.writeMessageBegin('addVendorItemMapping', TMessageType.CALL, self._seqid)
1481 
    args = addVendorItemMapping_args()
1482 
    args.key = key
1483 
    args.vendorItemMapping = vendorItemMapping
1484 
    args.write(self._oprot)
1485 
    self._oprot.writeMessageEnd()
1486 
    self._oprot.trans.flush()
1487 
 
1488 
  def recv_addVendorItemMapping(self, ):
1489 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1490 
    if mtype == TMessageType.EXCEPTION:
1491 
      x = TApplicationException()
1492 
      x.read(self._iprot)
1493 
      self._iprot.readMessageEnd()
1494 
      raise x
1495 
    result = addVendorItemMapping_result()
1496 
    result.read(self._iprot)
1497 
    self._iprot.readMessageEnd()
1498 
    if result.cex is not None:
1499 
      raise result.cex
1500 
    return
1501 
 
1502 
  def getVendorItemMappings(self, itemId):
1503 
    """
1504 
    Returns the list of vendor item mapping corresponding to itemId passed as parameter.
1505 
    Raises an exception if item not found corresponding to itemId
1506 
 
1507 
    Parameters:
1508 
     - itemId
1509 
    """
1510 
    self.send_getVendorItemMappings(itemId)
1511 
    return self.recv_getVendorItemMappings()
1512 
 
1513 
  def send_getVendorItemMappings(self, itemId):
1514 
    self._oprot.writeMessageBegin('getVendorItemMappings', TMessageType.CALL, self._seqid)
1515 
    args = getVendorItemMappings_args()
1516 
    args.itemId = itemId
1517 
    args.write(self._oprot)
1518 
    self._oprot.writeMessageEnd()
1519 
    self._oprot.trans.flush()
1520 
 
1521 
  def recv_getVendorItemMappings(self, ):
1522 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1523 
    if mtype == TMessageType.EXCEPTION:
1524 
      x = TApplicationException()
1525 
      x.read(self._iprot)
1526 
      self._iprot.readMessageEnd()
1527 
      raise x
1528 
    result = getVendorItemMappings_result()
1529 
    result.read(self._iprot)
1530 
    self._iprot.readMessageEnd()
1531 
    if result.success is not None:
1532 
      return result.success
1533 
    if result.cex is not None:
1534 
      raise result.cex
1535 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVendorItemMappings failed: unknown result");
1536 
 
1537 
  def getPendingOrdersInventory(self, vendorid):
1538 
    """
1539 
    Returns a list of inventory stock for items for which there are pending orders for the given vendor.
1540 
 
1541 
    Parameters:
1542 
     - vendorid
1543 
    """
1544 
    self.send_getPendingOrdersInventory(vendorid)
1545 
    return self.recv_getPendingOrdersInventory()
1546 
 
1547 
  def send_getPendingOrdersInventory(self, vendorid):
1548 
    self._oprot.writeMessageBegin('getPendingOrdersInventory', TMessageType.CALL, self._seqid)
1549 
    args = getPendingOrdersInventory_args()
1550 
    args.vendorid = vendorid
1551 
    args.write(self._oprot)
1552 
    self._oprot.writeMessageEnd()
1553 
    self._oprot.trans.flush()
1554 
 
1555 
  def recv_getPendingOrdersInventory(self, ):
1556 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1557 
    if mtype == TMessageType.EXCEPTION:
1558 
      x = TApplicationException()
1559 
      x.read(self._iprot)
1560 
      self._iprot.readMessageEnd()
1561 
      raise x
1562 
    result = getPendingOrdersInventory_result()
1563 
    result.read(self._iprot)
1564 
    self._iprot.readMessageEnd()
1565 
    if result.success is not None:
1566 
      return result.success
1567 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPendingOrdersInventory failed: unknown result");
1568 
 
1569 
  def getWarehouses(self, warehouseType, inventoryType, vendorId, billingWarehouseId, shippingWarehouseId):
1570 
    """
1571 
    This method returns all warehouses for a given warehosueType, inventoryType, vendor, billingWarehouse and shippingWarehouse.
1572 
    getWarehouses(WarehouseType.OURS, InventoryType.GOOD, 3, 7, 7) would return ours warehouse with GOOD type inventory for vendor 1 for billing warehouse 7 and shipping warehouse 7
1573 
    getWarehouses(WarehouseType.OURS, InventoryType.GOOD, 3, 7, 7) would return ours warehouse with GOOD type inventory for vendor 3 for billing warehouse 7 and shipping warehouse 7
1574 
       getWarehouses(null, null, 3, 7, 7) would return all type warehouses with all type inventory for vendor 3 for billing warehouse 7 and shipping warehouse 7
1575 
       getWarehouses(null, null, 0, 0, 7) would return all type warehouses with all type inventory for all vendors for all billing warehouses at shipping warehouse 7
1576 
 
1577 
    Parameters:
1578 
     - warehouseType
1579 
     - inventoryType
1580 
     - vendorId
1581 
     - billingWarehouseId
1582 
     - shippingWarehouseId
1583 
    """
1584 
    self.send_getWarehouses(warehouseType, inventoryType, vendorId, billingWarehouseId, shippingWarehouseId)
1585 
    return self.recv_getWarehouses()
1586 
 
1587 
  def send_getWarehouses(self, warehouseType, inventoryType, vendorId, billingWarehouseId, shippingWarehouseId):
1588 
    self._oprot.writeMessageBegin('getWarehouses', TMessageType.CALL, self._seqid)
1589 
    args = getWarehouses_args()
1590 
    args.warehouseType = warehouseType
1591 
    args.inventoryType = inventoryType
1592 
    args.vendorId = vendorId
1593 
    args.billingWarehouseId = billingWarehouseId
1594 
    args.shippingWarehouseId = shippingWarehouseId
1595 
    args.write(self._oprot)
1596 
    self._oprot.writeMessageEnd()
1597 
    self._oprot.trans.flush()
1598 
 
1599 
  def recv_getWarehouses(self, ):
1600 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1601 
    if mtype == TMessageType.EXCEPTION:
1602 
      x = TApplicationException()
1603 
      x.read(self._iprot)
1604 
      self._iprot.readMessageEnd()
1605 
      raise x
1606 
    result = getWarehouses_result()
1607 
    result.read(self._iprot)
1608 
    self._iprot.readMessageEnd()
1609 
    if result.success is not None:
1610 
      return result.success
1611 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getWarehouses failed: unknown result");
1612 
 
1613 
  def resetAvailability(self, itemKey, vendorId, quantity, warehouseId):
1614 
    """
1615 
    Resets availability of an item to the quantity mentioned in a warehouse.
1616 
 
1617 
    Parameters:
1618 
     - itemKey
1619 
     - vendorId
1620 
     - quantity
1621 
     - warehouseId
1622 
    """
1623 
    self.send_resetAvailability(itemKey, vendorId, quantity, warehouseId)
1624 
    self.recv_resetAvailability()
1625 
 
1626 
  def send_resetAvailability(self, itemKey, vendorId, quantity, warehouseId):
1627 
    self._oprot.writeMessageBegin('resetAvailability', TMessageType.CALL, self._seqid)
1628 
    args = resetAvailability_args()
1629 
    args.itemKey = itemKey
1630 
    args.vendorId = vendorId
1631 
    args.quantity = quantity
1632 
    args.warehouseId = warehouseId
1633 
    args.write(self._oprot)
1634 
    self._oprot.writeMessageEnd()
1635 
    self._oprot.trans.flush()
1636 
 
1637 
  def recv_resetAvailability(self, ):
1638 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1639 
    if mtype == TMessageType.EXCEPTION:
1640 
      x = TApplicationException()
1641 
      x.read(self._iprot)
1642 
      self._iprot.readMessageEnd()
1643 
      raise x
1644 
    result = resetAvailability_result()
1645 
    result.read(self._iprot)
1646 
    self._iprot.readMessageEnd()
1647 
    if result.cex is not None:
1648 
      raise result.cex
1649 
    return
1650 
 
1651 
  def resetAvailabilityForWarehouse(self, warehouseId):
1652 
    """
1653 
    Resets availability of a warehouse to zero.
1654 
 
1655 
    Parameters:
1656 
     - warehouseId
1657 
    """
1658 
    self.send_resetAvailabilityForWarehouse(warehouseId)
1659 
    self.recv_resetAvailabilityForWarehouse()
1660 
 
1661 
  def send_resetAvailabilityForWarehouse(self, warehouseId):
1662 
    self._oprot.writeMessageBegin('resetAvailabilityForWarehouse', TMessageType.CALL, self._seqid)
1663 
    args = resetAvailabilityForWarehouse_args()
1664 
    args.warehouseId = warehouseId
1665 
    args.write(self._oprot)
1666 
    self._oprot.writeMessageEnd()
1667 
    self._oprot.trans.flush()
1668 
 
1669 
  def recv_resetAvailabilityForWarehouse(self, ):
1670 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1671 
    if mtype == TMessageType.EXCEPTION:
1672 
      x = TApplicationException()
1673 
      x.read(self._iprot)
1674 
      self._iprot.readMessageEnd()
1675 
      raise x
1676 
    result = resetAvailabilityForWarehouse_result()
1677 
    result.read(self._iprot)
1678 
    self._iprot.readMessageEnd()
1679 
    if result.cex is not None:
1680 
      raise result.cex
1681 
    return
1682 
 
1683 
  def getItemKeysToBeProcessed(self, warehouseId):
1684 
    """
1685 
    Returns the list of item keys which need to be processed for a given warehouse.
1686 
    This is currently used by Support application to send item keys whose inventory needs
1687 
    to be updated from PLB
1688 
 
1689 
    Parameters:
1690 
     - warehouseId
1691 
    """
1692 
    self.send_getItemKeysToBeProcessed(warehouseId)
1693 
    return self.recv_getItemKeysToBeProcessed()
1694 
 
1695 
  def send_getItemKeysToBeProcessed(self, warehouseId):
1696 
    self._oprot.writeMessageBegin('getItemKeysToBeProcessed', TMessageType.CALL, self._seqid)
1697 
    args = getItemKeysToBeProcessed_args()
1698 
    args.warehouseId = warehouseId
1699 
    args.write(self._oprot)
1700 
    self._oprot.writeMessageEnd()
1701 
    self._oprot.trans.flush()
1702 
 
1703 
  def recv_getItemKeysToBeProcessed(self, ):
1704 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1705 
    if mtype == TMessageType.EXCEPTION:
1706 
      x = TApplicationException()
1707 
      x.read(self._iprot)
1708 
      self._iprot.readMessageEnd()
1709 
      raise x
1710 
    result = getItemKeysToBeProcessed_result()
1711 
    result.read(self._iprot)
1712 
    self._iprot.readMessageEnd()
1713 
    if result.success is not None:
1714 
      return result.success
1715 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemKeysToBeProcessed failed: unknown result");
1716 
 
1717 
  def markMissedInventoryUpdatesAsProcessed(self, itemKey, warehouseId):
1718 
    """
1719 
    Marks/Deletes missed inventory updates for a given key and warehouse.
1720 
    This generally happens when updates from PLB are applied on the currentinventorysnapshot for an item
1721 
 
1722 
    Parameters:
1723 
     - itemKey
1724 
     - warehouseId
1725 
    """
1726 
    self.send_markMissedInventoryUpdatesAsProcessed(itemKey, warehouseId)
1727 
    self.recv_markMissedInventoryUpdatesAsProcessed()
1728 
 
1729 
  def send_markMissedInventoryUpdatesAsProcessed(self, itemKey, warehouseId):
1730 
    self._oprot.writeMessageBegin('markMissedInventoryUpdatesAsProcessed', TMessageType.CALL, self._seqid)
1731 
    args = markMissedInventoryUpdatesAsProcessed_args()
1732 
    args.itemKey = itemKey
1733 
    args.warehouseId = warehouseId
1734 
    args.write(self._oprot)
1735 
    self._oprot.writeMessageEnd()
1736 
    self._oprot.trans.flush()
1737 
 
1738 
  def recv_markMissedInventoryUpdatesAsProcessed(self, ):
1739 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1740 
    if mtype == TMessageType.EXCEPTION:
1741 
      x = TApplicationException()
1742 
      x.read(self._iprot)
1743 
      self._iprot.readMessageEnd()
1744 
      raise x
1745 
    result = markMissedInventoryUpdatesAsProcessed_result()
1746 
    result.read(self._iprot)
1747 
    self._iprot.readMessageEnd()
1748 
    return
1749 
 
1750 
  def getIgnoredItemKeys(self, ):
1751 
    """
1752 
    Returns all the item key mappings that have been ignored until date. Value of map has the warehouse id
1753 
    and the timestamp from where alert was raised.
1754 
    """
1755 
    self.send_getIgnoredItemKeys()
1756 
    return self.recv_getIgnoredItemKeys()
1757 
 
1758 
  def send_getIgnoredItemKeys(self, ):
1759 
    self._oprot.writeMessageBegin('getIgnoredItemKeys', TMessageType.CALL, self._seqid)
1760 
    args = getIgnoredItemKeys_args()
1761 
    args.write(self._oprot)
1762 
    self._oprot.writeMessageEnd()
1763 
    self._oprot.trans.flush()
1764 
 
1765 
  def recv_getIgnoredItemKeys(self, ):
1766 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1767 
    if mtype == TMessageType.EXCEPTION:
1768 
      x = TApplicationException()
1769 
      x.read(self._iprot)
1770 
      self._iprot.readMessageEnd()
1771 
      raise x
1772 
    result = getIgnoredItemKeys_result()
1773 
    result.read(self._iprot)
1774 
    self._iprot.readMessageEnd()
1775 
    if result.success is not None:
1776 
      return result.success
1777 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getIgnoredItemKeys failed: unknown result");
1778 
 
1779 
  def addBadInventory(self, itemId, warehouseId, quantity):
1780 
    """
1781 
    Add the BAD type inventory to existing stock.
1782 
 
1783 
    Parameters:
1784 
     - itemId
1785 
     - warehouseId
1786 
     - quantity
1787 
    """
1788 
    self.send_addBadInventory(itemId, warehouseId, quantity)
1789 
    self.recv_addBadInventory()
1790 
 
1791 
  def send_addBadInventory(self, itemId, warehouseId, quantity):
1792 
    self._oprot.writeMessageBegin('addBadInventory', TMessageType.CALL, self._seqid)
1793 
    args = addBadInventory_args()
1794 
    args.itemId = itemId
1795 
    args.warehouseId = warehouseId
1796 
    args.quantity = quantity
1797 
    args.write(self._oprot)
1798 
    self._oprot.writeMessageEnd()
1799 
    self._oprot.trans.flush()
1800 
 
1801 
  def recv_addBadInventory(self, ):
1802 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1803 
    if mtype == TMessageType.EXCEPTION:
1804 
      x = TApplicationException()
1805 
      x.read(self._iprot)
1806 
      self._iprot.readMessageEnd()
1807 
      raise x
1808 
    result = addBadInventory_result()
1809 
    result.read(self._iprot)
1810 
    self._iprot.readMessageEnd()
1811 
    if result.cex is not None:
1812 
      raise result.cex
1813 
    return
1814 
 
1815 
  def getShippingLocations(self, ):
1816 
    """
1817 
    Returns all shipping locations
1818 
    """
1819 
    self.send_getShippingLocations()
1820 
    return self.recv_getShippingLocations()
1821 
 
1822 
  def send_getShippingLocations(self, ):
1823 
    self._oprot.writeMessageBegin('getShippingLocations', TMessageType.CALL, self._seqid)
1824 
    args = getShippingLocations_args()
1825 
    args.write(self._oprot)
1826 
    self._oprot.writeMessageEnd()
1827 
    self._oprot.trans.flush()
1828 
 
1829 
  def recv_getShippingLocations(self, ):
1830 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1831 
    if mtype == TMessageType.EXCEPTION:
1832 
      x = TApplicationException()
1833 
      x.read(self._iprot)
1834 
      self._iprot.readMessageEnd()
1835 
      raise x
1836 
    result = getShippingLocations_result()
1837 
    result.read(self._iprot)
1838 
    self._iprot.readMessageEnd()
1839 
    if result.success is not None:
1840 
      return result.success
1841 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getShippingLocations failed: unknown result");
1842 
 
1843 
  def getAllVendorItemMappings(self, ):
1844 
    """
1845 
    Fetches all the vendor item mappings present.
1846 
    """
1847 
    self.send_getAllVendorItemMappings()
1848 
    return self.recv_getAllVendorItemMappings()
1849 
 
1850 
  def send_getAllVendorItemMappings(self, ):
1851 
    self._oprot.writeMessageBegin('getAllVendorItemMappings', TMessageType.CALL, self._seqid)
1852 
    args = getAllVendorItemMappings_args()
1853 
    args.write(self._oprot)
1854 
    self._oprot.writeMessageEnd()
1855 
    self._oprot.trans.flush()
1856 
 
1857 
  def recv_getAllVendorItemMappings(self, ):
1858 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1859 
    if mtype == TMessageType.EXCEPTION:
1860 
      x = TApplicationException()
1861 
      x.read(self._iprot)
1862 
      self._iprot.readMessageEnd()
1863 
      raise x
1864 
    result = getAllVendorItemMappings_result()
1865 
    result.read(self._iprot)
1866 
    self._iprot.readMessageEnd()
1867 
    if result.success is not None:
1868 
      return result.success
1869 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVendorItemMappings failed: unknown result");
1870 
 
1871 
  def getInventorySnapshot(self, warehouseId):
1872 
    """
1873 
    Gets items' inventory for a warehouse
1874 
    If warehouse is passed as zero, items' inventory across all warehouses is sent
1875 
 
1876 
    Parameters:
1877 
     - warehouseId
1878 
    """
1879 
    self.send_getInventorySnapshot(warehouseId)
1880 
    return self.recv_getInventorySnapshot()
1881 
 
1882 
  def send_getInventorySnapshot(self, warehouseId):
1883 
    self._oprot.writeMessageBegin('getInventorySnapshot', TMessageType.CALL, self._seqid)
1884 
    args = getInventorySnapshot_args()
1885 
    args.warehouseId = warehouseId
1886 
    args.write(self._oprot)
1887 
    self._oprot.writeMessageEnd()
1888 
    self._oprot.trans.flush()
1889 
 
1890 
  def recv_getInventorySnapshot(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 = getInventorySnapshot_result()
1898 
    result.read(self._iprot)
1899 
    self._iprot.readMessageEnd()
1900 
    if result.success is not None:
1901 
      return result.success
1902 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInventorySnapshot failed: unknown result");
1903 
 
1904 
  def clearItemAvailabilityCache(self, ):
1905 
    """
1906 
    Clear item availability cache.
1907 
    """
1908 
    self.send_clearItemAvailabilityCache()
1909 
    self.recv_clearItemAvailabilityCache()
1910 
 
1911 
  def send_clearItemAvailabilityCache(self, ):
1912 
    self._oprot.writeMessageBegin('clearItemAvailabilityCache', TMessageType.CALL, self._seqid)
1913 
    args = clearItemAvailabilityCache_args()
1914 
    args.write(self._oprot)
1915 
    self._oprot.writeMessageEnd()
1916 
    self._oprot.trans.flush()
1917 
 
1918 
  def recv_clearItemAvailabilityCache(self, ):
1919 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1920 
    if mtype == TMessageType.EXCEPTION:
1921 
      x = TApplicationException()
1922 
      x.read(self._iprot)
1923 
      self._iprot.readMessageEnd()
1924 
      raise x
1925 
    result = clearItemAvailabilityCache_result()
1926 
    result.read(self._iprot)
1927 
    self._iprot.readMessageEnd()
1928 
    return
1929 
 
1930 
  def updateVendorString(self, warehouseId, vendorString):
1931 
    """
1932 
    Parameters:
1933 
     - warehouseId
1934 
     - vendorString
1935 
    """
1936 
    self.send_updateVendorString(warehouseId, vendorString)
1937 
    self.recv_updateVendorString()
1938 
 
1939 
  def send_updateVendorString(self, warehouseId, vendorString):
1940 
    self._oprot.writeMessageBegin('updateVendorString', TMessageType.CALL, self._seqid)
1941 
    args = updateVendorString_args()
1942 
    args.warehouseId = warehouseId
1943 
    args.vendorString = vendorString
1944 
    args.write(self._oprot)
1945 
    self._oprot.writeMessageEnd()
1946 
    self._oprot.trans.flush()
1947 
 
1948 
  def recv_updateVendorString(self, ):
1949 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1950 
    if mtype == TMessageType.EXCEPTION:
1951 
      x = TApplicationException()
1952 
      x.read(self._iprot)
1953 
      self._iprot.readMessageEnd()
1954 
      raise x
1955 
    result = updateVendorString_result()
1956 
    result.read(self._iprot)
1957 
    self._iprot.readMessageEnd()
1958 
    return
1959 
 
6096 amit.gupta 1960 
  def clearItemAvailabilityCacheForItem(self, item_id):
1961 
    """
1962 
    Parameters:
1963 
     - item_id
1964 
    """
1965 
    self.send_clearItemAvailabilityCacheForItem(item_id)
1966 
    self.recv_clearItemAvailabilityCacheForItem()
5944 mandeep.dh 1967 
 
6096 amit.gupta 1968 
  def send_clearItemAvailabilityCacheForItem(self, item_id):
1969 
    self._oprot.writeMessageBegin('clearItemAvailabilityCacheForItem', TMessageType.CALL, self._seqid)
1970 
    args = clearItemAvailabilityCacheForItem_args()
1971 
    args.item_id = item_id
1972 
    args.write(self._oprot)
1973 
    self._oprot.writeMessageEnd()
1974 
    self._oprot.trans.flush()
1975 
 
1976 
  def recv_clearItemAvailabilityCacheForItem(self, ):
1977 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1978 
    if mtype == TMessageType.EXCEPTION:
1979 
      x = TApplicationException()
1980 
      x.read(self._iprot)
1981 
      self._iprot.readMessageEnd()
1982 
      raise x
1983 
    result = clearItemAvailabilityCacheForItem_result()
1984 
    result.read(self._iprot)
1985 
    self._iprot.readMessageEnd()
1986 
    return
1987 
 
7718 amar.kumar 1988 
  def getOurWarehouseIdForVendor(self, vendorId, billingWarehouseId):
6467 amar.kumar 1989 
    """
1990 
    Parameters:
1991 
     - vendorId
7718 amar.kumar 1992 
     - billingWarehouseId
6467 amar.kumar 1993 
    """
7718 amar.kumar 1994 
    self.send_getOurWarehouseIdForVendor(vendorId, billingWarehouseId)
6467 amar.kumar 1995 
    return self.recv_getOurWarehouseIdForVendor()
6096 amit.gupta 1996 
 
7718 amar.kumar 1997 
  def send_getOurWarehouseIdForVendor(self, vendorId, billingWarehouseId):
6467 amar.kumar 1998 
    self._oprot.writeMessageBegin('getOurWarehouseIdForVendor', TMessageType.CALL, self._seqid)
1999 
    args = getOurWarehouseIdForVendor_args()
2000 
    args.vendorId = vendorId
7718 amar.kumar 2001 
    args.billingWarehouseId = billingWarehouseId
6467 amar.kumar 2002 
    args.write(self._oprot)
2003 
    self._oprot.writeMessageEnd()
2004 
    self._oprot.trans.flush()
2005 
 
2006 
  def recv_getOurWarehouseIdForVendor(self, ):
2007 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2008 
    if mtype == TMessageType.EXCEPTION:
2009 
      x = TApplicationException()
2010 
      x.read(self._iprot)
2011 
      self._iprot.readMessageEnd()
2012 
      raise x
2013 
    result = getOurWarehouseIdForVendor_result()
2014 
    result.read(self._iprot)
2015 
    self._iprot.readMessageEnd()
2016 
    if result.success is not None:
2017 
      return result.success
2018 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOurWarehouseIdForVendor failed: unknown result");
2019 
 
6484 amar.kumar 2020 
  def getItemAvailabilitiesAtOurWarehouses(self, item_ids):
2021 
    """
2022 
    Parameters:
2023 
     - item_ids
2024 
    """
2025 
    self.send_getItemAvailabilitiesAtOurWarehouses(item_ids)
2026 
    return self.recv_getItemAvailabilitiesAtOurWarehouses()
6467 amar.kumar 2027 
 
6484 amar.kumar 2028 
  def send_getItemAvailabilitiesAtOurWarehouses(self, item_ids):
2029 
    self._oprot.writeMessageBegin('getItemAvailabilitiesAtOurWarehouses', TMessageType.CALL, self._seqid)
2030 
    args = getItemAvailabilitiesAtOurWarehouses_args()
2031 
    args.item_ids = item_ids
2032 
    args.write(self._oprot)
2033 
    self._oprot.writeMessageEnd()
2034 
    self._oprot.trans.flush()
2035 
 
2036 
  def recv_getItemAvailabilitiesAtOurWarehouses(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 = getItemAvailabilitiesAtOurWarehouses_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, "getItemAvailabilitiesAtOurWarehouses failed: unknown result");
2049 
 
6531 vikram.rag 2050 
  def getMonitoredWarehouseForVendors(self, vendorIds):
2051 
    """
2052 
    Parameters:
2053 
     - vendorIds
2054 
    """
2055 
    self.send_getMonitoredWarehouseForVendors(vendorIds)
2056 
    return self.recv_getMonitoredWarehouseForVendors()
6484 amar.kumar 2057 
 
6531 vikram.rag 2058 
  def send_getMonitoredWarehouseForVendors(self, vendorIds):
2059 
    self._oprot.writeMessageBegin('getMonitoredWarehouseForVendors', TMessageType.CALL, self._seqid)
2060 
    args = getMonitoredWarehouseForVendors_args()
2061 
    args.vendorIds = vendorIds
2062 
    args.write(self._oprot)
2063 
    self._oprot.writeMessageEnd()
2064 
    self._oprot.trans.flush()
2065 
 
2066 
  def recv_getMonitoredWarehouseForVendors(self, ):
2067 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2068 
    if mtype == TMessageType.EXCEPTION:
2069 
      x = TApplicationException()
2070 
      x.read(self._iprot)
2071 
      self._iprot.readMessageEnd()
2072 
      raise x
2073 
    result = getMonitoredWarehouseForVendors_result()
2074 
    result.read(self._iprot)
2075 
    self._iprot.readMessageEnd()
2076 
    if result.success is not None:
2077 
      return result.success
2078 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMonitoredWarehouseForVendors failed: unknown result");
2079 
 
2080 
  def getIgnoredWarehouseidsAndItemids(self, ):
2081 
    self.send_getIgnoredWarehouseidsAndItemids()
2082 
    return self.recv_getIgnoredWarehouseidsAndItemids()
2083 
 
2084 
  def send_getIgnoredWarehouseidsAndItemids(self, ):
2085 
    self._oprot.writeMessageBegin('getIgnoredWarehouseidsAndItemids', TMessageType.CALL, self._seqid)
2086 
    args = getIgnoredWarehouseidsAndItemids_args()
2087 
    args.write(self._oprot)
2088 
    self._oprot.writeMessageEnd()
2089 
    self._oprot.trans.flush()
2090 
 
2091 
  def recv_getIgnoredWarehouseidsAndItemids(self, ):
2092 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2093 
    if mtype == TMessageType.EXCEPTION:
2094 
      x = TApplicationException()
2095 
      x.read(self._iprot)
2096 
      self._iprot.readMessageEnd()
2097 
      raise x
2098 
    result = getIgnoredWarehouseidsAndItemids_result()
2099 
    result.read(self._iprot)
2100 
    self._iprot.readMessageEnd()
2101 
    if result.success is not None:
2102 
      return result.success
2103 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getIgnoredWarehouseidsAndItemids failed: unknown result");
2104 
 
2105 
  def insertItemtoIgnoreInventoryUpdatelist(self, item_id, warehouse_id):
2106 
    """
2107 
    Parameters:
2108 
     - item_id
2109 
     - warehouse_id
2110 
    """
2111 
    self.send_insertItemtoIgnoreInventoryUpdatelist(item_id, warehouse_id)
2112 
    return self.recv_insertItemtoIgnoreInventoryUpdatelist()
2113 
 
2114 
  def send_insertItemtoIgnoreInventoryUpdatelist(self, item_id, warehouse_id):
2115 
    self._oprot.writeMessageBegin('insertItemtoIgnoreInventoryUpdatelist', TMessageType.CALL, self._seqid)
2116 
    args = insertItemtoIgnoreInventoryUpdatelist_args()
2117 
    args.item_id = item_id
2118 
    args.warehouse_id = warehouse_id
2119 
    args.write(self._oprot)
2120 
    self._oprot.writeMessageEnd()
2121 
    self._oprot.trans.flush()
2122 
 
2123 
  def recv_insertItemtoIgnoreInventoryUpdatelist(self, ):
2124 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2125 
    if mtype == TMessageType.EXCEPTION:
2126 
      x = TApplicationException()
2127 
      x.read(self._iprot)
2128 
      self._iprot.readMessageEnd()
2129 
      raise x
2130 
    result = insertItemtoIgnoreInventoryUpdatelist_result()
2131 
    result.read(self._iprot)
2132 
    self._iprot.readMessageEnd()
2133 
    if result.success is not None:
2134 
      return result.success
2135 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "insertItemtoIgnoreInventoryUpdatelist failed: unknown result");
2136 
 
2137 
  def deleteItemFromIgnoredInventoryUpdateList(self, item_id, warehouse_id):
2138 
    """
2139 
    Parameters:
2140 
     - item_id
2141 
     - warehouse_id
2142 
    """
2143 
    self.send_deleteItemFromIgnoredInventoryUpdateList(item_id, warehouse_id)
2144 
    return self.recv_deleteItemFromIgnoredInventoryUpdateList()
2145 
 
2146 
  def send_deleteItemFromIgnoredInventoryUpdateList(self, item_id, warehouse_id):
2147 
    self._oprot.writeMessageBegin('deleteItemFromIgnoredInventoryUpdateList', TMessageType.CALL, self._seqid)
2148 
    args = deleteItemFromIgnoredInventoryUpdateList_args()
2149 
    args.item_id = item_id
2150 
    args.warehouse_id = warehouse_id
2151 
    args.write(self._oprot)
2152 
    self._oprot.writeMessageEnd()
2153 
    self._oprot.trans.flush()
2154 
 
2155 
  def recv_deleteItemFromIgnoredInventoryUpdateList(self, ):
2156 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2157 
    if mtype == TMessageType.EXCEPTION:
2158 
      x = TApplicationException()
2159 
      x.read(self._iprot)
2160 
      self._iprot.readMessageEnd()
2161 
      raise x
2162 
    result = deleteItemFromIgnoredInventoryUpdateList_result()
2163 
    result.read(self._iprot)
2164 
    self._iprot.readMessageEnd()
2165 
    if result.success is not None:
2166 
      return result.success
2167 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteItemFromIgnoredInventoryUpdateList failed: unknown result");
2168 
 
2169 
  def getAllIgnoredInventoryupdateItemsCount(self, ):
2170 
    self.send_getAllIgnoredInventoryupdateItemsCount()
2171 
    return self.recv_getAllIgnoredInventoryupdateItemsCount()
2172 
 
2173 
  def send_getAllIgnoredInventoryupdateItemsCount(self, ):
2174 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryupdateItemsCount', TMessageType.CALL, self._seqid)
2175 
    args = getAllIgnoredInventoryupdateItemsCount_args()
2176 
    args.write(self._oprot)
2177 
    self._oprot.writeMessageEnd()
2178 
    self._oprot.trans.flush()
2179 
 
2180 
  def recv_getAllIgnoredInventoryupdateItemsCount(self, ):
2181 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2182 
    if mtype == TMessageType.EXCEPTION:
2183 
      x = TApplicationException()
2184 
      x.read(self._iprot)
2185 
      self._iprot.readMessageEnd()
2186 
      raise x
2187 
    result = getAllIgnoredInventoryupdateItemsCount_result()
2188 
    result.read(self._iprot)
2189 
    self._iprot.readMessageEnd()
2190 
    if result.success is not None:
2191 
      return result.success
2192 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryupdateItemsCount failed: unknown result");
2193 
 
2194 
  def getIgnoredInventoryUpdateItemids(self, offset, limit):
2195 
    """
2196 
    Parameters:
2197 
     - offset
2198 
     - limit
2199 
    """
2200 
    self.send_getIgnoredInventoryUpdateItemids(offset, limit)
2201 
    return self.recv_getIgnoredInventoryUpdateItemids()
2202 
 
2203 
  def send_getIgnoredInventoryUpdateItemids(self, offset, limit):
2204 
    self._oprot.writeMessageBegin('getIgnoredInventoryUpdateItemids', TMessageType.CALL, self._seqid)
2205 
    args = getIgnoredInventoryUpdateItemids_args()
2206 
    args.offset = offset
2207 
    args.limit = limit
2208 
    args.write(self._oprot)
2209 
    self._oprot.writeMessageEnd()
2210 
    self._oprot.trans.flush()
2211 
 
2212 
  def recv_getIgnoredInventoryUpdateItemids(self, ):
2213 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2214 
    if mtype == TMessageType.EXCEPTION:
2215 
      x = TApplicationException()
2216 
      x.read(self._iprot)
2217 
      self._iprot.readMessageEnd()
2218 
      raise x
2219 
    result = getIgnoredInventoryUpdateItemids_result()
2220 
    result.read(self._iprot)
2221 
    self._iprot.readMessageEnd()
2222 
    if result.success is not None:
2223 
      return result.success
2224 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getIgnoredInventoryUpdateItemids failed: unknown result");
2225 
 
6821 amar.kumar 2226 
  def updateItemStockPurchaseParams(self, item_id, numOfDaysStock, minStockLevel):
2227 
    """
2228 
    Parameters:
2229 
     - item_id
2230 
     - numOfDaysStock
2231 
     - minStockLevel
2232 
    """
2233 
    self.send_updateItemStockPurchaseParams(item_id, numOfDaysStock, minStockLevel)
2234 
    self.recv_updateItemStockPurchaseParams()
6531 vikram.rag 2235 
 
6821 amar.kumar 2236 
  def send_updateItemStockPurchaseParams(self, item_id, numOfDaysStock, minStockLevel):
2237 
    self._oprot.writeMessageBegin('updateItemStockPurchaseParams', TMessageType.CALL, self._seqid)
2238 
    args = updateItemStockPurchaseParams_args()
2239 
    args.item_id = item_id
2240 
    args.numOfDaysStock = numOfDaysStock
2241 
    args.minStockLevel = minStockLevel
2242 
    args.write(self._oprot)
2243 
    self._oprot.writeMessageEnd()
2244 
    self._oprot.trans.flush()
2245 
 
2246 
  def recv_updateItemStockPurchaseParams(self, ):
2247 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2248 
    if mtype == TMessageType.EXCEPTION:
2249 
      x = TApplicationException()
2250 
      x.read(self._iprot)
2251 
      self._iprot.readMessageEnd()
2252 
      raise x
2253 
    result = updateItemStockPurchaseParams_result()
2254 
    result.read(self._iprot)
2255 
    self._iprot.readMessageEnd()
2256 
    return
2257 
 
2258 
  def getItemStockPurchaseParams(self, itemId):
2259 
    """
2260 
    Parameters:
2261 
     - itemId
2262 
    """
2263 
    self.send_getItemStockPurchaseParams(itemId)
2264 
    return self.recv_getItemStockPurchaseParams()
2265 
 
2266 
  def send_getItemStockPurchaseParams(self, itemId):
2267 
    self._oprot.writeMessageBegin('getItemStockPurchaseParams', TMessageType.CALL, self._seqid)
2268 
    args = getItemStockPurchaseParams_args()
2269 
    args.itemId = itemId
2270 
    args.write(self._oprot)
2271 
    self._oprot.writeMessageEnd()
2272 
    self._oprot.trans.flush()
2273 
 
2274 
  def recv_getItemStockPurchaseParams(self, ):
2275 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2276 
    if mtype == TMessageType.EXCEPTION:
2277 
      x = TApplicationException()
2278 
      x.read(self._iprot)
2279 
      self._iprot.readMessageEnd()
2280 
      raise x
2281 
    result = getItemStockPurchaseParams_result()
2282 
    result.read(self._iprot)
2283 
    self._iprot.readMessageEnd()
2284 
    if result.success is not None:
2285 
      return result.success
2286 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStockPurchaseParams failed: unknown result");
2287 
 
2288 
  def addOosStatusForItem(self, oosStatusMap, date):
2289 
    """
2290 
    Parameters:
2291 
     - oosStatusMap
2292 
     - date
2293 
    """
2294 
    self.send_addOosStatusForItem(oosStatusMap, date)
2295 
    self.recv_addOosStatusForItem()
2296 
 
2297 
  def send_addOosStatusForItem(self, oosStatusMap, date):
2298 
    self._oprot.writeMessageBegin('addOosStatusForItem', TMessageType.CALL, self._seqid)
2299 
    args = addOosStatusForItem_args()
2300 
    args.oosStatusMap = oosStatusMap
2301 
    args.date = date
2302 
    args.write(self._oprot)
2303 
    self._oprot.writeMessageEnd()
2304 
    self._oprot.trans.flush()
2305 
 
2306 
  def recv_addOosStatusForItem(self, ):
2307 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2308 
    if mtype == TMessageType.EXCEPTION:
2309 
      x = TApplicationException()
2310 
      x.read(self._iprot)
2311 
      self._iprot.readMessageEnd()
2312 
      raise x
2313 
    result = addOosStatusForItem_result()
2314 
    result.read(self._iprot)
2315 
    self._iprot.readMessageEnd()
2316 
    return
2317 
 
9762 amar.kumar 2318 
  def getOosStatusesForXDaysForItem(self, itemId, sourceId, days):
6832 amar.kumar 2319 
    """
2320 
    Parameters:
2321 
     - itemId
9762 amar.kumar 2322 
     - sourceId
6832 amar.kumar 2323 
     - days
2324 
    """
9762 amar.kumar 2325 
    self.send_getOosStatusesForXDaysForItem(itemId, sourceId, days)
6832 amar.kumar 2326 
    return self.recv_getOosStatusesForXDaysForItem()
6821 amar.kumar 2327 
 
9762 amar.kumar 2328 
  def send_getOosStatusesForXDaysForItem(self, itemId, sourceId, days):
6832 amar.kumar 2329 
    self._oprot.writeMessageBegin('getOosStatusesForXDaysForItem', TMessageType.CALL, self._seqid)
2330 
    args = getOosStatusesForXDaysForItem_args()
2331 
    args.itemId = itemId
9762 amar.kumar 2332 
    args.sourceId = sourceId
6832 amar.kumar 2333 
    args.days = days
2334 
    args.write(self._oprot)
2335 
    self._oprot.writeMessageEnd()
2336 
    self._oprot.trans.flush()
2337 
 
2338 
  def recv_getOosStatusesForXDaysForItem(self, ):
2339 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2340 
    if mtype == TMessageType.EXCEPTION:
2341 
      x = TApplicationException()
2342 
      x.read(self._iprot)
2343 
      self._iprot.readMessageEnd()
2344 
      raise x
2345 
    result = getOosStatusesForXDaysForItem_result()
2346 
    result.read(self._iprot)
2347 
    self._iprot.readMessageEnd()
2348 
    if result.success is not None:
2349 
      return result.success
2350 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOosStatusesForXDaysForItem failed: unknown result");
2351 
 
10126 amar.kumar 2352 
  def getOosStatusesForXDays(self, sourceId, days):
2353 
    """
2354 
    Parameters:
2355 
     - sourceId
2356 
     - days
2357 
    """
2358 
    self.send_getOosStatusesForXDays(sourceId, days)
2359 
    return self.recv_getOosStatusesForXDays()
2360 
 
2361 
  def send_getOosStatusesForXDays(self, sourceId, days):
2362 
    self._oprot.writeMessageBegin('getOosStatusesForXDays', TMessageType.CALL, self._seqid)
2363 
    args = getOosStatusesForXDays_args()
2364 
    args.sourceId = sourceId
2365 
    args.days = days
2366 
    args.write(self._oprot)
2367 
    self._oprot.writeMessageEnd()
2368 
    self._oprot.trans.flush()
2369 
 
2370 
  def recv_getOosStatusesForXDays(self, ):
2371 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2372 
    if mtype == TMessageType.EXCEPTION:
2373 
      x = TApplicationException()
2374 
      x.read(self._iprot)
2375 
      self._iprot.readMessageEnd()
2376 
      raise x
2377 
    result = getOosStatusesForXDays_result()
2378 
    result.read(self._iprot)
2379 
    self._iprot.readMessageEnd()
2380 
    if result.success is not None:
2381 
      return result.success
2382 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOosStatusesForXDays failed: unknown result");
2383 
 
2384 
  def getAllVendorItemPricing(self, itemId, vendorId):
2385 
    """
2386 
    Parameters:
2387 
     - itemId
2388 
     - vendorId
2389 
    """
2390 
    self.send_getAllVendorItemPricing(itemId, vendorId)
2391 
    return self.recv_getAllVendorItemPricing()
2392 
 
2393 
  def send_getAllVendorItemPricing(self, itemId, vendorId):
2394 
    self._oprot.writeMessageBegin('getAllVendorItemPricing', TMessageType.CALL, self._seqid)
2395 
    args = getAllVendorItemPricing_args()
2396 
    args.itemId = itemId
2397 
    args.vendorId = vendorId
2398 
    args.write(self._oprot)
2399 
    self._oprot.writeMessageEnd()
2400 
    self._oprot.trans.flush()
2401 
 
2402 
  def recv_getAllVendorItemPricing(self, ):
2403 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2404 
    if mtype == TMessageType.EXCEPTION:
2405 
      x = TApplicationException()
2406 
      x.read(self._iprot)
2407 
      self._iprot.readMessageEnd()
2408 
      raise x
2409 
    result = getAllVendorItemPricing_result()
2410 
    result.read(self._iprot)
2411 
    self._iprot.readMessageEnd()
2412 
    if result.success is not None:
2413 
      return result.success
2414 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVendorItemPricing failed: unknown result");
2415 
 
6857 amar.kumar 2416 
  def getNonZeroItemStockPurchaseParams(self, ):
2417 
    self.send_getNonZeroItemStockPurchaseParams()
2418 
    return self.recv_getNonZeroItemStockPurchaseParams()
6832 amar.kumar 2419 
 
6857 amar.kumar 2420 
  def send_getNonZeroItemStockPurchaseParams(self, ):
2421 
    self._oprot.writeMessageBegin('getNonZeroItemStockPurchaseParams', TMessageType.CALL, self._seqid)
2422 
    args = getNonZeroItemStockPurchaseParams_args()
2423 
    args.write(self._oprot)
2424 
    self._oprot.writeMessageEnd()
2425 
    self._oprot.trans.flush()
2426 
 
2427 
  def recv_getNonZeroItemStockPurchaseParams(self, ):
2428 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2429 
    if mtype == TMessageType.EXCEPTION:
2430 
      x = TApplicationException()
2431 
      x.read(self._iprot)
2432 
      self._iprot.readMessageEnd()
2433 
      raise x
2434 
    result = getNonZeroItemStockPurchaseParams_result()
2435 
    result.read(self._iprot)
2436 
    self._iprot.readMessageEnd()
2437 
    if result.success is not None:
2438 
      return result.success
2439 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonZeroItemStockPurchaseParams failed: unknown result");
2440 
 
7149 amar.kumar 2441 
  def getBillableInventoryAndPendingOrders(self, ):
2442 
    """
2443 
    Returns a list of inventory stock for items for which there are pending orders or have billable inventory.
2444 
    """
2445 
    self.send_getBillableInventoryAndPendingOrders()
2446 
    return self.recv_getBillableInventoryAndPendingOrders()
6857 amar.kumar 2447 
 
7149 amar.kumar 2448 
  def send_getBillableInventoryAndPendingOrders(self, ):
2449 
    self._oprot.writeMessageBegin('getBillableInventoryAndPendingOrders', TMessageType.CALL, self._seqid)
2450 
    args = getBillableInventoryAndPendingOrders_args()
2451 
    args.write(self._oprot)
2452 
    self._oprot.writeMessageEnd()
2453 
    self._oprot.trans.flush()
2454 
 
2455 
  def recv_getBillableInventoryAndPendingOrders(self, ):
2456 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2457 
    if mtype == TMessageType.EXCEPTION:
2458 
      x = TApplicationException()
2459 
      x.read(self._iprot)
2460 
      self._iprot.readMessageEnd()
2461 
      raise x
2462 
    result = getBillableInventoryAndPendingOrders_result()
2463 
    result.read(self._iprot)
2464 
    self._iprot.readMessageEnd()
2465 
    if result.success is not None:
2466 
      return result.success
2467 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBillableInventoryAndPendingOrders failed: unknown result");
2468 
 
7281 kshitij.so 2469 
  def getWarehouseName(self, warehouse_id):
2470 
    """
2471 
    Parameters:
2472 
     - warehouse_id
2473 
    """
2474 
    self.send_getWarehouseName(warehouse_id)
2475 
    return self.recv_getWarehouseName()
7149 amar.kumar 2476 
 
7281 kshitij.so 2477 
  def send_getWarehouseName(self, warehouse_id):
2478 
    self._oprot.writeMessageBegin('getWarehouseName', TMessageType.CALL, self._seqid)
2479 
    args = getWarehouseName_args()
2480 
    args.warehouse_id = warehouse_id
2481 
    args.write(self._oprot)
2482 
    self._oprot.writeMessageEnd()
2483 
    self._oprot.trans.flush()
2484 
 
2485 
  def recv_getWarehouseName(self, ):
2486 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2487 
    if mtype == TMessageType.EXCEPTION:
2488 
      x = TApplicationException()
2489 
      x.read(self._iprot)
2490 
      self._iprot.readMessageEnd()
2491 
      raise x
2492 
    result = getWarehouseName_result()
2493 
    result.read(self._iprot)
2494 
    self._iprot.readMessageEnd()
2495 
    if result.success is not None:
2496 
      return result.success
2497 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getWarehouseName failed: unknown result");
2498 
 
2499 
  def getAmazonInventoryForItem(self, item_id):
2500 
    """
2501 
    Parameters:
2502 
     - item_id
2503 
    """
2504 
    self.send_getAmazonInventoryForItem(item_id)
2505 
    return self.recv_getAmazonInventoryForItem()
2506 
 
2507 
  def send_getAmazonInventoryForItem(self, item_id):
2508 
    self._oprot.writeMessageBegin('getAmazonInventoryForItem', TMessageType.CALL, self._seqid)
2509 
    args = getAmazonInventoryForItem_args()
2510 
    args.item_id = item_id
2511 
    args.write(self._oprot)
2512 
    self._oprot.writeMessageEnd()
2513 
    self._oprot.trans.flush()
2514 
 
2515 
  def recv_getAmazonInventoryForItem(self, ):
2516 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2517 
    if mtype == TMessageType.EXCEPTION:
2518 
      x = TApplicationException()
2519 
      x.read(self._iprot)
2520 
      self._iprot.readMessageEnd()
2521 
      raise x
2522 
    result = getAmazonInventoryForItem_result()
2523 
    result.read(self._iprot)
2524 
    self._iprot.readMessageEnd()
2525 
    if result.success is not None:
2526 
      return result.success
2527 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonInventoryForItem failed: unknown result");
2528 
 
2529 
  def getAllAmazonInventory(self, ):
2530 
    self.send_getAllAmazonInventory()
2531 
    return self.recv_getAllAmazonInventory()
2532 
 
2533 
  def send_getAllAmazonInventory(self, ):
2534 
    self._oprot.writeMessageBegin('getAllAmazonInventory', TMessageType.CALL, self._seqid)
2535 
    args = getAllAmazonInventory_args()
2536 
    args.write(self._oprot)
2537 
    self._oprot.writeMessageEnd()
2538 
    self._oprot.trans.flush()
2539 
 
2540 
  def recv_getAllAmazonInventory(self, ):
2541 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2542 
    if mtype == TMessageType.EXCEPTION:
2543 
      x = TApplicationException()
2544 
      x.read(self._iprot)
2545 
      self._iprot.readMessageEnd()
2546 
      raise x
2547 
    result = getAllAmazonInventory_result()
2548 
    result.read(self._iprot)
2549 
    self._iprot.readMessageEnd()
2550 
    if result.success is not None:
2551 
      return result.success
2552 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonInventory failed: unknown result");
2553 
 
10450 vikram.rag 2554 
  def addOrUpdateAmazonInventoryForItem(self, amazonInventorySnapshot, time):
7281 kshitij.so 2555 
    """
2556 
    Parameters:
2557 
     - amazonInventorySnapshot
10450 vikram.rag 2558 
     - time
7281 kshitij.so 2559 
    """
10450 vikram.rag 2560 
    self.send_addOrUpdateAmazonInventoryForItem(amazonInventorySnapshot, time)
7281 kshitij.so 2561 
    self.recv_addOrUpdateAmazonInventoryForItem()
2562 
 
10450 vikram.rag 2563 
  def send_addOrUpdateAmazonInventoryForItem(self, amazonInventorySnapshot, time):
7281 kshitij.so 2564 
    self._oprot.writeMessageBegin('addOrUpdateAmazonInventoryForItem', TMessageType.CALL, self._seqid)
2565 
    args = addOrUpdateAmazonInventoryForItem_args()
2566 
    args.amazonInventorySnapshot = amazonInventorySnapshot
10450 vikram.rag 2567 
    args.time = time
7281 kshitij.so 2568 
    args.write(self._oprot)
2569 
    self._oprot.writeMessageEnd()
2570 
    self._oprot.trans.flush()
2571 
 
2572 
  def recv_addOrUpdateAmazonInventoryForItem(self, ):
2573 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2574 
    if mtype == TMessageType.EXCEPTION:
2575 
      x = TApplicationException()
2576 
      x.read(self._iprot)
2577 
      self._iprot.readMessageEnd()
2578 
      raise x
2579 
    result = addOrUpdateAmazonInventoryForItem_result()
2580 
    result.read(self._iprot)
2581 
    self._iprot.readMessageEnd()
2582 
    return
2583 
 
7972 amar.kumar 2584 
  def getLastNdaySaleForItem(self, itemId, numberOfDays):
2585 
    """
2586 
    Parameters:
2587 
     - itemId
2588 
     - numberOfDays
2589 
    """
2590 
    self.send_getLastNdaySaleForItem(itemId, numberOfDays)
2591 
    return self.recv_getLastNdaySaleForItem()
7281 kshitij.so 2592 
 
7972 amar.kumar 2593 
  def send_getLastNdaySaleForItem(self, itemId, numberOfDays):
2594 
    self._oprot.writeMessageBegin('getLastNdaySaleForItem', TMessageType.CALL, self._seqid)
2595 
    args = getLastNdaySaleForItem_args()
2596 
    args.itemId = itemId
2597 
    args.numberOfDays = numberOfDays
2598 
    args.write(self._oprot)
2599 
    self._oprot.writeMessageEnd()
2600 
    self._oprot.trans.flush()
2601 
 
2602 
  def recv_getLastNdaySaleForItem(self, ):
2603 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2604 
    if mtype == TMessageType.EXCEPTION:
2605 
      x = TApplicationException()
2606 
      x.read(self._iprot)
2607 
      self._iprot.readMessageEnd()
2608 
      raise x
2609 
    result = getLastNdaySaleForItem_result()
2610 
    result.read(self._iprot)
2611 
    self._iprot.readMessageEnd()
2612 
    if result.success is not None:
2613 
      return result.success
2614 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLastNdaySaleForItem failed: unknown result");
2615 
 
8282 kshitij.so 2616 
  def addOrUpdateAmazonFbaInventory(self, amazonfbainventorysnapshot):
2617 
    """
2618 
    Parameters:
2619 
     - amazonfbainventorysnapshot
2620 
    """
2621 
    self.send_addOrUpdateAmazonFbaInventory(amazonfbainventorysnapshot)
2622 
    self.recv_addOrUpdateAmazonFbaInventory()
2623 
 
2624 
  def send_addOrUpdateAmazonFbaInventory(self, amazonfbainventorysnapshot):
2625 
    self._oprot.writeMessageBegin('addOrUpdateAmazonFbaInventory', TMessageType.CALL, self._seqid)
2626 
    args = addOrUpdateAmazonFbaInventory_args()
2627 
    args.amazonfbainventorysnapshot = amazonfbainventorysnapshot
2628 
    args.write(self._oprot)
2629 
    self._oprot.writeMessageEnd()
2630 
    self._oprot.trans.flush()
2631 
 
2632 
  def recv_addOrUpdateAmazonFbaInventory(self, ):
2633 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2634 
    if mtype == TMessageType.EXCEPTION:
2635 
      x = TApplicationException()
2636 
      x.read(self._iprot)
2637 
      self._iprot.readMessageEnd()
2638 
      raise x
2639 
    result = addOrUpdateAmazonFbaInventory_result()
2640 
    result.read(self._iprot)
2641 
    self._iprot.readMessageEnd()
2642 
    return
2643 
 
8182 amar.kumar 2644 
  def addUpdateHoldInventory(self, itemId, warehouseId, holdQuantity, source):
2645 
    """
2646 
    Parameters:
2647 
     - itemId
2648 
     - warehouseId
2649 
     - holdQuantity
2650 
     - source
2651 
    """
2652 
    self.send_addUpdateHoldInventory(itemId, warehouseId, holdQuantity, source)
2653 
    self.recv_addUpdateHoldInventory()
7972 amar.kumar 2654 
 
8182 amar.kumar 2655 
  def send_addUpdateHoldInventory(self, itemId, warehouseId, holdQuantity, source):
2656 
    self._oprot.writeMessageBegin('addUpdateHoldInventory', TMessageType.CALL, self._seqid)
2657 
    args = addUpdateHoldInventory_args()
2658 
    args.itemId = itemId
2659 
    args.warehouseId = warehouseId
2660 
    args.holdQuantity = holdQuantity
2661 
    args.source = source
2662 
    args.write(self._oprot)
2663 
    self._oprot.writeMessageEnd()
2664 
    self._oprot.trans.flush()
2665 
 
2666 
  def recv_addUpdateHoldInventory(self, ):
2667 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2668 
    if mtype == TMessageType.EXCEPTION:
2669 
      x = TApplicationException()
2670 
      x.read(self._iprot)
2671 
      self._iprot.readMessageEnd()
2672 
      raise x
2673 
    result = addUpdateHoldInventory_result()
2674 
    result.read(self._iprot)
2675 
    self._iprot.readMessageEnd()
9762 amar.kumar 2676 
    if result.cex is not None:
2677 
      raise result.cex
8182 amar.kumar 2678 
    return
2679 
 
8282 kshitij.so 2680 
  def getAmazonFbaItemInventory(self, itemId):
2681 
    """
2682 
    Parameters:
2683 
     - itemId
2684 
    """
2685 
    self.send_getAmazonFbaItemInventory(itemId)
2686 
    return self.recv_getAmazonFbaItemInventory()
8182 amar.kumar 2687 
 
8282 kshitij.so 2688 
  def send_getAmazonFbaItemInventory(self, itemId):
2689 
    self._oprot.writeMessageBegin('getAmazonFbaItemInventory', TMessageType.CALL, self._seqid)
2690 
    args = getAmazonFbaItemInventory_args()
2691 
    args.itemId = itemId
2692 
    args.write(self._oprot)
2693 
    self._oprot.writeMessageEnd()
2694 
    self._oprot.trans.flush()
2695 
 
2696 
  def recv_getAmazonFbaItemInventory(self, ):
2697 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2698 
    if mtype == TMessageType.EXCEPTION:
2699 
      x = TApplicationException()
2700 
      x.read(self._iprot)
2701 
      self._iprot.readMessageEnd()
2702 
      raise x
2703 
    result = getAmazonFbaItemInventory_result()
2704 
    result.read(self._iprot)
2705 
    self._iprot.readMessageEnd()
2706 
    if result.success is not None:
2707 
      return result.success
2708 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonFbaItemInventory failed: unknown result");
2709 
 
8363 vikram.rag 2710 
  def getAllAmazonFbaItemInventory(self, ):
2711 
    self.send_getAllAmazonFbaItemInventory()
2712 
    return self.recv_getAllAmazonFbaItemInventory()
8282 kshitij.so 2713 
 
8363 vikram.rag 2714 
  def send_getAllAmazonFbaItemInventory(self, ):
2715 
    self._oprot.writeMessageBegin('getAllAmazonFbaItemInventory', TMessageType.CALL, self._seqid)
2716 
    args = getAllAmazonFbaItemInventory_args()
8282 kshitij.so 2717 
    args.write(self._oprot)
2718 
    self._oprot.writeMessageEnd()
2719 
    self._oprot.trans.flush()
2720 
 
8363 vikram.rag 2721 
  def recv_getAllAmazonFbaItemInventory(self, ):
8282 kshitij.so 2722 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2723 
    if mtype == TMessageType.EXCEPTION:
2724 
      x = TApplicationException()
2725 
      x.read(self._iprot)
2726 
      self._iprot.readMessageEnd()
2727 
      raise x
8363 vikram.rag 2728 
    result = getAllAmazonFbaItemInventory_result()
8282 kshitij.so 2729 
    result.read(self._iprot)
2730 
    self._iprot.readMessageEnd()
2731 
    if result.success is not None:
2732 
      return result.success
8363 vikram.rag 2733 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonFbaItemInventory failed: unknown result");
8282 kshitij.so 2734 
 
8363 vikram.rag 2735 
  def getOursGoodWarehouseIdsForLocation(self, state_id):
2736 
    """
2737 
    Parameters:
2738 
     - state_id
2739 
    """
2740 
    self.send_getOursGoodWarehouseIdsForLocation(state_id)
2741 
    return self.recv_getOursGoodWarehouseIdsForLocation()
8282 kshitij.so 2742 
 
8363 vikram.rag 2743 
  def send_getOursGoodWarehouseIdsForLocation(self, state_id):
2744 
    self._oprot.writeMessageBegin('getOursGoodWarehouseIdsForLocation', TMessageType.CALL, self._seqid)
2745 
    args = getOursGoodWarehouseIdsForLocation_args()
2746 
    args.state_id = state_id
2747 
    args.write(self._oprot)
2748 
    self._oprot.writeMessageEnd()
2749 
    self._oprot.trans.flush()
2750 
 
2751 
  def recv_getOursGoodWarehouseIdsForLocation(self, ):
2752 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2753 
    if mtype == TMessageType.EXCEPTION:
2754 
      x = TApplicationException()
2755 
      x.read(self._iprot)
2756 
      self._iprot.readMessageEnd()
2757 
      raise x
2758 
    result = getOursGoodWarehouseIdsForLocation_result()
2759 
    result.read(self._iprot)
2760 
    self._iprot.readMessageEnd()
2761 
    if result.success is not None:
2762 
      return result.success
2763 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOursGoodWarehouseIdsForLocation failed: unknown result");
2764 
 
8955 vikram.rag 2765 
  def getHoldInventoryDetailForItemForWarehouseIdExceptSource(self, id, warehouse_id, source):
2766 
    """
2767 
    Parameters:
2768 
     - id
2769 
     - warehouse_id
2770 
     - source
2771 
    """
2772 
    self.send_getHoldInventoryDetailForItemForWarehouseIdExceptSource(id, warehouse_id, source)
2773 
    return self.recv_getHoldInventoryDetailForItemForWarehouseIdExceptSource()
8363 vikram.rag 2774 
 
8955 vikram.rag 2775 
  def send_getHoldInventoryDetailForItemForWarehouseIdExceptSource(self, id, warehouse_id, source):
2776 
    self._oprot.writeMessageBegin('getHoldInventoryDetailForItemForWarehouseIdExceptSource', TMessageType.CALL, self._seqid)
2777 
    args = getHoldInventoryDetailForItemForWarehouseIdExceptSource_args()
2778 
    args.id = id
2779 
    args.warehouse_id = warehouse_id
2780 
    args.source = source
2781 
    args.write(self._oprot)
2782 
    self._oprot.writeMessageEnd()
2783 
    self._oprot.trans.flush()
2784 
 
2785 
  def recv_getHoldInventoryDetailForItemForWarehouseIdExceptSource(self, ):
2786 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2787 
    if mtype == TMessageType.EXCEPTION:
2788 
      x = TApplicationException()
2789 
      x.read(self._iprot)
2790 
      self._iprot.readMessageEnd()
2791 
      raise x
2792 
    result = getHoldInventoryDetailForItemForWarehouseIdExceptSource_result()
2793 
    result.read(self._iprot)
2794 
    self._iprot.readMessageEnd()
2795 
    if result.success is not None:
2796 
      return result.success
2797 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getHoldInventoryDetailForItemForWarehouseIdExceptSource failed: unknown result");
2798 
 
9404 vikram.rag 2799 
  def getSnapdealInventoryForItem(self, item_id):
2800 
    """
2801 
    Parameters:
2802 
     - item_id
2803 
    """
2804 
    self.send_getSnapdealInventoryForItem(item_id)
2805 
    return self.recv_getSnapdealInventoryForItem()
8955 vikram.rag 2806 
 
9404 vikram.rag 2807 
  def send_getSnapdealInventoryForItem(self, item_id):
2808 
    self._oprot.writeMessageBegin('getSnapdealInventoryForItem', TMessageType.CALL, self._seqid)
2809 
    args = getSnapdealInventoryForItem_args()
2810 
    args.item_id = item_id
2811 
    args.write(self._oprot)
2812 
    self._oprot.writeMessageEnd()
2813 
    self._oprot.trans.flush()
2814 
 
2815 
  def recv_getSnapdealInventoryForItem(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 = getSnapdealInventoryForItem_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, "getSnapdealInventoryForItem failed: unknown result");
2828 
 
2829 
  def addOrUpdateSnapdealInventoryForItem(self, snapdealinventoryitem):
2830 
    """
2831 
    Parameters:
2832 
     - snapdealinventoryitem
2833 
    """
2834 
    self.send_addOrUpdateSnapdealInventoryForItem(snapdealinventoryitem)
2835 
    self.recv_addOrUpdateSnapdealInventoryForItem()
2836 
 
2837 
  def send_addOrUpdateSnapdealInventoryForItem(self, snapdealinventoryitem):
2838 
    self._oprot.writeMessageBegin('addOrUpdateSnapdealInventoryForItem', TMessageType.CALL, self._seqid)
2839 
    args = addOrUpdateSnapdealInventoryForItem_args()
2840 
    args.snapdealinventoryitem = snapdealinventoryitem
2841 
    args.write(self._oprot)
2842 
    self._oprot.writeMessageEnd()
2843 
    self._oprot.trans.flush()
2844 
 
2845 
  def recv_addOrUpdateSnapdealInventoryForItem(self, ):
2846 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2847 
    if mtype == TMessageType.EXCEPTION:
2848 
      x = TApplicationException()
2849 
      x.read(self._iprot)
2850 
      self._iprot.readMessageEnd()
2851 
      raise x
2852 
    result = addOrUpdateSnapdealInventoryForItem_result()
2853 
    result.read(self._iprot)
2854 
    self._iprot.readMessageEnd()
2855 
    return
2856 
 
2857 
  def getNlcForWarehouse(self, warehouse_id, item_id):
2858 
    """
2859 
    Parameters:
2860 
     - warehouse_id
2861 
     - item_id
2862 
    """
2863 
    self.send_getNlcForWarehouse(warehouse_id, item_id)
2864 
    return self.recv_getNlcForWarehouse()
2865 
 
2866 
  def send_getNlcForWarehouse(self, warehouse_id, item_id):
2867 
    self._oprot.writeMessageBegin('getNlcForWarehouse', TMessageType.CALL, self._seqid)
2868 
    args = getNlcForWarehouse_args()
2869 
    args.warehouse_id = warehouse_id
2870 
    args.item_id = item_id
2871 
    args.write(self._oprot)
2872 
    self._oprot.writeMessageEnd()
2873 
    self._oprot.trans.flush()
2874 
 
2875 
  def recv_getNlcForWarehouse(self, ):
2876 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2877 
    if mtype == TMessageType.EXCEPTION:
2878 
      x = TApplicationException()
2879 
      x.read(self._iprot)
2880 
      self._iprot.readMessageEnd()
2881 
      raise x
2882 
    result = getNlcForWarehouse_result()
2883 
    result.read(self._iprot)
2884 
    self._iprot.readMessageEnd()
2885 
    if result.success is not None:
2886 
      return result.success
2887 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNlcForWarehouse failed: unknown result");
2888 
 
9640 amar.kumar 2889 
  def getHeldInventoryMapForItem(self, item_id, warehouse_id):
2890 
    """
2891 
    Parameters:
2892 
     - item_id
2893 
     - warehouse_id
2894 
    """
2895 
    self.send_getHeldInventoryMapForItem(item_id, warehouse_id)
2896 
    return self.recv_getHeldInventoryMapForItem()
2897 
 
2898 
  def send_getHeldInventoryMapForItem(self, item_id, warehouse_id):
2899 
    self._oprot.writeMessageBegin('getHeldInventoryMapForItem', TMessageType.CALL, self._seqid)
2900 
    args = getHeldInventoryMapForItem_args()
2901 
    args.item_id = item_id
2902 
    args.warehouse_id = warehouse_id
2903 
    args.write(self._oprot)
2904 
    self._oprot.writeMessageEnd()
2905 
    self._oprot.trans.flush()
2906 
 
2907 
  def recv_getHeldInventoryMapForItem(self, ):
2908 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2909 
    if mtype == TMessageType.EXCEPTION:
2910 
      x = TApplicationException()
2911 
      x.read(self._iprot)
2912 
      self._iprot.readMessageEnd()
2913 
      raise x
2914 
    result = getHeldInventoryMapForItem_result()
2915 
    result.read(self._iprot)
2916 
    self._iprot.readMessageEnd()
2917 
    if result.success is not None:
2918 
      return result.success
2919 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getHeldInventoryMapForItem failed: unknown result");
2920 
 
9495 vikram.rag 2921 
  def addOrUpdateAllAmazonFbaInventory(self, allamazonfbainventorysnapshot):
2922 
    """
2923 
    Parameters:
2924 
     - allamazonfbainventorysnapshot
2925 
    """
2926 
    self.send_addOrUpdateAllAmazonFbaInventory(allamazonfbainventorysnapshot)
2927 
    self.recv_addOrUpdateAllAmazonFbaInventory()
9404 vikram.rag 2928 
 
9495 vikram.rag 2929 
  def send_addOrUpdateAllAmazonFbaInventory(self, allamazonfbainventorysnapshot):
2930 
    self._oprot.writeMessageBegin('addOrUpdateAllAmazonFbaInventory', TMessageType.CALL, self._seqid)
2931 
    args = addOrUpdateAllAmazonFbaInventory_args()
2932 
    args.allamazonfbainventorysnapshot = allamazonfbainventorysnapshot
9456 vikram.rag 2933 
    args.write(self._oprot)
2934 
    self._oprot.writeMessageEnd()
2935 
    self._oprot.trans.flush()
2936 
 
9495 vikram.rag 2937 
  def recv_addOrUpdateAllAmazonFbaInventory(self, ):
9456 vikram.rag 2938 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2939 
    if mtype == TMessageType.EXCEPTION:
2940 
      x = TApplicationException()
2941 
      x.read(self._iprot)
2942 
      self._iprot.readMessageEnd()
2943 
      raise x
9495 vikram.rag 2944 
    result = addOrUpdateAllAmazonFbaInventory_result()
9456 vikram.rag 2945 
    result.read(self._iprot)
2946 
    self._iprot.readMessageEnd()
9495 vikram.rag 2947 
    return
9456 vikram.rag 2948 
 
9495 vikram.rag 2949 
  def addOrUpdateAllSnapdealInventory(self, allsnapdealinventorysnapshot):
9482 vikram.rag 2950 
    """
2951 
    Parameters:
9495 vikram.rag 2952 
     - allsnapdealinventorysnapshot
9482 vikram.rag 2953 
    """
9495 vikram.rag 2954 
    self.send_addOrUpdateAllSnapdealInventory(allsnapdealinventorysnapshot)
2955 
    self.recv_addOrUpdateAllSnapdealInventory()
9456 vikram.rag 2956 
 
9495 vikram.rag 2957 
  def send_addOrUpdateAllSnapdealInventory(self, allsnapdealinventorysnapshot):
2958 
    self._oprot.writeMessageBegin('addOrUpdateAllSnapdealInventory', TMessageType.CALL, self._seqid)
2959 
    args = addOrUpdateAllSnapdealInventory_args()
2960 
    args.allsnapdealinventorysnapshot = allsnapdealinventorysnapshot
9482 vikram.rag 2961 
    args.write(self._oprot)
2962 
    self._oprot.writeMessageEnd()
2963 
    self._oprot.trans.flush()
2964 
 
9495 vikram.rag 2965 
  def recv_addOrUpdateAllSnapdealInventory(self, ):
9482 vikram.rag 2966 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2967 
    if mtype == TMessageType.EXCEPTION:
2968 
      x = TApplicationException()
2969 
      x.read(self._iprot)
2970 
      self._iprot.readMessageEnd()
2971 
      raise x
9495 vikram.rag 2972 
    result = addOrUpdateAllSnapdealInventory_result()
9482 vikram.rag 2973 
    result.read(self._iprot)
2974 
    self._iprot.readMessageEnd()
2975 
    return
2976 
 
9495 vikram.rag 2977 
  def getSnapdealInventorySnapshot(self, ):
2978 
    self.send_getSnapdealInventorySnapshot()
2979 
    return self.recv_getSnapdealInventorySnapshot()
9482 vikram.rag 2980 
 
9495 vikram.rag 2981 
  def send_getSnapdealInventorySnapshot(self, ):
2982 
    self._oprot.writeMessageBegin('getSnapdealInventorySnapshot', TMessageType.CALL, self._seqid)
2983 
    args = getSnapdealInventorySnapshot_args()
2984 
    args.write(self._oprot)
2985 
    self._oprot.writeMessageEnd()
2986 
    self._oprot.trans.flush()
2987 
 
2988 
  def recv_getSnapdealInventorySnapshot(self, ):
2989 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2990 
    if mtype == TMessageType.EXCEPTION:
2991 
      x = TApplicationException()
2992 
      x.read(self._iprot)
2993 
      self._iprot.readMessageEnd()
2994 
      raise x
2995 
    result = getSnapdealInventorySnapshot_result()
2996 
    result.read(self._iprot)
2997 
    self._iprot.readMessageEnd()
2998 
    if result.success is not None:
2999 
      return result.success
3000 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealInventorySnapshot failed: unknown result");
3001 
 
9761 amar.kumar 3002 
  def getHoldInventoryDetails(self, itemId, warehouseId, source):
3003 
    """
3004 
    Parameters:
3005 
     - itemId
3006 
     - warehouseId
3007 
     - source
3008 
    """
3009 
    self.send_getHoldInventoryDetails(itemId, warehouseId, source)
3010 
    return self.recv_getHoldInventoryDetails()
9495 vikram.rag 3011 
 
9761 amar.kumar 3012 
  def send_getHoldInventoryDetails(self, itemId, warehouseId, source):
3013 
    self._oprot.writeMessageBegin('getHoldInventoryDetails', TMessageType.CALL, self._seqid)
3014 
    args = getHoldInventoryDetails_args()
3015 
    args.itemId = itemId
3016 
    args.warehouseId = warehouseId
3017 
    args.source = source
3018 
    args.write(self._oprot)
3019 
    self._oprot.writeMessageEnd()
3020 
    self._oprot.trans.flush()
3021 
 
3022 
  def recv_getHoldInventoryDetails(self, ):
3023 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3024 
    if mtype == TMessageType.EXCEPTION:
3025 
      x = TApplicationException()
3026 
      x.read(self._iprot)
3027 
      self._iprot.readMessageEnd()
3028 
      raise x
3029 
    result = getHoldInventoryDetails_result()
3030 
    result.read(self._iprot)
3031 
    self._iprot.readMessageEnd()
3032 
    if result.success is not None:
3033 
      return result.success
3034 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getHoldInventoryDetails failed: unknown result");
3035 
 
10450 vikram.rag 3036 
  def addOrUpdateFlipkartInventorySnapshot(self, flipkartInventorySnapshot, time):
10050 vikram.rag 3037 
    """
3038 
    Parameters:
3039 
     - flipkartInventorySnapshot
10450 vikram.rag 3040 
     - time
10050 vikram.rag 3041 
    """
10450 vikram.rag 3042 
    self.send_addOrUpdateFlipkartInventorySnapshot(flipkartInventorySnapshot, time)
10050 vikram.rag 3043 
    self.recv_addOrUpdateFlipkartInventorySnapshot()
9761 amar.kumar 3044 
 
10450 vikram.rag 3045 
  def send_addOrUpdateFlipkartInventorySnapshot(self, flipkartInventorySnapshot, time):
10050 vikram.rag 3046 
    self._oprot.writeMessageBegin('addOrUpdateFlipkartInventorySnapshot', TMessageType.CALL, self._seqid)
3047 
    args = addOrUpdateFlipkartInventorySnapshot_args()
3048 
    args.flipkartInventorySnapshot = flipkartInventorySnapshot
10450 vikram.rag 3049 
    args.time = time
10050 vikram.rag 3050 
    args.write(self._oprot)
3051 
    self._oprot.writeMessageEnd()
3052 
    self._oprot.trans.flush()
3053 
 
3054 
  def recv_addOrUpdateFlipkartInventorySnapshot(self, ):
3055 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3056 
    if mtype == TMessageType.EXCEPTION:
3057 
      x = TApplicationException()
3058 
      x.read(self._iprot)
3059 
      self._iprot.readMessageEnd()
3060 
      raise x
3061 
    result = addOrUpdateFlipkartInventorySnapshot_result()
3062 
    result.read(self._iprot)
3063 
    self._iprot.readMessageEnd()
3064 
    return
3065 
 
3066 
  def getFlipkartInventorySnapshot(self, ):
3067 
    self.send_getFlipkartInventorySnapshot()
3068 
    return self.recv_getFlipkartInventorySnapshot()
3069 
 
3070 
  def send_getFlipkartInventorySnapshot(self, ):
3071 
    self._oprot.writeMessageBegin('getFlipkartInventorySnapshot', TMessageType.CALL, self._seqid)
3072 
    args = getFlipkartInventorySnapshot_args()
3073 
    args.write(self._oprot)
3074 
    self._oprot.writeMessageEnd()
3075 
    self._oprot.trans.flush()
3076 
 
3077 
  def recv_getFlipkartInventorySnapshot(self, ):
3078 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3079 
    if mtype == TMessageType.EXCEPTION:
3080 
      x = TApplicationException()
3081 
      x.read(self._iprot)
3082 
      self._iprot.readMessageEnd()
3083 
      raise x
3084 
    result = getFlipkartInventorySnapshot_result()
3085 
    result.read(self._iprot)
3086 
    self._iprot.readMessageEnd()
3087 
    if result.success is not None:
3088 
      return result.success
3089 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartInventorySnapshot failed: unknown result");
3090 
 
10097 kshitij.so 3091 
  def getFlipkartlInventoryForItem(self, item_id):
3092 
    """
3093 
    Parameters:
3094 
     - item_id
3095 
    """
3096 
    self.send_getFlipkartlInventoryForItem(item_id)
3097 
    return self.recv_getFlipkartlInventoryForItem()
10050 vikram.rag 3098 
 
10097 kshitij.so 3099 
  def send_getFlipkartlInventoryForItem(self, item_id):
3100 
    self._oprot.writeMessageBegin('getFlipkartlInventoryForItem', TMessageType.CALL, self._seqid)
3101 
    args = getFlipkartlInventoryForItem_args()
3102 
    args.item_id = item_id
3103 
    args.write(self._oprot)
3104 
    self._oprot.writeMessageEnd()
3105 
    self._oprot.trans.flush()
3106 
 
3107 
  def recv_getFlipkartlInventoryForItem(self, ):
3108 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3109 
    if mtype == TMessageType.EXCEPTION:
3110 
      x = TApplicationException()
3111 
      x.read(self._iprot)
3112 
      self._iprot.readMessageEnd()
3113 
      raise x
3114 
    result = getFlipkartlInventoryForItem_result()
3115 
    result.read(self._iprot)
3116 
    self._iprot.readMessageEnd()
3117 
    if result.success is not None:
3118 
      return result.success
3119 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFlipkartlInventoryForItem failed: unknown result");
3120 
 
10485 vikram.rag 3121 
  def getStateMaster(self, ):
3122 
    self.send_getStateMaster()
3123 
    return self.recv_getStateMaster()
10097 kshitij.so 3124 
 
10485 vikram.rag 3125 
  def send_getStateMaster(self, ):
3126 
    self._oprot.writeMessageBegin('getStateMaster', TMessageType.CALL, self._seqid)
3127 
    args = getStateMaster_args()
3128 
    args.write(self._oprot)
3129 
    self._oprot.writeMessageEnd()
3130 
    self._oprot.trans.flush()
3131 
 
3132 
  def recv_getStateMaster(self, ):
3133 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3134 
    if mtype == TMessageType.EXCEPTION:
3135 
      x = TApplicationException()
3136 
      x.read(self._iprot)
3137 
      self._iprot.readMessageEnd()
3138 
      raise x
3139 
    result = getStateMaster_result()
3140 
    result.read(self._iprot)
3141 
    self._iprot.readMessageEnd()
3142 
    if result.success is not None:
3143 
      return result.success
3144 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStateMaster failed: unknown result");
3145 
 
10544 vikram.rag 3146 
  def updateSnapdealStockAtEOD(self, allsnapdealstock):
3147 
    """
3148 
    Parameters:
3149 
     - allsnapdealstock
3150 
    """
3151 
    self.send_updateSnapdealStockAtEOD(allsnapdealstock)
3152 
    self.recv_updateSnapdealStockAtEOD()
10485 vikram.rag 3153 
 
10544 vikram.rag 3154 
  def send_updateSnapdealStockAtEOD(self, allsnapdealstock):
3155 
    self._oprot.writeMessageBegin('updateSnapdealStockAtEOD', TMessageType.CALL, self._seqid)
3156 
    args = updateSnapdealStockAtEOD_args()
3157 
    args.allsnapdealstock = allsnapdealstock
3158 
    args.write(self._oprot)
3159 
    self._oprot.writeMessageEnd()
3160 
    self._oprot.trans.flush()
3161 
 
3162 
  def recv_updateSnapdealStockAtEOD(self, ):
3163 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3164 
    if mtype == TMessageType.EXCEPTION:
3165 
      x = TApplicationException()
3166 
      x.read(self._iprot)
3167 
      self._iprot.readMessageEnd()
3168 
      raise x
3169 
    result = updateSnapdealStockAtEOD_result()
3170 
    result.read(self._iprot)
3171 
    self._iprot.readMessageEnd()
3172 
    return
3173 
 
3174 
  def updateFlipkartStockAtEOD(self, allflipkartstock):
3175 
    """
3176 
    Parameters:
3177 
     - allflipkartstock
3178 
    """
3179 
    self.send_updateFlipkartStockAtEOD(allflipkartstock)
3180 
    self.recv_updateFlipkartStockAtEOD()
3181 
 
3182 
  def send_updateFlipkartStockAtEOD(self, allflipkartstock):
3183 
    self._oprot.writeMessageBegin('updateFlipkartStockAtEOD', TMessageType.CALL, self._seqid)
3184 
    args = updateFlipkartStockAtEOD_args()
3185 
    args.allflipkartstock = allflipkartstock
3186 
    args.write(self._oprot)
3187 
    self._oprot.writeMessageEnd()
3188 
    self._oprot.trans.flush()
3189 
 
3190 
  def recv_updateFlipkartStockAtEOD(self, ):
3191 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3192 
    if mtype == TMessageType.EXCEPTION:
3193 
      x = TApplicationException()
3194 
      x.read(self._iprot)
3195 
      self._iprot.readMessageEnd()
3196 
      raise x
3197 
    result = updateFlipkartStockAtEOD_result()
3198 
    result.read(self._iprot)
3199 
    self._iprot.readMessageEnd()
3200 
    return
3201 
 
12363 kshitij.so 3202 
  def getWanNlcForSource(self, item_id, source):
3203 
    """
3204 
    Parameters:
3205 
     - item_id
3206 
     - source
3207 
    """
3208 
    self.send_getWanNlcForSource(item_id, source)
3209 
    return self.recv_getWanNlcForSource()
10544 vikram.rag 3210 
 
12363 kshitij.so 3211 
  def send_getWanNlcForSource(self, item_id, source):
3212 
    self._oprot.writeMessageBegin('getWanNlcForSource', TMessageType.CALL, self._seqid)
3213 
    args = getWanNlcForSource_args()
3214 
    args.item_id = item_id
3215 
    args.source = source
3216 
    args.write(self._oprot)
3217 
    self._oprot.writeMessageEnd()
3218 
    self._oprot.trans.flush()
3219 
 
3220 
  def recv_getWanNlcForSource(self, ):
3221 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3222 
    if mtype == TMessageType.EXCEPTION:
3223 
      x = TApplicationException()
3224 
      x.read(self._iprot)
3225 
      self._iprot.readMessageEnd()
3226 
      raise x
3227 
    result = getWanNlcForSource_result()
3228 
    result.read(self._iprot)
3229 
    self._iprot.readMessageEnd()
3230 
    if result.success is not None:
3231 
      return result.success
3232 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getWanNlcForSource failed: unknown result");
3233 
 
3234 
  def getAllAvailableAmazonFbaItemInventory(self, ):
3235 
    self.send_getAllAvailableAmazonFbaItemInventory()
3236 
    return self.recv_getAllAvailableAmazonFbaItemInventory()
3237 
 
3238 
  def send_getAllAvailableAmazonFbaItemInventory(self, ):
3239 
    self._oprot.writeMessageBegin('getAllAvailableAmazonFbaItemInventory', TMessageType.CALL, self._seqid)
3240 
    args = getAllAvailableAmazonFbaItemInventory_args()
3241 
    args.write(self._oprot)
3242 
    self._oprot.writeMessageEnd()
3243 
    self._oprot.trans.flush()
3244 
 
3245 
  def recv_getAllAvailableAmazonFbaItemInventory(self, ):
3246 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3247 
    if mtype == TMessageType.EXCEPTION:
3248 
      x = TApplicationException()
3249 
      x.read(self._iprot)
3250 
      self._iprot.readMessageEnd()
3251 
      raise x
3252 
    result = getAllAvailableAmazonFbaItemInventory_result()
3253 
    result.read(self._iprot)
3254 
    self._iprot.readMessageEnd()
3255 
    if result.success is not None:
3256 
      return result.success
3257 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAvailableAmazonFbaItemInventory failed: unknown result");
3258 
 
17990 kshitij.so 3259 
  def updateItemAvailabilityForItemIds(self, itemIds):
3260 
    """
3261 
    Parameters:
3262 
     - itemIds
3263 
    """
3264 
    self.send_updateItemAvailabilityForItemIds(itemIds)
3265 
    return self.recv_updateItemAvailabilityForItemIds()
12363 kshitij.so 3266 
 
17990 kshitij.so 3267 
  def send_updateItemAvailabilityForItemIds(self, itemIds):
3268 
    self._oprot.writeMessageBegin('updateItemAvailabilityForItemIds', TMessageType.CALL, self._seqid)
3269 
    args = updateItemAvailabilityForItemIds_args()
3270 
    args.itemIds = itemIds
3271 
    args.write(self._oprot)
3272 
    self._oprot.writeMessageEnd()
3273 
    self._oprot.trans.flush()
3274 
 
3275 
  def recv_updateItemAvailabilityForItemIds(self, ):
3276 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3277 
    if mtype == TMessageType.EXCEPTION:
3278 
      x = TApplicationException()
3279 
      x.read(self._iprot)
3280 
      self._iprot.readMessageEnd()
3281 
      raise x
3282 
    result = updateItemAvailabilityForItemIds_result()
3283 
    result.read(self._iprot)
3284 
    self._iprot.readMessageEnd()
3285 
    if result.success is not None:
3286 
      return result.success
3287 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItemAvailabilityForItemIds failed: unknown result");
3288 
 
19247 kshitij.so 3289 
  def addVendorItemPricingInBulk(self, vendorItemPricingList):
3290 
    """
3291 
    Parameters:
3292 
     - vendorItemPricingList
3293 
    """
3294 
    self.send_addVendorItemPricingInBulk(vendorItemPricingList)
3295 
    return self.recv_addVendorItemPricingInBulk()
17990 kshitij.so 3296 
 
19247 kshitij.so 3297 
  def send_addVendorItemPricingInBulk(self, vendorItemPricingList):
3298 
    self._oprot.writeMessageBegin('addVendorItemPricingInBulk', TMessageType.CALL, self._seqid)
3299 
    args = addVendorItemPricingInBulk_args()
3300 
    args.vendorItemPricingList = vendorItemPricingList
3301 
    args.write(self._oprot)
3302 
    self._oprot.writeMessageEnd()
3303 
    self._oprot.trans.flush()
3304 
 
3305 
  def recv_addVendorItemPricingInBulk(self, ):
3306 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3307 
    if mtype == TMessageType.EXCEPTION:
3308 
      x = TApplicationException()
3309 
      x.read(self._iprot)
3310 
      self._iprot.readMessageEnd()
3311 
      raise x
3312 
    result = addVendorItemPricingInBulk_result()
3313 
    result.read(self._iprot)
3314 
    self._iprot.readMessageEnd()
3315 
    if result.success is not None:
3316 
      return result.success
3317 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addVendorItemPricingInBulk failed: unknown result");
3318 
 
3319 
  def addInventoryInBulk(self, bulkInventoryList):
3320 
    """
3321 
    Parameters:
3322 
     - bulkInventoryList
3323 
    """
3324 
    self.send_addInventoryInBulk(bulkInventoryList)
3325 
    self.recv_addInventoryInBulk()
3326 
 
3327 
  def send_addInventoryInBulk(self, bulkInventoryList):
3328 
    self._oprot.writeMessageBegin('addInventoryInBulk', TMessageType.CALL, self._seqid)
3329 
    args = addInventoryInBulk_args()
3330 
    args.bulkInventoryList = bulkInventoryList
3331 
    args.write(self._oprot)
3332 
    self._oprot.writeMessageEnd()
3333 
    self._oprot.trans.flush()
3334 
 
3335 
  def recv_addInventoryInBulk(self, ):
3336 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3337 
    if mtype == TMessageType.EXCEPTION:
3338 
      x = TApplicationException()
3339 
      x.read(self._iprot)
3340 
      self._iprot.readMessageEnd()
3341 
      raise x
3342 
    result = addInventoryInBulk_result()
3343 
    result.read(self._iprot)
3344 
    self._iprot.readMessageEnd()
3345 
    if result.cex is not None:
3346 
      raise result.cex
3347 
    return
3348 
 
19413 amit.gupta 3349 
  def getItemLocationAvailabilityCache(self, itemLocations):
3350 
    """
3351 
    Parameters:
3352 
     - itemLocations
3353 
    """
3354 
    self.send_getItemLocationAvailabilityCache(itemLocations)
3355 
    return self.recv_getItemLocationAvailabilityCache()
19247 kshitij.so 3356 
 
19413 amit.gupta 3357 
  def send_getItemLocationAvailabilityCache(self, itemLocations):
3358 
    self._oprot.writeMessageBegin('getItemLocationAvailabilityCache', TMessageType.CALL, self._seqid)
3359 
    args = getItemLocationAvailabilityCache_args()
3360 
    args.itemLocations = itemLocations
3361 
    args.write(self._oprot)
3362 
    self._oprot.writeMessageEnd()
3363 
    self._oprot.trans.flush()
3364 
 
3365 
  def recv_getItemLocationAvailabilityCache(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 = getItemLocationAvailabilityCache_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, "getItemLocationAvailabilityCache failed: unknown result");
3378 
 
3379 
  def getItemLocationAvailabilityCacheByItemId(self, itemIds):
3380 
    """
3381 
    Parameters:
3382 
     - itemIds
3383 
    """
3384 
    self.send_getItemLocationAvailabilityCacheByItemId(itemIds)
3385 
    return self.recv_getItemLocationAvailabilityCacheByItemId()
3386 
 
3387 
  def send_getItemLocationAvailabilityCacheByItemId(self, itemIds):
3388 
    self._oprot.writeMessageBegin('getItemLocationAvailabilityCacheByItemId', TMessageType.CALL, self._seqid)
3389 
    args = getItemLocationAvailabilityCacheByItemId_args()
3390 
    args.itemIds = itemIds
3391 
    args.write(self._oprot)
3392 
    self._oprot.writeMessageEnd()
3393 
    self._oprot.trans.flush()
3394 
 
3395 
  def recv_getItemLocationAvailabilityCacheByItemId(self, ):
3396 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3397 
    if mtype == TMessageType.EXCEPTION:
3398 
      x = TApplicationException()
3399 
      x.read(self._iprot)
3400 
      self._iprot.readMessageEnd()
3401 
      raise x
3402 
    result = getItemLocationAvailabilityCacheByItemId_result()
3403 
    result.read(self._iprot)
3404 
    self._iprot.readMessageEnd()
3405 
    if result.success is not None:
3406 
      return result.success
3407 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemLocationAvailabilityCacheByItemId failed: unknown result");
3408 
 
19416 amit.gupta 3409 
  def getItemPincodeAvailability(self, itempricing, pincode):
19413 amit.gupta 3410 
    """
3411 
    Parameters:
19416 amit.gupta 3412 
     - itempricing
19413 amit.gupta 3413 
     - pincode
3414 
    """
19416 amit.gupta 3415 
    self.send_getItemPincodeAvailability(itempricing, pincode)
19413 amit.gupta 3416 
    return self.recv_getItemPincodeAvailability()
3417 
 
19416 amit.gupta 3418 
  def send_getItemPincodeAvailability(self, itempricing, pincode):
19413 amit.gupta 3419 
    self._oprot.writeMessageBegin('getItemPincodeAvailability', TMessageType.CALL, self._seqid)
3420 
    args = getItemPincodeAvailability_args()
19416 amit.gupta 3421 
    args.itempricing = itempricing
19413 amit.gupta 3422 
    args.pincode = pincode
3423 
    args.write(self._oprot)
3424 
    self._oprot.writeMessageEnd()
3425 
    self._oprot.trans.flush()
3426 
 
3427 
  def recv_getItemPincodeAvailability(self, ):
3428 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3429 
    if mtype == TMessageType.EXCEPTION:
3430 
      x = TApplicationException()
3431 
      x.read(self._iprot)
3432 
      self._iprot.readMessageEnd()
3433 
      raise x
3434 
    result = getItemPincodeAvailability_result()
3435 
    result.read(self._iprot)
3436 
    self._iprot.readMessageEnd()
3437 
    if result.success is not None:
3438 
      return result.success
3439 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPincodeAvailability failed: unknown result");
3440 
 
3441 
 
5944 mandeep.dh 3442 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
3443 
  def __init__(self, handler):
3444 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
3445 
    self._processMap["addWarehouse"] = Processor.process_addWarehouse
3446 
    self._processMap["addVendor"] = Processor.process_addVendor
3447 
    self._processMap["updateInventoryHistory"] = Processor.process_updateInventoryHistory
3448 
    self._processMap["updateInventory"] = Processor.process_updateInventory
3449 
    self._processMap["addInventory"] = Processor.process_addInventory
3450 
    self._processMap["retireWarehouse"] = Processor.process_retireWarehouse
3451 
    self._processMap["getItemInventoryByItemId"] = Processor.process_getItemInventoryByItemId
3452 
    self._processMap["getItemAvailibilityAtWarehouse"] = Processor.process_getItemAvailibilityAtWarehouse
3453 
    self._processMap["getItemAvailabilityAtLocation"] = Processor.process_getItemAvailabilityAtLocation
3454 
    self._processMap["getAllWarehouses"] = Processor.process_getAllWarehouses
3455 
    self._processMap["getWarehouse"] = Processor.process_getWarehouse
3456 
    self._processMap["getAllItemsForWarehouse"] = Processor.process_getAllItemsForWarehouse
5966 rajveer 3457 
    self._processMap["isOrderBillable"] = Processor.process_isOrderBillable
5944 mandeep.dh 3458 
    self._processMap["reserveItemInWarehouse"] = Processor.process_reserveItemInWarehouse
7968 amar.kumar 3459 
    self._processMap["updateReservationForOrder"] = Processor.process_updateReservationForOrder
5944 mandeep.dh 3460 
    self._processMap["reduceReservationCount"] = Processor.process_reduceReservationCount
3461 
    self._processMap["getItemPricing"] = Processor.process_getItemPricing
3462 
    self._processMap["getAllItemPricing"] = Processor.process_getAllItemPricing
3463 
    self._processMap["addVendorItemPricing"] = Processor.process_addVendorItemPricing
3464 
    self._processMap["getVendor"] = Processor.process_getVendor
3465 
    self._processMap["getAllVendors"] = Processor.process_getAllVendors
3466 
    self._processMap["addVendorItemMapping"] = Processor.process_addVendorItemMapping
3467 
    self._processMap["getVendorItemMappings"] = Processor.process_getVendorItemMappings
3468 
    self._processMap["getPendingOrdersInventory"] = Processor.process_getPendingOrdersInventory
3469 
    self._processMap["getWarehouses"] = Processor.process_getWarehouses
3470 
    self._processMap["resetAvailability"] = Processor.process_resetAvailability
3471 
    self._processMap["resetAvailabilityForWarehouse"] = Processor.process_resetAvailabilityForWarehouse
3472 
    self._processMap["getItemKeysToBeProcessed"] = Processor.process_getItemKeysToBeProcessed
3473 
    self._processMap["markMissedInventoryUpdatesAsProcessed"] = Processor.process_markMissedInventoryUpdatesAsProcessed
3474 
    self._processMap["getIgnoredItemKeys"] = Processor.process_getIgnoredItemKeys
3475 
    self._processMap["addBadInventory"] = Processor.process_addBadInventory
3476 
    self._processMap["getShippingLocations"] = Processor.process_getShippingLocations
3477 
    self._processMap["getAllVendorItemMappings"] = Processor.process_getAllVendorItemMappings
3478 
    self._processMap["getInventorySnapshot"] = Processor.process_getInventorySnapshot
3479 
    self._processMap["clearItemAvailabilityCache"] = Processor.process_clearItemAvailabilityCache
3480 
    self._processMap["updateVendorString"] = Processor.process_updateVendorString
6096 amit.gupta 3481 
    self._processMap["clearItemAvailabilityCacheForItem"] = Processor.process_clearItemAvailabilityCacheForItem
6467 amar.kumar 3482 
    self._processMap["getOurWarehouseIdForVendor"] = Processor.process_getOurWarehouseIdForVendor
6484 amar.kumar 3483 
    self._processMap["getItemAvailabilitiesAtOurWarehouses"] = Processor.process_getItemAvailabilitiesAtOurWarehouses
6531 vikram.rag 3484 
    self._processMap["getMonitoredWarehouseForVendors"] = Processor.process_getMonitoredWarehouseForVendors
3485 
    self._processMap["getIgnoredWarehouseidsAndItemids"] = Processor.process_getIgnoredWarehouseidsAndItemids
3486 
    self._processMap["insertItemtoIgnoreInventoryUpdatelist"] = Processor.process_insertItemtoIgnoreInventoryUpdatelist
3487 
    self._processMap["deleteItemFromIgnoredInventoryUpdateList"] = Processor.process_deleteItemFromIgnoredInventoryUpdateList
3488 
    self._processMap["getAllIgnoredInventoryupdateItemsCount"] = Processor.process_getAllIgnoredInventoryupdateItemsCount
3489 
    self._processMap["getIgnoredInventoryUpdateItemids"] = Processor.process_getIgnoredInventoryUpdateItemids
6821 amar.kumar 3490 
    self._processMap["updateItemStockPurchaseParams"] = Processor.process_updateItemStockPurchaseParams
3491 
    self._processMap["getItemStockPurchaseParams"] = Processor.process_getItemStockPurchaseParams
3492 
    self._processMap["addOosStatusForItem"] = Processor.process_addOosStatusForItem
6832 amar.kumar 3493 
    self._processMap["getOosStatusesForXDaysForItem"] = Processor.process_getOosStatusesForXDaysForItem
10126 amar.kumar 3494 
    self._processMap["getOosStatusesForXDays"] = Processor.process_getOosStatusesForXDays
3495 
    self._processMap["getAllVendorItemPricing"] = Processor.process_getAllVendorItemPricing
6857 amar.kumar 3496 
    self._processMap["getNonZeroItemStockPurchaseParams"] = Processor.process_getNonZeroItemStockPurchaseParams
7149 amar.kumar 3497 
    self._processMap["getBillableInventoryAndPendingOrders"] = Processor.process_getBillableInventoryAndPendingOrders
7281 kshitij.so 3498 
    self._processMap["getWarehouseName"] = Processor.process_getWarehouseName
3499 
    self._processMap["getAmazonInventoryForItem"] = Processor.process_getAmazonInventoryForItem
3500 
    self._processMap["getAllAmazonInventory"] = Processor.process_getAllAmazonInventory
3501 
    self._processMap["addOrUpdateAmazonInventoryForItem"] = Processor.process_addOrUpdateAmazonInventoryForItem
7972 amar.kumar 3502 
    self._processMap["getLastNdaySaleForItem"] = Processor.process_getLastNdaySaleForItem
8282 kshitij.so 3503 
    self._processMap["addOrUpdateAmazonFbaInventory"] = Processor.process_addOrUpdateAmazonFbaInventory
8182 amar.kumar 3504 
    self._processMap["addUpdateHoldInventory"] = Processor.process_addUpdateHoldInventory
8282 kshitij.so 3505 
    self._processMap["getAmazonFbaItemInventory"] = Processor.process_getAmazonFbaItemInventory
8363 vikram.rag 3506 
    self._processMap["getAllAmazonFbaItemInventory"] = Processor.process_getAllAmazonFbaItemInventory
3507 
    self._processMap["getOursGoodWarehouseIdsForLocation"] = Processor.process_getOursGoodWarehouseIdsForLocation
8955 vikram.rag 3508 
    self._processMap["getHoldInventoryDetailForItemForWarehouseIdExceptSource"] = Processor.process_getHoldInventoryDetailForItemForWarehouseIdExceptSource
9404 vikram.rag 3509 
    self._processMap["getSnapdealInventoryForItem"] = Processor.process_getSnapdealInventoryForItem
3510 
    self._processMap["addOrUpdateSnapdealInventoryForItem"] = Processor.process_addOrUpdateSnapdealInventoryForItem
3511 
    self._processMap["getNlcForWarehouse"] = Processor.process_getNlcForWarehouse
9640 amar.kumar 3512 
    self._processMap["getHeldInventoryMapForItem"] = Processor.process_getHeldInventoryMapForItem
9482 vikram.rag 3513 
    self._processMap["addOrUpdateAllAmazonFbaInventory"] = Processor.process_addOrUpdateAllAmazonFbaInventory
9495 vikram.rag 3514 
    self._processMap["addOrUpdateAllSnapdealInventory"] = Processor.process_addOrUpdateAllSnapdealInventory
3515 
    self._processMap["getSnapdealInventorySnapshot"] = Processor.process_getSnapdealInventorySnapshot
9761 amar.kumar 3516 
    self._processMap["getHoldInventoryDetails"] = Processor.process_getHoldInventoryDetails
10050 vikram.rag 3517 
    self._processMap["addOrUpdateFlipkartInventorySnapshot"] = Processor.process_addOrUpdateFlipkartInventorySnapshot
3518 
    self._processMap["getFlipkartInventorySnapshot"] = Processor.process_getFlipkartInventorySnapshot
10097 kshitij.so 3519 
    self._processMap["getFlipkartlInventoryForItem"] = Processor.process_getFlipkartlInventoryForItem
10485 vikram.rag 3520 
    self._processMap["getStateMaster"] = Processor.process_getStateMaster
10544 vikram.rag 3521 
    self._processMap["updateSnapdealStockAtEOD"] = Processor.process_updateSnapdealStockAtEOD
3522 
    self._processMap["updateFlipkartStockAtEOD"] = Processor.process_updateFlipkartStockAtEOD
12363 kshitij.so 3523 
    self._processMap["getWanNlcForSource"] = Processor.process_getWanNlcForSource
3524 
    self._processMap["getAllAvailableAmazonFbaItemInventory"] = Processor.process_getAllAvailableAmazonFbaItemInventory
17990 kshitij.so 3525 
    self._processMap["updateItemAvailabilityForItemIds"] = Processor.process_updateItemAvailabilityForItemIds
19247 kshitij.so 3526 
    self._processMap["addVendorItemPricingInBulk"] = Processor.process_addVendorItemPricingInBulk
3527 
    self._processMap["addInventoryInBulk"] = Processor.process_addInventoryInBulk
19413 amit.gupta 3528 
    self._processMap["getItemLocationAvailabilityCache"] = Processor.process_getItemLocationAvailabilityCache
3529 
    self._processMap["getItemLocationAvailabilityCacheByItemId"] = Processor.process_getItemLocationAvailabilityCacheByItemId
3530 
    self._processMap["getItemPincodeAvailability"] = Processor.process_getItemPincodeAvailability
5944 mandeep.dh 3531 
 
3532 
  def process(self, iprot, oprot):
3533 
    (name, type, seqid) = iprot.readMessageBegin()
3534 
    if name not in self._processMap:
3535 
      iprot.skip(TType.STRUCT)
3536 
      iprot.readMessageEnd()
3537 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3538 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3539 
      x.write(oprot)
3540 
      oprot.writeMessageEnd()
3541 
      oprot.trans.flush()
3542 
      return
3543 
    else:
3544 
      self._processMap[name](self, seqid, iprot, oprot)
3545 
    return True
3546 
 
3547 
  def process_addWarehouse(self, seqid, iprot, oprot):
3548 
    args = addWarehouse_args()
3549 
    args.read(iprot)
3550 
    iprot.readMessageEnd()
3551 
    result = addWarehouse_result()
3552 
    try:
3553 
      result.success = self._handler.addWarehouse(args.warehouse)
3554 
    except InventoryServiceException, cex:
3555 
      result.cex = cex
3556 
    oprot.writeMessageBegin("addWarehouse", TMessageType.REPLY, seqid)
3557 
    result.write(oprot)
3558 
    oprot.writeMessageEnd()
3559 
    oprot.trans.flush()
3560 
 
3561 
  def process_addVendor(self, seqid, iprot, oprot):
3562 
    args = addVendor_args()
3563 
    args.read(iprot)
3564 
    iprot.readMessageEnd()
3565 
    result = addVendor_result()
3566 
    try:
3567 
      result.success = self._handler.addVendor(args.vendor)
3568 
    except InventoryServiceException, cex:
3569 
      result.cex = cex
3570 
    oprot.writeMessageBegin("addVendor", TMessageType.REPLY, seqid)
3571 
    result.write(oprot)
3572 
    oprot.writeMessageEnd()
3573 
    oprot.trans.flush()
3574 
 
3575 
  def process_updateInventoryHistory(self, seqid, iprot, oprot):
3576 
    args = updateInventoryHistory_args()
3577 
    args.read(iprot)
3578 
    iprot.readMessageEnd()
3579 
    result = updateInventoryHistory_result()
3580 
    try:
3581 
      self._handler.updateInventoryHistory(args.warehouse_id, args.timestamp, args.availability)
3582 
    except InventoryServiceException, cex:
3583 
      result.cex = cex
3584 
    oprot.writeMessageBegin("updateInventoryHistory", TMessageType.REPLY, seqid)
3585 
    result.write(oprot)
3586 
    oprot.writeMessageEnd()
3587 
    oprot.trans.flush()
3588 
 
3589 
  def process_updateInventory(self, seqid, iprot, oprot):
3590 
    args = updateInventory_args()
3591 
    args.read(iprot)
3592 
    iprot.readMessageEnd()
3593 
    result = updateInventory_result()
3594 
    try:
3595 
      self._handler.updateInventory(args.warehouse_id, args.timestamp, args.availability)
3596 
    except InventoryServiceException, cex:
3597 
      result.cex = cex
3598 
    oprot.writeMessageBegin("updateInventory", TMessageType.REPLY, seqid)
3599 
    result.write(oprot)
3600 
    oprot.writeMessageEnd()
3601 
    oprot.trans.flush()
3602 
 
3603 
  def process_addInventory(self, seqid, iprot, oprot):
3604 
    args = addInventory_args()
3605 
    args.read(iprot)
3606 
    iprot.readMessageEnd()
3607 
    result = addInventory_result()
3608 
    try:
3609 
      self._handler.addInventory(args.itemId, args.warehouseId, args.quantity)
3610 
    except InventoryServiceException, cex:
3611 
      result.cex = cex
3612 
    oprot.writeMessageBegin("addInventory", TMessageType.REPLY, seqid)
3613 
    result.write(oprot)
3614 
    oprot.writeMessageEnd()
3615 
    oprot.trans.flush()
3616 
 
3617 
  def process_retireWarehouse(self, seqid, iprot, oprot):
3618 
    args = retireWarehouse_args()
3619 
    args.read(iprot)
3620 
    iprot.readMessageEnd()
3621 
    result = retireWarehouse_result()
3622 
    try:
3623 
      self._handler.retireWarehouse(args.warehouse_id)
3624 
    except InventoryServiceException, cex:
3625 
      result.cex = cex
3626 
    oprot.writeMessageBegin("retireWarehouse", TMessageType.REPLY, seqid)
3627 
    result.write(oprot)
3628 
    oprot.writeMessageEnd()
3629 
    oprot.trans.flush()
3630 
 
3631 
  def process_getItemInventoryByItemId(self, seqid, iprot, oprot):
3632 
    args = getItemInventoryByItemId_args()
3633 
    args.read(iprot)
3634 
    iprot.readMessageEnd()
3635 
    result = getItemInventoryByItemId_result()
3636 
    try:
3637 
      result.success = self._handler.getItemInventoryByItemId(args.item_id)
3638 
    except InventoryServiceException, cex:
3639 
      result.cex = cex
3640 
    oprot.writeMessageBegin("getItemInventoryByItemId", TMessageType.REPLY, seqid)
3641 
    result.write(oprot)
3642 
    oprot.writeMessageEnd()
3643 
    oprot.trans.flush()
3644 
 
3645 
  def process_getItemAvailibilityAtWarehouse(self, seqid, iprot, oprot):
3646 
    args = getItemAvailibilityAtWarehouse_args()
3647 
    args.read(iprot)
3648 
    iprot.readMessageEnd()
3649 
    result = getItemAvailibilityAtWarehouse_result()
3650 
    try:
3651 
      result.success = self._handler.getItemAvailibilityAtWarehouse(args.warehouse_id, args.item_id)
3652 
    except InventoryServiceException, cex:
3653 
      result.cex = cex
3654 
    oprot.writeMessageBegin("getItemAvailibilityAtWarehouse", TMessageType.REPLY, seqid)
3655 
    result.write(oprot)
3656 
    oprot.writeMessageEnd()
3657 
    oprot.trans.flush()
3658 
 
3659 
  def process_getItemAvailabilityAtLocation(self, seqid, iprot, oprot):
3660 
    args = getItemAvailabilityAtLocation_args()
3661 
    args.read(iprot)
3662 
    iprot.readMessageEnd()
3663 
    result = getItemAvailabilityAtLocation_result()
3664 
    try:
5978 rajveer 3665 
      result.success = self._handler.getItemAvailabilityAtLocation(args.itemId, args.sourceId)
5944 mandeep.dh 3666 
    except InventoryServiceException, isex:
3667 
      result.isex = isex
3668 
    oprot.writeMessageBegin("getItemAvailabilityAtLocation", TMessageType.REPLY, seqid)
3669 
    result.write(oprot)
3670 
    oprot.writeMessageEnd()
3671 
    oprot.trans.flush()
3672 
 
3673 
  def process_getAllWarehouses(self, seqid, iprot, oprot):
3674 
    args = getAllWarehouses_args()
3675 
    args.read(iprot)
3676 
    iprot.readMessageEnd()
3677 
    result = getAllWarehouses_result()
3678 
    try:
3679 
      result.success = self._handler.getAllWarehouses(args.isActive)
3680 
    except InventoryServiceException, cex:
3681 
      result.cex = cex
3682 
    oprot.writeMessageBegin("getAllWarehouses", TMessageType.REPLY, seqid)
3683 
    result.write(oprot)
3684 
    oprot.writeMessageEnd()
3685 
    oprot.trans.flush()
3686 
 
3687 
  def process_getWarehouse(self, seqid, iprot, oprot):
3688 
    args = getWarehouse_args()
3689 
    args.read(iprot)
3690 
    iprot.readMessageEnd()
3691 
    result = getWarehouse_result()
3692 
    try:
3693 
      result.success = self._handler.getWarehouse(args.warehouse_id)
3694 
    except InventoryServiceException, cex:
3695 
      result.cex = cex
3696 
    oprot.writeMessageBegin("getWarehouse", TMessageType.REPLY, seqid)
3697 
    result.write(oprot)
3698 
    oprot.writeMessageEnd()
3699 
    oprot.trans.flush()
3700 
 
3701 
  def process_getAllItemsForWarehouse(self, seqid, iprot, oprot):
3702 
    args = getAllItemsForWarehouse_args()
3703 
    args.read(iprot)
3704 
    iprot.readMessageEnd()
3705 
    result = getAllItemsForWarehouse_result()
3706 
    try:
3707 
      result.success = self._handler.getAllItemsForWarehouse(args.warehouse_id)
3708 
    except InventoryServiceException, cex:
3709 
      result.cex = cex
3710 
    oprot.writeMessageBegin("getAllItemsForWarehouse", TMessageType.REPLY, seqid)
3711 
    result.write(oprot)
3712 
    oprot.writeMessageEnd()
3713 
    oprot.trans.flush()
3714 
 
5966 rajveer 3715 
  def process_isOrderBillable(self, seqid, iprot, oprot):
3716 
    args = isOrderBillable_args()
3717 
    args.read(iprot)
3718 
    iprot.readMessageEnd()
3719 
    result = isOrderBillable_result()
3720 
    result.success = self._handler.isOrderBillable(args.itemId, args.warehouseId, args.sourceId, args.orderId)
3721 
    oprot.writeMessageBegin("isOrderBillable", TMessageType.REPLY, seqid)
3722 
    result.write(oprot)
3723 
    oprot.writeMessageEnd()
3724 
    oprot.trans.flush()
3725 
 
5944 mandeep.dh 3726 
  def process_reserveItemInWarehouse(self, seqid, iprot, oprot):
3727 
    args = reserveItemInWarehouse_args()
3728 
    args.read(iprot)
3729 
    iprot.readMessageEnd()
3730 
    result = reserveItemInWarehouse_result()
3731 
    try:
5966 rajveer 3732 
      result.success = self._handler.reserveItemInWarehouse(args.itemId, args.warehouseId, args.sourceId, args.orderId, args.createdTimestamp, args.promisedShippingTimestamp, args.quantity)
5944 mandeep.dh 3733 
    except InventoryServiceException, cex:
3734 
      result.cex = cex
3735 
    oprot.writeMessageBegin("reserveItemInWarehouse", TMessageType.REPLY, seqid)
3736 
    result.write(oprot)
3737 
    oprot.writeMessageEnd()
3738 
    oprot.trans.flush()
3739 
 
7968 amar.kumar 3740 
  def process_updateReservationForOrder(self, seqid, iprot, oprot):
3741 
    args = updateReservationForOrder_args()
3742 
    args.read(iprot)
3743 
    iprot.readMessageEnd()
3744 
    result = updateReservationForOrder_result()
3745 
    try:
3746 
      result.success = self._handler.updateReservationForOrder(args.itemId, args.warehouseId, args.sourceId, args.orderId, args.createdTimestamp, args.promisedShippingTimestamp, args.quantity)
3747 
    except InventoryServiceException, cex:
3748 
      result.cex = cex
3749 
    oprot.writeMessageBegin("updateReservationForOrder", TMessageType.REPLY, seqid)
3750 
    result.write(oprot)
3751 
    oprot.writeMessageEnd()
3752 
    oprot.trans.flush()
3753 
 
5944 mandeep.dh 3754 
  def process_reduceReservationCount(self, seqid, iprot, oprot):
3755 
    args = reduceReservationCount_args()
3756 
    args.read(iprot)
3757 
    iprot.readMessageEnd()
3758 
    result = reduceReservationCount_result()
3759 
    try:
5966 rajveer 3760 
      result.success = self._handler.reduceReservationCount(args.itemId, args.warehouseId, args.sourceId, args.orderId, args.quantity)
5944 mandeep.dh 3761 
    except InventoryServiceException, cex:
3762 
      result.cex = cex
3763 
    oprot.writeMessageBegin("reduceReservationCount", TMessageType.REPLY, seqid)
3764 
    result.write(oprot)
3765 
    oprot.writeMessageEnd()
3766 
    oprot.trans.flush()
3767 
 
3768 
  def process_getItemPricing(self, seqid, iprot, oprot):
3769 
    args = getItemPricing_args()
3770 
    args.read(iprot)
3771 
    iprot.readMessageEnd()
3772 
    result = getItemPricing_result()
3773 
    try:
3774 
      result.success = self._handler.getItemPricing(args.itemId, args.vendorId)
3775 
    except InventoryServiceException, cex:
3776 
      result.cex = cex
3777 
    oprot.writeMessageBegin("getItemPricing", TMessageType.REPLY, seqid)
3778 
    result.write(oprot)
3779 
    oprot.writeMessageEnd()
3780 
    oprot.trans.flush()
3781 
 
3782 
  def process_getAllItemPricing(self, seqid, iprot, oprot):
3783 
    args = getAllItemPricing_args()
3784 
    args.read(iprot)
3785 
    iprot.readMessageEnd()
3786 
    result = getAllItemPricing_result()
3787 
    try:
3788 
      result.success = self._handler.getAllItemPricing(args.itemId)
3789 
    except InventoryServiceException, cex:
3790 
      result.cex = cex
3791 
    oprot.writeMessageBegin("getAllItemPricing", TMessageType.REPLY, seqid)
3792 
    result.write(oprot)
3793 
    oprot.writeMessageEnd()
3794 
    oprot.trans.flush()
3795 
 
3796 
  def process_addVendorItemPricing(self, seqid, iprot, oprot):
3797 
    args = addVendorItemPricing_args()
3798 
    args.read(iprot)
3799 
    iprot.readMessageEnd()
3800 
    result = addVendorItemPricing_result()
3801 
    try:
3802 
      self._handler.addVendorItemPricing(args.vendorItemPricing)
3803 
    except InventoryServiceException, cex:
3804 
      result.cex = cex
3805 
    oprot.writeMessageBegin("addVendorItemPricing", TMessageType.REPLY, seqid)
3806 
    result.write(oprot)
3807 
    oprot.writeMessageEnd()
3808 
    oprot.trans.flush()
3809 
 
3810 
  def process_getVendor(self, seqid, iprot, oprot):
3811 
    args = getVendor_args()
3812 
    args.read(iprot)
3813 
    iprot.readMessageEnd()
3814 
    result = getVendor_result()
3815 
    result.success = self._handler.getVendor(args.vendorId)
3816 
    oprot.writeMessageBegin("getVendor", TMessageType.REPLY, seqid)
3817 
    result.write(oprot)
3818 
    oprot.writeMessageEnd()
3819 
    oprot.trans.flush()
3820 
 
3821 
  def process_getAllVendors(self, seqid, iprot, oprot):
3822 
    args = getAllVendors_args()
3823 
    args.read(iprot)
3824 
    iprot.readMessageEnd()
3825 
    result = getAllVendors_result()
3826 
    result.success = self._handler.getAllVendors()
3827 
    oprot.writeMessageBegin("getAllVendors", TMessageType.REPLY, seqid)
3828 
    result.write(oprot)
3829 
    oprot.writeMessageEnd()
3830 
    oprot.trans.flush()
3831 
 
3832 
  def process_addVendorItemMapping(self, seqid, iprot, oprot):
3833 
    args = addVendorItemMapping_args()
3834 
    args.read(iprot)
3835 
    iprot.readMessageEnd()
3836 
    result = addVendorItemMapping_result()
3837 
    try:
3838 
      self._handler.addVendorItemMapping(args.key, args.vendorItemMapping)
3839 
    except InventoryServiceException, cex:
3840 
      result.cex = cex
3841 
    oprot.writeMessageBegin("addVendorItemMapping", TMessageType.REPLY, seqid)
3842 
    result.write(oprot)
3843 
    oprot.writeMessageEnd()
3844 
    oprot.trans.flush()
3845 
 
3846 
  def process_getVendorItemMappings(self, seqid, iprot, oprot):
3847 
    args = getVendorItemMappings_args()
3848 
    args.read(iprot)
3849 
    iprot.readMessageEnd()
3850 
    result = getVendorItemMappings_result()
3851 
    try:
3852 
      result.success = self._handler.getVendorItemMappings(args.itemId)
3853 
    except InventoryServiceException, cex:
3854 
      result.cex = cex
3855 
    oprot.writeMessageBegin("getVendorItemMappings", TMessageType.REPLY, seqid)
3856 
    result.write(oprot)
3857 
    oprot.writeMessageEnd()
3858 
    oprot.trans.flush()
3859 
 
3860 
  def process_getPendingOrdersInventory(self, seqid, iprot, oprot):
3861 
    args = getPendingOrdersInventory_args()
3862 
    args.read(iprot)
3863 
    iprot.readMessageEnd()
3864 
    result = getPendingOrdersInventory_result()
3865 
    result.success = self._handler.getPendingOrdersInventory(args.vendorid)
3866 
    oprot.writeMessageBegin("getPendingOrdersInventory", TMessageType.REPLY, seqid)
3867 
    result.write(oprot)
3868 
    oprot.writeMessageEnd()
3869 
    oprot.trans.flush()
3870 
 
3871 
  def process_getWarehouses(self, seqid, iprot, oprot):
3872 
    args = getWarehouses_args()
3873 
    args.read(iprot)
3874 
    iprot.readMessageEnd()
3875 
    result = getWarehouses_result()
3876 
    result.success = self._handler.getWarehouses(args.warehouseType, args.inventoryType, args.vendorId, args.billingWarehouseId, args.shippingWarehouseId)
3877 
    oprot.writeMessageBegin("getWarehouses", TMessageType.REPLY, seqid)
3878 
    result.write(oprot)
3879 
    oprot.writeMessageEnd()
3880 
    oprot.trans.flush()
3881 
 
3882 
  def process_resetAvailability(self, seqid, iprot, oprot):
3883 
    args = resetAvailability_args()
3884 
    args.read(iprot)
3885 
    iprot.readMessageEnd()
3886 
    result = resetAvailability_result()
3887 
    try:
3888 
      self._handler.resetAvailability(args.itemKey, args.vendorId, args.quantity, args.warehouseId)
3889 
    except InventoryServiceException, cex:
3890 
      result.cex = cex
3891 
    oprot.writeMessageBegin("resetAvailability", TMessageType.REPLY, seqid)
3892 
    result.write(oprot)
3893 
    oprot.writeMessageEnd()
3894 
    oprot.trans.flush()
3895 
 
3896 
  def process_resetAvailabilityForWarehouse(self, seqid, iprot, oprot):
3897 
    args = resetAvailabilityForWarehouse_args()
3898 
    args.read(iprot)
3899 
    iprot.readMessageEnd()
3900 
    result = resetAvailabilityForWarehouse_result()
3901 
    try:
3902 
      self._handler.resetAvailabilityForWarehouse(args.warehouseId)
3903 
    except InventoryServiceException, cex:
3904 
      result.cex = cex
3905 
    oprot.writeMessageBegin("resetAvailabilityForWarehouse", TMessageType.REPLY, seqid)
3906 
    result.write(oprot)
3907 
    oprot.writeMessageEnd()
3908 
    oprot.trans.flush()
3909 
 
3910 
  def process_getItemKeysToBeProcessed(self, seqid, iprot, oprot):
3911 
    args = getItemKeysToBeProcessed_args()
3912 
    args.read(iprot)
3913 
    iprot.readMessageEnd()
3914 
    result = getItemKeysToBeProcessed_result()
3915 
    result.success = self._handler.getItemKeysToBeProcessed(args.warehouseId)
3916 
    oprot.writeMessageBegin("getItemKeysToBeProcessed", TMessageType.REPLY, seqid)
3917 
    result.write(oprot)
3918 
    oprot.writeMessageEnd()
3919 
    oprot.trans.flush()
3920 
 
3921 
  def process_markMissedInventoryUpdatesAsProcessed(self, seqid, iprot, oprot):
3922 
    args = markMissedInventoryUpdatesAsProcessed_args()
3923 
    args.read(iprot)
3924 
    iprot.readMessageEnd()
3925 
    result = markMissedInventoryUpdatesAsProcessed_result()
3926 
    self._handler.markMissedInventoryUpdatesAsProcessed(args.itemKey, args.warehouseId)
3927 
    oprot.writeMessageBegin("markMissedInventoryUpdatesAsProcessed", TMessageType.REPLY, seqid)
3928 
    result.write(oprot)
3929 
    oprot.writeMessageEnd()
3930 
    oprot.trans.flush()
3931 
 
3932 
  def process_getIgnoredItemKeys(self, seqid, iprot, oprot):
3933 
    args = getIgnoredItemKeys_args()
3934 
    args.read(iprot)
3935 
    iprot.readMessageEnd()
3936 
    result = getIgnoredItemKeys_result()
3937 
    result.success = self._handler.getIgnoredItemKeys()
3938 
    oprot.writeMessageBegin("getIgnoredItemKeys", TMessageType.REPLY, seqid)
3939 
    result.write(oprot)
3940 
    oprot.writeMessageEnd()
3941 
    oprot.trans.flush()
3942 
 
3943 
  def process_addBadInventory(self, seqid, iprot, oprot):
3944 
    args = addBadInventory_args()
3945 
    args.read(iprot)
3946 
    iprot.readMessageEnd()
3947 
    result = addBadInventory_result()
3948 
    try:
3949 
      self._handler.addBadInventory(args.itemId, args.warehouseId, args.quantity)
3950 
    except InventoryServiceException, cex:
3951 
      result.cex = cex
3952 
    oprot.writeMessageBegin("addBadInventory", TMessageType.REPLY, seqid)
3953 
    result.write(oprot)
3954 
    oprot.writeMessageEnd()
3955 
    oprot.trans.flush()
3956 
 
3957 
  def process_getShippingLocations(self, seqid, iprot, oprot):
3958 
    args = getShippingLocations_args()
3959 
    args.read(iprot)
3960 
    iprot.readMessageEnd()
3961 
    result = getShippingLocations_result()
3962 
    result.success = self._handler.getShippingLocations()
3963 
    oprot.writeMessageBegin("getShippingLocations", TMessageType.REPLY, seqid)
3964 
    result.write(oprot)
3965 
    oprot.writeMessageEnd()
3966 
    oprot.trans.flush()
3967 
 
3968 
  def process_getAllVendorItemMappings(self, seqid, iprot, oprot):
3969 
    args = getAllVendorItemMappings_args()
3970 
    args.read(iprot)
3971 
    iprot.readMessageEnd()
3972 
    result = getAllVendorItemMappings_result()
3973 
    result.success = self._handler.getAllVendorItemMappings()
3974 
    oprot.writeMessageBegin("getAllVendorItemMappings", TMessageType.REPLY, seqid)
3975 
    result.write(oprot)
3976 
    oprot.writeMessageEnd()
3977 
    oprot.trans.flush()
3978 
 
3979 
  def process_getInventorySnapshot(self, seqid, iprot, oprot):
3980 
    args = getInventorySnapshot_args()
3981 
    args.read(iprot)
3982 
    iprot.readMessageEnd()
3983 
    result = getInventorySnapshot_result()
3984 
    result.success = self._handler.getInventorySnapshot(args.warehouseId)
3985 
    oprot.writeMessageBegin("getInventorySnapshot", TMessageType.REPLY, seqid)
3986 
    result.write(oprot)
3987 
    oprot.writeMessageEnd()
3988 
    oprot.trans.flush()
3989 
 
3990 
  def process_clearItemAvailabilityCache(self, seqid, iprot, oprot):
3991 
    args = clearItemAvailabilityCache_args()
3992 
    args.read(iprot)
3993 
    iprot.readMessageEnd()
3994 
    result = clearItemAvailabilityCache_result()
3995 
    self._handler.clearItemAvailabilityCache()
3996 
    oprot.writeMessageBegin("clearItemAvailabilityCache", TMessageType.REPLY, seqid)
3997 
    result.write(oprot)
3998 
    oprot.writeMessageEnd()
3999 
    oprot.trans.flush()
4000 
 
4001 
  def process_updateVendorString(self, seqid, iprot, oprot):
4002 
    args = updateVendorString_args()
4003 
    args.read(iprot)
4004 
    iprot.readMessageEnd()
4005 
    result = updateVendorString_result()
4006 
    self._handler.updateVendorString(args.warehouseId, args.vendorString)
4007 
    oprot.writeMessageBegin("updateVendorString", TMessageType.REPLY, seqid)
4008 
    result.write(oprot)
4009 
    oprot.writeMessageEnd()
4010 
    oprot.trans.flush()
4011 
 
6096 amit.gupta 4012 
  def process_clearItemAvailabilityCacheForItem(self, seqid, iprot, oprot):
4013 
    args = clearItemAvailabilityCacheForItem_args()
4014 
    args.read(iprot)
4015 
    iprot.readMessageEnd()
4016 
    result = clearItemAvailabilityCacheForItem_result()
4017 
    self._handler.clearItemAvailabilityCacheForItem(args.item_id)
4018 
    oprot.writeMessageBegin("clearItemAvailabilityCacheForItem", TMessageType.REPLY, seqid)
4019 
    result.write(oprot)
4020 
    oprot.writeMessageEnd()
4021 
    oprot.trans.flush()
5944 mandeep.dh 4022 
 
6467 amar.kumar 4023 
  def process_getOurWarehouseIdForVendor(self, seqid, iprot, oprot):
4024 
    args = getOurWarehouseIdForVendor_args()
4025 
    args.read(iprot)
4026 
    iprot.readMessageEnd()
4027 
    result = getOurWarehouseIdForVendor_result()
7718 amar.kumar 4028 
    result.success = self._handler.getOurWarehouseIdForVendor(args.vendorId, args.billingWarehouseId)
6467 amar.kumar 4029 
    oprot.writeMessageBegin("getOurWarehouseIdForVendor", TMessageType.REPLY, seqid)
4030 
    result.write(oprot)
4031 
    oprot.writeMessageEnd()
4032 
    oprot.trans.flush()
6096 amit.gupta 4033 
 
6484 amar.kumar 4034 
  def process_getItemAvailabilitiesAtOurWarehouses(self, seqid, iprot, oprot):
4035 
    args = getItemAvailabilitiesAtOurWarehouses_args()
4036 
    args.read(iprot)
4037 
    iprot.readMessageEnd()
4038 
    result = getItemAvailabilitiesAtOurWarehouses_result()
4039 
    result.success = self._handler.getItemAvailabilitiesAtOurWarehouses(args.item_ids)
4040 
    oprot.writeMessageBegin("getItemAvailabilitiesAtOurWarehouses", TMessageType.REPLY, seqid)
4041 
    result.write(oprot)
4042 
    oprot.writeMessageEnd()
4043 
    oprot.trans.flush()
6467 amar.kumar 4044 
 
6531 vikram.rag 4045 
  def process_getMonitoredWarehouseForVendors(self, seqid, iprot, oprot):
4046 
    args = getMonitoredWarehouseForVendors_args()
4047 
    args.read(iprot)
4048 
    iprot.readMessageEnd()
4049 
    result = getMonitoredWarehouseForVendors_result()
4050 
    result.success = self._handler.getMonitoredWarehouseForVendors(args.vendorIds)
4051 
    oprot.writeMessageBegin("getMonitoredWarehouseForVendors", TMessageType.REPLY, seqid)
4052 
    result.write(oprot)
4053 
    oprot.writeMessageEnd()
4054 
    oprot.trans.flush()
6484 amar.kumar 4055 
 
6531 vikram.rag 4056 
  def process_getIgnoredWarehouseidsAndItemids(self, seqid, iprot, oprot):
4057 
    args = getIgnoredWarehouseidsAndItemids_args()
4058 
    args.read(iprot)
4059 
    iprot.readMessageEnd()
4060 
    result = getIgnoredWarehouseidsAndItemids_result()
4061 
    result.success = self._handler.getIgnoredWarehouseidsAndItemids()
4062 
    oprot.writeMessageBegin("getIgnoredWarehouseidsAndItemids", TMessageType.REPLY, seqid)
4063 
    result.write(oprot)
4064 
    oprot.writeMessageEnd()
4065 
    oprot.trans.flush()
4066 
 
4067 
  def process_insertItemtoIgnoreInventoryUpdatelist(self, seqid, iprot, oprot):
4068 
    args = insertItemtoIgnoreInventoryUpdatelist_args()
4069 
    args.read(iprot)
4070 
    iprot.readMessageEnd()
4071 
    result = insertItemtoIgnoreInventoryUpdatelist_result()
4072 
    result.success = self._handler.insertItemtoIgnoreInventoryUpdatelist(args.item_id, args.warehouse_id)
4073 
    oprot.writeMessageBegin("insertItemtoIgnoreInventoryUpdatelist", TMessageType.REPLY, seqid)
4074 
    result.write(oprot)
4075 
    oprot.writeMessageEnd()
4076 
    oprot.trans.flush()
4077 
 
4078 
  def process_deleteItemFromIgnoredInventoryUpdateList(self, seqid, iprot, oprot):
4079 
    args = deleteItemFromIgnoredInventoryUpdateList_args()
4080 
    args.read(iprot)
4081 
    iprot.readMessageEnd()
4082 
    result = deleteItemFromIgnoredInventoryUpdateList_result()
4083 
    result.success = self._handler.deleteItemFromIgnoredInventoryUpdateList(args.item_id, args.warehouse_id)
4084 
    oprot.writeMessageBegin("deleteItemFromIgnoredInventoryUpdateList", TMessageType.REPLY, seqid)
4085 
    result.write(oprot)
4086 
    oprot.writeMessageEnd()
4087 
    oprot.trans.flush()
4088 
 
4089 
  def process_getAllIgnoredInventoryupdateItemsCount(self, seqid, iprot, oprot):
4090 
    args = getAllIgnoredInventoryupdateItemsCount_args()
4091 
    args.read(iprot)
4092 
    iprot.readMessageEnd()
4093 
    result = getAllIgnoredInventoryupdateItemsCount_result()
4094 
    result.success = self._handler.getAllIgnoredInventoryupdateItemsCount()
4095 
    oprot.writeMessageBegin("getAllIgnoredInventoryupdateItemsCount", TMessageType.REPLY, seqid)
4096 
    result.write(oprot)
4097 
    oprot.writeMessageEnd()
4098 
    oprot.trans.flush()
4099 
 
4100 
  def process_getIgnoredInventoryUpdateItemids(self, seqid, iprot, oprot):
4101 
    args = getIgnoredInventoryUpdateItemids_args()
4102 
    args.read(iprot)
4103 
    iprot.readMessageEnd()
4104 
    result = getIgnoredInventoryUpdateItemids_result()
4105 
    result.success = self._handler.getIgnoredInventoryUpdateItemids(args.offset, args.limit)
4106 
    oprot.writeMessageBegin("getIgnoredInventoryUpdateItemids", TMessageType.REPLY, seqid)
4107 
    result.write(oprot)
4108 
    oprot.writeMessageEnd()
4109 
    oprot.trans.flush()
4110 
 
6821 amar.kumar 4111 
  def process_updateItemStockPurchaseParams(self, seqid, iprot, oprot):
4112 
    args = updateItemStockPurchaseParams_args()
4113 
    args.read(iprot)
4114 
    iprot.readMessageEnd()
4115 
    result = updateItemStockPurchaseParams_result()
4116 
    self._handler.updateItemStockPurchaseParams(args.item_id, args.numOfDaysStock, args.minStockLevel)
4117 
    oprot.writeMessageBegin("updateItemStockPurchaseParams", TMessageType.REPLY, seqid)
4118 
    result.write(oprot)
4119 
    oprot.writeMessageEnd()
4120 
    oprot.trans.flush()
6531 vikram.rag 4121 
 
6821 amar.kumar 4122 
  def process_getItemStockPurchaseParams(self, seqid, iprot, oprot):
4123 
    args = getItemStockPurchaseParams_args()
4124 
    args.read(iprot)
4125 
    iprot.readMessageEnd()
4126 
    result = getItemStockPurchaseParams_result()
4127 
    result.success = self._handler.getItemStockPurchaseParams(args.itemId)
4128 
    oprot.writeMessageBegin("getItemStockPurchaseParams", TMessageType.REPLY, seqid)
4129 
    result.write(oprot)
4130 
    oprot.writeMessageEnd()
4131 
    oprot.trans.flush()
4132 
 
4133 
  def process_addOosStatusForItem(self, seqid, iprot, oprot):
4134 
    args = addOosStatusForItem_args()
4135 
    args.read(iprot)
4136 
    iprot.readMessageEnd()
4137 
    result = addOosStatusForItem_result()
4138 
    self._handler.addOosStatusForItem(args.oosStatusMap, args.date)
4139 
    oprot.writeMessageBegin("addOosStatusForItem", TMessageType.REPLY, seqid)
4140 
    result.write(oprot)
4141 
    oprot.writeMessageEnd()
4142 
    oprot.trans.flush()
4143 
 
6832 amar.kumar 4144 
  def process_getOosStatusesForXDaysForItem(self, seqid, iprot, oprot):
4145 
    args = getOosStatusesForXDaysForItem_args()
4146 
    args.read(iprot)
4147 
    iprot.readMessageEnd()
4148 
    result = getOosStatusesForXDaysForItem_result()
9762 amar.kumar 4149 
    result.success = self._handler.getOosStatusesForXDaysForItem(args.itemId, args.sourceId, args.days)
6832 amar.kumar 4150 
    oprot.writeMessageBegin("getOosStatusesForXDaysForItem", TMessageType.REPLY, seqid)
4151 
    result.write(oprot)
4152 
    oprot.writeMessageEnd()
4153 
    oprot.trans.flush()
6821 amar.kumar 4154 
 
10126 amar.kumar 4155 
  def process_getOosStatusesForXDays(self, seqid, iprot, oprot):
4156 
    args = getOosStatusesForXDays_args()
4157 
    args.read(iprot)
4158 
    iprot.readMessageEnd()
4159 
    result = getOosStatusesForXDays_result()
4160 
    result.success = self._handler.getOosStatusesForXDays(args.sourceId, args.days)
4161 
    oprot.writeMessageBegin("getOosStatusesForXDays", TMessageType.REPLY, seqid)
4162 
    result.write(oprot)
4163 
    oprot.writeMessageEnd()
4164 
    oprot.trans.flush()
4165 
 
4166 
  def process_getAllVendorItemPricing(self, seqid, iprot, oprot):
4167 
    args = getAllVendorItemPricing_args()
4168 
    args.read(iprot)
4169 
    iprot.readMessageEnd()
4170 
    result = getAllVendorItemPricing_result()
4171 
    result.success = self._handler.getAllVendorItemPricing(args.itemId, args.vendorId)
4172 
    oprot.writeMessageBegin("getAllVendorItemPricing", TMessageType.REPLY, seqid)
4173 
    result.write(oprot)
4174 
    oprot.writeMessageEnd()
4175 
    oprot.trans.flush()
4176 
 
6857 amar.kumar 4177 
  def process_getNonZeroItemStockPurchaseParams(self, seqid, iprot, oprot):
4178 
    args = getNonZeroItemStockPurchaseParams_args()
4179 
    args.read(iprot)
4180 
    iprot.readMessageEnd()
4181 
    result = getNonZeroItemStockPurchaseParams_result()
4182 
    result.success = self._handler.getNonZeroItemStockPurchaseParams()
4183 
    oprot.writeMessageBegin("getNonZeroItemStockPurchaseParams", TMessageType.REPLY, seqid)
4184 
    result.write(oprot)
4185 
    oprot.writeMessageEnd()
4186 
    oprot.trans.flush()
6832 amar.kumar 4187 
 
7149 amar.kumar 4188 
  def process_getBillableInventoryAndPendingOrders(self, seqid, iprot, oprot):
4189 
    args = getBillableInventoryAndPendingOrders_args()
4190 
    args.read(iprot)
4191 
    iprot.readMessageEnd()
4192 
    result = getBillableInventoryAndPendingOrders_result()
4193 
    result.success = self._handler.getBillableInventoryAndPendingOrders()
4194 
    oprot.writeMessageBegin("getBillableInventoryAndPendingOrders", TMessageType.REPLY, seqid)
4195 
    result.write(oprot)
4196 
    oprot.writeMessageEnd()
4197 
    oprot.trans.flush()
6857 amar.kumar 4198 
 
7281 kshitij.so 4199 
  def process_getWarehouseName(self, seqid, iprot, oprot):
4200 
    args = getWarehouseName_args()
4201 
    args.read(iprot)
4202 
    iprot.readMessageEnd()
4203 
    result = getWarehouseName_result()
4204 
    result.success = self._handler.getWarehouseName(args.warehouse_id)
4205 
    oprot.writeMessageBegin("getWarehouseName", TMessageType.REPLY, seqid)
4206 
    result.write(oprot)
4207 
    oprot.writeMessageEnd()
4208 
    oprot.trans.flush()
7149 amar.kumar 4209 
 
7281 kshitij.so 4210 
  def process_getAmazonInventoryForItem(self, seqid, iprot, oprot):
4211 
    args = getAmazonInventoryForItem_args()
4212 
    args.read(iprot)
4213 
    iprot.readMessageEnd()
4214 
    result = getAmazonInventoryForItem_result()
4215 
    result.success = self._handler.getAmazonInventoryForItem(args.item_id)
4216 
    oprot.writeMessageBegin("getAmazonInventoryForItem", TMessageType.REPLY, seqid)
4217 
    result.write(oprot)
4218 
    oprot.writeMessageEnd()
4219 
    oprot.trans.flush()
4220 
 
4221 
  def process_getAllAmazonInventory(self, seqid, iprot, oprot):
4222 
    args = getAllAmazonInventory_args()
4223 
    args.read(iprot)
4224 
    iprot.readMessageEnd()
4225 
    result = getAllAmazonInventory_result()
4226 
    result.success = self._handler.getAllAmazonInventory()
4227 
    oprot.writeMessageBegin("getAllAmazonInventory", TMessageType.REPLY, seqid)
4228 
    result.write(oprot)
4229 
    oprot.writeMessageEnd()
4230 
    oprot.trans.flush()
4231 
 
4232 
  def process_addOrUpdateAmazonInventoryForItem(self, seqid, iprot, oprot):
4233 
    args = addOrUpdateAmazonInventoryForItem_args()
4234 
    args.read(iprot)
4235 
    iprot.readMessageEnd()
4236 
    result = addOrUpdateAmazonInventoryForItem_result()
10450 vikram.rag 4237 
    self._handler.addOrUpdateAmazonInventoryForItem(args.amazonInventorySnapshot, args.time)
7281 kshitij.so 4238 
    oprot.writeMessageBegin("addOrUpdateAmazonInventoryForItem", TMessageType.REPLY, seqid)
4239 
    result.write(oprot)
4240 
    oprot.writeMessageEnd()
4241 
    oprot.trans.flush()
4242 
 
7972 amar.kumar 4243 
  def process_getLastNdaySaleForItem(self, seqid, iprot, oprot):
4244 
    args = getLastNdaySaleForItem_args()
4245 
    args.read(iprot)
4246 
    iprot.readMessageEnd()
4247 
    result = getLastNdaySaleForItem_result()
4248 
    result.success = self._handler.getLastNdaySaleForItem(args.itemId, args.numberOfDays)
4249 
    oprot.writeMessageBegin("getLastNdaySaleForItem", TMessageType.REPLY, seqid)
4250 
    result.write(oprot)
4251 
    oprot.writeMessageEnd()
4252 
    oprot.trans.flush()
7281 kshitij.so 4253 
 
8282 kshitij.so 4254 
  def process_addOrUpdateAmazonFbaInventory(self, seqid, iprot, oprot):
4255 
    args = addOrUpdateAmazonFbaInventory_args()
4256 
    args.read(iprot)
4257 
    iprot.readMessageEnd()
4258 
    result = addOrUpdateAmazonFbaInventory_result()
4259 
    self._handler.addOrUpdateAmazonFbaInventory(args.amazonfbainventorysnapshot)
4260 
    oprot.writeMessageBegin("addOrUpdateAmazonFbaInventory", TMessageType.REPLY, seqid)
4261 
    result.write(oprot)
4262 
    oprot.writeMessageEnd()
4263 
    oprot.trans.flush()
4264 
 
8182 amar.kumar 4265 
  def process_addUpdateHoldInventory(self, seqid, iprot, oprot):
4266 
    args = addUpdateHoldInventory_args()
4267 
    args.read(iprot)
4268 
    iprot.readMessageEnd()
4269 
    result = addUpdateHoldInventory_result()
9762 amar.kumar 4270 
    try:
4271 
      self._handler.addUpdateHoldInventory(args.itemId, args.warehouseId, args.holdQuantity, args.source)
4272 
    except InventoryServiceException, cex:
4273 
      result.cex = cex
8182 amar.kumar 4274 
    oprot.writeMessageBegin("addUpdateHoldInventory", TMessageType.REPLY, seqid)
4275 
    result.write(oprot)
4276 
    oprot.writeMessageEnd()
4277 
    oprot.trans.flush()
7972 amar.kumar 4278 
 
8282 kshitij.so 4279 
  def process_getAmazonFbaItemInventory(self, seqid, iprot, oprot):
4280 
    args = getAmazonFbaItemInventory_args()
4281 
    args.read(iprot)
4282 
    iprot.readMessageEnd()
4283 
    result = getAmazonFbaItemInventory_result()
4284 
    result.success = self._handler.getAmazonFbaItemInventory(args.itemId)
4285 
    oprot.writeMessageBegin("getAmazonFbaItemInventory", TMessageType.REPLY, seqid)
4286 
    result.write(oprot)
4287 
    oprot.writeMessageEnd()
4288 
    oprot.trans.flush()
8182 amar.kumar 4289 
 
8363 vikram.rag 4290 
  def process_getAllAmazonFbaItemInventory(self, seqid, iprot, oprot):
4291 
    args = getAllAmazonFbaItemInventory_args()
8282 kshitij.so 4292 
    args.read(iprot)
4293 
    iprot.readMessageEnd()
8363 vikram.rag 4294 
    result = getAllAmazonFbaItemInventory_result()
4295 
    result.success = self._handler.getAllAmazonFbaItemInventory()
4296 
    oprot.writeMessageBegin("getAllAmazonFbaItemInventory", TMessageType.REPLY, seqid)
8282 kshitij.so 4297 
    result.write(oprot)
4298 
    oprot.writeMessageEnd()
4299 
    oprot.trans.flush()
4300 
 
8363 vikram.rag 4301 
  def process_getOursGoodWarehouseIdsForLocation(self, seqid, iprot, oprot):
4302 
    args = getOursGoodWarehouseIdsForLocation_args()
4303 
    args.read(iprot)
4304 
    iprot.readMessageEnd()
4305 
    result = getOursGoodWarehouseIdsForLocation_result()
4306 
    result.success = self._handler.getOursGoodWarehouseIdsForLocation(args.state_id)
4307 
    oprot.writeMessageBegin("getOursGoodWarehouseIdsForLocation", TMessageType.REPLY, seqid)
4308 
    result.write(oprot)
4309 
    oprot.writeMessageEnd()
4310 
    oprot.trans.flush()
8282 kshitij.so 4311 
 
8955 vikram.rag 4312 
  def process_getHoldInventoryDetailForItemForWarehouseIdExceptSource(self, seqid, iprot, oprot):
4313 
    args = getHoldInventoryDetailForItemForWarehouseIdExceptSource_args()
4314 
    args.read(iprot)
4315 
    iprot.readMessageEnd()
4316 
    result = getHoldInventoryDetailForItemForWarehouseIdExceptSource_result()
4317 
    result.success = self._handler.getHoldInventoryDetailForItemForWarehouseIdExceptSource(args.id, args.warehouse_id, args.source)
4318 
    oprot.writeMessageBegin("getHoldInventoryDetailForItemForWarehouseIdExceptSource", TMessageType.REPLY, seqid)
4319 
    result.write(oprot)
4320 
    oprot.writeMessageEnd()
4321 
    oprot.trans.flush()
8363 vikram.rag 4322 
 
9404 vikram.rag 4323 
  def process_getSnapdealInventoryForItem(self, seqid, iprot, oprot):
4324 
    args = getSnapdealInventoryForItem_args()
4325 
    args.read(iprot)
4326 
    iprot.readMessageEnd()
4327 
    result = getSnapdealInventoryForItem_result()
4328 
    result.success = self._handler.getSnapdealInventoryForItem(args.item_id)
4329 
    oprot.writeMessageBegin("getSnapdealInventoryForItem", TMessageType.REPLY, seqid)
4330 
    result.write(oprot)
4331 
    oprot.writeMessageEnd()
4332 
    oprot.trans.flush()
8955 vikram.rag 4333 
 
9404 vikram.rag 4334 
  def process_addOrUpdateSnapdealInventoryForItem(self, seqid, iprot, oprot):
4335 
    args = addOrUpdateSnapdealInventoryForItem_args()
4336 
    args.read(iprot)
4337 
    iprot.readMessageEnd()
4338 
    result = addOrUpdateSnapdealInventoryForItem_result()
4339 
    self._handler.addOrUpdateSnapdealInventoryForItem(args.snapdealinventoryitem)
4340 
    oprot.writeMessageBegin("addOrUpdateSnapdealInventoryForItem", TMessageType.REPLY, seqid)
4341 
    result.write(oprot)
4342 
    oprot.writeMessageEnd()
4343 
    oprot.trans.flush()
4344 
 
4345 
  def process_getNlcForWarehouse(self, seqid, iprot, oprot):
4346 
    args = getNlcForWarehouse_args()
4347 
    args.read(iprot)
4348 
    iprot.readMessageEnd()
4349 
    result = getNlcForWarehouse_result()
4350 
    result.success = self._handler.getNlcForWarehouse(args.warehouse_id, args.item_id)
4351 
    oprot.writeMessageBegin("getNlcForWarehouse", TMessageType.REPLY, seqid)
4352 
    result.write(oprot)
4353 
    oprot.writeMessageEnd()
4354 
    oprot.trans.flush()
4355 
 
9640 amar.kumar 4356 
  def process_getHeldInventoryMapForItem(self, seqid, iprot, oprot):
4357 
    args = getHeldInventoryMapForItem_args()
4358 
    args.read(iprot)
4359 
    iprot.readMessageEnd()
4360 
    result = getHeldInventoryMapForItem_result()
4361 
    result.success = self._handler.getHeldInventoryMapForItem(args.item_id, args.warehouse_id)
4362 
    oprot.writeMessageBegin("getHeldInventoryMapForItem", TMessageType.REPLY, seqid)
4363 
    result.write(oprot)
4364 
    oprot.writeMessageEnd()
4365 
    oprot.trans.flush()
4366 
 
9495 vikram.rag 4367 
  def process_addOrUpdateAllAmazonFbaInventory(self, seqid, iprot, oprot):
4368 
    args = addOrUpdateAllAmazonFbaInventory_args()
9456 vikram.rag 4369 
    args.read(iprot)
4370 
    iprot.readMessageEnd()
9495 vikram.rag 4371 
    result = addOrUpdateAllAmazonFbaInventory_result()
4372 
    self._handler.addOrUpdateAllAmazonFbaInventory(args.allamazonfbainventorysnapshot)
4373 
    oprot.writeMessageBegin("addOrUpdateAllAmazonFbaInventory", TMessageType.REPLY, seqid)
9456 vikram.rag 4374 
    result.write(oprot)
4375 
    oprot.writeMessageEnd()
4376 
    oprot.trans.flush()
9404 vikram.rag 4377 
 
9495 vikram.rag 4378 
  def process_addOrUpdateAllSnapdealInventory(self, seqid, iprot, oprot):
4379 
    args = addOrUpdateAllSnapdealInventory_args()
9482 vikram.rag 4380 
    args.read(iprot)
4381 
    iprot.readMessageEnd()
9495 vikram.rag 4382 
    result = addOrUpdateAllSnapdealInventory_result()
4383 
    self._handler.addOrUpdateAllSnapdealInventory(args.allsnapdealinventorysnapshot)
4384 
    oprot.writeMessageBegin("addOrUpdateAllSnapdealInventory", TMessageType.REPLY, seqid)
9482 vikram.rag 4385 
    result.write(oprot)
4386 
    oprot.writeMessageEnd()
4387 
    oprot.trans.flush()
9456 vikram.rag 4388 
 
9495 vikram.rag 4389 
  def process_getSnapdealInventorySnapshot(self, seqid, iprot, oprot):
4390 
    args = getSnapdealInventorySnapshot_args()
4391 
    args.read(iprot)
4392 
    iprot.readMessageEnd()
4393 
    result = getSnapdealInventorySnapshot_result()
4394 
    result.success = self._handler.getSnapdealInventorySnapshot()
4395 
    oprot.writeMessageBegin("getSnapdealInventorySnapshot", TMessageType.REPLY, seqid)
4396 
    result.write(oprot)
4397 
    oprot.writeMessageEnd()
4398 
    oprot.trans.flush()
9482 vikram.rag 4399 
 
9761 amar.kumar 4400 
  def process_getHoldInventoryDetails(self, seqid, iprot, oprot):
4401 
    args = getHoldInventoryDetails_args()
4402 
    args.read(iprot)
4403 
    iprot.readMessageEnd()
4404 
    result = getHoldInventoryDetails_result()
4405 
    result.success = self._handler.getHoldInventoryDetails(args.itemId, args.warehouseId, args.source)
4406 
    oprot.writeMessageBegin("getHoldInventoryDetails", TMessageType.REPLY, seqid)
4407 
    result.write(oprot)
4408 
    oprot.writeMessageEnd()
4409 
    oprot.trans.flush()
9495 vikram.rag 4410 
 
10050 vikram.rag 4411 
  def process_addOrUpdateFlipkartInventorySnapshot(self, seqid, iprot, oprot):
4412 
    args = addOrUpdateFlipkartInventorySnapshot_args()
4413 
    args.read(iprot)
4414 
    iprot.readMessageEnd()
4415 
    result = addOrUpdateFlipkartInventorySnapshot_result()
10450 vikram.rag 4416 
    self._handler.addOrUpdateFlipkartInventorySnapshot(args.flipkartInventorySnapshot, args.time)
10050 vikram.rag 4417 
    oprot.writeMessageBegin("addOrUpdateFlipkartInventorySnapshot", TMessageType.REPLY, seqid)
4418 
    result.write(oprot)
4419 
    oprot.writeMessageEnd()
4420 
    oprot.trans.flush()
9761 amar.kumar 4421 
 
10050 vikram.rag 4422 
  def process_getFlipkartInventorySnapshot(self, seqid, iprot, oprot):
4423 
    args = getFlipkartInventorySnapshot_args()
4424 
    args.read(iprot)
4425 
    iprot.readMessageEnd()
4426 
    result = getFlipkartInventorySnapshot_result()
4427 
    result.success = self._handler.getFlipkartInventorySnapshot()
4428 
    oprot.writeMessageBegin("getFlipkartInventorySnapshot", TMessageType.REPLY, seqid)
4429 
    result.write(oprot)
4430 
    oprot.writeMessageEnd()
4431 
    oprot.trans.flush()
4432 
 
10097 kshitij.so 4433 
  def process_getFlipkartlInventoryForItem(self, seqid, iprot, oprot):
4434 
    args = getFlipkartlInventoryForItem_args()
4435 
    args.read(iprot)
4436 
    iprot.readMessageEnd()
4437 
    result = getFlipkartlInventoryForItem_result()
4438 
    result.success = self._handler.getFlipkartlInventoryForItem(args.item_id)
4439 
    oprot.writeMessageBegin("getFlipkartlInventoryForItem", TMessageType.REPLY, seqid)
4440 
    result.write(oprot)
4441 
    oprot.writeMessageEnd()
4442 
    oprot.trans.flush()
10050 vikram.rag 4443 
 
10485 vikram.rag 4444 
  def process_getStateMaster(self, seqid, iprot, oprot):
4445 
    args = getStateMaster_args()
4446 
    args.read(iprot)
4447 
    iprot.readMessageEnd()
4448 
    result = getStateMaster_result()
4449 
    result.success = self._handler.getStateMaster()
4450 
    oprot.writeMessageBegin("getStateMaster", TMessageType.REPLY, seqid)
4451 
    result.write(oprot)
4452 
    oprot.writeMessageEnd()
4453 
    oprot.trans.flush()
10097 kshitij.so 4454 
 
10544 vikram.rag 4455 
  def process_updateSnapdealStockAtEOD(self, seqid, iprot, oprot):
4456 
    args = updateSnapdealStockAtEOD_args()
4457 
    args.read(iprot)
4458 
    iprot.readMessageEnd()
4459 
    result = updateSnapdealStockAtEOD_result()
4460 
    self._handler.updateSnapdealStockAtEOD(args.allsnapdealstock)
4461 
    oprot.writeMessageBegin("updateSnapdealStockAtEOD", TMessageType.REPLY, seqid)
4462 
    result.write(oprot)
4463 
    oprot.writeMessageEnd()
4464 
    oprot.trans.flush()
10485 vikram.rag 4465 
 
10544 vikram.rag 4466 
  def process_updateFlipkartStockAtEOD(self, seqid, iprot, oprot):
4467 
    args = updateFlipkartStockAtEOD_args()
4468 
    args.read(iprot)
4469 
    iprot.readMessageEnd()
4470 
    result = updateFlipkartStockAtEOD_result()
4471 
    self._handler.updateFlipkartStockAtEOD(args.allflipkartstock)
4472 
    oprot.writeMessageBegin("updateFlipkartStockAtEOD", TMessageType.REPLY, seqid)
4473 
    result.write(oprot)
4474 
    oprot.writeMessageEnd()
4475 
    oprot.trans.flush()
4476 
 
12363 kshitij.so 4477 
  def process_getWanNlcForSource(self, seqid, iprot, oprot):
4478 
    args = getWanNlcForSource_args()
4479 
    args.read(iprot)
4480 
    iprot.readMessageEnd()
4481 
    result = getWanNlcForSource_result()
4482 
    result.success = self._handler.getWanNlcForSource(args.item_id, args.source)
4483 
    oprot.writeMessageBegin("getWanNlcForSource", TMessageType.REPLY, seqid)
4484 
    result.write(oprot)
4485 
    oprot.writeMessageEnd()
4486 
    oprot.trans.flush()
10544 vikram.rag 4487 
 
12363 kshitij.so 4488 
  def process_getAllAvailableAmazonFbaItemInventory(self, seqid, iprot, oprot):
4489 
    args = getAllAvailableAmazonFbaItemInventory_args()
4490 
    args.read(iprot)
4491 
    iprot.readMessageEnd()
4492 
    result = getAllAvailableAmazonFbaItemInventory_result()
4493 
    result.success = self._handler.getAllAvailableAmazonFbaItemInventory()
4494 
    oprot.writeMessageBegin("getAllAvailableAmazonFbaItemInventory", TMessageType.REPLY, seqid)
4495 
    result.write(oprot)
4496 
    oprot.writeMessageEnd()
4497 
    oprot.trans.flush()
4498 
 
17990 kshitij.so 4499 
  def process_updateItemAvailabilityForItemIds(self, seqid, iprot, oprot):
4500 
    args = updateItemAvailabilityForItemIds_args()
4501 
    args.read(iprot)
4502 
    iprot.readMessageEnd()
4503 
    result = updateItemAvailabilityForItemIds_result()
4504 
    result.success = self._handler.updateItemAvailabilityForItemIds(args.itemIds)
4505 
    oprot.writeMessageBegin("updateItemAvailabilityForItemIds", TMessageType.REPLY, seqid)
4506 
    result.write(oprot)
4507 
    oprot.writeMessageEnd()
4508 
    oprot.trans.flush()
12363 kshitij.so 4509 
 
19247 kshitij.so 4510 
  def process_addVendorItemPricingInBulk(self, seqid, iprot, oprot):
4511 
    args = addVendorItemPricingInBulk_args()
4512 
    args.read(iprot)
4513 
    iprot.readMessageEnd()
4514 
    result = addVendorItemPricingInBulk_result()
4515 
    result.success = self._handler.addVendorItemPricingInBulk(args.vendorItemPricingList)
4516 
    oprot.writeMessageBegin("addVendorItemPricingInBulk", TMessageType.REPLY, seqid)
4517 
    result.write(oprot)
4518 
    oprot.writeMessageEnd()
4519 
    oprot.trans.flush()
17990 kshitij.so 4520 
 
19247 kshitij.so 4521 
  def process_addInventoryInBulk(self, seqid, iprot, oprot):
4522 
    args = addInventoryInBulk_args()
4523 
    args.read(iprot)
4524 
    iprot.readMessageEnd()
4525 
    result = addInventoryInBulk_result()
4526 
    try:
4527 
      self._handler.addInventoryInBulk(args.bulkInventoryList)
4528 
    except InventoryServiceException, cex:
4529 
      result.cex = cex
4530 
    oprot.writeMessageBegin("addInventoryInBulk", TMessageType.REPLY, seqid)
4531 
    result.write(oprot)
4532 
    oprot.writeMessageEnd()
4533 
    oprot.trans.flush()
4534 
 
19413 amit.gupta 4535 
  def process_getItemLocationAvailabilityCache(self, seqid, iprot, oprot):
4536 
    args = getItemLocationAvailabilityCache_args()
4537 
    args.read(iprot)
4538 
    iprot.readMessageEnd()
4539 
    result = getItemLocationAvailabilityCache_result()
4540 
    result.success = self._handler.getItemLocationAvailabilityCache(args.itemLocations)
4541 
    oprot.writeMessageBegin("getItemLocationAvailabilityCache", TMessageType.REPLY, seqid)
4542 
    result.write(oprot)
4543 
    oprot.writeMessageEnd()
4544 
    oprot.trans.flush()
19247 kshitij.so 4545 
 
19413 amit.gupta 4546 
  def process_getItemLocationAvailabilityCacheByItemId(self, seqid, iprot, oprot):
4547 
    args = getItemLocationAvailabilityCacheByItemId_args()
4548 
    args.read(iprot)
4549 
    iprot.readMessageEnd()
4550 
    result = getItemLocationAvailabilityCacheByItemId_result()
4551 
    result.success = self._handler.getItemLocationAvailabilityCacheByItemId(args.itemIds)
4552 
    oprot.writeMessageBegin("getItemLocationAvailabilityCacheByItemId", TMessageType.REPLY, seqid)
4553 
    result.write(oprot)
4554 
    oprot.writeMessageEnd()
4555 
    oprot.trans.flush()
4556 
 
4557 
  def process_getItemPincodeAvailability(self, seqid, iprot, oprot):
4558 
    args = getItemPincodeAvailability_args()
4559 
    args.read(iprot)
4560 
    iprot.readMessageEnd()
4561 
    result = getItemPincodeAvailability_result()
19416 amit.gupta 4562 
    result.success = self._handler.getItemPincodeAvailability(args.itempricing, args.pincode)
19413 amit.gupta 4563 
    oprot.writeMessageBegin("getItemPincodeAvailability", TMessageType.REPLY, seqid)
4564 
    result.write(oprot)
4565 
    oprot.writeMessageEnd()
4566 
    oprot.trans.flush()
4567 
 
4568 
 
5944 mandeep.dh 4569 
# HELPER FUNCTIONS AND STRUCTURES
4570 
 
4571 
class addWarehouse_args:
4572 
  """
4573 
  Attributes:
4574 
   - warehouse
4575 
  """
4576 
 
4577 
  thrift_spec = (
4578 
    None, # 0
4579 
    (1, TType.STRUCT, 'warehouse', (Warehouse, Warehouse.thrift_spec), None, ), # 1
4580 
  )
4581 
 
4582 
  def __init__(self, warehouse=None,):
4583 
    self.warehouse = warehouse
4584 
 
4585 
  def read(self, iprot):
4586 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4587 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4588 
      return
4589 
    iprot.readStructBegin()
4590 
    while True:
4591 
      (fname, ftype, fid) = iprot.readFieldBegin()
4592 
      if ftype == TType.STOP:
4593 
        break
4594 
      if fid == 1:
4595 
        if ftype == TType.STRUCT:
4596 
          self.warehouse = Warehouse()
4597 
          self.warehouse.read(iprot)
4598 
        else:
4599 
          iprot.skip(ftype)
4600 
      else:
4601 
        iprot.skip(ftype)
4602 
      iprot.readFieldEnd()
4603 
    iprot.readStructEnd()
4604 
 
4605 
  def write(self, oprot):
4606 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4607 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4608 
      return
4609 
    oprot.writeStructBegin('addWarehouse_args')
4610 
    if self.warehouse is not None:
4611 
      oprot.writeFieldBegin('warehouse', TType.STRUCT, 1)
4612 
      self.warehouse.write(oprot)
4613 
      oprot.writeFieldEnd()
4614 
    oprot.writeFieldStop()
4615 
    oprot.writeStructEnd()
4616 
 
4617 
  def validate(self):
4618 
    return
4619 
 
4620 
 
4621 
  def __repr__(self):
4622 
    L = ['%s=%r' % (key, value)
4623 
      for key, value in self.__dict__.iteritems()]
4624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4625 
 
4626 
  def __eq__(self, other):
4627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4628 
 
4629 
  def __ne__(self, other):
4630 
    return not (self == other)
4631 
 
4632 
class addWarehouse_result:
4633 
  """
4634 
  Attributes:
4635 
   - success
4636 
   - cex
4637 
  """
4638 
 
4639 
  thrift_spec = (
4640 
    (0, TType.I64, 'success', None, None, ), # 0
4641 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
4642 
  )
4643 
 
4644 
  def __init__(self, success=None, cex=None,):
4645 
    self.success = success
4646 
    self.cex = cex
4647 
 
4648 
  def read(self, iprot):
4649 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4650 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4651 
      return
4652 
    iprot.readStructBegin()
4653 
    while True:
4654 
      (fname, ftype, fid) = iprot.readFieldBegin()
4655 
      if ftype == TType.STOP:
4656 
        break
4657 
      if fid == 0:
4658 
        if ftype == TType.I64:
4659 
          self.success = iprot.readI64();
4660 
        else:
4661 
          iprot.skip(ftype)
4662 
      elif fid == 1:
4663 
        if ftype == TType.STRUCT:
4664 
          self.cex = InventoryServiceException()
4665 
          self.cex.read(iprot)
4666 
        else:
4667 
          iprot.skip(ftype)
4668 
      else:
4669 
        iprot.skip(ftype)
4670 
      iprot.readFieldEnd()
4671 
    iprot.readStructEnd()
4672 
 
4673 
  def write(self, oprot):
4674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4676 
      return
4677 
    oprot.writeStructBegin('addWarehouse_result')
4678 
    if self.success is not None:
4679 
      oprot.writeFieldBegin('success', TType.I64, 0)
4680 
      oprot.writeI64(self.success)
4681 
      oprot.writeFieldEnd()
4682 
    if self.cex is not None:
4683 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
4684 
      self.cex.write(oprot)
4685 
      oprot.writeFieldEnd()
4686 
    oprot.writeFieldStop()
4687 
    oprot.writeStructEnd()
4688 
 
4689 
  def validate(self):
4690 
    return
4691 
 
4692 
 
4693 
  def __repr__(self):
4694 
    L = ['%s=%r' % (key, value)
4695 
      for key, value in self.__dict__.iteritems()]
4696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4697 
 
4698 
  def __eq__(self, other):
4699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4700 
 
4701 
  def __ne__(self, other):
4702 
    return not (self == other)
4703 
 
4704 
class addVendor_args:
4705 
  """
4706 
  Attributes:
4707 
   - vendor
4708 
  """
4709 
 
4710 
  thrift_spec = (
4711 
    None, # 0
4712 
    (1, TType.STRUCT, 'vendor', (Vendor, Vendor.thrift_spec), None, ), # 1
4713 
  )
4714 
 
4715 
  def __init__(self, vendor=None,):
4716 
    self.vendor = vendor
4717 
 
4718 
  def read(self, iprot):
4719 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4720 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4721 
      return
4722 
    iprot.readStructBegin()
4723 
    while True:
4724 
      (fname, ftype, fid) = iprot.readFieldBegin()
4725 
      if ftype == TType.STOP:
4726 
        break
4727 
      if fid == 1:
4728 
        if ftype == TType.STRUCT:
4729 
          self.vendor = Vendor()
4730 
          self.vendor.read(iprot)
4731 
        else:
4732 
          iprot.skip(ftype)
4733 
      else:
4734 
        iprot.skip(ftype)
4735 
      iprot.readFieldEnd()
4736 
    iprot.readStructEnd()
4737 
 
4738 
  def write(self, oprot):
4739 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4740 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4741 
      return
4742 
    oprot.writeStructBegin('addVendor_args')
4743 
    if self.vendor is not None:
4744 
      oprot.writeFieldBegin('vendor', TType.STRUCT, 1)
4745 
      self.vendor.write(oprot)
4746 
      oprot.writeFieldEnd()
4747 
    oprot.writeFieldStop()
4748 
    oprot.writeStructEnd()
4749 
 
4750 
  def validate(self):
4751 
    return
4752 
 
4753 
 
4754 
  def __repr__(self):
4755 
    L = ['%s=%r' % (key, value)
4756 
      for key, value in self.__dict__.iteritems()]
4757 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4758 
 
4759 
  def __eq__(self, other):
4760 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4761 
 
4762 
  def __ne__(self, other):
4763 
    return not (self == other)
4764 
 
4765 
class addVendor_result:
4766 
  """
4767 
  Attributes:
4768 
   - success
4769 
   - cex
4770 
  """
4771 
 
4772 
  thrift_spec = (
4773 
    (0, TType.I64, 'success', None, None, ), # 0
4774 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
4775 
  )
4776 
 
4777 
  def __init__(self, success=None, cex=None,):
4778 
    self.success = success
4779 
    self.cex = cex
4780 
 
4781 
  def read(self, iprot):
4782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4784 
      return
4785 
    iprot.readStructBegin()
4786 
    while True:
4787 
      (fname, ftype, fid) = iprot.readFieldBegin()
4788 
      if ftype == TType.STOP:
4789 
        break
4790 
      if fid == 0:
4791 
        if ftype == TType.I64:
4792 
          self.success = iprot.readI64();
4793 
        else:
4794 
          iprot.skip(ftype)
4795 
      elif fid == 1:
4796 
        if ftype == TType.STRUCT:
4797 
          self.cex = InventoryServiceException()
4798 
          self.cex.read(iprot)
4799 
        else:
4800 
          iprot.skip(ftype)
4801 
      else:
4802 
        iprot.skip(ftype)
4803 
      iprot.readFieldEnd()
4804 
    iprot.readStructEnd()
4805 
 
4806 
  def write(self, oprot):
4807 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4808 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4809 
      return
4810 
    oprot.writeStructBegin('addVendor_result')
4811 
    if self.success is not None:
4812 
      oprot.writeFieldBegin('success', TType.I64, 0)
4813 
      oprot.writeI64(self.success)
4814 
      oprot.writeFieldEnd()
4815 
    if self.cex is not None:
4816 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
4817 
      self.cex.write(oprot)
4818 
      oprot.writeFieldEnd()
4819 
    oprot.writeFieldStop()
4820 
    oprot.writeStructEnd()
4821 
 
4822 
  def validate(self):
4823 
    return
4824 
 
4825 
 
4826 
  def __repr__(self):
4827 
    L = ['%s=%r' % (key, value)
4828 
      for key, value in self.__dict__.iteritems()]
4829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4830 
 
4831 
  def __eq__(self, other):
4832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4833 
 
4834 
  def __ne__(self, other):
4835 
    return not (self == other)
4836 
 
4837 
class updateInventoryHistory_args:
4838 
  """
4839 
  Attributes:
4840 
   - warehouse_id
4841 
   - timestamp
4842 
   - availability
4843 
  """
4844 
 
4845 
  thrift_spec = (
4846 
    None, # 0
4847 
    (1, TType.I64, 'warehouse_id', None, None, ), # 1
4848 
    (2, TType.STRING, 'timestamp', None, None, ), # 2
4849 
    (3, TType.MAP, 'availability', (TType.STRING,None,TType.I64,None), None, ), # 3
4850 
  )
4851 
 
4852 
  def __init__(self, warehouse_id=None, timestamp=None, availability=None,):
4853 
    self.warehouse_id = warehouse_id
4854 
    self.timestamp = timestamp
4855 
    self.availability = availability
4856 
 
4857 
  def read(self, iprot):
4858 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4859 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4860 
      return
4861 
    iprot.readStructBegin()
4862 
    while True:
4863 
      (fname, ftype, fid) = iprot.readFieldBegin()
4864 
      if ftype == TType.STOP:
4865 
        break
4866 
      if fid == 1:
4867 
        if ftype == TType.I64:
4868 
          self.warehouse_id = iprot.readI64();
4869 
        else:
4870 
          iprot.skip(ftype)
4871 
      elif fid == 2:
4872 
        if ftype == TType.STRING:
4873 
          self.timestamp = iprot.readString();
4874 
        else:
4875 
          iprot.skip(ftype)
4876 
      elif fid == 3:
4877 
        if ftype == TType.MAP:
4878 
          self.availability = {}
8182 amar.kumar 4879 
          (_ktype28, _vtype29, _size27 ) = iprot.readMapBegin()
4880 
          for _i31 in xrange(_size27):
4881 
            _key32 = iprot.readString();
4882 
            _val33 = iprot.readI64();
4883 
            self.availability[_key32] = _val33
5944 mandeep.dh 4884 
          iprot.readMapEnd()
4885 
        else:
4886 
          iprot.skip(ftype)
4887 
      else:
4888 
        iprot.skip(ftype)
4889 
      iprot.readFieldEnd()
4890 
    iprot.readStructEnd()
4891 
 
4892 
  def write(self, oprot):
4893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4895 
      return
4896 
    oprot.writeStructBegin('updateInventoryHistory_args')
4897 
    if self.warehouse_id is not None:
4898 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 1)
4899 
      oprot.writeI64(self.warehouse_id)
4900 
      oprot.writeFieldEnd()
4901 
    if self.timestamp is not None:
4902 
      oprot.writeFieldBegin('timestamp', TType.STRING, 2)
4903 
      oprot.writeString(self.timestamp)
4904 
      oprot.writeFieldEnd()
4905 
    if self.availability is not None:
4906 
      oprot.writeFieldBegin('availability', TType.MAP, 3)
4907 
      oprot.writeMapBegin(TType.STRING, TType.I64, len(self.availability))
8182 amar.kumar 4908 
      for kiter34,viter35 in self.availability.items():
4909 
        oprot.writeString(kiter34)
4910 
        oprot.writeI64(viter35)
5944 mandeep.dh 4911 
      oprot.writeMapEnd()
4912 
      oprot.writeFieldEnd()
4913 
    oprot.writeFieldStop()
4914 
    oprot.writeStructEnd()
4915 
 
4916 
  def validate(self):
4917 
    return
4918 
 
4919 
 
4920 
  def __repr__(self):
4921 
    L = ['%s=%r' % (key, value)
4922 
      for key, value in self.__dict__.iteritems()]
4923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4924 
 
4925 
  def __eq__(self, other):
4926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4927 
 
4928 
  def __ne__(self, other):
4929 
    return not (self == other)
4930 
 
4931 
class updateInventoryHistory_result:
4932 
  """
4933 
  Attributes:
4934 
   - cex
4935 
  """
4936 
 
4937 
  thrift_spec = (
4938 
    None, # 0
4939 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
4940 
  )
4941 
 
4942 
  def __init__(self, cex=None,):
4943 
    self.cex = cex
4944 
 
4945 
  def read(self, iprot):
4946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4948 
      return
4949 
    iprot.readStructBegin()
4950 
    while True:
4951 
      (fname, ftype, fid) = iprot.readFieldBegin()
4952 
      if ftype == TType.STOP:
4953 
        break
4954 
      if fid == 1:
4955 
        if ftype == TType.STRUCT:
4956 
          self.cex = InventoryServiceException()
4957 
          self.cex.read(iprot)
4958 
        else:
4959 
          iprot.skip(ftype)
4960 
      else:
4961 
        iprot.skip(ftype)
4962 
      iprot.readFieldEnd()
4963 
    iprot.readStructEnd()
4964 
 
4965 
  def write(self, oprot):
4966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4968 
      return
4969 
    oprot.writeStructBegin('updateInventoryHistory_result')
4970 
    if self.cex is not None:
4971 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
4972 
      self.cex.write(oprot)
4973 
      oprot.writeFieldEnd()
4974 
    oprot.writeFieldStop()
4975 
    oprot.writeStructEnd()
4976 
 
4977 
  def validate(self):
4978 
    return
4979 
 
4980 
 
4981 
  def __repr__(self):
4982 
    L = ['%s=%r' % (key, value)
4983 
      for key, value in self.__dict__.iteritems()]
4984 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4985 
 
4986 
  def __eq__(self, other):
4987 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4988 
 
4989 
  def __ne__(self, other):
4990 
    return not (self == other)
4991 
 
4992 
class updateInventory_args:
4993 
  """
4994 
  Attributes:
4995 
   - warehouse_id
4996 
   - timestamp
4997 
   - availability
4998 
  """
4999 
 
5000 
  thrift_spec = (
5001 
    None, # 0
5002 
    (1, TType.I64, 'warehouse_id', None, None, ), # 1
5003 
    (2, TType.STRING, 'timestamp', None, None, ), # 2
5004 
    (3, TType.MAP, 'availability', (TType.STRING,None,TType.I64,None), None, ), # 3
5005 
  )
5006 
 
5007 
  def __init__(self, warehouse_id=None, timestamp=None, availability=None,):
5008 
    self.warehouse_id = warehouse_id
5009 
    self.timestamp = timestamp
5010 
    self.availability = availability
5011 
 
5012 
  def read(self, iprot):
5013 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5014 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5015 
      return
5016 
    iprot.readStructBegin()
5017 
    while True:
5018 
      (fname, ftype, fid) = iprot.readFieldBegin()
5019 
      if ftype == TType.STOP:
5020 
        break
5021 
      if fid == 1:
5022 
        if ftype == TType.I64:
5023 
          self.warehouse_id = iprot.readI64();
5024 
        else:
5025 
          iprot.skip(ftype)
5026 
      elif fid == 2:
5027 
        if ftype == TType.STRING:
5028 
          self.timestamp = iprot.readString();
5029 
        else:
5030 
          iprot.skip(ftype)
5031 
      elif fid == 3:
5032 
        if ftype == TType.MAP:
5033 
          self.availability = {}
8182 amar.kumar 5034 
          (_ktype37, _vtype38, _size36 ) = iprot.readMapBegin()
5035 
          for _i40 in xrange(_size36):
5036 
            _key41 = iprot.readString();
5037 
            _val42 = iprot.readI64();
5038 
            self.availability[_key41] = _val42
5944 mandeep.dh 5039 
          iprot.readMapEnd()
5040 
        else:
5041 
          iprot.skip(ftype)
5042 
      else:
5043 
        iprot.skip(ftype)
5044 
      iprot.readFieldEnd()
5045 
    iprot.readStructEnd()
5046 
 
5047 
  def write(self, oprot):
5048 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5049 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5050 
      return
5051 
    oprot.writeStructBegin('updateInventory_args')
5052 
    if self.warehouse_id is not None:
5053 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 1)
5054 
      oprot.writeI64(self.warehouse_id)
5055 
      oprot.writeFieldEnd()
5056 
    if self.timestamp is not None:
5057 
      oprot.writeFieldBegin('timestamp', TType.STRING, 2)
5058 
      oprot.writeString(self.timestamp)
5059 
      oprot.writeFieldEnd()
5060 
    if self.availability is not None:
5061 
      oprot.writeFieldBegin('availability', TType.MAP, 3)
5062 
      oprot.writeMapBegin(TType.STRING, TType.I64, len(self.availability))
8182 amar.kumar 5063 
      for kiter43,viter44 in self.availability.items():
5064 
        oprot.writeString(kiter43)
5065 
        oprot.writeI64(viter44)
5944 mandeep.dh 5066 
      oprot.writeMapEnd()
5067 
      oprot.writeFieldEnd()
5068 
    oprot.writeFieldStop()
5069 
    oprot.writeStructEnd()
5070 
 
5071 
  def validate(self):
5072 
    return
5073 
 
5074 
 
5075 
  def __repr__(self):
5076 
    L = ['%s=%r' % (key, value)
5077 
      for key, value in self.__dict__.iteritems()]
5078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5079 
 
5080 
  def __eq__(self, other):
5081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5082 
 
5083 
  def __ne__(self, other):
5084 
    return not (self == other)
5085 
 
5086 
class updateInventory_result:
5087 
  """
5088 
  Attributes:
5089 
   - cex
5090 
  """
5091 
 
5092 
  thrift_spec = (
5093 
    None, # 0
5094 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
5095 
  )
5096 
 
5097 
  def __init__(self, cex=None,):
5098 
    self.cex = cex
5099 
 
5100 
  def read(self, iprot):
5101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5103 
      return
5104 
    iprot.readStructBegin()
5105 
    while True:
5106 
      (fname, ftype, fid) = iprot.readFieldBegin()
5107 
      if ftype == TType.STOP:
5108 
        break
5109 
      if fid == 1:
5110 
        if ftype == TType.STRUCT:
5111 
          self.cex = InventoryServiceException()
5112 
          self.cex.read(iprot)
5113 
        else:
5114 
          iprot.skip(ftype)
5115 
      else:
5116 
        iprot.skip(ftype)
5117 
      iprot.readFieldEnd()
5118 
    iprot.readStructEnd()
5119 
 
5120 
  def write(self, oprot):
5121 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5122 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5123 
      return
5124 
    oprot.writeStructBegin('updateInventory_result')
5125 
    if self.cex is not None:
5126 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5127 
      self.cex.write(oprot)
5128 
      oprot.writeFieldEnd()
5129 
    oprot.writeFieldStop()
5130 
    oprot.writeStructEnd()
5131 
 
5132 
  def validate(self):
5133 
    return
5134 
 
5135 
 
5136 
  def __repr__(self):
5137 
    L = ['%s=%r' % (key, value)
5138 
      for key, value in self.__dict__.iteritems()]
5139 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5140 
 
5141 
  def __eq__(self, other):
5142 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5143 
 
5144 
  def __ne__(self, other):
5145 
    return not (self == other)
5146 
 
5147 
class addInventory_args:
5148 
  """
5149 
  Attributes:
5150 
   - itemId
5151 
   - warehouseId
5152 
   - quantity
5153 
  """
5154 
 
5155 
  thrift_spec = (
5156 
    None, # 0
5157 
    (1, TType.I64, 'itemId', None, None, ), # 1
5158 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
5159 
    (3, TType.I64, 'quantity', None, None, ), # 3
5160 
  )
5161 
 
5162 
  def __init__(self, itemId=None, warehouseId=None, quantity=None,):
5163 
    self.itemId = itemId
5164 
    self.warehouseId = warehouseId
5165 
    self.quantity = quantity
5166 
 
5167 
  def read(self, iprot):
5168 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5169 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5170 
      return
5171 
    iprot.readStructBegin()
5172 
    while True:
5173 
      (fname, ftype, fid) = iprot.readFieldBegin()
5174 
      if ftype == TType.STOP:
5175 
        break
5176 
      if fid == 1:
5177 
        if ftype == TType.I64:
5178 
          self.itemId = iprot.readI64();
5179 
        else:
5180 
          iprot.skip(ftype)
5181 
      elif fid == 2:
5182 
        if ftype == TType.I64:
5183 
          self.warehouseId = iprot.readI64();
5184 
        else:
5185 
          iprot.skip(ftype)
5186 
      elif fid == 3:
5187 
        if ftype == TType.I64:
5188 
          self.quantity = iprot.readI64();
5189 
        else:
5190 
          iprot.skip(ftype)
5191 
      else:
5192 
        iprot.skip(ftype)
5193 
      iprot.readFieldEnd()
5194 
    iprot.readStructEnd()
5195 
 
5196 
  def write(self, oprot):
5197 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5198 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5199 
      return
5200 
    oprot.writeStructBegin('addInventory_args')
5201 
    if self.itemId is not None:
5202 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
5203 
      oprot.writeI64(self.itemId)
5204 
      oprot.writeFieldEnd()
5205 
    if self.warehouseId is not None:
5206 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
5207 
      oprot.writeI64(self.warehouseId)
5208 
      oprot.writeFieldEnd()
5209 
    if self.quantity is not None:
5210 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
5211 
      oprot.writeI64(self.quantity)
5212 
      oprot.writeFieldEnd()
5213 
    oprot.writeFieldStop()
5214 
    oprot.writeStructEnd()
5215 
 
5216 
  def validate(self):
5217 
    return
5218 
 
5219 
 
5220 
  def __repr__(self):
5221 
    L = ['%s=%r' % (key, value)
5222 
      for key, value in self.__dict__.iteritems()]
5223 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5224 
 
5225 
  def __eq__(self, other):
5226 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5227 
 
5228 
  def __ne__(self, other):
5229 
    return not (self == other)
5230 
 
5231 
class addInventory_result:
5232 
  """
5233 
  Attributes:
5234 
   - cex
5235 
  """
5236 
 
5237 
  thrift_spec = (
5238 
    None, # 0
5239 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
5240 
  )
5241 
 
5242 
  def __init__(self, cex=None,):
5243 
    self.cex = cex
5244 
 
5245 
  def read(self, iprot):
5246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5248 
      return
5249 
    iprot.readStructBegin()
5250 
    while True:
5251 
      (fname, ftype, fid) = iprot.readFieldBegin()
5252 
      if ftype == TType.STOP:
5253 
        break
5254 
      if fid == 1:
5255 
        if ftype == TType.STRUCT:
5256 
          self.cex = InventoryServiceException()
5257 
          self.cex.read(iprot)
5258 
        else:
5259 
          iprot.skip(ftype)
5260 
      else:
5261 
        iprot.skip(ftype)
5262 
      iprot.readFieldEnd()
5263 
    iprot.readStructEnd()
5264 
 
5265 
  def write(self, oprot):
5266 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5267 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5268 
      return
5269 
    oprot.writeStructBegin('addInventory_result')
5270 
    if self.cex is not None:
5271 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5272 
      self.cex.write(oprot)
5273 
      oprot.writeFieldEnd()
5274 
    oprot.writeFieldStop()
5275 
    oprot.writeStructEnd()
5276 
 
5277 
  def validate(self):
5278 
    return
5279 
 
5280 
 
5281 
  def __repr__(self):
5282 
    L = ['%s=%r' % (key, value)
5283 
      for key, value in self.__dict__.iteritems()]
5284 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5285 
 
5286 
  def __eq__(self, other):
5287 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5288 
 
5289 
  def __ne__(self, other):
5290 
    return not (self == other)
5291 
 
5292 
class retireWarehouse_args:
5293 
  """
5294 
  Attributes:
5295 
   - warehouse_id
5296 
  """
5297 
 
5298 
  thrift_spec = (
5299 
    None, # 0
5300 
    (1, TType.I64, 'warehouse_id', None, None, ), # 1
5301 
  )
5302 
 
5303 
  def __init__(self, warehouse_id=None,):
5304 
    self.warehouse_id = warehouse_id
5305 
 
5306 
  def read(self, iprot):
5307 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5308 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5309 
      return
5310 
    iprot.readStructBegin()
5311 
    while True:
5312 
      (fname, ftype, fid) = iprot.readFieldBegin()
5313 
      if ftype == TType.STOP:
5314 
        break
5315 
      if fid == 1:
5316 
        if ftype == TType.I64:
5317 
          self.warehouse_id = iprot.readI64();
5318 
        else:
5319 
          iprot.skip(ftype)
5320 
      else:
5321 
        iprot.skip(ftype)
5322 
      iprot.readFieldEnd()
5323 
    iprot.readStructEnd()
5324 
 
5325 
  def write(self, oprot):
5326 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5327 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5328 
      return
5329 
    oprot.writeStructBegin('retireWarehouse_args')
5330 
    if self.warehouse_id is not None:
5331 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 1)
5332 
      oprot.writeI64(self.warehouse_id)
5333 
      oprot.writeFieldEnd()
5334 
    oprot.writeFieldStop()
5335 
    oprot.writeStructEnd()
5336 
 
5337 
  def validate(self):
5338 
    return
5339 
 
5340 
 
5341 
  def __repr__(self):
5342 
    L = ['%s=%r' % (key, value)
5343 
      for key, value in self.__dict__.iteritems()]
5344 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5345 
 
5346 
  def __eq__(self, other):
5347 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5348 
 
5349 
  def __ne__(self, other):
5350 
    return not (self == other)
5351 
 
5352 
class retireWarehouse_result:
5353 
  """
5354 
  Attributes:
5355 
   - cex
5356 
  """
5357 
 
5358 
  thrift_spec = (
5359 
    None, # 0
5360 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
5361 
  )
5362 
 
5363 
  def __init__(self, cex=None,):
5364 
    self.cex = cex
5365 
 
5366 
  def read(self, iprot):
5367 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5368 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5369 
      return
5370 
    iprot.readStructBegin()
5371 
    while True:
5372 
      (fname, ftype, fid) = iprot.readFieldBegin()
5373 
      if ftype == TType.STOP:
5374 
        break
5375 
      if fid == 1:
5376 
        if ftype == TType.STRUCT:
5377 
          self.cex = InventoryServiceException()
5378 
          self.cex.read(iprot)
5379 
        else:
5380 
          iprot.skip(ftype)
5381 
      else:
5382 
        iprot.skip(ftype)
5383 
      iprot.readFieldEnd()
5384 
    iprot.readStructEnd()
5385 
 
5386 
  def write(self, oprot):
5387 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5388 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5389 
      return
5390 
    oprot.writeStructBegin('retireWarehouse_result')
5391 
    if self.cex is not None:
5392 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5393 
      self.cex.write(oprot)
5394 
      oprot.writeFieldEnd()
5395 
    oprot.writeFieldStop()
5396 
    oprot.writeStructEnd()
5397 
 
5398 
  def validate(self):
5399 
    return
5400 
 
5401 
 
5402 
  def __repr__(self):
5403 
    L = ['%s=%r' % (key, value)
5404 
      for key, value in self.__dict__.iteritems()]
5405 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5406 
 
5407 
  def __eq__(self, other):
5408 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5409 
 
5410 
  def __ne__(self, other):
5411 
    return not (self == other)
5412 
 
5413 
class getItemInventoryByItemId_args:
5414 
  """
5415 
  Attributes:
5416 
   - item_id
5417 
  """
5418 
 
5419 
  thrift_spec = (
5420 
    None, # 0
5421 
    (1, TType.I64, 'item_id', None, None, ), # 1
5422 
  )
5423 
 
5424 
  def __init__(self, item_id=None,):
5425 
    self.item_id = item_id
5426 
 
5427 
  def read(self, iprot):
5428 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5429 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5430 
      return
5431 
    iprot.readStructBegin()
5432 
    while True:
5433 
      (fname, ftype, fid) = iprot.readFieldBegin()
5434 
      if ftype == TType.STOP:
5435 
        break
5436 
      if fid == 1:
5437 
        if ftype == TType.I64:
5438 
          self.item_id = iprot.readI64();
5439 
        else:
5440 
          iprot.skip(ftype)
5441 
      else:
5442 
        iprot.skip(ftype)
5443 
      iprot.readFieldEnd()
5444 
    iprot.readStructEnd()
5445 
 
5446 
  def write(self, oprot):
5447 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5448 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5449 
      return
5450 
    oprot.writeStructBegin('getItemInventoryByItemId_args')
5451 
    if self.item_id is not None:
5452 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
5453 
      oprot.writeI64(self.item_id)
5454 
      oprot.writeFieldEnd()
5455 
    oprot.writeFieldStop()
5456 
    oprot.writeStructEnd()
5457 
 
5458 
  def validate(self):
5459 
    return
5460 
 
5461 
 
5462 
  def __repr__(self):
5463 
    L = ['%s=%r' % (key, value)
5464 
      for key, value in self.__dict__.iteritems()]
5465 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5466 
 
5467 
  def __eq__(self, other):
5468 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5469 
 
5470 
  def __ne__(self, other):
5471 
    return not (self == other)
5472 
 
5473 
class getItemInventoryByItemId_result:
5474 
  """
5475 
  Attributes:
5476 
   - success
5477 
   - cex
5478 
  """
5479 
 
5480 
  thrift_spec = (
5481 
    (0, TType.STRUCT, 'success', (ItemInventory, ItemInventory.thrift_spec), None, ), # 0
5482 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
5483 
  )
5484 
 
5485 
  def __init__(self, success=None, cex=None,):
5486 
    self.success = success
5487 
    self.cex = cex
5488 
 
5489 
  def read(self, iprot):
5490 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5491 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5492 
      return
5493 
    iprot.readStructBegin()
5494 
    while True:
5495 
      (fname, ftype, fid) = iprot.readFieldBegin()
5496 
      if ftype == TType.STOP:
5497 
        break
5498 
      if fid == 0:
5499 
        if ftype == TType.STRUCT:
5500 
          self.success = ItemInventory()
5501 
          self.success.read(iprot)
5502 
        else:
5503 
          iprot.skip(ftype)
5504 
      elif fid == 1:
5505 
        if ftype == TType.STRUCT:
5506 
          self.cex = InventoryServiceException()
5507 
          self.cex.read(iprot)
5508 
        else:
5509 
          iprot.skip(ftype)
5510 
      else:
5511 
        iprot.skip(ftype)
5512 
      iprot.readFieldEnd()
5513 
    iprot.readStructEnd()
5514 
 
5515 
  def write(self, oprot):
5516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5518 
      return
5519 
    oprot.writeStructBegin('getItemInventoryByItemId_result')
5520 
    if self.success is not None:
5521 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5522 
      self.success.write(oprot)
5523 
      oprot.writeFieldEnd()
5524 
    if self.cex is not None:
5525 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5526 
      self.cex.write(oprot)
5527 
      oprot.writeFieldEnd()
5528 
    oprot.writeFieldStop()
5529 
    oprot.writeStructEnd()
5530 
 
5531 
  def validate(self):
5532 
    return
5533 
 
5534 
 
5535 
  def __repr__(self):
5536 
    L = ['%s=%r' % (key, value)
5537 
      for key, value in self.__dict__.iteritems()]
5538 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5539 
 
5540 
  def __eq__(self, other):
5541 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5542 
 
5543 
  def __ne__(self, other):
5544 
    return not (self == other)
5545 
 
5546 
class getItemAvailibilityAtWarehouse_args:
5547 
  """
5548 
  Attributes:
5549 
   - warehouse_id
5550 
   - item_id
5551 
  """
5552 
 
5553 
  thrift_spec = (
5554 
    None, # 0
5555 
    (1, TType.I64, 'warehouse_id', None, None, ), # 1
5556 
    (2, TType.I64, 'item_id', None, None, ), # 2
5557 
  )
5558 
 
5559 
  def __init__(self, warehouse_id=None, item_id=None,):
5560 
    self.warehouse_id = warehouse_id
5561 
    self.item_id = item_id
5562 
 
5563 
  def read(self, iprot):
5564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5566 
      return
5567 
    iprot.readStructBegin()
5568 
    while True:
5569 
      (fname, ftype, fid) = iprot.readFieldBegin()
5570 
      if ftype == TType.STOP:
5571 
        break
5572 
      if fid == 1:
5573 
        if ftype == TType.I64:
5574 
          self.warehouse_id = iprot.readI64();
5575 
        else:
5576 
          iprot.skip(ftype)
5577 
      elif fid == 2:
5578 
        if ftype == TType.I64:
5579 
          self.item_id = iprot.readI64();
5580 
        else:
5581 
          iprot.skip(ftype)
5582 
      else:
5583 
        iprot.skip(ftype)
5584 
      iprot.readFieldEnd()
5585 
    iprot.readStructEnd()
5586 
 
5587 
  def write(self, oprot):
5588 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5589 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5590 
      return
5591 
    oprot.writeStructBegin('getItemAvailibilityAtWarehouse_args')
5592 
    if self.warehouse_id is not None:
5593 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 1)
5594 
      oprot.writeI64(self.warehouse_id)
5595 
      oprot.writeFieldEnd()
5596 
    if self.item_id is not None:
5597 
      oprot.writeFieldBegin('item_id', TType.I64, 2)
5598 
      oprot.writeI64(self.item_id)
5599 
      oprot.writeFieldEnd()
5600 
    oprot.writeFieldStop()
5601 
    oprot.writeStructEnd()
5602 
 
5603 
  def validate(self):
5604 
    return
5605 
 
5606 
 
5607 
  def __repr__(self):
5608 
    L = ['%s=%r' % (key, value)
5609 
      for key, value in self.__dict__.iteritems()]
5610 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5611 
 
5612 
  def __eq__(self, other):
5613 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5614 
 
5615 
  def __ne__(self, other):
5616 
    return not (self == other)
5617 
 
5618 
class getItemAvailibilityAtWarehouse_result:
5619 
  """
5620 
  Attributes:
5621 
   - success
5622 
   - cex
5623 
  """
5624 
 
5625 
  thrift_spec = (
5626 
    (0, TType.I64, 'success', None, None, ), # 0
5627 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
5628 
  )
5629 
 
5630 
  def __init__(self, success=None, cex=None,):
5631 
    self.success = success
5632 
    self.cex = cex
5633 
 
5634 
  def read(self, iprot):
5635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5637 
      return
5638 
    iprot.readStructBegin()
5639 
    while True:
5640 
      (fname, ftype, fid) = iprot.readFieldBegin()
5641 
      if ftype == TType.STOP:
5642 
        break
5643 
      if fid == 0:
5644 
        if ftype == TType.I64:
5645 
          self.success = iprot.readI64();
5646 
        else:
5647 
          iprot.skip(ftype)
5648 
      elif fid == 1:
5649 
        if ftype == TType.STRUCT:
5650 
          self.cex = InventoryServiceException()
5651 
          self.cex.read(iprot)
5652 
        else:
5653 
          iprot.skip(ftype)
5654 
      else:
5655 
        iprot.skip(ftype)
5656 
      iprot.readFieldEnd()
5657 
    iprot.readStructEnd()
5658 
 
5659 
  def write(self, oprot):
5660 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5661 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5662 
      return
5663 
    oprot.writeStructBegin('getItemAvailibilityAtWarehouse_result')
5664 
    if self.success is not None:
5665 
      oprot.writeFieldBegin('success', TType.I64, 0)
5666 
      oprot.writeI64(self.success)
5667 
      oprot.writeFieldEnd()
5668 
    if self.cex is not None:
5669 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5670 
      self.cex.write(oprot)
5671 
      oprot.writeFieldEnd()
5672 
    oprot.writeFieldStop()
5673 
    oprot.writeStructEnd()
5674 
 
5675 
  def validate(self):
5676 
    return
5677 
 
5678 
 
5679 
  def __repr__(self):
5680 
    L = ['%s=%r' % (key, value)
5681 
      for key, value in self.__dict__.iteritems()]
5682 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5683 
 
5684 
  def __eq__(self, other):
5685 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5686 
 
5687 
  def __ne__(self, other):
5688 
    return not (self == other)
5689 
 
5690 
class getItemAvailabilityAtLocation_args:
5691 
  """
5692 
  Attributes:
5693 
   - itemId
5978 rajveer 5694 
   - sourceId
5944 mandeep.dh 5695 
  """
5696 
 
5697 
  thrift_spec = (
5698 
    None, # 0
5699 
    (1, TType.I64, 'itemId', None, None, ), # 1
5978 rajveer 5700 
    (2, TType.I64, 'sourceId', None, None, ), # 2
5944 mandeep.dh 5701 
  )
5702 
 
5978 rajveer 5703 
  def __init__(self, itemId=None, sourceId=None,):
5944 mandeep.dh 5704 
    self.itemId = itemId
5978 rajveer 5705 
    self.sourceId = sourceId
5944 mandeep.dh 5706 
 
5707 
  def read(self, iprot):
5708 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5709 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5710 
      return
5711 
    iprot.readStructBegin()
5712 
    while True:
5713 
      (fname, ftype, fid) = iprot.readFieldBegin()
5714 
      if ftype == TType.STOP:
5715 
        break
5716 
      if fid == 1:
5717 
        if ftype == TType.I64:
5718 
          self.itemId = iprot.readI64();
5719 
        else:
5720 
          iprot.skip(ftype)
5978 rajveer 5721 
      elif fid == 2:
5722 
        if ftype == TType.I64:
5723 
          self.sourceId = iprot.readI64();
5724 
        else:
5725 
          iprot.skip(ftype)
5944 mandeep.dh 5726 
      else:
5727 
        iprot.skip(ftype)
5728 
      iprot.readFieldEnd()
5729 
    iprot.readStructEnd()
5730 
 
5731 
  def write(self, oprot):
5732 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5733 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5734 
      return
5735 
    oprot.writeStructBegin('getItemAvailabilityAtLocation_args')
5736 
    if self.itemId is not None:
5737 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
5738 
      oprot.writeI64(self.itemId)
5739 
      oprot.writeFieldEnd()
5978 rajveer 5740 
    if self.sourceId is not None:
5741 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
5742 
      oprot.writeI64(self.sourceId)
5743 
      oprot.writeFieldEnd()
5944 mandeep.dh 5744 
    oprot.writeFieldStop()
5745 
    oprot.writeStructEnd()
5746 
 
5747 
  def validate(self):
5748 
    return
5749 
 
5750 
 
5751 
  def __repr__(self):
5752 
    L = ['%s=%r' % (key, value)
5753 
      for key, value in self.__dict__.iteritems()]
5754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5755 
 
5756 
  def __eq__(self, other):
5757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5758 
 
5759 
  def __ne__(self, other):
5760 
    return not (self == other)
5761 
 
5762 
class getItemAvailabilityAtLocation_result:
5763 
  """
5764 
  Attributes:
5765 
   - success
5766 
   - isex
5767 
  """
5768 
 
5769 
  thrift_spec = (
5770 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
5771 
    (1, TType.STRUCT, 'isex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
5772 
  )
5773 
 
5774 
  def __init__(self, success=None, isex=None,):
5775 
    self.success = success
5776 
    self.isex = isex
5777 
 
5778 
  def read(self, iprot):
5779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5781 
      return
5782 
    iprot.readStructBegin()
5783 
    while True:
5784 
      (fname, ftype, fid) = iprot.readFieldBegin()
5785 
      if ftype == TType.STOP:
5786 
        break
5787 
      if fid == 0:
5788 
        if ftype == TType.LIST:
5789 
          self.success = []
8182 amar.kumar 5790 
          (_etype48, _size45) = iprot.readListBegin()
5791 
          for _i49 in xrange(_size45):
5792 
            _elem50 = iprot.readI64();
5793 
            self.success.append(_elem50)
5944 mandeep.dh 5794 
          iprot.readListEnd()
5795 
        else:
5796 
          iprot.skip(ftype)
5797 
      elif fid == 1:
5798 
        if ftype == TType.STRUCT:
5799 
          self.isex = InventoryServiceException()
5800 
          self.isex.read(iprot)
5801 
        else:
5802 
          iprot.skip(ftype)
5803 
      else:
5804 
        iprot.skip(ftype)
5805 
      iprot.readFieldEnd()
5806 
    iprot.readStructEnd()
5807 
 
5808 
  def write(self, oprot):
5809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5811 
      return
5812 
    oprot.writeStructBegin('getItemAvailabilityAtLocation_result')
5813 
    if self.success is not None:
5814 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5815 
      oprot.writeListBegin(TType.I64, len(self.success))
8182 amar.kumar 5816 
      for iter51 in self.success:
5817 
        oprot.writeI64(iter51)
5944 mandeep.dh 5818 
      oprot.writeListEnd()
5819 
      oprot.writeFieldEnd()
5820 
    if self.isex is not None:
5821 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
5822 
      self.isex.write(oprot)
5823 
      oprot.writeFieldEnd()
5824 
    oprot.writeFieldStop()
5825 
    oprot.writeStructEnd()
5826 
 
5827 
  def validate(self):
5828 
    return
5829 
 
5830 
 
5831 
  def __repr__(self):
5832 
    L = ['%s=%r' % (key, value)
5833 
      for key, value in self.__dict__.iteritems()]
5834 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5835 
 
5836 
  def __eq__(self, other):
5837 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5838 
 
5839 
  def __ne__(self, other):
5840 
    return not (self == other)
5841 
 
5842 
class getAllWarehouses_args:
5843 
  """
5844 
  Attributes:
5845 
   - isActive
5846 
  """
5847 
 
5848 
  thrift_spec = (
5849 
    None, # 0
5850 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
5851 
  )
5852 
 
5853 
  def __init__(self, isActive=None,):
5854 
    self.isActive = isActive
5855 
 
5856 
  def read(self, iprot):
5857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5859 
      return
5860 
    iprot.readStructBegin()
5861 
    while True:
5862 
      (fname, ftype, fid) = iprot.readFieldBegin()
5863 
      if ftype == TType.STOP:
5864 
        break
5865 
      if fid == 1:
5866 
        if ftype == TType.BOOL:
5867 
          self.isActive = iprot.readBool();
5868 
        else:
5869 
          iprot.skip(ftype)
5870 
      else:
5871 
        iprot.skip(ftype)
5872 
      iprot.readFieldEnd()
5873 
    iprot.readStructEnd()
5874 
 
5875 
  def write(self, oprot):
5876 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5877 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5878 
      return
5879 
    oprot.writeStructBegin('getAllWarehouses_args')
5880 
    if self.isActive is not None:
5881 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
5882 
      oprot.writeBool(self.isActive)
5883 
      oprot.writeFieldEnd()
5884 
    oprot.writeFieldStop()
5885 
    oprot.writeStructEnd()
5886 
 
5887 
  def validate(self):
5888 
    return
5889 
 
5890 
 
5891 
  def __repr__(self):
5892 
    L = ['%s=%r' % (key, value)
5893 
      for key, value in self.__dict__.iteritems()]
5894 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5895 
 
5896 
  def __eq__(self, other):
5897 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5898 
 
5899 
  def __ne__(self, other):
5900 
    return not (self == other)
5901 
 
5902 
class getAllWarehouses_result:
5903 
  """
5904 
  Attributes:
5905 
   - success
5906 
   - cex
5907 
  """
5908 
 
5909 
  thrift_spec = (
5910 
    (0, TType.LIST, 'success', (TType.STRUCT,(Warehouse, Warehouse.thrift_spec)), None, ), # 0
5911 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
5912 
  )
5913 
 
5914 
  def __init__(self, success=None, cex=None,):
5915 
    self.success = success
5916 
    self.cex = cex
5917 
 
5918 
  def read(self, iprot):
5919 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5920 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5921 
      return
5922 
    iprot.readStructBegin()
5923 
    while True:
5924 
      (fname, ftype, fid) = iprot.readFieldBegin()
5925 
      if ftype == TType.STOP:
5926 
        break
5927 
      if fid == 0:
5928 
        if ftype == TType.LIST:
5929 
          self.success = []
8182 amar.kumar 5930 
          (_etype55, _size52) = iprot.readListBegin()
5931 
          for _i56 in xrange(_size52):
5932 
            _elem57 = Warehouse()
5933 
            _elem57.read(iprot)
5934 
            self.success.append(_elem57)
5944 mandeep.dh 5935 
          iprot.readListEnd()
5936 
        else:
5937 
          iprot.skip(ftype)
5938 
      elif fid == 1:
5939 
        if ftype == TType.STRUCT:
5940 
          self.cex = InventoryServiceException()
5941 
          self.cex.read(iprot)
5942 
        else:
5943 
          iprot.skip(ftype)
5944 
      else:
5945 
        iprot.skip(ftype)
5946 
      iprot.readFieldEnd()
5947 
    iprot.readStructEnd()
5948 
 
5949 
  def write(self, oprot):
5950 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5951 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5952 
      return
5953 
    oprot.writeStructBegin('getAllWarehouses_result')
5954 
    if self.success is not None:
5955 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5956 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 5957 
      for iter58 in self.success:
5958 
        iter58.write(oprot)
5944 mandeep.dh 5959 
      oprot.writeListEnd()
5960 
      oprot.writeFieldEnd()
5961 
    if self.cex is not None:
5962 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5963 
      self.cex.write(oprot)
5964 
      oprot.writeFieldEnd()
5965 
    oprot.writeFieldStop()
5966 
    oprot.writeStructEnd()
5967 
 
5968 
  def validate(self):
5969 
    return
5970 
 
5971 
 
5972 
  def __repr__(self):
5973 
    L = ['%s=%r' % (key, value)
5974 
      for key, value in self.__dict__.iteritems()]
5975 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5976 
 
5977 
  def __eq__(self, other):
5978 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5979 
 
5980 
  def __ne__(self, other):
5981 
    return not (self == other)
5982 
 
5983 
class getWarehouse_args:
5984 
  """
5985 
  Attributes:
5986 
   - warehouse_id
5987 
  """
5988 
 
5989 
  thrift_spec = (
5990 
    None, # 0
5991 
    (1, TType.I64, 'warehouse_id', None, None, ), # 1
5992 
  )
5993 
 
5994 
  def __init__(self, warehouse_id=None,):
5995 
    self.warehouse_id = warehouse_id
5996 
 
5997 
  def read(self, iprot):
5998 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5999 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6000 
      return
6001 
    iprot.readStructBegin()
6002 
    while True:
6003 
      (fname, ftype, fid) = iprot.readFieldBegin()
6004 
      if ftype == TType.STOP:
6005 
        break
6006 
      if fid == 1:
6007 
        if ftype == TType.I64:
6008 
          self.warehouse_id = iprot.readI64();
6009 
        else:
6010 
          iprot.skip(ftype)
6011 
      else:
6012 
        iprot.skip(ftype)
6013 
      iprot.readFieldEnd()
6014 
    iprot.readStructEnd()
6015 
 
6016 
  def write(self, oprot):
6017 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6018 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6019 
      return
6020 
    oprot.writeStructBegin('getWarehouse_args')
6021 
    if self.warehouse_id is not None:
6022 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 1)
6023 
      oprot.writeI64(self.warehouse_id)
6024 
      oprot.writeFieldEnd()
6025 
    oprot.writeFieldStop()
6026 
    oprot.writeStructEnd()
6027 
 
6028 
  def validate(self):
6029 
    return
6030 
 
6031 
 
6032 
  def __repr__(self):
6033 
    L = ['%s=%r' % (key, value)
6034 
      for key, value in self.__dict__.iteritems()]
6035 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6036 
 
6037 
  def __eq__(self, other):
6038 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6039 
 
6040 
  def __ne__(self, other):
6041 
    return not (self == other)
6042 
 
6043 
class getWarehouse_result:
6044 
  """
6045 
  Attributes:
6046 
   - success
6047 
   - cex
6048 
  """
6049 
 
6050 
  thrift_spec = (
6051 
    (0, TType.STRUCT, 'success', (Warehouse, Warehouse.thrift_spec), None, ), # 0
6052 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
6053 
  )
6054 
 
6055 
  def __init__(self, success=None, cex=None,):
6056 
    self.success = success
6057 
    self.cex = cex
6058 
 
6059 
  def read(self, iprot):
6060 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6061 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6062 
      return
6063 
    iprot.readStructBegin()
6064 
    while True:
6065 
      (fname, ftype, fid) = iprot.readFieldBegin()
6066 
      if ftype == TType.STOP:
6067 
        break
6068 
      if fid == 0:
6069 
        if ftype == TType.STRUCT:
6070 
          self.success = Warehouse()
6071 
          self.success.read(iprot)
6072 
        else:
6073 
          iprot.skip(ftype)
6074 
      elif fid == 1:
6075 
        if ftype == TType.STRUCT:
6076 
          self.cex = InventoryServiceException()
6077 
          self.cex.read(iprot)
6078 
        else:
6079 
          iprot.skip(ftype)
6080 
      else:
6081 
        iprot.skip(ftype)
6082 
      iprot.readFieldEnd()
6083 
    iprot.readStructEnd()
6084 
 
6085 
  def write(self, oprot):
6086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6088 
      return
6089 
    oprot.writeStructBegin('getWarehouse_result')
6090 
    if self.success is not None:
6091 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6092 
      self.success.write(oprot)
6093 
      oprot.writeFieldEnd()
6094 
    if self.cex is not None:
6095 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6096 
      self.cex.write(oprot)
6097 
      oprot.writeFieldEnd()
6098 
    oprot.writeFieldStop()
6099 
    oprot.writeStructEnd()
6100 
 
6101 
  def validate(self):
6102 
    return
6103 
 
6104 
 
6105 
  def __repr__(self):
6106 
    L = ['%s=%r' % (key, value)
6107 
      for key, value in self.__dict__.iteritems()]
6108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6109 
 
6110 
  def __eq__(self, other):
6111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6112 
 
6113 
  def __ne__(self, other):
6114 
    return not (self == other)
6115 
 
6116 
class getAllItemsForWarehouse_args:
6117 
  """
6118 
  Attributes:
6119 
   - warehouse_id
6120 
  """
6121 
 
6122 
  thrift_spec = (
6123 
    None, # 0
6124 
    (1, TType.I64, 'warehouse_id', None, None, ), # 1
6125 
  )
6126 
 
6127 
  def __init__(self, warehouse_id=None,):
6128 
    self.warehouse_id = warehouse_id
6129 
 
6130 
  def read(self, iprot):
6131 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6132 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6133 
      return
6134 
    iprot.readStructBegin()
6135 
    while True:
6136 
      (fname, ftype, fid) = iprot.readFieldBegin()
6137 
      if ftype == TType.STOP:
6138 
        break
6139 
      if fid == 1:
6140 
        if ftype == TType.I64:
6141 
          self.warehouse_id = iprot.readI64();
6142 
        else:
6143 
          iprot.skip(ftype)
6144 
      else:
6145 
        iprot.skip(ftype)
6146 
      iprot.readFieldEnd()
6147 
    iprot.readStructEnd()
6148 
 
6149 
  def write(self, oprot):
6150 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6151 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6152 
      return
6153 
    oprot.writeStructBegin('getAllItemsForWarehouse_args')
6154 
    if self.warehouse_id is not None:
6155 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 1)
6156 
      oprot.writeI64(self.warehouse_id)
6157 
      oprot.writeFieldEnd()
6158 
    oprot.writeFieldStop()
6159 
    oprot.writeStructEnd()
6160 
 
6161 
  def validate(self):
6162 
    return
6163 
 
6164 
 
6165 
  def __repr__(self):
6166 
    L = ['%s=%r' % (key, value)
6167 
      for key, value in self.__dict__.iteritems()]
6168 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6169 
 
6170 
  def __eq__(self, other):
6171 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6172 
 
6173 
  def __ne__(self, other):
6174 
    return not (self == other)
6175 
 
6176 
class getAllItemsForWarehouse_result:
6177 
  """
6178 
  Attributes:
6179 
   - success
6180 
   - cex
6181 
  """
6182 
 
6183 
  thrift_spec = (
6184 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
6185 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
6186 
  )
6187 
 
6188 
  def __init__(self, success=None, cex=None,):
6189 
    self.success = success
6190 
    self.cex = cex
6191 
 
6192 
  def read(self, iprot):
6193 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6194 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6195 
      return
6196 
    iprot.readStructBegin()
6197 
    while True:
6198 
      (fname, ftype, fid) = iprot.readFieldBegin()
6199 
      if ftype == TType.STOP:
6200 
        break
6201 
      if fid == 0:
6202 
        if ftype == TType.LIST:
6203 
          self.success = []
8182 amar.kumar 6204 
          (_etype62, _size59) = iprot.readListBegin()
6205 
          for _i63 in xrange(_size59):
6206 
            _elem64 = iprot.readI64();
6207 
            self.success.append(_elem64)
5944 mandeep.dh 6208 
          iprot.readListEnd()
6209 
        else:
6210 
          iprot.skip(ftype)
6211 
      elif fid == 1:
6212 
        if ftype == TType.STRUCT:
6213 
          self.cex = InventoryServiceException()
6214 
          self.cex.read(iprot)
6215 
        else:
6216 
          iprot.skip(ftype)
6217 
      else:
6218 
        iprot.skip(ftype)
6219 
      iprot.readFieldEnd()
6220 
    iprot.readStructEnd()
6221 
 
6222 
  def write(self, oprot):
6223 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6224 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6225 
      return
6226 
    oprot.writeStructBegin('getAllItemsForWarehouse_result')
6227 
    if self.success is not None:
6228 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6229 
      oprot.writeListBegin(TType.I64, len(self.success))
8182 amar.kumar 6230 
      for iter65 in self.success:
6231 
        oprot.writeI64(iter65)
5944 mandeep.dh 6232 
      oprot.writeListEnd()
6233 
      oprot.writeFieldEnd()
6234 
    if self.cex is not None:
6235 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6236 
      self.cex.write(oprot)
6237 
      oprot.writeFieldEnd()
6238 
    oprot.writeFieldStop()
6239 
    oprot.writeStructEnd()
6240 
 
6241 
  def validate(self):
6242 
    return
6243 
 
6244 
 
6245 
  def __repr__(self):
6246 
    L = ['%s=%r' % (key, value)
6247 
      for key, value in self.__dict__.iteritems()]
6248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6249 
 
6250 
  def __eq__(self, other):
6251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6252 
 
6253 
  def __ne__(self, other):
6254 
    return not (self == other)
6255 
 
5966 rajveer 6256 
class isOrderBillable_args:
6257 
  """
6258 
  Attributes:
6259 
   - itemId
6260 
   - warehouseId
6261 
   - sourceId
6262 
   - orderId
6263 
  """
6264 
 
6265 
  thrift_spec = (
6266 
    None, # 0
6267 
    (1, TType.I64, 'itemId', None, None, ), # 1
6268 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
6269 
    (3, TType.I64, 'sourceId', None, None, ), # 3
6270 
    (4, TType.I64, 'orderId', None, None, ), # 4
6271 
  )
6272 
 
6273 
  def __init__(self, itemId=None, warehouseId=None, sourceId=None, orderId=None,):
6274 
    self.itemId = itemId
6275 
    self.warehouseId = warehouseId
6276 
    self.sourceId = sourceId
6277 
    self.orderId = orderId
6278 
 
6279 
  def read(self, iprot):
6280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6282 
      return
6283 
    iprot.readStructBegin()
6284 
    while True:
6285 
      (fname, ftype, fid) = iprot.readFieldBegin()
6286 
      if ftype == TType.STOP:
6287 
        break
6288 
      if fid == 1:
6289 
        if ftype == TType.I64:
6290 
          self.itemId = iprot.readI64();
6291 
        else:
6292 
          iprot.skip(ftype)
6293 
      elif fid == 2:
6294 
        if ftype == TType.I64:
6295 
          self.warehouseId = iprot.readI64();
6296 
        else:
6297 
          iprot.skip(ftype)
6298 
      elif fid == 3:
6299 
        if ftype == TType.I64:
6300 
          self.sourceId = iprot.readI64();
6301 
        else:
6302 
          iprot.skip(ftype)
6303 
      elif fid == 4:
6304 
        if ftype == TType.I64:
6305 
          self.orderId = iprot.readI64();
6306 
        else:
6307 
          iprot.skip(ftype)
6308 
      else:
6309 
        iprot.skip(ftype)
6310 
      iprot.readFieldEnd()
6311 
    iprot.readStructEnd()
6312 
 
6313 
  def write(self, oprot):
6314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6316 
      return
6317 
    oprot.writeStructBegin('isOrderBillable_args')
6318 
    if self.itemId is not None:
6319 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
6320 
      oprot.writeI64(self.itemId)
6321 
      oprot.writeFieldEnd()
6322 
    if self.warehouseId is not None:
6323 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
6324 
      oprot.writeI64(self.warehouseId)
6325 
      oprot.writeFieldEnd()
6326 
    if self.sourceId is not None:
6327 
      oprot.writeFieldBegin('sourceId', TType.I64, 3)
6328 
      oprot.writeI64(self.sourceId)
6329 
      oprot.writeFieldEnd()
6330 
    if self.orderId is not None:
6331 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
6332 
      oprot.writeI64(self.orderId)
6333 
      oprot.writeFieldEnd()
6334 
    oprot.writeFieldStop()
6335 
    oprot.writeStructEnd()
6336 
 
6337 
  def validate(self):
6338 
    return
6339 
 
6340 
 
6341 
  def __repr__(self):
6342 
    L = ['%s=%r' % (key, value)
6343 
      for key, value in self.__dict__.iteritems()]
6344 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6345 
 
6346 
  def __eq__(self, other):
6347 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6348 
 
6349 
  def __ne__(self, other):
6350 
    return not (self == other)
6351 
 
6352 
class isOrderBillable_result:
6353 
  """
6354 
  Attributes:
6355 
   - success
6356 
  """
6357 
 
6358 
  thrift_spec = (
6359 
    (0, TType.BOOL, 'success', None, None, ), # 0
6360 
  )
6361 
 
6362 
  def __init__(self, success=None,):
6363 
    self.success = success
6364 
 
6365 
  def read(self, iprot):
6366 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6367 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6368 
      return
6369 
    iprot.readStructBegin()
6370 
    while True:
6371 
      (fname, ftype, fid) = iprot.readFieldBegin()
6372 
      if ftype == TType.STOP:
6373 
        break
6374 
      if fid == 0:
6375 
        if ftype == TType.BOOL:
6376 
          self.success = iprot.readBool();
6377 
        else:
6378 
          iprot.skip(ftype)
6379 
      else:
6380 
        iprot.skip(ftype)
6381 
      iprot.readFieldEnd()
6382 
    iprot.readStructEnd()
6383 
 
6384 
  def write(self, oprot):
6385 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6386 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6387 
      return
6388 
    oprot.writeStructBegin('isOrderBillable_result')
6389 
    if self.success is not None:
6390 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6391 
      oprot.writeBool(self.success)
6392 
      oprot.writeFieldEnd()
6393 
    oprot.writeFieldStop()
6394 
    oprot.writeStructEnd()
6395 
 
6396 
  def validate(self):
6397 
    return
6398 
 
6399 
 
6400 
  def __repr__(self):
6401 
    L = ['%s=%r' % (key, value)
6402 
      for key, value in self.__dict__.iteritems()]
6403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6404 
 
6405 
  def __eq__(self, other):
6406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6407 
 
6408 
  def __ne__(self, other):
6409 
    return not (self == other)
6410 
 
5944 mandeep.dh 6411 
class reserveItemInWarehouse_args:
6412 
  """
6413 
  Attributes:
6414 
   - itemId
6415 
   - warehouseId
5966 rajveer 6416 
   - sourceId
6417 
   - orderId
6418 
   - createdTimestamp
6419 
   - promisedShippingTimestamp
5944 mandeep.dh 6420 
   - quantity
6421 
  """
6422 
 
6423 
  thrift_spec = (
6424 
    None, # 0
6425 
    (1, TType.I64, 'itemId', None, None, ), # 1
6426 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
5966 rajveer 6427 
    (3, TType.I64, 'sourceId', None, None, ), # 3
6428 
    (4, TType.I64, 'orderId', None, None, ), # 4
6429 
    (5, TType.I64, 'createdTimestamp', None, None, ), # 5
6430 
    (6, TType.I64, 'promisedShippingTimestamp', None, None, ), # 6
6431 
    (7, TType.DOUBLE, 'quantity', None, None, ), # 7
5944 mandeep.dh 6432 
  )
6433 
 
5966 rajveer 6434 
  def __init__(self, itemId=None, warehouseId=None, sourceId=None, orderId=None, createdTimestamp=None, promisedShippingTimestamp=None, quantity=None,):
5944 mandeep.dh 6435 
    self.itemId = itemId
6436 
    self.warehouseId = warehouseId
5966 rajveer 6437 
    self.sourceId = sourceId
6438 
    self.orderId = orderId
6439 
    self.createdTimestamp = createdTimestamp
6440 
    self.promisedShippingTimestamp = promisedShippingTimestamp
5944 mandeep.dh 6441 
    self.quantity = quantity
6442 
 
6443 
  def read(self, iprot):
6444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6446 
      return
6447 
    iprot.readStructBegin()
6448 
    while True:
6449 
      (fname, ftype, fid) = iprot.readFieldBegin()
6450 
      if ftype == TType.STOP:
6451 
        break
6452 
      if fid == 1:
6453 
        if ftype == TType.I64:
6454 
          self.itemId = iprot.readI64();
6455 
        else:
6456 
          iprot.skip(ftype)
6457 
      elif fid == 2:
6458 
        if ftype == TType.I64:
6459 
          self.warehouseId = iprot.readI64();
6460 
        else:
6461 
          iprot.skip(ftype)
6462 
      elif fid == 3:
5966 rajveer 6463 
        if ftype == TType.I64:
6464 
          self.sourceId = iprot.readI64();
6465 
        else:
6466 
          iprot.skip(ftype)
6467 
      elif fid == 4:
6468 
        if ftype == TType.I64:
6469 
          self.orderId = iprot.readI64();
6470 
        else:
6471 
          iprot.skip(ftype)
6472 
      elif fid == 5:
6473 
        if ftype == TType.I64:
6474 
          self.createdTimestamp = iprot.readI64();
6475 
        else:
6476 
          iprot.skip(ftype)
6477 
      elif fid == 6:
6478 
        if ftype == TType.I64:
6479 
          self.promisedShippingTimestamp = iprot.readI64();
6480 
        else:
6481 
          iprot.skip(ftype)
6482 
      elif fid == 7:
5944 mandeep.dh 6483 
        if ftype == TType.DOUBLE:
6484 
          self.quantity = iprot.readDouble();
6485 
        else:
6486 
          iprot.skip(ftype)
6487 
      else:
6488 
        iprot.skip(ftype)
6489 
      iprot.readFieldEnd()
6490 
    iprot.readStructEnd()
6491 
 
6492 
  def write(self, oprot):
6493 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6494 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6495 
      return
6496 
    oprot.writeStructBegin('reserveItemInWarehouse_args')
6497 
    if self.itemId is not None:
6498 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
6499 
      oprot.writeI64(self.itemId)
6500 
      oprot.writeFieldEnd()
6501 
    if self.warehouseId is not None:
6502 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
6503 
      oprot.writeI64(self.warehouseId)
6504 
      oprot.writeFieldEnd()
5966 rajveer 6505 
    if self.sourceId is not None:
6506 
      oprot.writeFieldBegin('sourceId', TType.I64, 3)
6507 
      oprot.writeI64(self.sourceId)
6508 
      oprot.writeFieldEnd()
6509 
    if self.orderId is not None:
6510 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
6511 
      oprot.writeI64(self.orderId)
6512 
      oprot.writeFieldEnd()
6513 
    if self.createdTimestamp is not None:
6514 
      oprot.writeFieldBegin('createdTimestamp', TType.I64, 5)
6515 
      oprot.writeI64(self.createdTimestamp)
6516 
      oprot.writeFieldEnd()
6517 
    if self.promisedShippingTimestamp is not None:
6518 
      oprot.writeFieldBegin('promisedShippingTimestamp', TType.I64, 6)
6519 
      oprot.writeI64(self.promisedShippingTimestamp)
6520 
      oprot.writeFieldEnd()
5944 mandeep.dh 6521 
    if self.quantity is not None:
5966 rajveer 6522 
      oprot.writeFieldBegin('quantity', TType.DOUBLE, 7)
5944 mandeep.dh 6523 
      oprot.writeDouble(self.quantity)
6524 
      oprot.writeFieldEnd()
6525 
    oprot.writeFieldStop()
6526 
    oprot.writeStructEnd()
6527 
 
6528 
  def validate(self):
6529 
    return
6530 
 
6531 
 
6532 
  def __repr__(self):
6533 
    L = ['%s=%r' % (key, value)
6534 
      for key, value in self.__dict__.iteritems()]
6535 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6536 
 
6537 
  def __eq__(self, other):
6538 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6539 
 
6540 
  def __ne__(self, other):
6541 
    return not (self == other)
6542 
 
6543 
class reserveItemInWarehouse_result:
6544 
  """
6545 
  Attributes:
6546 
   - success
6547 
   - cex
6548 
  """
6549 
 
6550 
  thrift_spec = (
6551 
    (0, TType.BOOL, 'success', None, None, ), # 0
6552 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
6553 
  )
6554 
 
6555 
  def __init__(self, success=None, cex=None,):
6556 
    self.success = success
6557 
    self.cex = cex
6558 
 
6559 
  def read(self, iprot):
6560 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6561 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6562 
      return
6563 
    iprot.readStructBegin()
6564 
    while True:
6565 
      (fname, ftype, fid) = iprot.readFieldBegin()
6566 
      if ftype == TType.STOP:
6567 
        break
6568 
      if fid == 0:
6569 
        if ftype == TType.BOOL:
6570 
          self.success = iprot.readBool();
6571 
        else:
6572 
          iprot.skip(ftype)
6573 
      elif fid == 1:
6574 
        if ftype == TType.STRUCT:
6575 
          self.cex = InventoryServiceException()
6576 
          self.cex.read(iprot)
6577 
        else:
6578 
          iprot.skip(ftype)
6579 
      else:
6580 
        iprot.skip(ftype)
6581 
      iprot.readFieldEnd()
6582 
    iprot.readStructEnd()
6583 
 
6584 
  def write(self, oprot):
6585 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6586 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6587 
      return
6588 
    oprot.writeStructBegin('reserveItemInWarehouse_result')
6589 
    if self.success is not None:
6590 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6591 
      oprot.writeBool(self.success)
6592 
      oprot.writeFieldEnd()
6593 
    if self.cex is not None:
6594 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6595 
      self.cex.write(oprot)
6596 
      oprot.writeFieldEnd()
6597 
    oprot.writeFieldStop()
6598 
    oprot.writeStructEnd()
6599 
 
6600 
  def validate(self):
6601 
    return
6602 
 
6603 
 
6604 
  def __repr__(self):
6605 
    L = ['%s=%r' % (key, value)
6606 
      for key, value in self.__dict__.iteritems()]
6607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6608 
 
6609 
  def __eq__(self, other):
6610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6611 
 
6612 
  def __ne__(self, other):
6613 
    return not (self == other)
6614 
 
7968 amar.kumar 6615 
class updateReservationForOrder_args:
6616 
  """
6617 
  Attributes:
6618 
   - itemId
6619 
   - warehouseId
6620 
   - sourceId
6621 
   - orderId
6622 
   - createdTimestamp
6623 
   - promisedShippingTimestamp
6624 
   - quantity
6625 
  """
6626 
 
6627 
  thrift_spec = (
6628 
    None, # 0
6629 
    (1, TType.I64, 'itemId', None, None, ), # 1
6630 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
6631 
    (3, TType.I64, 'sourceId', None, None, ), # 3
6632 
    (4, TType.I64, 'orderId', None, None, ), # 4
6633 
    (5, TType.I64, 'createdTimestamp', None, None, ), # 5
6634 
    (6, TType.I64, 'promisedShippingTimestamp', None, None, ), # 6
6635 
    (7, TType.DOUBLE, 'quantity', None, None, ), # 7
6636 
  )
6637 
 
6638 
  def __init__(self, itemId=None, warehouseId=None, sourceId=None, orderId=None, createdTimestamp=None, promisedShippingTimestamp=None, quantity=None,):
6639 
    self.itemId = itemId
6640 
    self.warehouseId = warehouseId
6641 
    self.sourceId = sourceId
6642 
    self.orderId = orderId
6643 
    self.createdTimestamp = createdTimestamp
6644 
    self.promisedShippingTimestamp = promisedShippingTimestamp
6645 
    self.quantity = quantity
6646 
 
6647 
  def read(self, iprot):
6648 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6649 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6650 
      return
6651 
    iprot.readStructBegin()
6652 
    while True:
6653 
      (fname, ftype, fid) = iprot.readFieldBegin()
6654 
      if ftype == TType.STOP:
6655 
        break
6656 
      if fid == 1:
6657 
        if ftype == TType.I64:
6658 
          self.itemId = iprot.readI64();
6659 
        else:
6660 
          iprot.skip(ftype)
6661 
      elif fid == 2:
6662 
        if ftype == TType.I64:
6663 
          self.warehouseId = iprot.readI64();
6664 
        else:
6665 
          iprot.skip(ftype)
6666 
      elif fid == 3:
6667 
        if ftype == TType.I64:
6668 
          self.sourceId = iprot.readI64();
6669 
        else:
6670 
          iprot.skip(ftype)
6671 
      elif fid == 4:
6672 
        if ftype == TType.I64:
6673 
          self.orderId = iprot.readI64();
6674 
        else:
6675 
          iprot.skip(ftype)
6676 
      elif fid == 5:
6677 
        if ftype == TType.I64:
6678 
          self.createdTimestamp = iprot.readI64();
6679 
        else:
6680 
          iprot.skip(ftype)
6681 
      elif fid == 6:
6682 
        if ftype == TType.I64:
6683 
          self.promisedShippingTimestamp = iprot.readI64();
6684 
        else:
6685 
          iprot.skip(ftype)
6686 
      elif fid == 7:
6687 
        if ftype == TType.DOUBLE:
6688 
          self.quantity = iprot.readDouble();
6689 
        else:
6690 
          iprot.skip(ftype)
6691 
      else:
6692 
        iprot.skip(ftype)
6693 
      iprot.readFieldEnd()
6694 
    iprot.readStructEnd()
6695 
 
6696 
  def write(self, oprot):
6697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6699 
      return
6700 
    oprot.writeStructBegin('updateReservationForOrder_args')
6701 
    if self.itemId is not None:
6702 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
6703 
      oprot.writeI64(self.itemId)
6704 
      oprot.writeFieldEnd()
6705 
    if self.warehouseId is not None:
6706 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
6707 
      oprot.writeI64(self.warehouseId)
6708 
      oprot.writeFieldEnd()
6709 
    if self.sourceId is not None:
6710 
      oprot.writeFieldBegin('sourceId', TType.I64, 3)
6711 
      oprot.writeI64(self.sourceId)
6712 
      oprot.writeFieldEnd()
6713 
    if self.orderId is not None:
6714 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
6715 
      oprot.writeI64(self.orderId)
6716 
      oprot.writeFieldEnd()
6717 
    if self.createdTimestamp is not None:
6718 
      oprot.writeFieldBegin('createdTimestamp', TType.I64, 5)
6719 
      oprot.writeI64(self.createdTimestamp)
6720 
      oprot.writeFieldEnd()
6721 
    if self.promisedShippingTimestamp is not None:
6722 
      oprot.writeFieldBegin('promisedShippingTimestamp', TType.I64, 6)
6723 
      oprot.writeI64(self.promisedShippingTimestamp)
6724 
      oprot.writeFieldEnd()
6725 
    if self.quantity is not None:
6726 
      oprot.writeFieldBegin('quantity', TType.DOUBLE, 7)
6727 
      oprot.writeDouble(self.quantity)
6728 
      oprot.writeFieldEnd()
6729 
    oprot.writeFieldStop()
6730 
    oprot.writeStructEnd()
6731 
 
6732 
  def validate(self):
6733 
    return
6734 
 
6735 
 
6736 
  def __repr__(self):
6737 
    L = ['%s=%r' % (key, value)
6738 
      for key, value in self.__dict__.iteritems()]
6739 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6740 
 
6741 
  def __eq__(self, other):
6742 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6743 
 
6744 
  def __ne__(self, other):
6745 
    return not (self == other)
6746 
 
6747 
class updateReservationForOrder_result:
6748 
  """
6749 
  Attributes:
6750 
   - success
6751 
   - cex
6752 
  """
6753 
 
6754 
  thrift_spec = (
6755 
    (0, TType.BOOL, 'success', None, None, ), # 0
6756 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
6757 
  )
6758 
 
6759 
  def __init__(self, success=None, cex=None,):
6760 
    self.success = success
6761 
    self.cex = cex
6762 
 
6763 
  def read(self, iprot):
6764 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6765 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6766 
      return
6767 
    iprot.readStructBegin()
6768 
    while True:
6769 
      (fname, ftype, fid) = iprot.readFieldBegin()
6770 
      if ftype == TType.STOP:
6771 
        break
6772 
      if fid == 0:
6773 
        if ftype == TType.BOOL:
6774 
          self.success = iprot.readBool();
6775 
        else:
6776 
          iprot.skip(ftype)
6777 
      elif fid == 1:
6778 
        if ftype == TType.STRUCT:
6779 
          self.cex = InventoryServiceException()
6780 
          self.cex.read(iprot)
6781 
        else:
6782 
          iprot.skip(ftype)
6783 
      else:
6784 
        iprot.skip(ftype)
6785 
      iprot.readFieldEnd()
6786 
    iprot.readStructEnd()
6787 
 
6788 
  def write(self, oprot):
6789 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6790 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6791 
      return
6792 
    oprot.writeStructBegin('updateReservationForOrder_result')
6793 
    if self.success is not None:
6794 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6795 
      oprot.writeBool(self.success)
6796 
      oprot.writeFieldEnd()
6797 
    if self.cex is not None:
6798 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6799 
      self.cex.write(oprot)
6800 
      oprot.writeFieldEnd()
6801 
    oprot.writeFieldStop()
6802 
    oprot.writeStructEnd()
6803 
 
6804 
  def validate(self):
6805 
    return
6806 
 
6807 
 
6808 
  def __repr__(self):
6809 
    L = ['%s=%r' % (key, value)
6810 
      for key, value in self.__dict__.iteritems()]
6811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6812 
 
6813 
  def __eq__(self, other):
6814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6815 
 
6816 
  def __ne__(self, other):
6817 
    return not (self == other)
6818 
 
5944 mandeep.dh 6819 
class reduceReservationCount_args:
6820 
  """
6821 
  Attributes:
6822 
   - itemId
6823 
   - warehouseId
5966 rajveer 6824 
   - sourceId
6825 
   - orderId
5944 mandeep.dh 6826 
   - quantity
6827 
  """
6828 
 
6829 
  thrift_spec = (
6830 
    None, # 0
6831 
    (1, TType.I64, 'itemId', None, None, ), # 1
6832 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
5966 rajveer 6833 
    (3, TType.I64, 'sourceId', None, None, ), # 3
6834 
    (4, TType.I64, 'orderId', None, None, ), # 4
6835 
    (5, TType.DOUBLE, 'quantity', None, None, ), # 5
5944 mandeep.dh 6836 
  )
6837 
 
5966 rajveer 6838 
  def __init__(self, itemId=None, warehouseId=None, sourceId=None, orderId=None, quantity=None,):
5944 mandeep.dh 6839 
    self.itemId = itemId
6840 
    self.warehouseId = warehouseId
5966 rajveer 6841 
    self.sourceId = sourceId
6842 
    self.orderId = orderId
5944 mandeep.dh 6843 
    self.quantity = quantity
6844 
 
6845 
  def read(self, iprot):
6846 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6847 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6848 
      return
6849 
    iprot.readStructBegin()
6850 
    while True:
6851 
      (fname, ftype, fid) = iprot.readFieldBegin()
6852 
      if ftype == TType.STOP:
6853 
        break
6854 
      if fid == 1:
6855 
        if ftype == TType.I64:
6856 
          self.itemId = iprot.readI64();
6857 
        else:
6858 
          iprot.skip(ftype)
6859 
      elif fid == 2:
6860 
        if ftype == TType.I64:
6861 
          self.warehouseId = iprot.readI64();
6862 
        else:
6863 
          iprot.skip(ftype)
6864 
      elif fid == 3:
5966 rajveer 6865 
        if ftype == TType.I64:
6866 
          self.sourceId = iprot.readI64();
6867 
        else:
6868 
          iprot.skip(ftype)
6869 
      elif fid == 4:
6870 
        if ftype == TType.I64:
6871 
          self.orderId = iprot.readI64();
6872 
        else:
6873 
          iprot.skip(ftype)
6874 
      elif fid == 5:
5944 mandeep.dh 6875 
        if ftype == TType.DOUBLE:
6876 
          self.quantity = iprot.readDouble();
6877 
        else:
6878 
          iprot.skip(ftype)
6879 
      else:
6880 
        iprot.skip(ftype)
6881 
      iprot.readFieldEnd()
6882 
    iprot.readStructEnd()
6883 
 
6884 
  def write(self, oprot):
6885 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6886 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6887 
      return
6888 
    oprot.writeStructBegin('reduceReservationCount_args')
6889 
    if self.itemId is not None:
6890 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
6891 
      oprot.writeI64(self.itemId)
6892 
      oprot.writeFieldEnd()
6893 
    if self.warehouseId is not None:
6894 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
6895 
      oprot.writeI64(self.warehouseId)
6896 
      oprot.writeFieldEnd()
5966 rajveer 6897 
    if self.sourceId is not None:
6898 
      oprot.writeFieldBegin('sourceId', TType.I64, 3)
6899 
      oprot.writeI64(self.sourceId)
6900 
      oprot.writeFieldEnd()
6901 
    if self.orderId is not None:
6902 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
6903 
      oprot.writeI64(self.orderId)
6904 
      oprot.writeFieldEnd()
5944 mandeep.dh 6905 
    if self.quantity is not None:
5966 rajveer 6906 
      oprot.writeFieldBegin('quantity', TType.DOUBLE, 5)
5944 mandeep.dh 6907 
      oprot.writeDouble(self.quantity)
6908 
      oprot.writeFieldEnd()
6909 
    oprot.writeFieldStop()
6910 
    oprot.writeStructEnd()
6911 
 
6912 
  def validate(self):
6913 
    return
6914 
 
6915 
 
6916 
  def __repr__(self):
6917 
    L = ['%s=%r' % (key, value)
6918 
      for key, value in self.__dict__.iteritems()]
6919 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6920 
 
6921 
  def __eq__(self, other):
6922 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6923 
 
6924 
  def __ne__(self, other):
6925 
    return not (self == other)
6926 
 
6927 
class reduceReservationCount_result:
6928 
  """
6929 
  Attributes:
6930 
   - success
6931 
   - cex
6932 
  """
6933 
 
6934 
  thrift_spec = (
6935 
    (0, TType.BOOL, 'success', None, None, ), # 0
6936 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
6937 
  )
6938 
 
6939 
  def __init__(self, success=None, cex=None,):
6940 
    self.success = success
6941 
    self.cex = cex
6942 
 
6943 
  def read(self, iprot):
6944 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6945 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6946 
      return
6947 
    iprot.readStructBegin()
6948 
    while True:
6949 
      (fname, ftype, fid) = iprot.readFieldBegin()
6950 
      if ftype == TType.STOP:
6951 
        break
6952 
      if fid == 0:
6953 
        if ftype == TType.BOOL:
6954 
          self.success = iprot.readBool();
6955 
        else:
6956 
          iprot.skip(ftype)
6957 
      elif fid == 1:
6958 
        if ftype == TType.STRUCT:
6959 
          self.cex = InventoryServiceException()
6960 
          self.cex.read(iprot)
6961 
        else:
6962 
          iprot.skip(ftype)
6963 
      else:
6964 
        iprot.skip(ftype)
6965 
      iprot.readFieldEnd()
6966 
    iprot.readStructEnd()
6967 
 
6968 
  def write(self, oprot):
6969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6971 
      return
6972 
    oprot.writeStructBegin('reduceReservationCount_result')
6973 
    if self.success is not None:
6974 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6975 
      oprot.writeBool(self.success)
6976 
      oprot.writeFieldEnd()
6977 
    if self.cex is not None:
6978 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6979 
      self.cex.write(oprot)
6980 
      oprot.writeFieldEnd()
6981 
    oprot.writeFieldStop()
6982 
    oprot.writeStructEnd()
6983 
 
6984 
  def validate(self):
6985 
    return
6986 
 
6987 
 
6988 
  def __repr__(self):
6989 
    L = ['%s=%r' % (key, value)
6990 
      for key, value in self.__dict__.iteritems()]
6991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6992 
 
6993 
  def __eq__(self, other):
6994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6995 
 
6996 
  def __ne__(self, other):
6997 
    return not (self == other)
6998 
 
6999 
class getItemPricing_args:
7000 
  """
7001 
  Attributes:
7002 
   - itemId
7003 
   - vendorId
7004 
  """
7005 
 
7006 
  thrift_spec = (
7007 
    None, # 0
7008 
    (1, TType.I64, 'itemId', None, None, ), # 1
7009 
    (2, TType.I64, 'vendorId', None, None, ), # 2
7010 
  )
7011 
 
7012 
  def __init__(self, itemId=None, vendorId=None,):
7013 
    self.itemId = itemId
7014 
    self.vendorId = vendorId
7015 
 
7016 
  def read(self, iprot):
7017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7019 
      return
7020 
    iprot.readStructBegin()
7021 
    while True:
7022 
      (fname, ftype, fid) = iprot.readFieldBegin()
7023 
      if ftype == TType.STOP:
7024 
        break
7025 
      if fid == 1:
7026 
        if ftype == TType.I64:
7027 
          self.itemId = iprot.readI64();
7028 
        else:
7029 
          iprot.skip(ftype)
7030 
      elif fid == 2:
7031 
        if ftype == TType.I64:
7032 
          self.vendorId = iprot.readI64();
7033 
        else:
7034 
          iprot.skip(ftype)
7035 
      else:
7036 
        iprot.skip(ftype)
7037 
      iprot.readFieldEnd()
7038 
    iprot.readStructEnd()
7039 
 
7040 
  def write(self, oprot):
7041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7043 
      return
7044 
    oprot.writeStructBegin('getItemPricing_args')
7045 
    if self.itemId is not None:
7046 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
7047 
      oprot.writeI64(self.itemId)
7048 
      oprot.writeFieldEnd()
7049 
    if self.vendorId is not None:
7050 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
7051 
      oprot.writeI64(self.vendorId)
7052 
      oprot.writeFieldEnd()
7053 
    oprot.writeFieldStop()
7054 
    oprot.writeStructEnd()
7055 
 
7056 
  def validate(self):
7057 
    return
7058 
 
7059 
 
7060 
  def __repr__(self):
7061 
    L = ['%s=%r' % (key, value)
7062 
      for key, value in self.__dict__.iteritems()]
7063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7064 
 
7065 
  def __eq__(self, other):
7066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7067 
 
7068 
  def __ne__(self, other):
7069 
    return not (self == other)
7070 
 
7071 
class getItemPricing_result:
7072 
  """
7073 
  Attributes:
7074 
   - success
7075 
   - cex
7076 
  """
7077 
 
7078 
  thrift_spec = (
7079 
    (0, TType.STRUCT, 'success', (VendorItemPricing, VendorItemPricing.thrift_spec), None, ), # 0
7080 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
7081 
  )
7082 
 
7083 
  def __init__(self, success=None, cex=None,):
7084 
    self.success = success
7085 
    self.cex = cex
7086 
 
7087 
  def read(self, iprot):
7088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7090 
      return
7091 
    iprot.readStructBegin()
7092 
    while True:
7093 
      (fname, ftype, fid) = iprot.readFieldBegin()
7094 
      if ftype == TType.STOP:
7095 
        break
7096 
      if fid == 0:
7097 
        if ftype == TType.STRUCT:
7098 
          self.success = VendorItemPricing()
7099 
          self.success.read(iprot)
7100 
        else:
7101 
          iprot.skip(ftype)
7102 
      elif fid == 1:
7103 
        if ftype == TType.STRUCT:
7104 
          self.cex = InventoryServiceException()
7105 
          self.cex.read(iprot)
7106 
        else:
7107 
          iprot.skip(ftype)
7108 
      else:
7109 
        iprot.skip(ftype)
7110 
      iprot.readFieldEnd()
7111 
    iprot.readStructEnd()
7112 
 
7113 
  def write(self, oprot):
7114 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7115 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7116 
      return
7117 
    oprot.writeStructBegin('getItemPricing_result')
7118 
    if self.success is not None:
7119 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7120 
      self.success.write(oprot)
7121 
      oprot.writeFieldEnd()
7122 
    if self.cex is not None:
7123 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7124 
      self.cex.write(oprot)
7125 
      oprot.writeFieldEnd()
7126 
    oprot.writeFieldStop()
7127 
    oprot.writeStructEnd()
7128 
 
7129 
  def validate(self):
7130 
    return
7131 
 
7132 
 
7133 
  def __repr__(self):
7134 
    L = ['%s=%r' % (key, value)
7135 
      for key, value in self.__dict__.iteritems()]
7136 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7137 
 
7138 
  def __eq__(self, other):
7139 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7140 
 
7141 
  def __ne__(self, other):
7142 
    return not (self == other)
7143 
 
7144 
class getAllItemPricing_args:
7145 
  """
7146 
  Attributes:
7147 
   - itemId
7148 
  """
7149 
 
7150 
  thrift_spec = (
7151 
    None, # 0
7152 
    (1, TType.I64, 'itemId', None, None, ), # 1
7153 
  )
7154 
 
7155 
  def __init__(self, itemId=None,):
7156 
    self.itemId = itemId
7157 
 
7158 
  def read(self, iprot):
7159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7161 
      return
7162 
    iprot.readStructBegin()
7163 
    while True:
7164 
      (fname, ftype, fid) = iprot.readFieldBegin()
7165 
      if ftype == TType.STOP:
7166 
        break
7167 
      if fid == 1:
7168 
        if ftype == TType.I64:
7169 
          self.itemId = iprot.readI64();
7170 
        else:
7171 
          iprot.skip(ftype)
7172 
      else:
7173 
        iprot.skip(ftype)
7174 
      iprot.readFieldEnd()
7175 
    iprot.readStructEnd()
7176 
 
7177 
  def write(self, oprot):
7178 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7179 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7180 
      return
7181 
    oprot.writeStructBegin('getAllItemPricing_args')
7182 
    if self.itemId is not None:
7183 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
7184 
      oprot.writeI64(self.itemId)
7185 
      oprot.writeFieldEnd()
7186 
    oprot.writeFieldStop()
7187 
    oprot.writeStructEnd()
7188 
 
7189 
  def validate(self):
7190 
    return
7191 
 
7192 
 
7193 
  def __repr__(self):
7194 
    L = ['%s=%r' % (key, value)
7195 
      for key, value in self.__dict__.iteritems()]
7196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7197 
 
7198 
  def __eq__(self, other):
7199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7200 
 
7201 
  def __ne__(self, other):
7202 
    return not (self == other)
7203 
 
7204 
class getAllItemPricing_result:
7205 
  """
7206 
  Attributes:
7207 
   - success
7208 
   - cex
7209 
  """
7210 
 
7211 
  thrift_spec = (
7212 
    (0, TType.LIST, 'success', (TType.STRUCT,(VendorItemPricing, VendorItemPricing.thrift_spec)), None, ), # 0
7213 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
7214 
  )
7215 
 
7216 
  def __init__(self, success=None, cex=None,):
7217 
    self.success = success
7218 
    self.cex = cex
7219 
 
7220 
  def read(self, iprot):
7221 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7222 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7223 
      return
7224 
    iprot.readStructBegin()
7225 
    while True:
7226 
      (fname, ftype, fid) = iprot.readFieldBegin()
7227 
      if ftype == TType.STOP:
7228 
        break
7229 
      if fid == 0:
7230 
        if ftype == TType.LIST:
7231 
          self.success = []
8182 amar.kumar 7232 
          (_etype69, _size66) = iprot.readListBegin()
7233 
          for _i70 in xrange(_size66):
7234 
            _elem71 = VendorItemPricing()
7235 
            _elem71.read(iprot)
7236 
            self.success.append(_elem71)
5944 mandeep.dh 7237 
          iprot.readListEnd()
7238 
        else:
7239 
          iprot.skip(ftype)
7240 
      elif fid == 1:
7241 
        if ftype == TType.STRUCT:
7242 
          self.cex = InventoryServiceException()
7243 
          self.cex.read(iprot)
7244 
        else:
7245 
          iprot.skip(ftype)
7246 
      else:
7247 
        iprot.skip(ftype)
7248 
      iprot.readFieldEnd()
7249 
    iprot.readStructEnd()
7250 
 
7251 
  def write(self, oprot):
7252 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7253 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7254 
      return
7255 
    oprot.writeStructBegin('getAllItemPricing_result')
7256 
    if self.success is not None:
7257 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7258 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 7259 
      for iter72 in self.success:
7260 
        iter72.write(oprot)
5944 mandeep.dh 7261 
      oprot.writeListEnd()
7262 
      oprot.writeFieldEnd()
7263 
    if self.cex is not None:
7264 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7265 
      self.cex.write(oprot)
7266 
      oprot.writeFieldEnd()
7267 
    oprot.writeFieldStop()
7268 
    oprot.writeStructEnd()
7269 
 
7270 
  def validate(self):
7271 
    return
7272 
 
7273 
 
7274 
  def __repr__(self):
7275 
    L = ['%s=%r' % (key, value)
7276 
      for key, value in self.__dict__.iteritems()]
7277 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7278 
 
7279 
  def __eq__(self, other):
7280 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7281 
 
7282 
  def __ne__(self, other):
7283 
    return not (self == other)
7284 
 
7285 
class addVendorItemPricing_args:
7286 
  """
7287 
  Attributes:
7288 
   - vendorItemPricing
7289 
  """
7290 
 
7291 
  thrift_spec = (
7292 
    None, # 0
7293 
    (1, TType.STRUCT, 'vendorItemPricing', (VendorItemPricing, VendorItemPricing.thrift_spec), None, ), # 1
7294 
  )
7295 
 
7296 
  def __init__(self, vendorItemPricing=None,):
7297 
    self.vendorItemPricing = vendorItemPricing
7298 
 
7299 
  def read(self, iprot):
7300 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7301 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7302 
      return
7303 
    iprot.readStructBegin()
7304 
    while True:
7305 
      (fname, ftype, fid) = iprot.readFieldBegin()
7306 
      if ftype == TType.STOP:
7307 
        break
7308 
      if fid == 1:
7309 
        if ftype == TType.STRUCT:
7310 
          self.vendorItemPricing = VendorItemPricing()
7311 
          self.vendorItemPricing.read(iprot)
7312 
        else:
7313 
          iprot.skip(ftype)
7314 
      else:
7315 
        iprot.skip(ftype)
7316 
      iprot.readFieldEnd()
7317 
    iprot.readStructEnd()
7318 
 
7319 
  def write(self, oprot):
7320 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7321 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7322 
      return
7323 
    oprot.writeStructBegin('addVendorItemPricing_args')
7324 
    if self.vendorItemPricing is not None:
7325 
      oprot.writeFieldBegin('vendorItemPricing', TType.STRUCT, 1)
7326 
      self.vendorItemPricing.write(oprot)
7327 
      oprot.writeFieldEnd()
7328 
    oprot.writeFieldStop()
7329 
    oprot.writeStructEnd()
7330 
 
7331 
  def validate(self):
7332 
    return
7333 
 
7334 
 
7335 
  def __repr__(self):
7336 
    L = ['%s=%r' % (key, value)
7337 
      for key, value in self.__dict__.iteritems()]
7338 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7339 
 
7340 
  def __eq__(self, other):
7341 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7342 
 
7343 
  def __ne__(self, other):
7344 
    return not (self == other)
7345 
 
7346 
class addVendorItemPricing_result:
7347 
  """
7348 
  Attributes:
7349 
   - cex
7350 
  """
7351 
 
7352 
  thrift_spec = (
7353 
    None, # 0
7354 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
7355 
  )
7356 
 
7357 
  def __init__(self, cex=None,):
7358 
    self.cex = cex
7359 
 
7360 
  def read(self, iprot):
7361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7363 
      return
7364 
    iprot.readStructBegin()
7365 
    while True:
7366 
      (fname, ftype, fid) = iprot.readFieldBegin()
7367 
      if ftype == TType.STOP:
7368 
        break
7369 
      if fid == 1:
7370 
        if ftype == TType.STRUCT:
7371 
          self.cex = InventoryServiceException()
7372 
          self.cex.read(iprot)
7373 
        else:
7374 
          iprot.skip(ftype)
7375 
      else:
7376 
        iprot.skip(ftype)
7377 
      iprot.readFieldEnd()
7378 
    iprot.readStructEnd()
7379 
 
7380 
  def write(self, oprot):
7381 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7382 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7383 
      return
7384 
    oprot.writeStructBegin('addVendorItemPricing_result')
7385 
    if self.cex is not None:
7386 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7387 
      self.cex.write(oprot)
7388 
      oprot.writeFieldEnd()
7389 
    oprot.writeFieldStop()
7390 
    oprot.writeStructEnd()
7391 
 
7392 
  def validate(self):
7393 
    return
7394 
 
7395 
 
7396 
  def __repr__(self):
7397 
    L = ['%s=%r' % (key, value)
7398 
      for key, value in self.__dict__.iteritems()]
7399 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7400 
 
7401 
  def __eq__(self, other):
7402 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7403 
 
7404 
  def __ne__(self, other):
7405 
    return not (self == other)
7406 
 
7407 
class getVendor_args:
7408 
  """
7409 
  Attributes:
7410 
   - vendorId
7411 
  """
7412 
 
7413 
  thrift_spec = (
7414 
    None, # 0
7415 
    (1, TType.I64, 'vendorId', None, None, ), # 1
7416 
  )
7417 
 
7418 
  def __init__(self, vendorId=None,):
7419 
    self.vendorId = vendorId
7420 
 
7421 
  def read(self, iprot):
7422 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7423 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7424 
      return
7425 
    iprot.readStructBegin()
7426 
    while True:
7427 
      (fname, ftype, fid) = iprot.readFieldBegin()
7428 
      if ftype == TType.STOP:
7429 
        break
7430 
      if fid == 1:
7431 
        if ftype == TType.I64:
7432 
          self.vendorId = iprot.readI64();
7433 
        else:
7434 
          iprot.skip(ftype)
7435 
      else:
7436 
        iprot.skip(ftype)
7437 
      iprot.readFieldEnd()
7438 
    iprot.readStructEnd()
7439 
 
7440 
  def write(self, oprot):
7441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7443 
      return
7444 
    oprot.writeStructBegin('getVendor_args')
7445 
    if self.vendorId is not None:
7446 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
7447 
      oprot.writeI64(self.vendorId)
7448 
      oprot.writeFieldEnd()
7449 
    oprot.writeFieldStop()
7450 
    oprot.writeStructEnd()
7451 
 
7452 
  def validate(self):
7453 
    return
7454 
 
7455 
 
7456 
  def __repr__(self):
7457 
    L = ['%s=%r' % (key, value)
7458 
      for key, value in self.__dict__.iteritems()]
7459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7460 
 
7461 
  def __eq__(self, other):
7462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7463 
 
7464 
  def __ne__(self, other):
7465 
    return not (self == other)
7466 
 
7467 
class getVendor_result:
7468 
  """
7469 
  Attributes:
7470 
   - success
7471 
  """
7472 
 
7473 
  thrift_spec = (
7474 
    (0, TType.STRUCT, 'success', (Vendor, Vendor.thrift_spec), None, ), # 0
7475 
  )
7476 
 
7477 
  def __init__(self, success=None,):
7478 
    self.success = success
7479 
 
7480 
  def read(self, iprot):
7481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7483 
      return
7484 
    iprot.readStructBegin()
7485 
    while True:
7486 
      (fname, ftype, fid) = iprot.readFieldBegin()
7487 
      if ftype == TType.STOP:
7488 
        break
7489 
      if fid == 0:
7490 
        if ftype == TType.STRUCT:
7491 
          self.success = Vendor()
7492 
          self.success.read(iprot)
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('getVendor_result')
7505 
    if self.success is not None:
7506 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7507 
      self.success.write(oprot)
7508 
      oprot.writeFieldEnd()
7509 
    oprot.writeFieldStop()
7510 
    oprot.writeStructEnd()
7511 
 
7512 
  def validate(self):
7513 
    return
7514 
 
7515 
 
7516 
  def __repr__(self):
7517 
    L = ['%s=%r' % (key, value)
7518 
      for key, value in self.__dict__.iteritems()]
7519 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7520 
 
7521 
  def __eq__(self, other):
7522 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7523 
 
7524 
  def __ne__(self, other):
7525 
    return not (self == other)
7526 
 
7527 
class getAllVendors_args:
7528 
 
7529 
  thrift_spec = (
7530 
  )
7531 
 
7532 
  def read(self, iprot):
7533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7535 
      return
7536 
    iprot.readStructBegin()
7537 
    while True:
7538 
      (fname, ftype, fid) = iprot.readFieldBegin()
7539 
      if ftype == TType.STOP:
7540 
        break
7541 
      else:
7542 
        iprot.skip(ftype)
7543 
      iprot.readFieldEnd()
7544 
    iprot.readStructEnd()
7545 
 
7546 
  def write(self, oprot):
7547 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7548 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7549 
      return
7550 
    oprot.writeStructBegin('getAllVendors_args')
7551 
    oprot.writeFieldStop()
7552 
    oprot.writeStructEnd()
7553 
 
7554 
  def validate(self):
7555 
    return
7556 
 
7557 
 
7558 
  def __repr__(self):
7559 
    L = ['%s=%r' % (key, value)
7560 
      for key, value in self.__dict__.iteritems()]
7561 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7562 
 
7563 
  def __eq__(self, other):
7564 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7565 
 
7566 
  def __ne__(self, other):
7567 
    return not (self == other)
7568 
 
7569 
class getAllVendors_result:
7570 
  """
7571 
  Attributes:
7572 
   - success
7573 
  """
7574 
 
7575 
  thrift_spec = (
7576 
    (0, TType.LIST, 'success', (TType.STRUCT,(Vendor, Vendor.thrift_spec)), None, ), # 0
7577 
  )
7578 
 
7579 
  def __init__(self, success=None,):
7580 
    self.success = success
7581 
 
7582 
  def read(self, iprot):
7583 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7584 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7585 
      return
7586 
    iprot.readStructBegin()
7587 
    while True:
7588 
      (fname, ftype, fid) = iprot.readFieldBegin()
7589 
      if ftype == TType.STOP:
7590 
        break
7591 
      if fid == 0:
7592 
        if ftype == TType.LIST:
7593 
          self.success = []
8182 amar.kumar 7594 
          (_etype76, _size73) = iprot.readListBegin()
7595 
          for _i77 in xrange(_size73):
7596 
            _elem78 = Vendor()
7597 
            _elem78.read(iprot)
7598 
            self.success.append(_elem78)
5944 mandeep.dh 7599 
          iprot.readListEnd()
7600 
        else:
7601 
          iprot.skip(ftype)
7602 
      else:
7603 
        iprot.skip(ftype)
7604 
      iprot.readFieldEnd()
7605 
    iprot.readStructEnd()
7606 
 
7607 
  def write(self, oprot):
7608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7610 
      return
7611 
    oprot.writeStructBegin('getAllVendors_result')
7612 
    if self.success is not None:
7613 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7614 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 7615 
      for iter79 in self.success:
7616 
        iter79.write(oprot)
5944 mandeep.dh 7617 
      oprot.writeListEnd()
7618 
      oprot.writeFieldEnd()
7619 
    oprot.writeFieldStop()
7620 
    oprot.writeStructEnd()
7621 
 
7622 
  def validate(self):
7623 
    return
7624 
 
7625 
 
7626 
  def __repr__(self):
7627 
    L = ['%s=%r' % (key, value)
7628 
      for key, value in self.__dict__.iteritems()]
7629 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7630 
 
7631 
  def __eq__(self, other):
7632 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7633 
 
7634 
  def __ne__(self, other):
7635 
    return not (self == other)
7636 
 
7637 
class addVendorItemMapping_args:
7638 
  """
7639 
  Attributes:
7640 
   - key
7641 
   - vendorItemMapping
7642 
  """
7643 
 
7644 
  thrift_spec = (
7645 
    None, # 0
7646 
    (1, TType.STRING, 'key', None, None, ), # 1
7647 
    (2, TType.STRUCT, 'vendorItemMapping', (VendorItemMapping, VendorItemMapping.thrift_spec), None, ), # 2
7648 
  )
7649 
 
7650 
  def __init__(self, key=None, vendorItemMapping=None,):
7651 
    self.key = key
7652 
    self.vendorItemMapping = vendorItemMapping
7653 
 
7654 
  def read(self, iprot):
7655 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7656 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7657 
      return
7658 
    iprot.readStructBegin()
7659 
    while True:
7660 
      (fname, ftype, fid) = iprot.readFieldBegin()
7661 
      if ftype == TType.STOP:
7662 
        break
7663 
      if fid == 1:
7664 
        if ftype == TType.STRING:
7665 
          self.key = iprot.readString();
7666 
        else:
7667 
          iprot.skip(ftype)
7668 
      elif fid == 2:
7669 
        if ftype == TType.STRUCT:
7670 
          self.vendorItemMapping = VendorItemMapping()
7671 
          self.vendorItemMapping.read(iprot)
7672 
        else:
7673 
          iprot.skip(ftype)
7674 
      else:
7675 
        iprot.skip(ftype)
7676 
      iprot.readFieldEnd()
7677 
    iprot.readStructEnd()
7678 
 
7679 
  def write(self, oprot):
7680 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7681 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7682 
      return
7683 
    oprot.writeStructBegin('addVendorItemMapping_args')
7684 
    if self.key is not None:
7685 
      oprot.writeFieldBegin('key', TType.STRING, 1)
7686 
      oprot.writeString(self.key)
7687 
      oprot.writeFieldEnd()
7688 
    if self.vendorItemMapping is not None:
7689 
      oprot.writeFieldBegin('vendorItemMapping', TType.STRUCT, 2)
7690 
      self.vendorItemMapping.write(oprot)
7691 
      oprot.writeFieldEnd()
7692 
    oprot.writeFieldStop()
7693 
    oprot.writeStructEnd()
7694 
 
7695 
  def validate(self):
7696 
    return
7697 
 
7698 
 
7699 
  def __repr__(self):
7700 
    L = ['%s=%r' % (key, value)
7701 
      for key, value in self.__dict__.iteritems()]
7702 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7703 
 
7704 
  def __eq__(self, other):
7705 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7706 
 
7707 
  def __ne__(self, other):
7708 
    return not (self == other)
7709 
 
7710 
class addVendorItemMapping_result:
7711 
  """
7712 
  Attributes:
7713 
   - cex
7714 
  """
7715 
 
7716 
  thrift_spec = (
7717 
    None, # 0
7718 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
7719 
  )
7720 
 
7721 
  def __init__(self, cex=None,):
7722 
    self.cex = cex
7723 
 
7724 
  def read(self, iprot):
7725 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7726 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7727 
      return
7728 
    iprot.readStructBegin()
7729 
    while True:
7730 
      (fname, ftype, fid) = iprot.readFieldBegin()
7731 
      if ftype == TType.STOP:
7732 
        break
7733 
      if fid == 1:
7734 
        if ftype == TType.STRUCT:
7735 
          self.cex = InventoryServiceException()
7736 
          self.cex.read(iprot)
7737 
        else:
7738 
          iprot.skip(ftype)
7739 
      else:
7740 
        iprot.skip(ftype)
7741 
      iprot.readFieldEnd()
7742 
    iprot.readStructEnd()
7743 
 
7744 
  def write(self, oprot):
7745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7747 
      return
7748 
    oprot.writeStructBegin('addVendorItemMapping_result')
7749 
    if self.cex is not None:
7750 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7751 
      self.cex.write(oprot)
7752 
      oprot.writeFieldEnd()
7753 
    oprot.writeFieldStop()
7754 
    oprot.writeStructEnd()
7755 
 
7756 
  def validate(self):
7757 
    return
7758 
 
7759 
 
7760 
  def __repr__(self):
7761 
    L = ['%s=%r' % (key, value)
7762 
      for key, value in self.__dict__.iteritems()]
7763 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7764 
 
7765 
  def __eq__(self, other):
7766 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7767 
 
7768 
  def __ne__(self, other):
7769 
    return not (self == other)
7770 
 
7771 
class getVendorItemMappings_args:
7772 
  """
7773 
  Attributes:
7774 
   - itemId
7775 
  """
7776 
 
7777 
  thrift_spec = (
7778 
    None, # 0
7779 
    (1, TType.I64, 'itemId', None, None, ), # 1
7780 
  )
7781 
 
7782 
  def __init__(self, itemId=None,):
7783 
    self.itemId = itemId
7784 
 
7785 
  def read(self, iprot):
7786 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7787 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7788 
      return
7789 
    iprot.readStructBegin()
7790 
    while True:
7791 
      (fname, ftype, fid) = iprot.readFieldBegin()
7792 
      if ftype == TType.STOP:
7793 
        break
7794 
      if fid == 1:
7795 
        if ftype == TType.I64:
7796 
          self.itemId = iprot.readI64();
7797 
        else:
7798 
          iprot.skip(ftype)
7799 
      else:
7800 
        iprot.skip(ftype)
7801 
      iprot.readFieldEnd()
7802 
    iprot.readStructEnd()
7803 
 
7804 
  def write(self, oprot):
7805 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7806 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7807 
      return
7808 
    oprot.writeStructBegin('getVendorItemMappings_args')
7809 
    if self.itemId is not None:
7810 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
7811 
      oprot.writeI64(self.itemId)
7812 
      oprot.writeFieldEnd()
7813 
    oprot.writeFieldStop()
7814 
    oprot.writeStructEnd()
7815 
 
7816 
  def validate(self):
7817 
    return
7818 
 
7819 
 
7820 
  def __repr__(self):
7821 
    L = ['%s=%r' % (key, value)
7822 
      for key, value in self.__dict__.iteritems()]
7823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7824 
 
7825 
  def __eq__(self, other):
7826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7827 
 
7828 
  def __ne__(self, other):
7829 
    return not (self == other)
7830 
 
7831 
class getVendorItemMappings_result:
7832 
  """
7833 
  Attributes:
7834 
   - success
7835 
   - cex
7836 
  """
7837 
 
7838 
  thrift_spec = (
7839 
    (0, TType.LIST, 'success', (TType.STRUCT,(VendorItemMapping, VendorItemMapping.thrift_spec)), None, ), # 0
7840 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
7841 
  )
7842 
 
7843 
  def __init__(self, success=None, cex=None,):
7844 
    self.success = success
7845 
    self.cex = cex
7846 
 
7847 
  def read(self, iprot):
7848 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7849 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7850 
      return
7851 
    iprot.readStructBegin()
7852 
    while True:
7853 
      (fname, ftype, fid) = iprot.readFieldBegin()
7854 
      if ftype == TType.STOP:
7855 
        break
7856 
      if fid == 0:
7857 
        if ftype == TType.LIST:
7858 
          self.success = []
8182 amar.kumar 7859 
          (_etype83, _size80) = iprot.readListBegin()
7860 
          for _i84 in xrange(_size80):
7861 
            _elem85 = VendorItemMapping()
7862 
            _elem85.read(iprot)
7863 
            self.success.append(_elem85)
5944 mandeep.dh 7864 
          iprot.readListEnd()
7865 
        else:
7866 
          iprot.skip(ftype)
7867 
      elif fid == 1:
7868 
        if ftype == TType.STRUCT:
7869 
          self.cex = InventoryServiceException()
7870 
          self.cex.read(iprot)
7871 
        else:
7872 
          iprot.skip(ftype)
7873 
      else:
7874 
        iprot.skip(ftype)
7875 
      iprot.readFieldEnd()
7876 
    iprot.readStructEnd()
7877 
 
7878 
  def write(self, oprot):
7879 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7880 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7881 
      return
7882 
    oprot.writeStructBegin('getVendorItemMappings_result')
7883 
    if self.success is not None:
7884 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7885 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 7886 
      for iter86 in self.success:
7887 
        iter86.write(oprot)
5944 mandeep.dh 7888 
      oprot.writeListEnd()
7889 
      oprot.writeFieldEnd()
7890 
    if self.cex is not None:
7891 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7892 
      self.cex.write(oprot)
7893 
      oprot.writeFieldEnd()
7894 
    oprot.writeFieldStop()
7895 
    oprot.writeStructEnd()
7896 
 
7897 
  def validate(self):
7898 
    return
7899 
 
7900 
 
7901 
  def __repr__(self):
7902 
    L = ['%s=%r' % (key, value)
7903 
      for key, value in self.__dict__.iteritems()]
7904 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7905 
 
7906 
  def __eq__(self, other):
7907 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7908 
 
7909 
  def __ne__(self, other):
7910 
    return not (self == other)
7911 
 
7912 
class getPendingOrdersInventory_args:
7913 
  """
7914 
  Attributes:
7915 
   - vendorid
7916 
  """
7917 
 
7918 
  thrift_spec = (
7919 
    None, # 0
7920 
    (1, TType.I64, 'vendorid', None, None, ), # 1
7921 
  )
7922 
 
7923 
  def __init__(self, vendorid=None,):
7924 
    self.vendorid = vendorid
7925 
 
7926 
  def read(self, iprot):
7927 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7928 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7929 
      return
7930 
    iprot.readStructBegin()
7931 
    while True:
7932 
      (fname, ftype, fid) = iprot.readFieldBegin()
7933 
      if ftype == TType.STOP:
7934 
        break
7935 
      if fid == 1:
7936 
        if ftype == TType.I64:
7937 
          self.vendorid = iprot.readI64();
7938 
        else:
7939 
          iprot.skip(ftype)
7940 
      else:
7941 
        iprot.skip(ftype)
7942 
      iprot.readFieldEnd()
7943 
    iprot.readStructEnd()
7944 
 
7945 
  def write(self, oprot):
7946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7948 
      return
7949 
    oprot.writeStructBegin('getPendingOrdersInventory_args')
7950 
    if self.vendorid is not None:
7951 
      oprot.writeFieldBegin('vendorid', TType.I64, 1)
7952 
      oprot.writeI64(self.vendorid)
7953 
      oprot.writeFieldEnd()
7954 
    oprot.writeFieldStop()
7955 
    oprot.writeStructEnd()
7956 
 
7957 
  def validate(self):
7958 
    return
7959 
 
7960 
 
7961 
  def __repr__(self):
7962 
    L = ['%s=%r' % (key, value)
7963 
      for key, value in self.__dict__.iteritems()]
7964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7965 
 
7966 
  def __eq__(self, other):
7967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7968 
 
7969 
  def __ne__(self, other):
7970 
    return not (self == other)
7971 
 
7972 
class getPendingOrdersInventory_result:
7973 
  """
7974 
  Attributes:
7975 
   - success
7976 
  """
7977 
 
7978 
  thrift_spec = (
7979 
    (0, TType.LIST, 'success', (TType.STRUCT,(AvailableAndReservedStock, AvailableAndReservedStock.thrift_spec)), None, ), # 0
7980 
  )
7981 
 
7982 
  def __init__(self, success=None,):
7983 
    self.success = success
7984 
 
7985 
  def read(self, iprot):
7986 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7987 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7988 
      return
7989 
    iprot.readStructBegin()
7990 
    while True:
7991 
      (fname, ftype, fid) = iprot.readFieldBegin()
7992 
      if ftype == TType.STOP:
7993 
        break
7994 
      if fid == 0:
7995 
        if ftype == TType.LIST:
7996 
          self.success = []
8182 amar.kumar 7997 
          (_etype90, _size87) = iprot.readListBegin()
7998 
          for _i91 in xrange(_size87):
7999 
            _elem92 = AvailableAndReservedStock()
8000 
            _elem92.read(iprot)
8001 
            self.success.append(_elem92)
5944 mandeep.dh 8002 
          iprot.readListEnd()
8003 
        else:
8004 
          iprot.skip(ftype)
8005 
      else:
8006 
        iprot.skip(ftype)
8007 
      iprot.readFieldEnd()
8008 
    iprot.readStructEnd()
8009 
 
8010 
  def write(self, oprot):
8011 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8012 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8013 
      return
8014 
    oprot.writeStructBegin('getPendingOrdersInventory_result')
8015 
    if self.success is not None:
8016 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8017 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 8018 
      for iter93 in self.success:
8019 
        iter93.write(oprot)
5944 mandeep.dh 8020 
      oprot.writeListEnd()
8021 
      oprot.writeFieldEnd()
8022 
    oprot.writeFieldStop()
8023 
    oprot.writeStructEnd()
8024 
 
8025 
  def validate(self):
8026 
    return
8027 
 
8028 
 
8029 
  def __repr__(self):
8030 
    L = ['%s=%r' % (key, value)
8031 
      for key, value in self.__dict__.iteritems()]
8032 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8033 
 
8034 
  def __eq__(self, other):
8035 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8036 
 
8037 
  def __ne__(self, other):
8038 
    return not (self == other)
8039 
 
8040 
class getWarehouses_args:
8041 
  """
8042 
  Attributes:
8043 
   - warehouseType
8044 
   - inventoryType
8045 
   - vendorId
8046 
   - billingWarehouseId
8047 
   - shippingWarehouseId
8048 
  """
8049 
 
8050 
  thrift_spec = (
8051 
    None, # 0
8052 
    (1, TType.I32, 'warehouseType', None, None, ), # 1
8053 
    (2, TType.I32, 'inventoryType', None, None, ), # 2
8054 
    (3, TType.I64, 'vendorId', None, None, ), # 3
8055 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
8056 
    (5, TType.I64, 'shippingWarehouseId', None, None, ), # 5
8057 
  )
8058 
 
8059 
  def __init__(self, warehouseType=None, inventoryType=None, vendorId=None, billingWarehouseId=None, shippingWarehouseId=None,):
8060 
    self.warehouseType = warehouseType
8061 
    self.inventoryType = inventoryType
8062 
    self.vendorId = vendorId
8063 
    self.billingWarehouseId = billingWarehouseId
8064 
    self.shippingWarehouseId = shippingWarehouseId
8065 
 
8066 
  def read(self, iprot):
8067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8069 
      return
8070 
    iprot.readStructBegin()
8071 
    while True:
8072 
      (fname, ftype, fid) = iprot.readFieldBegin()
8073 
      if ftype == TType.STOP:
8074 
        break
8075 
      if fid == 1:
8076 
        if ftype == TType.I32:
8077 
          self.warehouseType = iprot.readI32();
8078 
        else:
8079 
          iprot.skip(ftype)
8080 
      elif fid == 2:
8081 
        if ftype == TType.I32:
8082 
          self.inventoryType = iprot.readI32();
8083 
        else:
8084 
          iprot.skip(ftype)
8085 
      elif fid == 3:
8086 
        if ftype == TType.I64:
8087 
          self.vendorId = iprot.readI64();
8088 
        else:
8089 
          iprot.skip(ftype)
8090 
      elif fid == 4:
8091 
        if ftype == TType.I64:
8092 
          self.billingWarehouseId = iprot.readI64();
8093 
        else:
8094 
          iprot.skip(ftype)
8095 
      elif fid == 5:
8096 
        if ftype == TType.I64:
8097 
          self.shippingWarehouseId = iprot.readI64();
8098 
        else:
8099 
          iprot.skip(ftype)
8100 
      else:
8101 
        iprot.skip(ftype)
8102 
      iprot.readFieldEnd()
8103 
    iprot.readStructEnd()
8104 
 
8105 
  def write(self, oprot):
8106 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8107 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8108 
      return
8109 
    oprot.writeStructBegin('getWarehouses_args')
8110 
    if self.warehouseType is not None:
8111 
      oprot.writeFieldBegin('warehouseType', TType.I32, 1)
8112 
      oprot.writeI32(self.warehouseType)
8113 
      oprot.writeFieldEnd()
8114 
    if self.inventoryType is not None:
8115 
      oprot.writeFieldBegin('inventoryType', TType.I32, 2)
8116 
      oprot.writeI32(self.inventoryType)
8117 
      oprot.writeFieldEnd()
8118 
    if self.vendorId is not None:
8119 
      oprot.writeFieldBegin('vendorId', TType.I64, 3)
8120 
      oprot.writeI64(self.vendorId)
8121 
      oprot.writeFieldEnd()
8122 
    if self.billingWarehouseId is not None:
8123 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
8124 
      oprot.writeI64(self.billingWarehouseId)
8125 
      oprot.writeFieldEnd()
8126 
    if self.shippingWarehouseId is not None:
8127 
      oprot.writeFieldBegin('shippingWarehouseId', TType.I64, 5)
8128 
      oprot.writeI64(self.shippingWarehouseId)
8129 
      oprot.writeFieldEnd()
8130 
    oprot.writeFieldStop()
8131 
    oprot.writeStructEnd()
8132 
 
8133 
  def validate(self):
8134 
    return
8135 
 
8136 
 
8137 
  def __repr__(self):
8138 
    L = ['%s=%r' % (key, value)
8139 
      for key, value in self.__dict__.iteritems()]
8140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8141 
 
8142 
  def __eq__(self, other):
8143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8144 
 
8145 
  def __ne__(self, other):
8146 
    return not (self == other)
8147 
 
8148 
class getWarehouses_result:
8149 
  """
8150 
  Attributes:
8151 
   - success
8152 
  """
8153 
 
8154 
  thrift_spec = (
8155 
    (0, TType.LIST, 'success', (TType.STRUCT,(Warehouse, Warehouse.thrift_spec)), None, ), # 0
8156 
  )
8157 
 
8158 
  def __init__(self, success=None,):
8159 
    self.success = success
8160 
 
8161 
  def read(self, iprot):
8162 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8163 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8164 
      return
8165 
    iprot.readStructBegin()
8166 
    while True:
8167 
      (fname, ftype, fid) = iprot.readFieldBegin()
8168 
      if ftype == TType.STOP:
8169 
        break
8170 
      if fid == 0:
8171 
        if ftype == TType.LIST:
8172 
          self.success = []
8182 amar.kumar 8173 
          (_etype97, _size94) = iprot.readListBegin()
8174 
          for _i98 in xrange(_size94):
8175 
            _elem99 = Warehouse()
8176 
            _elem99.read(iprot)
8177 
            self.success.append(_elem99)
5944 mandeep.dh 8178 
          iprot.readListEnd()
8179 
        else:
8180 
          iprot.skip(ftype)
8181 
      else:
8182 
        iprot.skip(ftype)
8183 
      iprot.readFieldEnd()
8184 
    iprot.readStructEnd()
8185 
 
8186 
  def write(self, oprot):
8187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8189 
      return
8190 
    oprot.writeStructBegin('getWarehouses_result')
8191 
    if self.success is not None:
8192 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8193 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 8194 
      for iter100 in self.success:
8195 
        iter100.write(oprot)
5944 mandeep.dh 8196 
      oprot.writeListEnd()
8197 
      oprot.writeFieldEnd()
8198 
    oprot.writeFieldStop()
8199 
    oprot.writeStructEnd()
8200 
 
8201 
  def validate(self):
8202 
    return
8203 
 
8204 
 
8205 
  def __repr__(self):
8206 
    L = ['%s=%r' % (key, value)
8207 
      for key, value in self.__dict__.iteritems()]
8208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8209 
 
8210 
  def __eq__(self, other):
8211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8212 
 
8213 
  def __ne__(self, other):
8214 
    return not (self == other)
8215 
 
8216 
class resetAvailability_args:
8217 
  """
8218 
  Attributes:
8219 
   - itemKey
8220 
   - vendorId
8221 
   - quantity
8222 
   - warehouseId
8223 
  """
8224 
 
8225 
  thrift_spec = (
8226 
    None, # 0
8227 
    (1, TType.STRING, 'itemKey', None, None, ), # 1
8228 
    (2, TType.I64, 'vendorId', None, None, ), # 2
8229 
    (3, TType.I64, 'quantity', None, None, ), # 3
8230 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
8231 
  )
8232 
 
8233 
  def __init__(self, itemKey=None, vendorId=None, quantity=None, warehouseId=None,):
8234 
    self.itemKey = itemKey
8235 
    self.vendorId = vendorId
8236 
    self.quantity = quantity
8237 
    self.warehouseId = warehouseId
8238 
 
8239 
  def read(self, iprot):
8240 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8241 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8242 
      return
8243 
    iprot.readStructBegin()
8244 
    while True:
8245 
      (fname, ftype, fid) = iprot.readFieldBegin()
8246 
      if ftype == TType.STOP:
8247 
        break
8248 
      if fid == 1:
8249 
        if ftype == TType.STRING:
8250 
          self.itemKey = iprot.readString();
8251 
        else:
8252 
          iprot.skip(ftype)
8253 
      elif fid == 2:
8254 
        if ftype == TType.I64:
8255 
          self.vendorId = iprot.readI64();
8256 
        else:
8257 
          iprot.skip(ftype)
8258 
      elif fid == 3:
8259 
        if ftype == TType.I64:
8260 
          self.quantity = iprot.readI64();
8261 
        else:
8262 
          iprot.skip(ftype)
8263 
      elif fid == 4:
8264 
        if ftype == TType.I64:
8265 
          self.warehouseId = iprot.readI64();
8266 
        else:
8267 
          iprot.skip(ftype)
8268 
      else:
8269 
        iprot.skip(ftype)
8270 
      iprot.readFieldEnd()
8271 
    iprot.readStructEnd()
8272 
 
8273 
  def write(self, oprot):
8274 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8275 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8276 
      return
8277 
    oprot.writeStructBegin('resetAvailability_args')
8278 
    if self.itemKey is not None:
8279 
      oprot.writeFieldBegin('itemKey', TType.STRING, 1)
8280 
      oprot.writeString(self.itemKey)
8281 
      oprot.writeFieldEnd()
8282 
    if self.vendorId is not None:
8283 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
8284 
      oprot.writeI64(self.vendorId)
8285 
      oprot.writeFieldEnd()
8286 
    if self.quantity is not None:
8287 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
8288 
      oprot.writeI64(self.quantity)
8289 
      oprot.writeFieldEnd()
8290 
    if self.warehouseId is not None:
8291 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
8292 
      oprot.writeI64(self.warehouseId)
8293 
      oprot.writeFieldEnd()
8294 
    oprot.writeFieldStop()
8295 
    oprot.writeStructEnd()
8296 
 
8297 
  def validate(self):
8298 
    return
8299 
 
8300 
 
8301 
  def __repr__(self):
8302 
    L = ['%s=%r' % (key, value)
8303 
      for key, value in self.__dict__.iteritems()]
8304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8305 
 
8306 
  def __eq__(self, other):
8307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8308 
 
8309 
  def __ne__(self, other):
8310 
    return not (self == other)
8311 
 
8312 
class resetAvailability_result:
8313 
  """
8314 
  Attributes:
8315 
   - cex
8316 
  """
8317 
 
8318 
  thrift_spec = (
8319 
    None, # 0
8320 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
8321 
  )
8322 
 
8323 
  def __init__(self, cex=None,):
8324 
    self.cex = cex
8325 
 
8326 
  def read(self, iprot):
8327 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8328 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8329 
      return
8330 
    iprot.readStructBegin()
8331 
    while True:
8332 
      (fname, ftype, fid) = iprot.readFieldBegin()
8333 
      if ftype == TType.STOP:
8334 
        break
8335 
      if fid == 1:
8336 
        if ftype == TType.STRUCT:
8337 
          self.cex = InventoryServiceException()
8338 
          self.cex.read(iprot)
8339 
        else:
8340 
          iprot.skip(ftype)
8341 
      else:
8342 
        iprot.skip(ftype)
8343 
      iprot.readFieldEnd()
8344 
    iprot.readStructEnd()
8345 
 
8346 
  def write(self, oprot):
8347 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8348 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8349 
      return
8350 
    oprot.writeStructBegin('resetAvailability_result')
8351 
    if self.cex is not None:
8352 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8353 
      self.cex.write(oprot)
8354 
      oprot.writeFieldEnd()
8355 
    oprot.writeFieldStop()
8356 
    oprot.writeStructEnd()
8357 
 
8358 
  def validate(self):
8359 
    return
8360 
 
8361 
 
8362 
  def __repr__(self):
8363 
    L = ['%s=%r' % (key, value)
8364 
      for key, value in self.__dict__.iteritems()]
8365 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8366 
 
8367 
  def __eq__(self, other):
8368 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8369 
 
8370 
  def __ne__(self, other):
8371 
    return not (self == other)
8372 
 
8373 
class resetAvailabilityForWarehouse_args:
8374 
  """
8375 
  Attributes:
8376 
   - warehouseId
8377 
  """
8378 
 
8379 
  thrift_spec = (
8380 
    None, # 0
8381 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
8382 
  )
8383 
 
8384 
  def __init__(self, warehouseId=None,):
8385 
    self.warehouseId = warehouseId
8386 
 
8387 
  def read(self, iprot):
8388 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8389 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8390 
      return
8391 
    iprot.readStructBegin()
8392 
    while True:
8393 
      (fname, ftype, fid) = iprot.readFieldBegin()
8394 
      if ftype == TType.STOP:
8395 
        break
8396 
      if fid == 1:
8397 
        if ftype == TType.I64:
8398 
          self.warehouseId = iprot.readI64();
8399 
        else:
8400 
          iprot.skip(ftype)
8401 
      else:
8402 
        iprot.skip(ftype)
8403 
      iprot.readFieldEnd()
8404 
    iprot.readStructEnd()
8405 
 
8406 
  def write(self, oprot):
8407 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8408 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8409 
      return
8410 
    oprot.writeStructBegin('resetAvailabilityForWarehouse_args')
8411 
    if self.warehouseId is not None:
8412 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
8413 
      oprot.writeI64(self.warehouseId)
8414 
      oprot.writeFieldEnd()
8415 
    oprot.writeFieldStop()
8416 
    oprot.writeStructEnd()
8417 
 
8418 
  def validate(self):
8419 
    return
8420 
 
8421 
 
8422 
  def __repr__(self):
8423 
    L = ['%s=%r' % (key, value)
8424 
      for key, value in self.__dict__.iteritems()]
8425 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8426 
 
8427 
  def __eq__(self, other):
8428 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8429 
 
8430 
  def __ne__(self, other):
8431 
    return not (self == other)
8432 
 
8433 
class resetAvailabilityForWarehouse_result:
8434 
  """
8435 
  Attributes:
8436 
   - cex
8437 
  """
8438 
 
8439 
  thrift_spec = (
8440 
    None, # 0
8441 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
8442 
  )
8443 
 
8444 
  def __init__(self, cex=None,):
8445 
    self.cex = cex
8446 
 
8447 
  def read(self, iprot):
8448 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8449 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8450 
      return
8451 
    iprot.readStructBegin()
8452 
    while True:
8453 
      (fname, ftype, fid) = iprot.readFieldBegin()
8454 
      if ftype == TType.STOP:
8455 
        break
8456 
      if fid == 1:
8457 
        if ftype == TType.STRUCT:
8458 
          self.cex = InventoryServiceException()
8459 
          self.cex.read(iprot)
8460 
        else:
8461 
          iprot.skip(ftype)
8462 
      else:
8463 
        iprot.skip(ftype)
8464 
      iprot.readFieldEnd()
8465 
    iprot.readStructEnd()
8466 
 
8467 
  def write(self, oprot):
8468 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8469 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8470 
      return
8471 
    oprot.writeStructBegin('resetAvailabilityForWarehouse_result')
8472 
    if self.cex is not None:
8473 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8474 
      self.cex.write(oprot)
8475 
      oprot.writeFieldEnd()
8476 
    oprot.writeFieldStop()
8477 
    oprot.writeStructEnd()
8478 
 
8479 
  def validate(self):
8480 
    return
8481 
 
8482 
 
8483 
  def __repr__(self):
8484 
    L = ['%s=%r' % (key, value)
8485 
      for key, value in self.__dict__.iteritems()]
8486 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8487 
 
8488 
  def __eq__(self, other):
8489 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8490 
 
8491 
  def __ne__(self, other):
8492 
    return not (self == other)
8493 
 
8494 
class getItemKeysToBeProcessed_args:
8495 
  """
8496 
  Attributes:
8497 
   - warehouseId
8498 
  """
8499 
 
8500 
  thrift_spec = (
8501 
    None, # 0
8502 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
8503 
  )
8504 
 
8505 
  def __init__(self, warehouseId=None,):
8506 
    self.warehouseId = warehouseId
8507 
 
8508 
  def read(self, iprot):
8509 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8510 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8511 
      return
8512 
    iprot.readStructBegin()
8513 
    while True:
8514 
      (fname, ftype, fid) = iprot.readFieldBegin()
8515 
      if ftype == TType.STOP:
8516 
        break
8517 
      if fid == 1:
8518 
        if ftype == TType.I64:
8519 
          self.warehouseId = iprot.readI64();
8520 
        else:
8521 
          iprot.skip(ftype)
8522 
      else:
8523 
        iprot.skip(ftype)
8524 
      iprot.readFieldEnd()
8525 
    iprot.readStructEnd()
8526 
 
8527 
  def write(self, oprot):
8528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8530 
      return
8531 
    oprot.writeStructBegin('getItemKeysToBeProcessed_args')
8532 
    if self.warehouseId is not None:
8533 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
8534 
      oprot.writeI64(self.warehouseId)
8535 
      oprot.writeFieldEnd()
8536 
    oprot.writeFieldStop()
8537 
    oprot.writeStructEnd()
8538 
 
8539 
  def validate(self):
8540 
    return
8541 
 
8542 
 
8543 
  def __repr__(self):
8544 
    L = ['%s=%r' % (key, value)
8545 
      for key, value in self.__dict__.iteritems()]
8546 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8547 
 
8548 
  def __eq__(self, other):
8549 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8550 
 
8551 
  def __ne__(self, other):
8552 
    return not (self == other)
8553 
 
8554 
class getItemKeysToBeProcessed_result:
8555 
  """
8556 
  Attributes:
8557 
   - success
8558 
  """
8559 
 
8560 
  thrift_spec = (
8561 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
8562 
  )
8563 
 
8564 
  def __init__(self, success=None,):
8565 
    self.success = success
8566 
 
8567 
  def read(self, iprot):
8568 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8569 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8570 
      return
8571 
    iprot.readStructBegin()
8572 
    while True:
8573 
      (fname, ftype, fid) = iprot.readFieldBegin()
8574 
      if ftype == TType.STOP:
8575 
        break
8576 
      if fid == 0:
8577 
        if ftype == TType.LIST:
8578 
          self.success = []
8182 amar.kumar 8579 
          (_etype104, _size101) = iprot.readListBegin()
8580 
          for _i105 in xrange(_size101):
8581 
            _elem106 = iprot.readString();
8582 
            self.success.append(_elem106)
5944 mandeep.dh 8583 
          iprot.readListEnd()
8584 
        else:
8585 
          iprot.skip(ftype)
8586 
      else:
8587 
        iprot.skip(ftype)
8588 
      iprot.readFieldEnd()
8589 
    iprot.readStructEnd()
8590 
 
8591 
  def write(self, oprot):
8592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8594 
      return
8595 
    oprot.writeStructBegin('getItemKeysToBeProcessed_result')
8596 
    if self.success is not None:
8597 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8598 
      oprot.writeListBegin(TType.STRING, len(self.success))
8182 amar.kumar 8599 
      for iter107 in self.success:
8600 
        oprot.writeString(iter107)
5944 mandeep.dh 8601 
      oprot.writeListEnd()
8602 
      oprot.writeFieldEnd()
8603 
    oprot.writeFieldStop()
8604 
    oprot.writeStructEnd()
8605 
 
8606 
  def validate(self):
8607 
    return
8608 
 
8609 
 
8610 
  def __repr__(self):
8611 
    L = ['%s=%r' % (key, value)
8612 
      for key, value in self.__dict__.iteritems()]
8613 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8614 
 
8615 
  def __eq__(self, other):
8616 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8617 
 
8618 
  def __ne__(self, other):
8619 
    return not (self == other)
8620 
 
8621 
class markMissedInventoryUpdatesAsProcessed_args:
8622 
  """
8623 
  Attributes:
8624 
   - itemKey
8625 
   - warehouseId
8626 
  """
8627 
 
8628 
  thrift_spec = (
8629 
    None, # 0
8630 
    (1, TType.STRING, 'itemKey', None, None, ), # 1
8631 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8632 
  )
8633 
 
8634 
  def __init__(self, itemKey=None, warehouseId=None,):
8635 
    self.itemKey = itemKey
8636 
    self.warehouseId = warehouseId
8637 
 
8638 
  def read(self, iprot):
8639 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8640 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8641 
      return
8642 
    iprot.readStructBegin()
8643 
    while True:
8644 
      (fname, ftype, fid) = iprot.readFieldBegin()
8645 
      if ftype == TType.STOP:
8646 
        break
8647 
      if fid == 1:
8648 
        if ftype == TType.STRING:
8649 
          self.itemKey = iprot.readString();
8650 
        else:
8651 
          iprot.skip(ftype)
8652 
      elif fid == 2:
8653 
        if ftype == TType.I64:
8654 
          self.warehouseId = iprot.readI64();
8655 
        else:
8656 
          iprot.skip(ftype)
8657 
      else:
8658 
        iprot.skip(ftype)
8659 
      iprot.readFieldEnd()
8660 
    iprot.readStructEnd()
8661 
 
8662 
  def write(self, oprot):
8663 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8664 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8665 
      return
8666 
    oprot.writeStructBegin('markMissedInventoryUpdatesAsProcessed_args')
8667 
    if self.itemKey is not None:
8668 
      oprot.writeFieldBegin('itemKey', TType.STRING, 1)
8669 
      oprot.writeString(self.itemKey)
8670 
      oprot.writeFieldEnd()
8671 
    if self.warehouseId is not None:
8672 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8673 
      oprot.writeI64(self.warehouseId)
8674 
      oprot.writeFieldEnd()
8675 
    oprot.writeFieldStop()
8676 
    oprot.writeStructEnd()
8677 
 
8678 
  def validate(self):
8679 
    return
8680 
 
8681 
 
8682 
  def __repr__(self):
8683 
    L = ['%s=%r' % (key, value)
8684 
      for key, value in self.__dict__.iteritems()]
8685 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8686 
 
8687 
  def __eq__(self, other):
8688 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8689 
 
8690 
  def __ne__(self, other):
8691 
    return not (self == other)
8692 
 
8693 
class markMissedInventoryUpdatesAsProcessed_result:
8694 
 
8695 
  thrift_spec = (
8696 
  )
8697 
 
8698 
  def read(self, iprot):
8699 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8700 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8701 
      return
8702 
    iprot.readStructBegin()
8703 
    while True:
8704 
      (fname, ftype, fid) = iprot.readFieldBegin()
8705 
      if ftype == TType.STOP:
8706 
        break
8707 
      else:
8708 
        iprot.skip(ftype)
8709 
      iprot.readFieldEnd()
8710 
    iprot.readStructEnd()
8711 
 
8712 
  def write(self, oprot):
8713 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8714 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8715 
      return
8716 
    oprot.writeStructBegin('markMissedInventoryUpdatesAsProcessed_result')
8717 
    oprot.writeFieldStop()
8718 
    oprot.writeStructEnd()
8719 
 
8720 
  def validate(self):
8721 
    return
8722 
 
8723 
 
8724 
  def __repr__(self):
8725 
    L = ['%s=%r' % (key, value)
8726 
      for key, value in self.__dict__.iteritems()]
8727 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8728 
 
8729 
  def __eq__(self, other):
8730 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8731 
 
8732 
  def __ne__(self, other):
8733 
    return not (self == other)
8734 
 
8735 
class getIgnoredItemKeys_args:
8736 
 
8737 
  thrift_spec = (
8738 
  )
8739 
 
8740 
  def read(self, iprot):
8741 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8742 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8743 
      return
8744 
    iprot.readStructBegin()
8745 
    while True:
8746 
      (fname, ftype, fid) = iprot.readFieldBegin()
8747 
      if ftype == TType.STOP:
8748 
        break
8749 
      else:
8750 
        iprot.skip(ftype)
8751 
      iprot.readFieldEnd()
8752 
    iprot.readStructEnd()
8753 
 
8754 
  def write(self, oprot):
8755 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8756 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8757 
      return
8758 
    oprot.writeStructBegin('getIgnoredItemKeys_args')
8759 
    oprot.writeFieldStop()
8760 
    oprot.writeStructEnd()
8761 
 
8762 
  def validate(self):
8763 
    return
8764 
 
8765 
 
8766 
  def __repr__(self):
8767 
    L = ['%s=%r' % (key, value)
8768 
      for key, value in self.__dict__.iteritems()]
8769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8770 
 
8771 
  def __eq__(self, other):
8772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8773 
 
8774 
  def __ne__(self, other):
8775 
    return not (self == other)
8776 
 
8777 
class getIgnoredItemKeys_result:
8778 
  """
8779 
  Attributes:
8780 
   - success
8781 
  """
8782 
 
8783 
  thrift_spec = (
8784 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.MAP,(TType.I64,None,TType.I64,None)), None, ), # 0
8785 
  )
8786 
 
8787 
  def __init__(self, success=None,):
8788 
    self.success = success
8789 
 
8790 
  def read(self, iprot):
8791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8793 
      return
8794 
    iprot.readStructBegin()
8795 
    while True:
8796 
      (fname, ftype, fid) = iprot.readFieldBegin()
8797 
      if ftype == TType.STOP:
8798 
        break
8799 
      if fid == 0:
8800 
        if ftype == TType.MAP:
8801 
          self.success = {}
8182 amar.kumar 8802 
          (_ktype109, _vtype110, _size108 ) = iprot.readMapBegin()
8803 
          for _i112 in xrange(_size108):
8804 
            _key113 = iprot.readString();
8805 
            _val114 = {}
8806 
            (_ktype116, _vtype117, _size115 ) = iprot.readMapBegin()
8807 
            for _i119 in xrange(_size115):
8808 
              _key120 = iprot.readI64();
8809 
              _val121 = iprot.readI64();
8810 
              _val114[_key120] = _val121
5944 mandeep.dh 8811 
            iprot.readMapEnd()
8182 amar.kumar 8812 
            self.success[_key113] = _val114
5944 mandeep.dh 8813 
          iprot.readMapEnd()
8814 
        else:
8815 
          iprot.skip(ftype)
8816 
      else:
8817 
        iprot.skip(ftype)
8818 
      iprot.readFieldEnd()
8819 
    iprot.readStructEnd()
8820 
 
8821 
  def write(self, oprot):
8822 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8823 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8824 
      return
8825 
    oprot.writeStructBegin('getIgnoredItemKeys_result')
8826 
    if self.success is not None:
8827 
      oprot.writeFieldBegin('success', TType.MAP, 0)
8828 
      oprot.writeMapBegin(TType.STRING, TType.MAP, len(self.success))
8182 amar.kumar 8829 
      for kiter122,viter123 in self.success.items():
8830 
        oprot.writeString(kiter122)
8831 
        oprot.writeMapBegin(TType.I64, TType.I64, len(viter123))
8832 
        for kiter124,viter125 in viter123.items():
8833 
          oprot.writeI64(kiter124)
8834 
          oprot.writeI64(viter125)
5944 mandeep.dh 8835 
        oprot.writeMapEnd()
8836 
      oprot.writeMapEnd()
8837 
      oprot.writeFieldEnd()
8838 
    oprot.writeFieldStop()
8839 
    oprot.writeStructEnd()
8840 
 
8841 
  def validate(self):
8842 
    return
8843 
 
8844 
 
8845 
  def __repr__(self):
8846 
    L = ['%s=%r' % (key, value)
8847 
      for key, value in self.__dict__.iteritems()]
8848 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8849 
 
8850 
  def __eq__(self, other):
8851 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8852 
 
8853 
  def __ne__(self, other):
8854 
    return not (self == other)
8855 
 
8856 
class addBadInventory_args:
8857 
  """
8858 
  Attributes:
8859 
   - itemId
8860 
   - warehouseId
8861 
   - quantity
8862 
  """
8863 
 
8864 
  thrift_spec = (
8865 
    None, # 0
8866 
    (1, TType.I64, 'itemId', None, None, ), # 1
8867 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8868 
    (3, TType.I64, 'quantity', None, None, ), # 3
8869 
  )
8870 
 
8871 
  def __init__(self, itemId=None, warehouseId=None, quantity=None,):
8872 
    self.itemId = itemId
8873 
    self.warehouseId = warehouseId
8874 
    self.quantity = quantity
8875 
 
8876 
  def read(self, iprot):
8877 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8878 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8879 
      return
8880 
    iprot.readStructBegin()
8881 
    while True:
8882 
      (fname, ftype, fid) = iprot.readFieldBegin()
8883 
      if ftype == TType.STOP:
8884 
        break
8885 
      if fid == 1:
8886 
        if ftype == TType.I64:
8887 
          self.itemId = iprot.readI64();
8888 
        else:
8889 
          iprot.skip(ftype)
8890 
      elif fid == 2:
8891 
        if ftype == TType.I64:
8892 
          self.warehouseId = iprot.readI64();
8893 
        else:
8894 
          iprot.skip(ftype)
8895 
      elif fid == 3:
8896 
        if ftype == TType.I64:
8897 
          self.quantity = iprot.readI64();
8898 
        else:
8899 
          iprot.skip(ftype)
8900 
      else:
8901 
        iprot.skip(ftype)
8902 
      iprot.readFieldEnd()
8903 
    iprot.readStructEnd()
8904 
 
8905 
  def write(self, oprot):
8906 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8907 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8908 
      return
8909 
    oprot.writeStructBegin('addBadInventory_args')
8910 
    if self.itemId is not None:
8911 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
8912 
      oprot.writeI64(self.itemId)
8913 
      oprot.writeFieldEnd()
8914 
    if self.warehouseId is not None:
8915 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8916 
      oprot.writeI64(self.warehouseId)
8917 
      oprot.writeFieldEnd()
8918 
    if self.quantity is not None:
8919 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
8920 
      oprot.writeI64(self.quantity)
8921 
      oprot.writeFieldEnd()
8922 
    oprot.writeFieldStop()
8923 
    oprot.writeStructEnd()
8924 
 
8925 
  def validate(self):
8926 
    return
8927 
 
8928 
 
8929 
  def __repr__(self):
8930 
    L = ['%s=%r' % (key, value)
8931 
      for key, value in self.__dict__.iteritems()]
8932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8933 
 
8934 
  def __eq__(self, other):
8935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8936 
 
8937 
  def __ne__(self, other):
8938 
    return not (self == other)
8939 
 
8940 
class addBadInventory_result:
8941 
  """
8942 
  Attributes:
8943 
   - cex
8944 
  """
8945 
 
8946 
  thrift_spec = (
8947 
    None, # 0
8948 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
8949 
  )
8950 
 
8951 
  def __init__(self, cex=None,):
8952 
    self.cex = cex
8953 
 
8954 
  def read(self, iprot):
8955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8957 
      return
8958 
    iprot.readStructBegin()
8959 
    while True:
8960 
      (fname, ftype, fid) = iprot.readFieldBegin()
8961 
      if ftype == TType.STOP:
8962 
        break
8963 
      if fid == 1:
8964 
        if ftype == TType.STRUCT:
8965 
          self.cex = InventoryServiceException()
8966 
          self.cex.read(iprot)
8967 
        else:
8968 
          iprot.skip(ftype)
8969 
      else:
8970 
        iprot.skip(ftype)
8971 
      iprot.readFieldEnd()
8972 
    iprot.readStructEnd()
8973 
 
8974 
  def write(self, oprot):
8975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8977 
      return
8978 
    oprot.writeStructBegin('addBadInventory_result')
8979 
    if self.cex is not None:
8980 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8981 
      self.cex.write(oprot)
8982 
      oprot.writeFieldEnd()
8983 
    oprot.writeFieldStop()
8984 
    oprot.writeStructEnd()
8985 
 
8986 
  def validate(self):
8987 
    return
8988 
 
8989 
 
8990 
  def __repr__(self):
8991 
    L = ['%s=%r' % (key, value)
8992 
      for key, value in self.__dict__.iteritems()]
8993 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8994 
 
8995 
  def __eq__(self, other):
8996 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8997 
 
8998 
  def __ne__(self, other):
8999 
    return not (self == other)
9000 
 
9001 
class getShippingLocations_args:
9002 
 
9003 
  thrift_spec = (
9004 
  )
9005 
 
9006 
  def read(self, iprot):
9007 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9008 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9009 
      return
9010 
    iprot.readStructBegin()
9011 
    while True:
9012 
      (fname, ftype, fid) = iprot.readFieldBegin()
9013 
      if ftype == TType.STOP:
9014 
        break
9015 
      else:
9016 
        iprot.skip(ftype)
9017 
      iprot.readFieldEnd()
9018 
    iprot.readStructEnd()
9019 
 
9020 
  def write(self, oprot):
9021 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9022 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9023 
      return
9024 
    oprot.writeStructBegin('getShippingLocations_args')
9025 
    oprot.writeFieldStop()
9026 
    oprot.writeStructEnd()
9027 
 
9028 
  def validate(self):
9029 
    return
9030 
 
9031 
 
9032 
  def __repr__(self):
9033 
    L = ['%s=%r' % (key, value)
9034 
      for key, value in self.__dict__.iteritems()]
9035 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9036 
 
9037 
  def __eq__(self, other):
9038 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9039 
 
9040 
  def __ne__(self, other):
9041 
    return not (self == other)
9042 
 
9043 
class getShippingLocations_result:
9044 
  """
9045 
  Attributes:
9046 
   - success
9047 
  """
9048 
 
9049 
  thrift_spec = (
9050 
    (0, TType.LIST, 'success', (TType.STRUCT,(Warehouse, Warehouse.thrift_spec)), None, ), # 0
9051 
  )
9052 
 
9053 
  def __init__(self, success=None,):
9054 
    self.success = success
9055 
 
9056 
  def read(self, iprot):
9057 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9058 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9059 
      return
9060 
    iprot.readStructBegin()
9061 
    while True:
9062 
      (fname, ftype, fid) = iprot.readFieldBegin()
9063 
      if ftype == TType.STOP:
9064 
        break
9065 
      if fid == 0:
9066 
        if ftype == TType.LIST:
9067 
          self.success = []
8182 amar.kumar 9068 
          (_etype129, _size126) = iprot.readListBegin()
9069 
          for _i130 in xrange(_size126):
9070 
            _elem131 = Warehouse()
9071 
            _elem131.read(iprot)
9072 
            self.success.append(_elem131)
5944 mandeep.dh 9073 
          iprot.readListEnd()
9074 
        else:
9075 
          iprot.skip(ftype)
9076 
      else:
9077 
        iprot.skip(ftype)
9078 
      iprot.readFieldEnd()
9079 
    iprot.readStructEnd()
9080 
 
9081 
  def write(self, oprot):
9082 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9083 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9084 
      return
9085 
    oprot.writeStructBegin('getShippingLocations_result')
9086 
    if self.success is not None:
9087 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9088 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 9089 
      for iter132 in self.success:
9090 
        iter132.write(oprot)
5944 mandeep.dh 9091 
      oprot.writeListEnd()
9092 
      oprot.writeFieldEnd()
9093 
    oprot.writeFieldStop()
9094 
    oprot.writeStructEnd()
9095 
 
9096 
  def validate(self):
9097 
    return
9098 
 
9099 
 
9100 
  def __repr__(self):
9101 
    L = ['%s=%r' % (key, value)
9102 
      for key, value in self.__dict__.iteritems()]
9103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9104 
 
9105 
  def __eq__(self, other):
9106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9107 
 
9108 
  def __ne__(self, other):
9109 
    return not (self == other)
9110 
 
9111 
class getAllVendorItemMappings_args:
9112 
 
9113 
  thrift_spec = (
9114 
  )
9115 
 
9116 
  def read(self, iprot):
9117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9119 
      return
9120 
    iprot.readStructBegin()
9121 
    while True:
9122 
      (fname, ftype, fid) = iprot.readFieldBegin()
9123 
      if ftype == TType.STOP:
9124 
        break
9125 
      else:
9126 
        iprot.skip(ftype)
9127 
      iprot.readFieldEnd()
9128 
    iprot.readStructEnd()
9129 
 
9130 
  def write(self, oprot):
9131 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9132 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9133 
      return
9134 
    oprot.writeStructBegin('getAllVendorItemMappings_args')
9135 
    oprot.writeFieldStop()
9136 
    oprot.writeStructEnd()
9137 
 
9138 
  def validate(self):
9139 
    return
9140 
 
9141 
 
9142 
  def __repr__(self):
9143 
    L = ['%s=%r' % (key, value)
9144 
      for key, value in self.__dict__.iteritems()]
9145 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9146 
 
9147 
  def __eq__(self, other):
9148 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9149 
 
9150 
  def __ne__(self, other):
9151 
    return not (self == other)
9152 
 
9153 
class getAllVendorItemMappings_result:
9154 
  """
9155 
  Attributes:
9156 
   - success
9157 
  """
9158 
 
9159 
  thrift_spec = (
9160 
    (0, TType.LIST, 'success', (TType.STRUCT,(VendorItemMapping, VendorItemMapping.thrift_spec)), None, ), # 0
9161 
  )
9162 
 
9163 
  def __init__(self, success=None,):
9164 
    self.success = success
9165 
 
9166 
  def read(self, iprot):
9167 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9168 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9169 
      return
9170 
    iprot.readStructBegin()
9171 
    while True:
9172 
      (fname, ftype, fid) = iprot.readFieldBegin()
9173 
      if ftype == TType.STOP:
9174 
        break
9175 
      if fid == 0:
9176 
        if ftype == TType.LIST:
9177 
          self.success = []
8182 amar.kumar 9178 
          (_etype136, _size133) = iprot.readListBegin()
9179 
          for _i137 in xrange(_size133):
9180 
            _elem138 = VendorItemMapping()
9181 
            _elem138.read(iprot)
9182 
            self.success.append(_elem138)
5944 mandeep.dh 9183 
          iprot.readListEnd()
9184 
        else:
9185 
          iprot.skip(ftype)
9186 
      else:
9187 
        iprot.skip(ftype)
9188 
      iprot.readFieldEnd()
9189 
    iprot.readStructEnd()
9190 
 
9191 
  def write(self, oprot):
9192 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9193 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9194 
      return
9195 
    oprot.writeStructBegin('getAllVendorItemMappings_result')
9196 
    if self.success is not None:
9197 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9198 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 9199 
      for iter139 in self.success:
9200 
        iter139.write(oprot)
5944 mandeep.dh 9201 
      oprot.writeListEnd()
9202 
      oprot.writeFieldEnd()
9203 
    oprot.writeFieldStop()
9204 
    oprot.writeStructEnd()
9205 
 
9206 
  def validate(self):
9207 
    return
9208 
 
9209 
 
9210 
  def __repr__(self):
9211 
    L = ['%s=%r' % (key, value)
9212 
      for key, value in self.__dict__.iteritems()]
9213 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9214 
 
9215 
  def __eq__(self, other):
9216 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9217 
 
9218 
  def __ne__(self, other):
9219 
    return not (self == other)
9220 
 
9221 
class getInventorySnapshot_args:
9222 
  """
9223 
  Attributes:
9224 
   - warehouseId
9225 
  """
9226 
 
9227 
  thrift_spec = (
9228 
    None, # 0
9229 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9230 
  )
9231 
 
9232 
  def __init__(self, warehouseId=None,):
9233 
    self.warehouseId = warehouseId
9234 
 
9235 
  def read(self, iprot):
9236 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9237 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9238 
      return
9239 
    iprot.readStructBegin()
9240 
    while True:
9241 
      (fname, ftype, fid) = iprot.readFieldBegin()
9242 
      if ftype == TType.STOP:
9243 
        break
9244 
      if fid == 1:
9245 
        if ftype == TType.I64:
9246 
          self.warehouseId = iprot.readI64();
9247 
        else:
9248 
          iprot.skip(ftype)
9249 
      else:
9250 
        iprot.skip(ftype)
9251 
      iprot.readFieldEnd()
9252 
    iprot.readStructEnd()
9253 
 
9254 
  def write(self, oprot):
9255 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9256 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9257 
      return
9258 
    oprot.writeStructBegin('getInventorySnapshot_args')
9259 
    if self.warehouseId is not None:
9260 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9261 
      oprot.writeI64(self.warehouseId)
9262 
      oprot.writeFieldEnd()
9263 
    oprot.writeFieldStop()
9264 
    oprot.writeStructEnd()
9265 
 
9266 
  def validate(self):
9267 
    return
9268 
 
9269 
 
9270 
  def __repr__(self):
9271 
    L = ['%s=%r' % (key, value)
9272 
      for key, value in self.__dict__.iteritems()]
9273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9274 
 
9275 
  def __eq__(self, other):
9276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9277 
 
9278 
  def __ne__(self, other):
9279 
    return not (self == other)
9280 
 
9281 
class getInventorySnapshot_result:
9282 
  """
9283 
  Attributes:
9284 
   - success
9285 
  """
9286 
 
9287 
  thrift_spec = (
9288 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRUCT,(ItemInventory, ItemInventory.thrift_spec)), None, ), # 0
9289 
  )
9290 
 
9291 
  def __init__(self, success=None,):
9292 
    self.success = success
9293 
 
9294 
  def read(self, iprot):
9295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9297 
      return
9298 
    iprot.readStructBegin()
9299 
    while True:
9300 
      (fname, ftype, fid) = iprot.readFieldBegin()
9301 
      if ftype == TType.STOP:
9302 
        break
9303 
      if fid == 0:
9304 
        if ftype == TType.MAP:
9305 
          self.success = {}
8182 amar.kumar 9306 
          (_ktype141, _vtype142, _size140 ) = iprot.readMapBegin()
9307 
          for _i144 in xrange(_size140):
9308 
            _key145 = iprot.readI64();
9309 
            _val146 = ItemInventory()
9310 
            _val146.read(iprot)
9311 
            self.success[_key145] = _val146
5944 mandeep.dh 9312 
          iprot.readMapEnd()
9313 
        else:
9314 
          iprot.skip(ftype)
9315 
      else:
9316 
        iprot.skip(ftype)
9317 
      iprot.readFieldEnd()
9318 
    iprot.readStructEnd()
9319 
 
9320 
  def write(self, oprot):
9321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9323 
      return
9324 
    oprot.writeStructBegin('getInventorySnapshot_result')
9325 
    if self.success is not None:
9326 
      oprot.writeFieldBegin('success', TType.MAP, 0)
9327 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.success))
8182 amar.kumar 9328 
      for kiter147,viter148 in self.success.items():
9329 
        oprot.writeI64(kiter147)
9330 
        viter148.write(oprot)
5944 mandeep.dh 9331 
      oprot.writeMapEnd()
9332 
      oprot.writeFieldEnd()
9333 
    oprot.writeFieldStop()
9334 
    oprot.writeStructEnd()
9335 
 
9336 
  def validate(self):
9337 
    return
9338 
 
9339 
 
9340 
  def __repr__(self):
9341 
    L = ['%s=%r' % (key, value)
9342 
      for key, value in self.__dict__.iteritems()]
9343 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9344 
 
9345 
  def __eq__(self, other):
9346 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9347 
 
9348 
  def __ne__(self, other):
9349 
    return not (self == other)
9350 
 
9351 
class clearItemAvailabilityCache_args:
9352 
 
9353 
  thrift_spec = (
9354 
  )
9355 
 
9356 
  def read(self, iprot):
9357 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9358 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9359 
      return
9360 
    iprot.readStructBegin()
9361 
    while True:
9362 
      (fname, ftype, fid) = iprot.readFieldBegin()
9363 
      if ftype == TType.STOP:
9364 
        break
9365 
      else:
9366 
        iprot.skip(ftype)
9367 
      iprot.readFieldEnd()
9368 
    iprot.readStructEnd()
9369 
 
9370 
  def write(self, oprot):
9371 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9372 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9373 
      return
9374 
    oprot.writeStructBegin('clearItemAvailabilityCache_args')
9375 
    oprot.writeFieldStop()
9376 
    oprot.writeStructEnd()
9377 
 
9378 
  def validate(self):
9379 
    return
9380 
 
9381 
 
9382 
  def __repr__(self):
9383 
    L = ['%s=%r' % (key, value)
9384 
      for key, value in self.__dict__.iteritems()]
9385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9386 
 
9387 
  def __eq__(self, other):
9388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9389 
 
9390 
  def __ne__(self, other):
9391 
    return not (self == other)
9392 
 
9393 
class clearItemAvailabilityCache_result:
9394 
 
9395 
  thrift_spec = (
9396 
  )
9397 
 
9398 
  def read(self, iprot):
9399 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9400 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9401 
      return
9402 
    iprot.readStructBegin()
9403 
    while True:
9404 
      (fname, ftype, fid) = iprot.readFieldBegin()
9405 
      if ftype == TType.STOP:
9406 
        break
9407 
      else:
9408 
        iprot.skip(ftype)
9409 
      iprot.readFieldEnd()
9410 
    iprot.readStructEnd()
9411 
 
9412 
  def write(self, oprot):
9413 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9414 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9415 
      return
9416 
    oprot.writeStructBegin('clearItemAvailabilityCache_result')
9417 
    oprot.writeFieldStop()
9418 
    oprot.writeStructEnd()
9419 
 
9420 
  def validate(self):
9421 
    return
9422 
 
9423 
 
9424 
  def __repr__(self):
9425 
    L = ['%s=%r' % (key, value)
9426 
      for key, value in self.__dict__.iteritems()]
9427 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9428 
 
9429 
  def __eq__(self, other):
9430 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9431 
 
9432 
  def __ne__(self, other):
9433 
    return not (self == other)
9434 
 
9435 
class updateVendorString_args:
9436 
  """
9437 
  Attributes:
9438 
   - warehouseId
9439 
   - vendorString
9440 
  """
9441 
 
9442 
  thrift_spec = (
9443 
    None, # 0
9444 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9445 
    (2, TType.STRING, 'vendorString', None, None, ), # 2
9446 
  )
9447 
 
9448 
  def __init__(self, warehouseId=None, vendorString=None,):
9449 
    self.warehouseId = warehouseId
9450 
    self.vendorString = vendorString
9451 
 
9452 
  def read(self, iprot):
9453 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9454 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9455 
      return
9456 
    iprot.readStructBegin()
9457 
    while True:
9458 
      (fname, ftype, fid) = iprot.readFieldBegin()
9459 
      if ftype == TType.STOP:
9460 
        break
9461 
      if fid == 1:
9462 
        if ftype == TType.I64:
9463 
          self.warehouseId = iprot.readI64();
9464 
        else:
9465 
          iprot.skip(ftype)
9466 
      elif fid == 2:
9467 
        if ftype == TType.STRING:
9468 
          self.vendorString = iprot.readString();
9469 
        else:
9470 
          iprot.skip(ftype)
9471 
      else:
9472 
        iprot.skip(ftype)
9473 
      iprot.readFieldEnd()
9474 
    iprot.readStructEnd()
9475 
 
9476 
  def write(self, oprot):
9477 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9478 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9479 
      return
9480 
    oprot.writeStructBegin('updateVendorString_args')
9481 
    if self.warehouseId is not None:
9482 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9483 
      oprot.writeI64(self.warehouseId)
9484 
      oprot.writeFieldEnd()
9485 
    if self.vendorString is not None:
9486 
      oprot.writeFieldBegin('vendorString', TType.STRING, 2)
9487 
      oprot.writeString(self.vendorString)
9488 
      oprot.writeFieldEnd()
9489 
    oprot.writeFieldStop()
9490 
    oprot.writeStructEnd()
9491 
 
9492 
  def validate(self):
9493 
    return
9494 
 
9495 
 
9496 
  def __repr__(self):
9497 
    L = ['%s=%r' % (key, value)
9498 
      for key, value in self.__dict__.iteritems()]
9499 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9500 
 
9501 
  def __eq__(self, other):
9502 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9503 
 
9504 
  def __ne__(self, other):
9505 
    return not (self == other)
9506 
 
9507 
class updateVendorString_result:
9508 
 
9509 
  thrift_spec = (
9510 
  )
9511 
 
9512 
  def read(self, iprot):
9513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9515 
      return
9516 
    iprot.readStructBegin()
9517 
    while True:
9518 
      (fname, ftype, fid) = iprot.readFieldBegin()
9519 
      if ftype == TType.STOP:
9520 
        break
9521 
      else:
9522 
        iprot.skip(ftype)
9523 
      iprot.readFieldEnd()
9524 
    iprot.readStructEnd()
9525 
 
9526 
  def write(self, oprot):
9527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9529 
      return
9530 
    oprot.writeStructBegin('updateVendorString_result')
9531 
    oprot.writeFieldStop()
9532 
    oprot.writeStructEnd()
9533 
 
9534 
  def validate(self):
9535 
    return
9536 
 
9537 
 
9538 
  def __repr__(self):
9539 
    L = ['%s=%r' % (key, value)
9540 
      for key, value in self.__dict__.iteritems()]
9541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9542 
 
9543 
  def __eq__(self, other):
9544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9545 
 
9546 
  def __ne__(self, other):
9547 
    return not (self == other)
6096 amit.gupta 9548 
 
9549 
class clearItemAvailabilityCacheForItem_args:
9550 
  """
9551 
  Attributes:
9552 
   - item_id
9553 
  """
9554 
 
9555 
  thrift_spec = (
9556 
    None, # 0
9557 
    (1, TType.I64, 'item_id', None, None, ), # 1
9558 
  )
9559 
 
9560 
  def __init__(self, item_id=None,):
9561 
    self.item_id = item_id
9562 
 
9563 
  def read(self, iprot):
9564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9566 
      return
9567 
    iprot.readStructBegin()
9568 
    while True:
9569 
      (fname, ftype, fid) = iprot.readFieldBegin()
9570 
      if ftype == TType.STOP:
9571 
        break
9572 
      if fid == 1:
9573 
        if ftype == TType.I64:
9574 
          self.item_id = iprot.readI64();
9575 
        else:
9576 
          iprot.skip(ftype)
9577 
      else:
9578 
        iprot.skip(ftype)
9579 
      iprot.readFieldEnd()
9580 
    iprot.readStructEnd()
9581 
 
9582 
  def write(self, oprot):
9583 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9584 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9585 
      return
9586 
    oprot.writeStructBegin('clearItemAvailabilityCacheForItem_args')
9587 
    if self.item_id is not None:
9588 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
9589 
      oprot.writeI64(self.item_id)
9590 
      oprot.writeFieldEnd()
9591 
    oprot.writeFieldStop()
9592 
    oprot.writeStructEnd()
9593 
 
9594 
  def validate(self):
9595 
    return
9596 
 
9597 
 
9598 
  def __repr__(self):
9599 
    L = ['%s=%r' % (key, value)
9600 
      for key, value in self.__dict__.iteritems()]
9601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9602 
 
9603 
  def __eq__(self, other):
9604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9605 
 
9606 
  def __ne__(self, other):
9607 
    return not (self == other)
9608 
 
9609 
class clearItemAvailabilityCacheForItem_result:
9610 
 
9611 
  thrift_spec = (
9612 
  )
9613 
 
9614 
  def read(self, iprot):
9615 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9616 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9617 
      return
9618 
    iprot.readStructBegin()
9619 
    while True:
9620 
      (fname, ftype, fid) = iprot.readFieldBegin()
9621 
      if ftype == TType.STOP:
9622 
        break
9623 
      else:
9624 
        iprot.skip(ftype)
9625 
      iprot.readFieldEnd()
9626 
    iprot.readStructEnd()
9627 
 
9628 
  def write(self, oprot):
9629 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9630 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9631 
      return
9632 
    oprot.writeStructBegin('clearItemAvailabilityCacheForItem_result')
9633 
    oprot.writeFieldStop()
9634 
    oprot.writeStructEnd()
9635 
 
9636 
  def validate(self):
9637 
    return
9638 
 
9639 
 
9640 
  def __repr__(self):
9641 
    L = ['%s=%r' % (key, value)
9642 
      for key, value in self.__dict__.iteritems()]
9643 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9644 
 
9645 
  def __eq__(self, other):
9646 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9647 
 
9648 
  def __ne__(self, other):
9649 
    return not (self == other)
6467 amar.kumar 9650 
 
9651 
class getOurWarehouseIdForVendor_args:
9652 
  """
9653 
  Attributes:
9654 
   - vendorId
7718 amar.kumar 9655 
   - billingWarehouseId
6467 amar.kumar 9656 
  """
9657 
 
9658 
  thrift_spec = (
9659 
    None, # 0
9660 
    (1, TType.I64, 'vendorId', None, None, ), # 1
7718 amar.kumar 9661 
    (2, TType.I64, 'billingWarehouseId', None, None, ), # 2
6467 amar.kumar 9662 
  )
9663 
 
7718 amar.kumar 9664 
  def __init__(self, vendorId=None, billingWarehouseId=None,):
6467 amar.kumar 9665 
    self.vendorId = vendorId
7718 amar.kumar 9666 
    self.billingWarehouseId = billingWarehouseId
6467 amar.kumar 9667 
 
9668 
  def read(self, iprot):
9669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9671 
      return
9672 
    iprot.readStructBegin()
9673 
    while True:
9674 
      (fname, ftype, fid) = iprot.readFieldBegin()
9675 
      if ftype == TType.STOP:
9676 
        break
9677 
      if fid == 1:
9678 
        if ftype == TType.I64:
9679 
          self.vendorId = iprot.readI64();
9680 
        else:
9681 
          iprot.skip(ftype)
7718 amar.kumar 9682 
      elif fid == 2:
9683 
        if ftype == TType.I64:
9684 
          self.billingWarehouseId = iprot.readI64();
9685 
        else:
9686 
          iprot.skip(ftype)
6467 amar.kumar 9687 
      else:
9688 
        iprot.skip(ftype)
9689 
      iprot.readFieldEnd()
9690 
    iprot.readStructEnd()
9691 
 
9692 
  def write(self, oprot):
9693 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9694 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9695 
      return
9696 
    oprot.writeStructBegin('getOurWarehouseIdForVendor_args')
9697 
    if self.vendorId is not None:
9698 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
9699 
      oprot.writeI64(self.vendorId)
9700 
      oprot.writeFieldEnd()
7718 amar.kumar 9701 
    if self.billingWarehouseId is not None:
9702 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 2)
9703 
      oprot.writeI64(self.billingWarehouseId)
9704 
      oprot.writeFieldEnd()
6467 amar.kumar 9705 
    oprot.writeFieldStop()
9706 
    oprot.writeStructEnd()
9707 
 
9708 
  def validate(self):
9709 
    return
9710 
 
9711 
 
9712 
  def __repr__(self):
9713 
    L = ['%s=%r' % (key, value)
9714 
      for key, value in self.__dict__.iteritems()]
9715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9716 
 
9717 
  def __eq__(self, other):
9718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9719 
 
9720 
  def __ne__(self, other):
9721 
    return not (self == other)
9722 
 
9723 
class getOurWarehouseIdForVendor_result:
9724 
  """
9725 
  Attributes:
9726 
   - success
9727 
  """
9728 
 
9729 
  thrift_spec = (
9730 
    (0, TType.I64, 'success', None, None, ), # 0
9731 
  )
9732 
 
9733 
  def __init__(self, success=None,):
9734 
    self.success = success
9735 
 
9736 
  def read(self, iprot):
9737 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9738 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9739 
      return
9740 
    iprot.readStructBegin()
9741 
    while True:
9742 
      (fname, ftype, fid) = iprot.readFieldBegin()
9743 
      if ftype == TType.STOP:
9744 
        break
9745 
      if fid == 0:
9746 
        if ftype == TType.I64:
9747 
          self.success = iprot.readI64();
9748 
        else:
9749 
          iprot.skip(ftype)
9750 
      else:
9751 
        iprot.skip(ftype)
9752 
      iprot.readFieldEnd()
9753 
    iprot.readStructEnd()
9754 
 
9755 
  def write(self, oprot):
9756 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9757 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9758 
      return
9759 
    oprot.writeStructBegin('getOurWarehouseIdForVendor_result')
9760 
    if self.success is not None:
9761 
      oprot.writeFieldBegin('success', TType.I64, 0)
9762 
      oprot.writeI64(self.success)
9763 
      oprot.writeFieldEnd()
9764 
    oprot.writeFieldStop()
9765 
    oprot.writeStructEnd()
9766 
 
9767 
  def validate(self):
9768 
    return
9769 
 
9770 
 
9771 
  def __repr__(self):
9772 
    L = ['%s=%r' % (key, value)
9773 
      for key, value in self.__dict__.iteritems()]
9774 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9775 
 
9776 
  def __eq__(self, other):
9777 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9778 
 
9779 
  def __ne__(self, other):
9780 
    return not (self == other)
6484 amar.kumar 9781 
 
9782 
class getItemAvailabilitiesAtOurWarehouses_args:
9783 
  """
9784 
  Attributes:
9785 
   - item_ids
9786 
  """
9787 
 
9788 
  thrift_spec = (
9789 
    None, # 0
9790 
    (1, TType.LIST, 'item_ids', (TType.I64,None), None, ), # 1
9791 
  )
9792 
 
9793 
  def __init__(self, item_ids=None,):
9794 
    self.item_ids = item_ids
9795 
 
9796 
  def read(self, iprot):
9797 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9798 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9799 
      return
9800 
    iprot.readStructBegin()
9801 
    while True:
9802 
      (fname, ftype, fid) = iprot.readFieldBegin()
9803 
      if ftype == TType.STOP:
9804 
        break
9805 
      if fid == 1:
9806 
        if ftype == TType.LIST:
9807 
          self.item_ids = []
8182 amar.kumar 9808 
          (_etype152, _size149) = iprot.readListBegin()
9809 
          for _i153 in xrange(_size149):
9810 
            _elem154 = iprot.readI64();
9811 
            self.item_ids.append(_elem154)
6484 amar.kumar 9812 
          iprot.readListEnd()
9813 
        else:
9814 
          iprot.skip(ftype)
9815 
      else:
9816 
        iprot.skip(ftype)
9817 
      iprot.readFieldEnd()
9818 
    iprot.readStructEnd()
9819 
 
9820 
  def write(self, oprot):
9821 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9822 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9823 
      return
9824 
    oprot.writeStructBegin('getItemAvailabilitiesAtOurWarehouses_args')
9825 
    if self.item_ids is not None:
9826 
      oprot.writeFieldBegin('item_ids', TType.LIST, 1)
9827 
      oprot.writeListBegin(TType.I64, len(self.item_ids))
8182 amar.kumar 9828 
      for iter155 in self.item_ids:
9829 
        oprot.writeI64(iter155)
6484 amar.kumar 9830 
      oprot.writeListEnd()
9831 
      oprot.writeFieldEnd()
9832 
    oprot.writeFieldStop()
9833 
    oprot.writeStructEnd()
9834 
 
9835 
  def validate(self):
9836 
    return
9837 
 
9838 
 
9839 
  def __repr__(self):
9840 
    L = ['%s=%r' % (key, value)
9841 
      for key, value in self.__dict__.iteritems()]
9842 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9843 
 
9844 
  def __eq__(self, other):
9845 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9846 
 
9847 
  def __ne__(self, other):
9848 
    return not (self == other)
9849 
 
9850 
class getItemAvailabilitiesAtOurWarehouses_result:
9851 
  """
9852 
  Attributes:
9853 
   - success
9854 
  """
9855 
 
9856 
  thrift_spec = (
9857 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
9858 
  )
9859 
 
9860 
  def __init__(self, success=None,):
9861 
    self.success = success
9862 
 
9863 
  def read(self, iprot):
9864 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9865 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9866 
      return
9867 
    iprot.readStructBegin()
9868 
    while True:
9869 
      (fname, ftype, fid) = iprot.readFieldBegin()
9870 
      if ftype == TType.STOP:
9871 
        break
9872 
      if fid == 0:
9873 
        if ftype == TType.MAP:
9874 
          self.success = {}
8182 amar.kumar 9875 
          (_ktype157, _vtype158, _size156 ) = iprot.readMapBegin()
9876 
          for _i160 in xrange(_size156):
9877 
            _key161 = iprot.readI64();
9878 
            _val162 = iprot.readI64();
9879 
            self.success[_key161] = _val162
6484 amar.kumar 9880 
          iprot.readMapEnd()
9881 
        else:
9882 
          iprot.skip(ftype)
9883 
      else:
9884 
        iprot.skip(ftype)
9885 
      iprot.readFieldEnd()
9886 
    iprot.readStructEnd()
9887 
 
9888 
  def write(self, oprot):
9889 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9890 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9891 
      return
9892 
    oprot.writeStructBegin('getItemAvailabilitiesAtOurWarehouses_result')
9893 
    if self.success is not None:
9894 
      oprot.writeFieldBegin('success', TType.MAP, 0)
9895 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
8182 amar.kumar 9896 
      for kiter163,viter164 in self.success.items():
9897 
        oprot.writeI64(kiter163)
9898 
        oprot.writeI64(viter164)
6484 amar.kumar 9899 
      oprot.writeMapEnd()
9900 
      oprot.writeFieldEnd()
9901 
    oprot.writeFieldStop()
9902 
    oprot.writeStructEnd()
9903 
 
9904 
  def validate(self):
9905 
    return
9906 
 
9907 
 
9908 
  def __repr__(self):
9909 
    L = ['%s=%r' % (key, value)
9910 
      for key, value in self.__dict__.iteritems()]
9911 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9912 
 
9913 
  def __eq__(self, other):
9914 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9915 
 
9916 
  def __ne__(self, other):
9917 
    return not (self == other)
6531 vikram.rag 9918 
 
9919 
class getMonitoredWarehouseForVendors_args:
9920 
  """
9921 
  Attributes:
9922 
   - vendorIds
9923 
  """
9924 
 
9925 
  thrift_spec = (
9926 
    None, # 0
9927 
    (1, TType.LIST, 'vendorIds', (TType.I64,None), None, ), # 1
9928 
  )
9929 
 
9930 
  def __init__(self, vendorIds=None,):
9931 
    self.vendorIds = vendorIds
9932 
 
9933 
  def read(self, iprot):
9934 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9935 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9936 
      return
9937 
    iprot.readStructBegin()
9938 
    while True:
9939 
      (fname, ftype, fid) = iprot.readFieldBegin()
9940 
      if ftype == TType.STOP:
9941 
        break
9942 
      if fid == 1:
9943 
        if ftype == TType.LIST:
9944 
          self.vendorIds = []
8182 amar.kumar 9945 
          (_etype168, _size165) = iprot.readListBegin()
9946 
          for _i169 in xrange(_size165):
9947 
            _elem170 = iprot.readI64();
9948 
            self.vendorIds.append(_elem170)
6531 vikram.rag 9949 
          iprot.readListEnd()
9950 
        else:
9951 
          iprot.skip(ftype)
9952 
      else:
9953 
        iprot.skip(ftype)
9954 
      iprot.readFieldEnd()
9955 
    iprot.readStructEnd()
9956 
 
9957 
  def write(self, oprot):
9958 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9959 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9960 
      return
9961 
    oprot.writeStructBegin('getMonitoredWarehouseForVendors_args')
9962 
    if self.vendorIds is not None:
9963 
      oprot.writeFieldBegin('vendorIds', TType.LIST, 1)
9964 
      oprot.writeListBegin(TType.I64, len(self.vendorIds))
8182 amar.kumar 9965 
      for iter171 in self.vendorIds:
9966 
        oprot.writeI64(iter171)
6531 vikram.rag 9967 
      oprot.writeListEnd()
9968 
      oprot.writeFieldEnd()
9969 
    oprot.writeFieldStop()
9970 
    oprot.writeStructEnd()
9971 
 
9972 
  def validate(self):
9973 
    return
9974 
 
9975 
 
9976 
  def __repr__(self):
9977 
    L = ['%s=%r' % (key, value)
9978 
      for key, value in self.__dict__.iteritems()]
9979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9980 
 
9981 
  def __eq__(self, other):
9982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9983 
 
9984 
  def __ne__(self, other):
9985 
    return not (self == other)
9986 
 
9987 
class getMonitoredWarehouseForVendors_result:
9988 
  """
9989 
  Attributes:
9990 
   - success
9991 
  """
9992 
 
9993 
  thrift_spec = (
9994 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9995 
  )
9996 
 
9997 
  def __init__(self, success=None,):
9998 
    self.success = success
9999 
 
10000 
  def read(self, iprot):
10001 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10002 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10003 
      return
10004 
    iprot.readStructBegin()
10005 
    while True:
10006 
      (fname, ftype, fid) = iprot.readFieldBegin()
10007 
      if ftype == TType.STOP:
10008 
        break
10009 
      if fid == 0:
10010 
        if ftype == TType.LIST:
10011 
          self.success = []
8182 amar.kumar 10012 
          (_etype175, _size172) = iprot.readListBegin()
10013 
          for _i176 in xrange(_size172):
10014 
            _elem177 = iprot.readI64();
10015 
            self.success.append(_elem177)
6531 vikram.rag 10016 
          iprot.readListEnd()
10017 
        else:
10018 
          iprot.skip(ftype)
10019 
      else:
10020 
        iprot.skip(ftype)
10021 
      iprot.readFieldEnd()
10022 
    iprot.readStructEnd()
10023 
 
10024 
  def write(self, oprot):
10025 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10026 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10027 
      return
10028 
    oprot.writeStructBegin('getMonitoredWarehouseForVendors_result')
10029 
    if self.success is not None:
10030 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10031 
      oprot.writeListBegin(TType.I64, len(self.success))
8182 amar.kumar 10032 
      for iter178 in self.success:
10033 
        oprot.writeI64(iter178)
6531 vikram.rag 10034 
      oprot.writeListEnd()
10035 
      oprot.writeFieldEnd()
10036 
    oprot.writeFieldStop()
10037 
    oprot.writeStructEnd()
10038 
 
10039 
  def validate(self):
10040 
    return
10041 
 
10042 
 
10043 
  def __repr__(self):
10044 
    L = ['%s=%r' % (key, value)
10045 
      for key, value in self.__dict__.iteritems()]
10046 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10047 
 
10048 
  def __eq__(self, other):
10049 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10050 
 
10051 
  def __ne__(self, other):
10052 
    return not (self == other)
10053 
 
10054 
class getIgnoredWarehouseidsAndItemids_args:
10055 
 
10056 
  thrift_spec = (
10057 
  )
10058 
 
10059 
  def read(self, iprot):
10060 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10061 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10062 
      return
10063 
    iprot.readStructBegin()
10064 
    while True:
10065 
      (fname, ftype, fid) = iprot.readFieldBegin()
10066 
      if ftype == TType.STOP:
10067 
        break
10068 
      else:
10069 
        iprot.skip(ftype)
10070 
      iprot.readFieldEnd()
10071 
    iprot.readStructEnd()
10072 
 
10073 
  def write(self, oprot):
10074 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10075 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10076 
      return
10077 
    oprot.writeStructBegin('getIgnoredWarehouseidsAndItemids_args')
10078 
    oprot.writeFieldStop()
10079 
    oprot.writeStructEnd()
10080 
 
10081 
  def validate(self):
10082 
    return
10083 
 
10084 
 
10085 
  def __repr__(self):
10086 
    L = ['%s=%r' % (key, value)
10087 
      for key, value in self.__dict__.iteritems()]
10088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10089 
 
10090 
  def __eq__(self, other):
10091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10092 
 
10093 
  def __ne__(self, other):
10094 
    return not (self == other)
10095 
 
10096 
class getIgnoredWarehouseidsAndItemids_result:
10097 
  """
10098 
  Attributes:
10099 
   - success
10100 
  """
10101 
 
10102 
  thrift_spec = (
10103 
    (0, TType.LIST, 'success', (TType.STRUCT,(IgnoredInventoryUpdateItems, IgnoredInventoryUpdateItems.thrift_spec)), None, ), # 0
10104 
  )
10105 
 
10106 
  def __init__(self, success=None,):
10107 
    self.success = success
10108 
 
10109 
  def read(self, iprot):
10110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10112 
      return
10113 
    iprot.readStructBegin()
10114 
    while True:
10115 
      (fname, ftype, fid) = iprot.readFieldBegin()
10116 
      if ftype == TType.STOP:
10117 
        break
10118 
      if fid == 0:
10119 
        if ftype == TType.LIST:
10120 
          self.success = []
8182 amar.kumar 10121 
          (_etype182, _size179) = iprot.readListBegin()
10122 
          for _i183 in xrange(_size179):
10123 
            _elem184 = IgnoredInventoryUpdateItems()
10124 
            _elem184.read(iprot)
10125 
            self.success.append(_elem184)
6531 vikram.rag 10126 
          iprot.readListEnd()
10127 
        else:
10128 
          iprot.skip(ftype)
10129 
      else:
10130 
        iprot.skip(ftype)
10131 
      iprot.readFieldEnd()
10132 
    iprot.readStructEnd()
10133 
 
10134 
  def write(self, oprot):
10135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10137 
      return
10138 
    oprot.writeStructBegin('getIgnoredWarehouseidsAndItemids_result')
10139 
    if self.success is not None:
10140 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10141 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 10142 
      for iter185 in self.success:
10143 
        iter185.write(oprot)
6531 vikram.rag 10144 
      oprot.writeListEnd()
10145 
      oprot.writeFieldEnd()
10146 
    oprot.writeFieldStop()
10147 
    oprot.writeStructEnd()
10148 
 
10149 
  def validate(self):
10150 
    return
10151 
 
10152 
 
10153 
  def __repr__(self):
10154 
    L = ['%s=%r' % (key, value)
10155 
      for key, value in self.__dict__.iteritems()]
10156 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10157 
 
10158 
  def __eq__(self, other):
10159 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10160 
 
10161 
  def __ne__(self, other):
10162 
    return not (self == other)
10163 
 
10164 
class insertItemtoIgnoreInventoryUpdatelist_args:
10165 
  """
10166 
  Attributes:
10167 
   - item_id
10168 
   - warehouse_id
10169 
  """
10170 
 
10171 
  thrift_spec = (
10172 
    None, # 0
10173 
    (1, TType.I64, 'item_id', None, None, ), # 1
10174 
    (2, TType.I64, 'warehouse_id', None, None, ), # 2
10175 
  )
10176 
 
10177 
  def __init__(self, item_id=None, warehouse_id=None,):
10178 
    self.item_id = item_id
10179 
    self.warehouse_id = warehouse_id
10180 
 
10181 
  def read(self, iprot):
10182 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10183 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10184 
      return
10185 
    iprot.readStructBegin()
10186 
    while True:
10187 
      (fname, ftype, fid) = iprot.readFieldBegin()
10188 
      if ftype == TType.STOP:
10189 
        break
10190 
      if fid == 1:
10191 
        if ftype == TType.I64:
10192 
          self.item_id = iprot.readI64();
10193 
        else:
10194 
          iprot.skip(ftype)
10195 
      elif fid == 2:
10196 
        if ftype == TType.I64:
10197 
          self.warehouse_id = iprot.readI64();
10198 
        else:
10199 
          iprot.skip(ftype)
10200 
      else:
10201 
        iprot.skip(ftype)
10202 
      iprot.readFieldEnd()
10203 
    iprot.readStructEnd()
10204 
 
10205 
  def write(self, oprot):
10206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10208 
      return
10209 
    oprot.writeStructBegin('insertItemtoIgnoreInventoryUpdatelist_args')
10210 
    if self.item_id is not None:
10211 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
10212 
      oprot.writeI64(self.item_id)
10213 
      oprot.writeFieldEnd()
10214 
    if self.warehouse_id is not None:
10215 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 2)
10216 
      oprot.writeI64(self.warehouse_id)
10217 
      oprot.writeFieldEnd()
10218 
    oprot.writeFieldStop()
10219 
    oprot.writeStructEnd()
10220 
 
10221 
  def validate(self):
10222 
    return
10223 
 
10224 
 
10225 
  def __repr__(self):
10226 
    L = ['%s=%r' % (key, value)
10227 
      for key, value in self.__dict__.iteritems()]
10228 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10229 
 
10230 
  def __eq__(self, other):
10231 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10232 
 
10233 
  def __ne__(self, other):
10234 
    return not (self == other)
10235 
 
10236 
class insertItemtoIgnoreInventoryUpdatelist_result:
10237 
  """
10238 
  Attributes:
10239 
   - success
10240 
  """
10241 
 
10242 
  thrift_spec = (
10243 
    (0, TType.BOOL, 'success', None, None, ), # 0
10244 
  )
10245 
 
10246 
  def __init__(self, success=None,):
10247 
    self.success = success
10248 
 
10249 
  def read(self, iprot):
10250 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10251 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10252 
      return
10253 
    iprot.readStructBegin()
10254 
    while True:
10255 
      (fname, ftype, fid) = iprot.readFieldBegin()
10256 
      if ftype == TType.STOP:
10257 
        break
10258 
      if fid == 0:
10259 
        if ftype == TType.BOOL:
10260 
          self.success = iprot.readBool();
10261 
        else:
10262 
          iprot.skip(ftype)
10263 
      else:
10264 
        iprot.skip(ftype)
10265 
      iprot.readFieldEnd()
10266 
    iprot.readStructEnd()
10267 
 
10268 
  def write(self, oprot):
10269 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10270 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10271 
      return
10272 
    oprot.writeStructBegin('insertItemtoIgnoreInventoryUpdatelist_result')
10273 
    if self.success is not None:
10274 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10275 
      oprot.writeBool(self.success)
10276 
      oprot.writeFieldEnd()
10277 
    oprot.writeFieldStop()
10278 
    oprot.writeStructEnd()
10279 
 
10280 
  def validate(self):
10281 
    return
10282 
 
10283 
 
10284 
  def __repr__(self):
10285 
    L = ['%s=%r' % (key, value)
10286 
      for key, value in self.__dict__.iteritems()]
10287 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10288 
 
10289 
  def __eq__(self, other):
10290 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10291 
 
10292 
  def __ne__(self, other):
10293 
    return not (self == other)
10294 
 
10295 
class deleteItemFromIgnoredInventoryUpdateList_args:
10296 
  """
10297 
  Attributes:
10298 
   - item_id
10299 
   - warehouse_id
10300 
  """
10301 
 
10302 
  thrift_spec = (
10303 
    None, # 0
10304 
    (1, TType.I64, 'item_id', None, None, ), # 1
10305 
    (2, TType.I64, 'warehouse_id', None, None, ), # 2
10306 
  )
10307 
 
10308 
  def __init__(self, item_id=None, warehouse_id=None,):
10309 
    self.item_id = item_id
10310 
    self.warehouse_id = warehouse_id
10311 
 
10312 
  def read(self, iprot):
10313 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10314 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10315 
      return
10316 
    iprot.readStructBegin()
10317 
    while True:
10318 
      (fname, ftype, fid) = iprot.readFieldBegin()
10319 
      if ftype == TType.STOP:
10320 
        break
10321 
      if fid == 1:
10322 
        if ftype == TType.I64:
10323 
          self.item_id = iprot.readI64();
10324 
        else:
10325 
          iprot.skip(ftype)
10326 
      elif fid == 2:
10327 
        if ftype == TType.I64:
10328 
          self.warehouse_id = iprot.readI64();
10329 
        else:
10330 
          iprot.skip(ftype)
10331 
      else:
10332 
        iprot.skip(ftype)
10333 
      iprot.readFieldEnd()
10334 
    iprot.readStructEnd()
10335 
 
10336 
  def write(self, oprot):
10337 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10338 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10339 
      return
10340 
    oprot.writeStructBegin('deleteItemFromIgnoredInventoryUpdateList_args')
10341 
    if self.item_id is not None:
10342 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
10343 
      oprot.writeI64(self.item_id)
10344 
      oprot.writeFieldEnd()
10345 
    if self.warehouse_id is not None:
10346 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 2)
10347 
      oprot.writeI64(self.warehouse_id)
10348 
      oprot.writeFieldEnd()
10349 
    oprot.writeFieldStop()
10350 
    oprot.writeStructEnd()
10351 
 
10352 
  def validate(self):
10353 
    return
10354 
 
10355 
 
10356 
  def __repr__(self):
10357 
    L = ['%s=%r' % (key, value)
10358 
      for key, value in self.__dict__.iteritems()]
10359 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10360 
 
10361 
  def __eq__(self, other):
10362 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10363 
 
10364 
  def __ne__(self, other):
10365 
    return not (self == other)
10366 
 
10367 
class deleteItemFromIgnoredInventoryUpdateList_result:
10368 
  """
10369 
  Attributes:
10370 
   - success
10371 
  """
10372 
 
10373 
  thrift_spec = (
10374 
    (0, TType.BOOL, 'success', None, None, ), # 0
10375 
  )
10376 
 
10377 
  def __init__(self, success=None,):
10378 
    self.success = success
10379 
 
10380 
  def read(self, iprot):
10381 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10382 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10383 
      return
10384 
    iprot.readStructBegin()
10385 
    while True:
10386 
      (fname, ftype, fid) = iprot.readFieldBegin()
10387 
      if ftype == TType.STOP:
10388 
        break
10389 
      if fid == 0:
10390 
        if ftype == TType.BOOL:
10391 
          self.success = iprot.readBool();
10392 
        else:
10393 
          iprot.skip(ftype)
10394 
      else:
10395 
        iprot.skip(ftype)
10396 
      iprot.readFieldEnd()
10397 
    iprot.readStructEnd()
10398 
 
10399 
  def write(self, oprot):
10400 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10401 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10402 
      return
10403 
    oprot.writeStructBegin('deleteItemFromIgnoredInventoryUpdateList_result')
10404 
    if self.success is not None:
10405 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10406 
      oprot.writeBool(self.success)
10407 
      oprot.writeFieldEnd()
10408 
    oprot.writeFieldStop()
10409 
    oprot.writeStructEnd()
10410 
 
10411 
  def validate(self):
10412 
    return
10413 
 
10414 
 
10415 
  def __repr__(self):
10416 
    L = ['%s=%r' % (key, value)
10417 
      for key, value in self.__dict__.iteritems()]
10418 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10419 
 
10420 
  def __eq__(self, other):
10421 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10422 
 
10423 
  def __ne__(self, other):
10424 
    return not (self == other)
10425 
 
10426 
class getAllIgnoredInventoryupdateItemsCount_args:
10427 
 
10428 
  thrift_spec = (
10429 
  )
10430 
 
10431 
  def read(self, iprot):
10432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10434 
      return
10435 
    iprot.readStructBegin()
10436 
    while True:
10437 
      (fname, ftype, fid) = iprot.readFieldBegin()
10438 
      if ftype == TType.STOP:
10439 
        break
10440 
      else:
10441 
        iprot.skip(ftype)
10442 
      iprot.readFieldEnd()
10443 
    iprot.readStructEnd()
10444 
 
10445 
  def write(self, oprot):
10446 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10447 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10448 
      return
10449 
    oprot.writeStructBegin('getAllIgnoredInventoryupdateItemsCount_args')
10450 
    oprot.writeFieldStop()
10451 
    oprot.writeStructEnd()
10452 
 
10453 
  def validate(self):
10454 
    return
10455 
 
10456 
 
10457 
  def __repr__(self):
10458 
    L = ['%s=%r' % (key, value)
10459 
      for key, value in self.__dict__.iteritems()]
10460 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10461 
 
10462 
  def __eq__(self, other):
10463 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10464 
 
10465 
  def __ne__(self, other):
10466 
    return not (self == other)
10467 
 
10468 
class getAllIgnoredInventoryupdateItemsCount_result:
10469 
  """
10470 
  Attributes:
10471 
   - success
10472 
  """
10473 
 
10474 
  thrift_spec = (
10475 
    (0, TType.I32, 'success', None, None, ), # 0
10476 
  )
10477 
 
10478 
  def __init__(self, success=None,):
10479 
    self.success = success
10480 
 
10481 
  def read(self, iprot):
10482 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10483 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10484 
      return
10485 
    iprot.readStructBegin()
10486 
    while True:
10487 
      (fname, ftype, fid) = iprot.readFieldBegin()
10488 
      if ftype == TType.STOP:
10489 
        break
10490 
      if fid == 0:
10491 
        if ftype == TType.I32:
10492 
          self.success = iprot.readI32();
10493 
        else:
10494 
          iprot.skip(ftype)
10495 
      else:
10496 
        iprot.skip(ftype)
10497 
      iprot.readFieldEnd()
10498 
    iprot.readStructEnd()
10499 
 
10500 
  def write(self, oprot):
10501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10503 
      return
10504 
    oprot.writeStructBegin('getAllIgnoredInventoryupdateItemsCount_result')
10505 
    if self.success is not None:
10506 
      oprot.writeFieldBegin('success', TType.I32, 0)
10507 
      oprot.writeI32(self.success)
10508 
      oprot.writeFieldEnd()
10509 
    oprot.writeFieldStop()
10510 
    oprot.writeStructEnd()
10511 
 
10512 
  def validate(self):
10513 
    return
10514 
 
10515 
 
10516 
  def __repr__(self):
10517 
    L = ['%s=%r' % (key, value)
10518 
      for key, value in self.__dict__.iteritems()]
10519 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10520 
 
10521 
  def __eq__(self, other):
10522 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10523 
 
10524 
  def __ne__(self, other):
10525 
    return not (self == other)
10526 
 
10527 
class getIgnoredInventoryUpdateItemids_args:
10528 
  """
10529 
  Attributes:
10530 
   - offset
10531 
   - limit
10532 
  """
10533 
 
10534 
  thrift_spec = (
10535 
    None, # 0
10536 
    (1, TType.I32, 'offset', None, None, ), # 1
10537 
    (2, TType.I32, 'limit', None, None, ), # 2
10538 
  )
10539 
 
10540 
  def __init__(self, offset=None, limit=None,):
10541 
    self.offset = offset
10542 
    self.limit = limit
10543 
 
10544 
  def read(self, iprot):
10545 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10546 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10547 
      return
10548 
    iprot.readStructBegin()
10549 
    while True:
10550 
      (fname, ftype, fid) = iprot.readFieldBegin()
10551 
      if ftype == TType.STOP:
10552 
        break
10553 
      if fid == 1:
10554 
        if ftype == TType.I32:
10555 
          self.offset = iprot.readI32();
10556 
        else:
10557 
          iprot.skip(ftype)
10558 
      elif fid == 2:
10559 
        if ftype == TType.I32:
10560 
          self.limit = iprot.readI32();
10561 
        else:
10562 
          iprot.skip(ftype)
10563 
      else:
10564 
        iprot.skip(ftype)
10565 
      iprot.readFieldEnd()
10566 
    iprot.readStructEnd()
10567 
 
10568 
  def write(self, oprot):
10569 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10570 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10571 
      return
10572 
    oprot.writeStructBegin('getIgnoredInventoryUpdateItemids_args')
10573 
    if self.offset is not None:
10574 
      oprot.writeFieldBegin('offset', TType.I32, 1)
10575 
      oprot.writeI32(self.offset)
10576 
      oprot.writeFieldEnd()
10577 
    if self.limit is not None:
10578 
      oprot.writeFieldBegin('limit', TType.I32, 2)
10579 
      oprot.writeI32(self.limit)
10580 
      oprot.writeFieldEnd()
10581 
    oprot.writeFieldStop()
10582 
    oprot.writeStructEnd()
10583 
 
10584 
  def validate(self):
10585 
    return
10586 
 
10587 
 
10588 
  def __repr__(self):
10589 
    L = ['%s=%r' % (key, value)
10590 
      for key, value in self.__dict__.iteritems()]
10591 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10592 
 
10593 
  def __eq__(self, other):
10594 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10595 
 
10596 
  def __ne__(self, other):
10597 
    return not (self == other)
10598 
 
10599 
class getIgnoredInventoryUpdateItemids_result:
10600 
  """
10601 
  Attributes:
10602 
   - success
10603 
  """
10604 
 
10605 
  thrift_spec = (
10606 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10607 
  )
10608 
 
10609 
  def __init__(self, success=None,):
10610 
    self.success = success
10611 
 
10612 
  def read(self, iprot):
10613 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10614 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10615 
      return
10616 
    iprot.readStructBegin()
10617 
    while True:
10618 
      (fname, ftype, fid) = iprot.readFieldBegin()
10619 
      if ftype == TType.STOP:
10620 
        break
10621 
      if fid == 0:
10622 
        if ftype == TType.LIST:
10623 
          self.success = []
8182 amar.kumar 10624 
          (_etype189, _size186) = iprot.readListBegin()
10625 
          for _i190 in xrange(_size186):
10626 
            _elem191 = iprot.readI64();
10627 
            self.success.append(_elem191)
6531 vikram.rag 10628 
          iprot.readListEnd()
10629 
        else:
10630 
          iprot.skip(ftype)
10631 
      else:
10632 
        iprot.skip(ftype)
10633 
      iprot.readFieldEnd()
10634 
    iprot.readStructEnd()
10635 
 
10636 
  def write(self, oprot):
10637 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10638 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10639 
      return
10640 
    oprot.writeStructBegin('getIgnoredInventoryUpdateItemids_result')
10641 
    if self.success is not None:
10642 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10643 
      oprot.writeListBegin(TType.I64, len(self.success))
8182 amar.kumar 10644 
      for iter192 in self.success:
10645 
        oprot.writeI64(iter192)
6531 vikram.rag 10646 
      oprot.writeListEnd()
10647 
      oprot.writeFieldEnd()
10648 
    oprot.writeFieldStop()
10649 
    oprot.writeStructEnd()
10650 
 
10651 
  def validate(self):
10652 
    return
10653 
 
10654 
 
10655 
  def __repr__(self):
10656 
    L = ['%s=%r' % (key, value)
10657 
      for key, value in self.__dict__.iteritems()]
10658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10659 
 
10660 
  def __eq__(self, other):
10661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10662 
 
10663 
  def __ne__(self, other):
10664 
    return not (self == other)
6821 amar.kumar 10665 
 
10666 
class updateItemStockPurchaseParams_args:
10667 
  """
10668 
  Attributes:
10669 
   - item_id
10670 
   - numOfDaysStock
10671 
   - minStockLevel
10672 
  """
10673 
 
10674 
  thrift_spec = (
10675 
    None, # 0
10676 
    (1, TType.I64, 'item_id', None, None, ), # 1
10677 
    (2, TType.I32, 'numOfDaysStock', None, None, ), # 2
10678 
    (3, TType.I64, 'minStockLevel', None, None, ), # 3
10679 
  )
10680 
 
10681 
  def __init__(self, item_id=None, numOfDaysStock=None, minStockLevel=None,):
10682 
    self.item_id = item_id
10683 
    self.numOfDaysStock = numOfDaysStock
10684 
    self.minStockLevel = minStockLevel
10685 
 
10686 
  def read(self, iprot):
10687 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10688 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10689 
      return
10690 
    iprot.readStructBegin()
10691 
    while True:
10692 
      (fname, ftype, fid) = iprot.readFieldBegin()
10693 
      if ftype == TType.STOP:
10694 
        break
10695 
      if fid == 1:
10696 
        if ftype == TType.I64:
10697 
          self.item_id = iprot.readI64();
10698 
        else:
10699 
          iprot.skip(ftype)
10700 
      elif fid == 2:
10701 
        if ftype == TType.I32:
10702 
          self.numOfDaysStock = iprot.readI32();
10703 
        else:
10704 
          iprot.skip(ftype)
10705 
      elif fid == 3:
10706 
        if ftype == TType.I64:
10707 
          self.minStockLevel = iprot.readI64();
10708 
        else:
10709 
          iprot.skip(ftype)
10710 
      else:
10711 
        iprot.skip(ftype)
10712 
      iprot.readFieldEnd()
10713 
    iprot.readStructEnd()
10714 
 
10715 
  def write(self, oprot):
10716 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10717 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10718 
      return
10719 
    oprot.writeStructBegin('updateItemStockPurchaseParams_args')
10720 
    if self.item_id is not None:
10721 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
10722 
      oprot.writeI64(self.item_id)
10723 
      oprot.writeFieldEnd()
10724 
    if self.numOfDaysStock is not None:
10725 
      oprot.writeFieldBegin('numOfDaysStock', TType.I32, 2)
10726 
      oprot.writeI32(self.numOfDaysStock)
10727 
      oprot.writeFieldEnd()
10728 
    if self.minStockLevel is not None:
10729 
      oprot.writeFieldBegin('minStockLevel', TType.I64, 3)
10730 
      oprot.writeI64(self.minStockLevel)
10731 
      oprot.writeFieldEnd()
10732 
    oprot.writeFieldStop()
10733 
    oprot.writeStructEnd()
10734 
 
10735 
  def validate(self):
10736 
    return
10737 
 
10738 
 
10739 
  def __repr__(self):
10740 
    L = ['%s=%r' % (key, value)
10741 
      for key, value in self.__dict__.iteritems()]
10742 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10743 
 
10744 
  def __eq__(self, other):
10745 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10746 
 
10747 
  def __ne__(self, other):
10748 
    return not (self == other)
10749 
 
10750 
class updateItemStockPurchaseParams_result:
10751 
 
10752 
  thrift_spec = (
10753 
  )
10754 
 
10755 
  def read(self, iprot):
10756 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10757 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10758 
      return
10759 
    iprot.readStructBegin()
10760 
    while True:
10761 
      (fname, ftype, fid) = iprot.readFieldBegin()
10762 
      if ftype == TType.STOP:
10763 
        break
10764 
      else:
10765 
        iprot.skip(ftype)
10766 
      iprot.readFieldEnd()
10767 
    iprot.readStructEnd()
10768 
 
10769 
  def write(self, oprot):
10770 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10771 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10772 
      return
10773 
    oprot.writeStructBegin('updateItemStockPurchaseParams_result')
10774 
    oprot.writeFieldStop()
10775 
    oprot.writeStructEnd()
10776 
 
10777 
  def validate(self):
10778 
    return
10779 
 
10780 
 
10781 
  def __repr__(self):
10782 
    L = ['%s=%r' % (key, value)
10783 
      for key, value in self.__dict__.iteritems()]
10784 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10785 
 
10786 
  def __eq__(self, other):
10787 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10788 
 
10789 
  def __ne__(self, other):
10790 
    return not (self == other)
10791 
 
10792 
class getItemStockPurchaseParams_args:
10793 
  """
10794 
  Attributes:
10795 
   - itemId
10796 
  """
10797 
 
10798 
  thrift_spec = (
10799 
    None, # 0
10800 
    (1, TType.I64, 'itemId', None, None, ), # 1
10801 
  )
10802 
 
10803 
  def __init__(self, itemId=None,):
10804 
    self.itemId = itemId
10805 
 
10806 
  def read(self, iprot):
10807 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10808 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10809 
      return
10810 
    iprot.readStructBegin()
10811 
    while True:
10812 
      (fname, ftype, fid) = iprot.readFieldBegin()
10813 
      if ftype == TType.STOP:
10814 
        break
10815 
      if fid == 1:
10816 
        if ftype == TType.I64:
10817 
          self.itemId = iprot.readI64();
10818 
        else:
10819 
          iprot.skip(ftype)
10820 
      else:
10821 
        iprot.skip(ftype)
10822 
      iprot.readFieldEnd()
10823 
    iprot.readStructEnd()
10824 
 
10825 
  def write(self, oprot):
10826 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10827 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10828 
      return
10829 
    oprot.writeStructBegin('getItemStockPurchaseParams_args')
10830 
    if self.itemId is not None:
10831 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
10832 
      oprot.writeI64(self.itemId)
10833 
      oprot.writeFieldEnd()
10834 
    oprot.writeFieldStop()
10835 
    oprot.writeStructEnd()
10836 
 
10837 
  def validate(self):
10838 
    return
10839 
 
10840 
 
10841 
  def __repr__(self):
10842 
    L = ['%s=%r' % (key, value)
10843 
      for key, value in self.__dict__.iteritems()]
10844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10845 
 
10846 
  def __eq__(self, other):
10847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10848 
 
10849 
  def __ne__(self, other):
10850 
    return not (self == other)
10851 
 
10852 
class getItemStockPurchaseParams_result:
10853 
  """
10854 
  Attributes:
10855 
   - success
10856 
  """
10857 
 
10858 
  thrift_spec = (
10859 
    (0, TType.STRUCT, 'success', (ItemStockPurchaseParams, ItemStockPurchaseParams.thrift_spec), None, ), # 0
10860 
  )
10861 
 
10862 
  def __init__(self, success=None,):
10863 
    self.success = success
10864 
 
10865 
  def read(self, iprot):
10866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10868 
      return
10869 
    iprot.readStructBegin()
10870 
    while True:
10871 
      (fname, ftype, fid) = iprot.readFieldBegin()
10872 
      if ftype == TType.STOP:
10873 
        break
10874 
      if fid == 0:
10875 
        if ftype == TType.STRUCT:
10876 
          self.success = ItemStockPurchaseParams()
10877 
          self.success.read(iprot)
10878 
        else:
10879 
          iprot.skip(ftype)
10880 
      else:
10881 
        iprot.skip(ftype)
10882 
      iprot.readFieldEnd()
10883 
    iprot.readStructEnd()
10884 
 
10885 
  def write(self, oprot):
10886 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10887 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10888 
      return
10889 
    oprot.writeStructBegin('getItemStockPurchaseParams_result')
10890 
    if self.success is not None:
10891 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10892 
      self.success.write(oprot)
10893 
      oprot.writeFieldEnd()
10894 
    oprot.writeFieldStop()
10895 
    oprot.writeStructEnd()
10896 
 
10897 
  def validate(self):
10898 
    return
10899 
 
10900 
 
10901 
  def __repr__(self):
10902 
    L = ['%s=%r' % (key, value)
10903 
      for key, value in self.__dict__.iteritems()]
10904 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10905 
 
10906 
  def __eq__(self, other):
10907 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10908 
 
10909 
  def __ne__(self, other):
10910 
    return not (self == other)
10911 
 
10912 
class addOosStatusForItem_args:
10913 
  """
10914 
  Attributes:
10915 
   - oosStatusMap
10916 
   - date
10917 
  """
10918 
 
10919 
  thrift_spec = (
10920 
    None, # 0
10921 
    (1, TType.MAP, 'oosStatusMap', (TType.I64,None,TType.BOOL,None), None, ), # 1
10922 
    (2, TType.I64, 'date', None, None, ), # 2
10923 
  )
10924 
 
10925 
  def __init__(self, oosStatusMap=None, date=None,):
10926 
    self.oosStatusMap = oosStatusMap
10927 
    self.date = date
10928 
 
10929 
  def read(self, iprot):
10930 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10931 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10932 
      return
10933 
    iprot.readStructBegin()
10934 
    while True:
10935 
      (fname, ftype, fid) = iprot.readFieldBegin()
10936 
      if ftype == TType.STOP:
10937 
        break
10938 
      if fid == 1:
10939 
        if ftype == TType.MAP:
10940 
          self.oosStatusMap = {}
8182 amar.kumar 10941 
          (_ktype194, _vtype195, _size193 ) = iprot.readMapBegin()
10942 
          for _i197 in xrange(_size193):
10943 
            _key198 = iprot.readI64();
10944 
            _val199 = iprot.readBool();
10945 
            self.oosStatusMap[_key198] = _val199
6821 amar.kumar 10946 
          iprot.readMapEnd()
10947 
        else:
10948 
          iprot.skip(ftype)
10949 
      elif fid == 2:
10950 
        if ftype == TType.I64:
10951 
          self.date = iprot.readI64();
10952 
        else:
10953 
          iprot.skip(ftype)
10954 
      else:
10955 
        iprot.skip(ftype)
10956 
      iprot.readFieldEnd()
10957 
    iprot.readStructEnd()
10958 
 
10959 
  def write(self, oprot):
10960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10962 
      return
10963 
    oprot.writeStructBegin('addOosStatusForItem_args')
10964 
    if self.oosStatusMap is not None:
10965 
      oprot.writeFieldBegin('oosStatusMap', TType.MAP, 1)
10966 
      oprot.writeMapBegin(TType.I64, TType.BOOL, len(self.oosStatusMap))
8182 amar.kumar 10967 
      for kiter200,viter201 in self.oosStatusMap.items():
10968 
        oprot.writeI64(kiter200)
10969 
        oprot.writeBool(viter201)
6821 amar.kumar 10970 
      oprot.writeMapEnd()
10971 
      oprot.writeFieldEnd()
10972 
    if self.date is not None:
10973 
      oprot.writeFieldBegin('date', TType.I64, 2)
10974 
      oprot.writeI64(self.date)
10975 
      oprot.writeFieldEnd()
10976 
    oprot.writeFieldStop()
10977 
    oprot.writeStructEnd()
10978 
 
10979 
  def validate(self):
10980 
    return
10981 
 
10982 
 
10983 
  def __repr__(self):
10984 
    L = ['%s=%r' % (key, value)
10985 
      for key, value in self.__dict__.iteritems()]
10986 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10987 
 
10988 
  def __eq__(self, other):
10989 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10990 
 
10991 
  def __ne__(self, other):
10992 
    return not (self == other)
10993 
 
10994 
class addOosStatusForItem_result:
10995 
 
10996 
  thrift_spec = (
10997 
  )
10998 
 
10999 
  def read(self, iprot):
11000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11002 
      return
11003 
    iprot.readStructBegin()
11004 
    while True:
11005 
      (fname, ftype, fid) = iprot.readFieldBegin()
11006 
      if ftype == TType.STOP:
11007 
        break
11008 
      else:
11009 
        iprot.skip(ftype)
11010 
      iprot.readFieldEnd()
11011 
    iprot.readStructEnd()
11012 
 
11013 
  def write(self, oprot):
11014 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11015 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11016 
      return
11017 
    oprot.writeStructBegin('addOosStatusForItem_result')
11018 
    oprot.writeFieldStop()
11019 
    oprot.writeStructEnd()
11020 
 
11021 
  def validate(self):
11022 
    return
11023 
 
11024 
 
11025 
  def __repr__(self):
11026 
    L = ['%s=%r' % (key, value)
11027 
      for key, value in self.__dict__.iteritems()]
11028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11029 
 
11030 
  def __eq__(self, other):
11031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11032 
 
11033 
  def __ne__(self, other):
11034 
    return not (self == other)
6832 amar.kumar 11035 
 
11036 
class getOosStatusesForXDaysForItem_args:
11037 
  """
11038 
  Attributes:
11039 
   - itemId
9762 amar.kumar 11040 
   - sourceId
6832 amar.kumar 11041 
   - days
11042 
  """
11043 
 
11044 
  thrift_spec = (
11045 
    None, # 0
11046 
    (1, TType.I64, 'itemId', None, None, ), # 1
9762 amar.kumar 11047 
    (2, TType.I32, 'sourceId', None, None, ), # 2
11048 
    (3, TType.I32, 'days', None, None, ), # 3
6832 amar.kumar 11049 
  )
11050 
 
9762 amar.kumar 11051 
  def __init__(self, itemId=None, sourceId=None, days=None,):
6832 amar.kumar 11052 
    self.itemId = itemId
9762 amar.kumar 11053 
    self.sourceId = sourceId
6832 amar.kumar 11054 
    self.days = days
11055 
 
11056 
  def read(self, iprot):
11057 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11058 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11059 
      return
11060 
    iprot.readStructBegin()
11061 
    while True:
11062 
      (fname, ftype, fid) = iprot.readFieldBegin()
11063 
      if ftype == TType.STOP:
11064 
        break
11065 
      if fid == 1:
11066 
        if ftype == TType.I64:
11067 
          self.itemId = iprot.readI64();
11068 
        else:
11069 
          iprot.skip(ftype)
11070 
      elif fid == 2:
11071 
        if ftype == TType.I32:
9762 amar.kumar 11072 
          self.sourceId = iprot.readI32();
11073 
        else:
11074 
          iprot.skip(ftype)
11075 
      elif fid == 3:
11076 
        if ftype == TType.I32:
6832 amar.kumar 11077 
          self.days = iprot.readI32();
11078 
        else:
11079 
          iprot.skip(ftype)
11080 
      else:
11081 
        iprot.skip(ftype)
11082 
      iprot.readFieldEnd()
11083 
    iprot.readStructEnd()
11084 
 
11085 
  def write(self, oprot):
11086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11088 
      return
11089 
    oprot.writeStructBegin('getOosStatusesForXDaysForItem_args')
11090 
    if self.itemId is not None:
11091 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11092 
      oprot.writeI64(self.itemId)
11093 
      oprot.writeFieldEnd()
9762 amar.kumar 11094 
    if self.sourceId is not None:
11095 
      oprot.writeFieldBegin('sourceId', TType.I32, 2)
11096 
      oprot.writeI32(self.sourceId)
11097 
      oprot.writeFieldEnd()
6832 amar.kumar 11098 
    if self.days is not None:
9762 amar.kumar 11099 
      oprot.writeFieldBegin('days', TType.I32, 3)
6832 amar.kumar 11100 
      oprot.writeI32(self.days)
11101 
      oprot.writeFieldEnd()
11102 
    oprot.writeFieldStop()
11103 
    oprot.writeStructEnd()
11104 
 
11105 
  def validate(self):
11106 
    return
11107 
 
11108 
 
11109 
  def __repr__(self):
11110 
    L = ['%s=%r' % (key, value)
11111 
      for key, value in self.__dict__.iteritems()]
11112 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11113 
 
11114 
  def __eq__(self, other):
11115 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11116 
 
11117 
  def __ne__(self, other):
11118 
    return not (self == other)
11119 
 
11120 
class getOosStatusesForXDaysForItem_result:
11121 
  """
11122 
  Attributes:
11123 
   - success
11124 
  """
11125 
 
11126 
  thrift_spec = (
11127 
    (0, TType.LIST, 'success', (TType.STRUCT,(OOSStatus, OOSStatus.thrift_spec)), None, ), # 0
11128 
  )
11129 
 
11130 
  def __init__(self, success=None,):
11131 
    self.success = success
11132 
 
11133 
  def read(self, iprot):
11134 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11135 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11136 
      return
11137 
    iprot.readStructBegin()
11138 
    while True:
11139 
      (fname, ftype, fid) = iprot.readFieldBegin()
11140 
      if ftype == TType.STOP:
11141 
        break
11142 
      if fid == 0:
11143 
        if ftype == TType.LIST:
11144 
          self.success = []
8182 amar.kumar 11145 
          (_etype205, _size202) = iprot.readListBegin()
11146 
          for _i206 in xrange(_size202):
11147 
            _elem207 = OOSStatus()
11148 
            _elem207.read(iprot)
11149 
            self.success.append(_elem207)
6832 amar.kumar 11150 
          iprot.readListEnd()
11151 
        else:
11152 
          iprot.skip(ftype)
11153 
      else:
11154 
        iprot.skip(ftype)
11155 
      iprot.readFieldEnd()
11156 
    iprot.readStructEnd()
11157 
 
11158 
  def write(self, oprot):
11159 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11160 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11161 
      return
11162 
    oprot.writeStructBegin('getOosStatusesForXDaysForItem_result')
11163 
    if self.success is not None:
11164 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11165 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 11166 
      for iter208 in self.success:
11167 
        iter208.write(oprot)
6832 amar.kumar 11168 
      oprot.writeListEnd()
11169 
      oprot.writeFieldEnd()
11170 
    oprot.writeFieldStop()
11171 
    oprot.writeStructEnd()
11172 
 
11173 
  def validate(self):
11174 
    return
11175 
 
11176 
 
11177 
  def __repr__(self):
11178 
    L = ['%s=%r' % (key, value)
11179 
      for key, value in self.__dict__.iteritems()]
11180 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11181 
 
11182 
  def __eq__(self, other):
11183 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11184 
 
11185 
  def __ne__(self, other):
11186 
    return not (self == other)
6857 amar.kumar 11187 
 
10126 amar.kumar 11188 
class getOosStatusesForXDays_args:
11189 
  """
11190 
  Attributes:
11191 
   - sourceId
11192 
   - days
11193 
  """
6857 amar.kumar 11194 
 
11195 
  thrift_spec = (
10126 amar.kumar 11196 
    None, # 0
11197 
    (1, TType.I32, 'sourceId', None, None, ), # 1
11198 
    (2, TType.I32, 'days', None, None, ), # 2
6857 amar.kumar 11199 
  )
11200 
 
10126 amar.kumar 11201 
  def __init__(self, sourceId=None, days=None,):
11202 
    self.sourceId = sourceId
11203 
    self.days = days
11204 
 
6857 amar.kumar 11205 
  def read(self, iprot):
11206 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11207 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11208 
      return
11209 
    iprot.readStructBegin()
11210 
    while True:
11211 
      (fname, ftype, fid) = iprot.readFieldBegin()
11212 
      if ftype == TType.STOP:
11213 
        break
10126 amar.kumar 11214 
      if fid == 1:
11215 
        if ftype == TType.I32:
11216 
          self.sourceId = iprot.readI32();
11217 
        else:
11218 
          iprot.skip(ftype)
11219 
      elif fid == 2:
11220 
        if ftype == TType.I32:
11221 
          self.days = iprot.readI32();
11222 
        else:
11223 
          iprot.skip(ftype)
6857 amar.kumar 11224 
      else:
11225 
        iprot.skip(ftype)
11226 
      iprot.readFieldEnd()
11227 
    iprot.readStructEnd()
11228 
 
11229 
  def write(self, oprot):
11230 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11231 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11232 
      return
10126 amar.kumar 11233 
    oprot.writeStructBegin('getOosStatusesForXDays_args')
11234 
    if self.sourceId is not None:
11235 
      oprot.writeFieldBegin('sourceId', TType.I32, 1)
11236 
      oprot.writeI32(self.sourceId)
11237 
      oprot.writeFieldEnd()
11238 
    if self.days is not None:
11239 
      oprot.writeFieldBegin('days', TType.I32, 2)
11240 
      oprot.writeI32(self.days)
11241 
      oprot.writeFieldEnd()
6857 amar.kumar 11242 
    oprot.writeFieldStop()
11243 
    oprot.writeStructEnd()
11244 
 
11245 
  def validate(self):
11246 
    return
11247 
 
11248 
 
11249 
  def __repr__(self):
11250 
    L = ['%s=%r' % (key, value)
11251 
      for key, value in self.__dict__.iteritems()]
11252 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11253 
 
11254 
  def __eq__(self, other):
11255 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11256 
 
11257 
  def __ne__(self, other):
11258 
    return not (self == other)
11259 
 
10126 amar.kumar 11260 
class getOosStatusesForXDays_result:
6857 amar.kumar 11261 
  """
11262 
  Attributes:
11263 
   - success
11264 
  """
11265 
 
11266 
  thrift_spec = (
10126 amar.kumar 11267 
    (0, TType.LIST, 'success', (TType.STRUCT,(OOSStatus, OOSStatus.thrift_spec)), None, ), # 0
6857 amar.kumar 11268 
  )
11269 
 
11270 
  def __init__(self, success=None,):
11271 
    self.success = success
11272 
 
11273 
  def read(self, iprot):
11274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11276 
      return
11277 
    iprot.readStructBegin()
11278 
    while True:
11279 
      (fname, ftype, fid) = iprot.readFieldBegin()
11280 
      if ftype == TType.STOP:
11281 
        break
11282 
      if fid == 0:
11283 
        if ftype == TType.LIST:
11284 
          self.success = []
8182 amar.kumar 11285 
          (_etype212, _size209) = iprot.readListBegin()
11286 
          for _i213 in xrange(_size209):
10126 amar.kumar 11287 
            _elem214 = OOSStatus()
8182 amar.kumar 11288 
            _elem214.read(iprot)
11289 
            self.success.append(_elem214)
6857 amar.kumar 11290 
          iprot.readListEnd()
11291 
        else:
11292 
          iprot.skip(ftype)
11293 
      else:
11294 
        iprot.skip(ftype)
11295 
      iprot.readFieldEnd()
11296 
    iprot.readStructEnd()
11297 
 
11298 
  def write(self, oprot):
11299 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11300 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11301 
      return
10126 amar.kumar 11302 
    oprot.writeStructBegin('getOosStatusesForXDays_result')
6857 amar.kumar 11303 
    if self.success is not None:
11304 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11305 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 11306 
      for iter215 in self.success:
11307 
        iter215.write(oprot)
6857 amar.kumar 11308 
      oprot.writeListEnd()
11309 
      oprot.writeFieldEnd()
11310 
    oprot.writeFieldStop()
11311 
    oprot.writeStructEnd()
11312 
 
11313 
  def validate(self):
11314 
    return
11315 
 
11316 
 
11317 
  def __repr__(self):
11318 
    L = ['%s=%r' % (key, value)
11319 
      for key, value in self.__dict__.iteritems()]
11320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11321 
 
11322 
  def __eq__(self, other):
11323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11324 
 
11325 
  def __ne__(self, other):
11326 
    return not (self == other)
7149 amar.kumar 11327 
 
10126 amar.kumar 11328 
class getAllVendorItemPricing_args:
11329 
  """
11330 
  Attributes:
11331 
   - itemId
11332 
   - vendorId
11333 
  """
7149 amar.kumar 11334 
 
11335 
  thrift_spec = (
10126 amar.kumar 11336 
    None, # 0
11337 
    (1, TType.I64, 'itemId', None, None, ), # 1
11338 
    (2, TType.I64, 'vendorId', None, None, ), # 2
7149 amar.kumar 11339 
  )
11340 
 
10126 amar.kumar 11341 
  def __init__(self, itemId=None, vendorId=None,):
11342 
    self.itemId = itemId
11343 
    self.vendorId = vendorId
11344 
 
7149 amar.kumar 11345 
  def read(self, iprot):
11346 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11347 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11348 
      return
11349 
    iprot.readStructBegin()
11350 
    while True:
11351 
      (fname, ftype, fid) = iprot.readFieldBegin()
11352 
      if ftype == TType.STOP:
11353 
        break
10126 amar.kumar 11354 
      if fid == 1:
11355 
        if ftype == TType.I64:
11356 
          self.itemId = iprot.readI64();
11357 
        else:
11358 
          iprot.skip(ftype)
11359 
      elif fid == 2:
11360 
        if ftype == TType.I64:
11361 
          self.vendorId = iprot.readI64();
11362 
        else:
11363 
          iprot.skip(ftype)
7149 amar.kumar 11364 
      else:
11365 
        iprot.skip(ftype)
11366 
      iprot.readFieldEnd()
11367 
    iprot.readStructEnd()
11368 
 
11369 
  def write(self, oprot):
11370 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11371 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11372 
      return
10126 amar.kumar 11373 
    oprot.writeStructBegin('getAllVendorItemPricing_args')
11374 
    if self.itemId is not None:
11375 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11376 
      oprot.writeI64(self.itemId)
11377 
      oprot.writeFieldEnd()
11378 
    if self.vendorId is not None:
11379 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
11380 
      oprot.writeI64(self.vendorId)
11381 
      oprot.writeFieldEnd()
7149 amar.kumar 11382 
    oprot.writeFieldStop()
11383 
    oprot.writeStructEnd()
11384 
 
11385 
  def validate(self):
11386 
    return
11387 
 
11388 
 
11389 
  def __repr__(self):
11390 
    L = ['%s=%r' % (key, value)
11391 
      for key, value in self.__dict__.iteritems()]
11392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11393 
 
11394 
  def __eq__(self, other):
11395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11396 
 
11397 
  def __ne__(self, other):
11398 
    return not (self == other)
11399 
 
10126 amar.kumar 11400 
class getAllVendorItemPricing_result:
7149 amar.kumar 11401 
  """
11402 
  Attributes:
11403 
   - success
11404 
  """
11405 
 
11406 
  thrift_spec = (
10126 amar.kumar 11407 
    (0, TType.LIST, 'success', (TType.STRUCT,(VendorItemPricing, VendorItemPricing.thrift_spec)), None, ), # 0
7149 amar.kumar 11408 
  )
11409 
 
11410 
  def __init__(self, success=None,):
11411 
    self.success = success
11412 
 
11413 
  def read(self, iprot):
11414 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11415 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11416 
      return
11417 
    iprot.readStructBegin()
11418 
    while True:
11419 
      (fname, ftype, fid) = iprot.readFieldBegin()
11420 
      if ftype == TType.STOP:
11421 
        break
11422 
      if fid == 0:
11423 
        if ftype == TType.LIST:
11424 
          self.success = []
8182 amar.kumar 11425 
          (_etype219, _size216) = iprot.readListBegin()
11426 
          for _i220 in xrange(_size216):
10126 amar.kumar 11427 
            _elem221 = VendorItemPricing()
8182 amar.kumar 11428 
            _elem221.read(iprot)
11429 
            self.success.append(_elem221)
7149 amar.kumar 11430 
          iprot.readListEnd()
11431 
        else:
11432 
          iprot.skip(ftype)
11433 
      else:
11434 
        iprot.skip(ftype)
11435 
      iprot.readFieldEnd()
11436 
    iprot.readStructEnd()
11437 
 
11438 
  def write(self, oprot):
11439 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11440 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11441 
      return
10126 amar.kumar 11442 
    oprot.writeStructBegin('getAllVendorItemPricing_result')
7149 amar.kumar 11443 
    if self.success is not None:
11444 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11445 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 11446 
      for iter222 in self.success:
11447 
        iter222.write(oprot)
7149 amar.kumar 11448 
      oprot.writeListEnd()
11449 
      oprot.writeFieldEnd()
11450 
    oprot.writeFieldStop()
11451 
    oprot.writeStructEnd()
11452 
 
11453 
  def validate(self):
11454 
    return
11455 
 
11456 
 
11457 
  def __repr__(self):
11458 
    L = ['%s=%r' % (key, value)
11459 
      for key, value in self.__dict__.iteritems()]
11460 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11461 
 
11462 
  def __eq__(self, other):
11463 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11464 
 
11465 
  def __ne__(self, other):
11466 
    return not (self == other)
7281 kshitij.so 11467 
 
10126 amar.kumar 11468 
class getNonZeroItemStockPurchaseParams_args:
11469 
 
11470 
  thrift_spec = (
11471 
  )
11472 
 
11473 
  def read(self, iprot):
11474 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11475 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11476 
      return
11477 
    iprot.readStructBegin()
11478 
    while True:
11479 
      (fname, ftype, fid) = iprot.readFieldBegin()
11480 
      if ftype == TType.STOP:
11481 
        break
11482 
      else:
11483 
        iprot.skip(ftype)
11484 
      iprot.readFieldEnd()
11485 
    iprot.readStructEnd()
11486 
 
11487 
  def write(self, oprot):
11488 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11489 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11490 
      return
11491 
    oprot.writeStructBegin('getNonZeroItemStockPurchaseParams_args')
11492 
    oprot.writeFieldStop()
11493 
    oprot.writeStructEnd()
11494 
 
11495 
  def validate(self):
11496 
    return
11497 
 
11498 
 
11499 
  def __repr__(self):
11500 
    L = ['%s=%r' % (key, value)
11501 
      for key, value in self.__dict__.iteritems()]
11502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11503 
 
11504 
  def __eq__(self, other):
11505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11506 
 
11507 
  def __ne__(self, other):
11508 
    return not (self == other)
11509 
 
11510 
class getNonZeroItemStockPurchaseParams_result:
11511 
  """
11512 
  Attributes:
11513 
   - success
11514 
  """
11515 
 
11516 
  thrift_spec = (
11517 
    (0, TType.LIST, 'success', (TType.STRUCT,(ItemStockPurchaseParams, ItemStockPurchaseParams.thrift_spec)), None, ), # 0
11518 
  )
11519 
 
11520 
  def __init__(self, success=None,):
11521 
    self.success = success
11522 
 
11523 
  def read(self, iprot):
11524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11526 
      return
11527 
    iprot.readStructBegin()
11528 
    while True:
11529 
      (fname, ftype, fid) = iprot.readFieldBegin()
11530 
      if ftype == TType.STOP:
11531 
        break
11532 
      if fid == 0:
11533 
        if ftype == TType.LIST:
11534 
          self.success = []
11535 
          (_etype226, _size223) = iprot.readListBegin()
11536 
          for _i227 in xrange(_size223):
11537 
            _elem228 = ItemStockPurchaseParams()
11538 
            _elem228.read(iprot)
11539 
            self.success.append(_elem228)
11540 
          iprot.readListEnd()
11541 
        else:
11542 
          iprot.skip(ftype)
11543 
      else:
11544 
        iprot.skip(ftype)
11545 
      iprot.readFieldEnd()
11546 
    iprot.readStructEnd()
11547 
 
11548 
  def write(self, oprot):
11549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11551 
      return
11552 
    oprot.writeStructBegin('getNonZeroItemStockPurchaseParams_result')
11553 
    if self.success is not None:
11554 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11555 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11556 
      for iter229 in self.success:
11557 
        iter229.write(oprot)
11558 
      oprot.writeListEnd()
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 getBillableInventoryAndPendingOrders_args:
11579 
 
11580 
  thrift_spec = (
11581 
  )
11582 
 
11583 
  def read(self, iprot):
11584 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11585 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11586 
      return
11587 
    iprot.readStructBegin()
11588 
    while True:
11589 
      (fname, ftype, fid) = iprot.readFieldBegin()
11590 
      if ftype == TType.STOP:
11591 
        break
11592 
      else:
11593 
        iprot.skip(ftype)
11594 
      iprot.readFieldEnd()
11595 
    iprot.readStructEnd()
11596 
 
11597 
  def write(self, oprot):
11598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11600 
      return
11601 
    oprot.writeStructBegin('getBillableInventoryAndPendingOrders_args')
11602 
    oprot.writeFieldStop()
11603 
    oprot.writeStructEnd()
11604 
 
11605 
  def validate(self):
11606 
    return
11607 
 
11608 
 
11609 
  def __repr__(self):
11610 
    L = ['%s=%r' % (key, value)
11611 
      for key, value in self.__dict__.iteritems()]
11612 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11613 
 
11614 
  def __eq__(self, other):
11615 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11616 
 
11617 
  def __ne__(self, other):
11618 
    return not (self == other)
11619 
 
11620 
class getBillableInventoryAndPendingOrders_result:
11621 
  """
11622 
  Attributes:
11623 
   - success
11624 
  """
11625 
 
11626 
  thrift_spec = (
11627 
    (0, TType.LIST, 'success', (TType.STRUCT,(AvailableAndReservedStock, AvailableAndReservedStock.thrift_spec)), None, ), # 0
11628 
  )
11629 
 
11630 
  def __init__(self, success=None,):
11631 
    self.success = success
11632 
 
11633 
  def read(self, iprot):
11634 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11635 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11636 
      return
11637 
    iprot.readStructBegin()
11638 
    while True:
11639 
      (fname, ftype, fid) = iprot.readFieldBegin()
11640 
      if ftype == TType.STOP:
11641 
        break
11642 
      if fid == 0:
11643 
        if ftype == TType.LIST:
11644 
          self.success = []
11645 
          (_etype233, _size230) = iprot.readListBegin()
11646 
          for _i234 in xrange(_size230):
11647 
            _elem235 = AvailableAndReservedStock()
11648 
            _elem235.read(iprot)
11649 
            self.success.append(_elem235)
11650 
          iprot.readListEnd()
11651 
        else:
11652 
          iprot.skip(ftype)
11653 
      else:
11654 
        iprot.skip(ftype)
11655 
      iprot.readFieldEnd()
11656 
    iprot.readStructEnd()
11657 
 
11658 
  def write(self, oprot):
11659 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11660 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11661 
      return
11662 
    oprot.writeStructBegin('getBillableInventoryAndPendingOrders_result')
11663 
    if self.success is not None:
11664 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11665 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11666 
      for iter236 in self.success:
11667 
        iter236.write(oprot)
11668 
      oprot.writeListEnd()
11669 
      oprot.writeFieldEnd()
11670 
    oprot.writeFieldStop()
11671 
    oprot.writeStructEnd()
11672 
 
11673 
  def validate(self):
11674 
    return
11675 
 
11676 
 
11677 
  def __repr__(self):
11678 
    L = ['%s=%r' % (key, value)
11679 
      for key, value in self.__dict__.iteritems()]
11680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11681 
 
11682 
  def __eq__(self, other):
11683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11684 
 
11685 
  def __ne__(self, other):
11686 
    return not (self == other)
11687 
 
7281 kshitij.so 11688 
class getWarehouseName_args:
11689 
  """
11690 
  Attributes:
11691 
   - warehouse_id
11692 
  """
11693 
 
11694 
  thrift_spec = (
11695 
    None, # 0
11696 
    (1, TType.I64, 'warehouse_id', None, None, ), # 1
11697 
  )
11698 
 
11699 
  def __init__(self, warehouse_id=None,):
11700 
    self.warehouse_id = warehouse_id
11701 
 
11702 
  def read(self, iprot):
11703 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11704 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11705 
      return
11706 
    iprot.readStructBegin()
11707 
    while True:
11708 
      (fname, ftype, fid) = iprot.readFieldBegin()
11709 
      if ftype == TType.STOP:
11710 
        break
11711 
      if fid == 1:
11712 
        if ftype == TType.I64:
11713 
          self.warehouse_id = iprot.readI64();
11714 
        else:
11715 
          iprot.skip(ftype)
11716 
      else:
11717 
        iprot.skip(ftype)
11718 
      iprot.readFieldEnd()
11719 
    iprot.readStructEnd()
11720 
 
11721 
  def write(self, oprot):
11722 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11723 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11724 
      return
11725 
    oprot.writeStructBegin('getWarehouseName_args')
11726 
    if self.warehouse_id is not None:
11727 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 1)
11728 
      oprot.writeI64(self.warehouse_id)
11729 
      oprot.writeFieldEnd()
11730 
    oprot.writeFieldStop()
11731 
    oprot.writeStructEnd()
11732 
 
11733 
  def validate(self):
11734 
    return
11735 
 
11736 
 
11737 
  def __repr__(self):
11738 
    L = ['%s=%r' % (key, value)
11739 
      for key, value in self.__dict__.iteritems()]
11740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11741 
 
11742 
  def __eq__(self, other):
11743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11744 
 
11745 
  def __ne__(self, other):
11746 
    return not (self == other)
11747 
 
11748 
class getWarehouseName_result:
11749 
  """
11750 
  Attributes:
11751 
   - success
11752 
  """
11753 
 
11754 
  thrift_spec = (
11755 
    (0, TType.STRING, 'success', None, None, ), # 0
11756 
  )
11757 
 
11758 
  def __init__(self, success=None,):
11759 
    self.success = success
11760 
 
11761 
  def read(self, iprot):
11762 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11763 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11764 
      return
11765 
    iprot.readStructBegin()
11766 
    while True:
11767 
      (fname, ftype, fid) = iprot.readFieldBegin()
11768 
      if ftype == TType.STOP:
11769 
        break
11770 
      if fid == 0:
11771 
        if ftype == TType.STRING:
11772 
          self.success = iprot.readString();
11773 
        else:
11774 
          iprot.skip(ftype)
11775 
      else:
11776 
        iprot.skip(ftype)
11777 
      iprot.readFieldEnd()
11778 
    iprot.readStructEnd()
11779 
 
11780 
  def write(self, oprot):
11781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11783 
      return
11784 
    oprot.writeStructBegin('getWarehouseName_result')
11785 
    if self.success is not None:
11786 
      oprot.writeFieldBegin('success', TType.STRING, 0)
11787 
      oprot.writeString(self.success)
11788 
      oprot.writeFieldEnd()
11789 
    oprot.writeFieldStop()
11790 
    oprot.writeStructEnd()
11791 
 
11792 
  def validate(self):
11793 
    return
11794 
 
11795 
 
11796 
  def __repr__(self):
11797 
    L = ['%s=%r' % (key, value)
11798 
      for key, value in self.__dict__.iteritems()]
11799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11800 
 
11801 
  def __eq__(self, other):
11802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11803 
 
11804 
  def __ne__(self, other):
11805 
    return not (self == other)
11806 
 
11807 
class getAmazonInventoryForItem_args:
11808 
  """
11809 
  Attributes:
11810 
   - item_id
11811 
  """
11812 
 
11813 
  thrift_spec = (
11814 
    None, # 0
11815 
    (1, TType.I64, 'item_id', None, None, ), # 1
11816 
  )
11817 
 
11818 
  def __init__(self, item_id=None,):
11819 
    self.item_id = item_id
11820 
 
11821 
  def read(self, iprot):
11822 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11823 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11824 
      return
11825 
    iprot.readStructBegin()
11826 
    while True:
11827 
      (fname, ftype, fid) = iprot.readFieldBegin()
11828 
      if ftype == TType.STOP:
11829 
        break
11830 
      if fid == 1:
11831 
        if ftype == TType.I64:
11832 
          self.item_id = iprot.readI64();
11833 
        else:
11834 
          iprot.skip(ftype)
11835 
      else:
11836 
        iprot.skip(ftype)
11837 
      iprot.readFieldEnd()
11838 
    iprot.readStructEnd()
11839 
 
11840 
  def write(self, oprot):
11841 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11842 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11843 
      return
11844 
    oprot.writeStructBegin('getAmazonInventoryForItem_args')
11845 
    if self.item_id is not None:
11846 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
11847 
      oprot.writeI64(self.item_id)
11848 
      oprot.writeFieldEnd()
11849 
    oprot.writeFieldStop()
11850 
    oprot.writeStructEnd()
11851 
 
11852 
  def validate(self):
11853 
    return
11854 
 
11855 
 
11856 
  def __repr__(self):
11857 
    L = ['%s=%r' % (key, value)
11858 
      for key, value in self.__dict__.iteritems()]
11859 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11860 
 
11861 
  def __eq__(self, other):
11862 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11863 
 
11864 
  def __ne__(self, other):
11865 
    return not (self == other)
11866 
 
11867 
class getAmazonInventoryForItem_result:
11868 
  """
11869 
  Attributes:
11870 
   - success
11871 
  """
11872 
 
11873 
  thrift_spec = (
11874 
    (0, TType.STRUCT, 'success', (AmazonInventorySnapshot, AmazonInventorySnapshot.thrift_spec), None, ), # 0
11875 
  )
11876 
 
11877 
  def __init__(self, success=None,):
11878 
    self.success = success
11879 
 
11880 
  def read(self, iprot):
11881 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11882 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11883 
      return
11884 
    iprot.readStructBegin()
11885 
    while True:
11886 
      (fname, ftype, fid) = iprot.readFieldBegin()
11887 
      if ftype == TType.STOP:
11888 
        break
11889 
      if fid == 0:
11890 
        if ftype == TType.STRUCT:
11891 
          self.success = AmazonInventorySnapshot()
11892 
          self.success.read(iprot)
11893 
        else:
11894 
          iprot.skip(ftype)
11895 
      else:
11896 
        iprot.skip(ftype)
11897 
      iprot.readFieldEnd()
11898 
    iprot.readStructEnd()
11899 
 
11900 
  def write(self, oprot):
11901 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11902 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11903 
      return
11904 
    oprot.writeStructBegin('getAmazonInventoryForItem_result')
11905 
    if self.success is not None:
11906 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11907 
      self.success.write(oprot)
11908 
      oprot.writeFieldEnd()
11909 
    oprot.writeFieldStop()
11910 
    oprot.writeStructEnd()
11911 
 
11912 
  def validate(self):
11913 
    return
11914 
 
11915 
 
11916 
  def __repr__(self):
11917 
    L = ['%s=%r' % (key, value)
11918 
      for key, value in self.__dict__.iteritems()]
11919 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11920 
 
11921 
  def __eq__(self, other):
11922 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11923 
 
11924 
  def __ne__(self, other):
11925 
    return not (self == other)
11926 
 
11927 
class getAllAmazonInventory_args:
11928 
 
11929 
  thrift_spec = (
11930 
  )
11931 
 
11932 
  def read(self, iprot):
11933 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11934 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11935 
      return
11936 
    iprot.readStructBegin()
11937 
    while True:
11938 
      (fname, ftype, fid) = iprot.readFieldBegin()
11939 
      if ftype == TType.STOP:
11940 
        break
11941 
      else:
11942 
        iprot.skip(ftype)
11943 
      iprot.readFieldEnd()
11944 
    iprot.readStructEnd()
11945 
 
11946 
  def write(self, oprot):
11947 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11948 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11949 
      return
11950 
    oprot.writeStructBegin('getAllAmazonInventory_args')
11951 
    oprot.writeFieldStop()
11952 
    oprot.writeStructEnd()
11953 
 
11954 
  def validate(self):
11955 
    return
11956 
 
11957 
 
11958 
  def __repr__(self):
11959 
    L = ['%s=%r' % (key, value)
11960 
      for key, value in self.__dict__.iteritems()]
11961 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11962 
 
11963 
  def __eq__(self, other):
11964 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11965 
 
11966 
  def __ne__(self, other):
11967 
    return not (self == other)
11968 
 
11969 
class getAllAmazonInventory_result:
11970 
  """
11971 
  Attributes:
11972 
   - success
11973 
  """
11974 
 
11975 
  thrift_spec = (
11976 
    (0, TType.LIST, 'success', (TType.STRUCT,(AmazonInventorySnapshot, AmazonInventorySnapshot.thrift_spec)), None, ), # 0
11977 
  )
11978 
 
11979 
  def __init__(self, success=None,):
11980 
    self.success = success
11981 
 
11982 
  def read(self, iprot):
11983 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11984 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11985 
      return
11986 
    iprot.readStructBegin()
11987 
    while True:
11988 
      (fname, ftype, fid) = iprot.readFieldBegin()
11989 
      if ftype == TType.STOP:
11990 
        break
11991 
      if fid == 0:
11992 
        if ftype == TType.LIST:
11993 
          self.success = []
10126 amar.kumar 11994 
          (_etype240, _size237) = iprot.readListBegin()
11995 
          for _i241 in xrange(_size237):
11996 
            _elem242 = AmazonInventorySnapshot()
11997 
            _elem242.read(iprot)
11998 
            self.success.append(_elem242)
7281 kshitij.so 11999 
          iprot.readListEnd()
12000 
        else:
12001 
          iprot.skip(ftype)
12002 
      else:
12003 
        iprot.skip(ftype)
12004 
      iprot.readFieldEnd()
12005 
    iprot.readStructEnd()
12006 
 
12007 
  def write(self, oprot):
12008 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12009 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12010 
      return
12011 
    oprot.writeStructBegin('getAllAmazonInventory_result')
12012 
    if self.success is not None:
12013 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12014 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
10126 amar.kumar 12015 
      for iter243 in self.success:
12016 
        iter243.write(oprot)
7281 kshitij.so 12017 
      oprot.writeListEnd()
12018 
      oprot.writeFieldEnd()
12019 
    oprot.writeFieldStop()
12020 
    oprot.writeStructEnd()
12021 
 
12022 
  def validate(self):
12023 
    return
12024 
 
12025 
 
12026 
  def __repr__(self):
12027 
    L = ['%s=%r' % (key, value)
12028 
      for key, value in self.__dict__.iteritems()]
12029 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12030 
 
12031 
  def __eq__(self, other):
12032 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12033 
 
12034 
  def __ne__(self, other):
12035 
    return not (self == other)
12036 
 
12037 
class addOrUpdateAmazonInventoryForItem_args:
12038 
  """
12039 
  Attributes:
12040 
   - amazonInventorySnapshot
10450 vikram.rag 12041 
   - time
7281 kshitij.so 12042 
  """
12043 
 
12044 
  thrift_spec = (
12045 
    None, # 0
12046 
    (1, TType.STRUCT, 'amazonInventorySnapshot', (AmazonInventorySnapshot, AmazonInventorySnapshot.thrift_spec), None, ), # 1
10450 vikram.rag 12047 
    (2, TType.I64, 'time', None, None, ), # 2
7281 kshitij.so 12048 
  )
12049 
 
10450 vikram.rag 12050 
  def __init__(self, amazonInventorySnapshot=None, time=None,):
7281 kshitij.so 12051 
    self.amazonInventorySnapshot = amazonInventorySnapshot
10450 vikram.rag 12052 
    self.time = time
7281 kshitij.so 12053 
 
12054 
  def read(self, iprot):
12055 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12056 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12057 
      return
12058 
    iprot.readStructBegin()
12059 
    while True:
12060 
      (fname, ftype, fid) = iprot.readFieldBegin()
12061 
      if ftype == TType.STOP:
12062 
        break
12063 
      if fid == 1:
12064 
        if ftype == TType.STRUCT:
12065 
          self.amazonInventorySnapshot = AmazonInventorySnapshot()
12066 
          self.amazonInventorySnapshot.read(iprot)
12067 
        else:
12068 
          iprot.skip(ftype)
10450 vikram.rag 12069 
      elif fid == 2:
12070 
        if ftype == TType.I64:
12071 
          self.time = iprot.readI64();
12072 
        else:
12073 
          iprot.skip(ftype)
7281 kshitij.so 12074 
      else:
12075 
        iprot.skip(ftype)
12076 
      iprot.readFieldEnd()
12077 
    iprot.readStructEnd()
12078 
 
12079 
  def write(self, oprot):
12080 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12081 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12082 
      return
12083 
    oprot.writeStructBegin('addOrUpdateAmazonInventoryForItem_args')
12084 
    if self.amazonInventorySnapshot is not None:
12085 
      oprot.writeFieldBegin('amazonInventorySnapshot', TType.STRUCT, 1)
12086 
      self.amazonInventorySnapshot.write(oprot)
12087 
      oprot.writeFieldEnd()
10450 vikram.rag 12088 
    if self.time is not None:
12089 
      oprot.writeFieldBegin('time', TType.I64, 2)
12090 
      oprot.writeI64(self.time)
12091 
      oprot.writeFieldEnd()
7281 kshitij.so 12092 
    oprot.writeFieldStop()
12093 
    oprot.writeStructEnd()
12094 
 
12095 
  def validate(self):
12096 
    return
12097 
 
12098 
 
12099 
  def __repr__(self):
12100 
    L = ['%s=%r' % (key, value)
12101 
      for key, value in self.__dict__.iteritems()]
12102 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12103 
 
12104 
  def __eq__(self, other):
12105 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12106 
 
12107 
  def __ne__(self, other):
12108 
    return not (self == other)
12109 
 
12110 
class addOrUpdateAmazonInventoryForItem_result:
12111 
 
12112 
  thrift_spec = (
12113 
  )
12114 
 
12115 
  def read(self, iprot):
12116 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12117 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12118 
      return
12119 
    iprot.readStructBegin()
12120 
    while True:
12121 
      (fname, ftype, fid) = iprot.readFieldBegin()
12122 
      if ftype == TType.STOP:
12123 
        break
12124 
      else:
12125 
        iprot.skip(ftype)
12126 
      iprot.readFieldEnd()
12127 
    iprot.readStructEnd()
12128 
 
12129 
  def write(self, oprot):
12130 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12131 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12132 
      return
12133 
    oprot.writeStructBegin('addOrUpdateAmazonInventoryForItem_result')
12134 
    oprot.writeFieldStop()
12135 
    oprot.writeStructEnd()
12136 
 
12137 
  def validate(self):
12138 
    return
12139 
 
12140 
 
12141 
  def __repr__(self):
12142 
    L = ['%s=%r' % (key, value)
12143 
      for key, value in self.__dict__.iteritems()]
12144 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12145 
 
12146 
  def __eq__(self, other):
12147 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12148 
 
12149 
  def __ne__(self, other):
12150 
    return not (self == other)
7972 amar.kumar 12151 
 
12152 
class getLastNdaySaleForItem_args:
12153 
  """
12154 
  Attributes:
12155 
   - itemId
12156 
   - numberOfDays
12157 
  """
12158 
 
12159 
  thrift_spec = (
12160 
    None, # 0
12161 
    (1, TType.I64, 'itemId', None, None, ), # 1
12162 
    (2, TType.I64, 'numberOfDays', None, None, ), # 2
12163 
  )
12164 
 
12165 
  def __init__(self, itemId=None, numberOfDays=None,):
12166 
    self.itemId = itemId
12167 
    self.numberOfDays = numberOfDays
12168 
 
12169 
  def read(self, iprot):
12170 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12171 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12172 
      return
12173 
    iprot.readStructBegin()
12174 
    while True:
12175 
      (fname, ftype, fid) = iprot.readFieldBegin()
12176 
      if ftype == TType.STOP:
12177 
        break
12178 
      if fid == 1:
12179 
        if ftype == TType.I64:
12180 
          self.itemId = iprot.readI64();
12181 
        else:
12182 
          iprot.skip(ftype)
12183 
      elif fid == 2:
12184 
        if ftype == TType.I64:
12185 
          self.numberOfDays = iprot.readI64();
12186 
        else:
12187 
          iprot.skip(ftype)
12188 
      else:
12189 
        iprot.skip(ftype)
12190 
      iprot.readFieldEnd()
12191 
    iprot.readStructEnd()
12192 
 
12193 
  def write(self, oprot):
12194 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12195 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12196 
      return
12197 
    oprot.writeStructBegin('getLastNdaySaleForItem_args')
12198 
    if self.itemId is not None:
12199 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12200 
      oprot.writeI64(self.itemId)
12201 
      oprot.writeFieldEnd()
12202 
    if self.numberOfDays is not None:
12203 
      oprot.writeFieldBegin('numberOfDays', TType.I64, 2)
12204 
      oprot.writeI64(self.numberOfDays)
12205 
      oprot.writeFieldEnd()
12206 
    oprot.writeFieldStop()
12207 
    oprot.writeStructEnd()
12208 
 
12209 
  def validate(self):
12210 
    return
12211 
 
12212 
 
12213 
  def __repr__(self):
12214 
    L = ['%s=%r' % (key, value)
12215 
      for key, value in self.__dict__.iteritems()]
12216 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12217 
 
12218 
  def __eq__(self, other):
12219 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12220 
 
12221 
  def __ne__(self, other):
12222 
    return not (self == other)
12223 
 
12224 
class getLastNdaySaleForItem_result:
12225 
  """
12226 
  Attributes:
12227 
   - success
12228 
  """
12229 
 
12230 
  thrift_spec = (
12231 
    (0, TType.STRING, 'success', None, None, ), # 0
12232 
  )
12233 
 
12234 
  def __init__(self, success=None,):
12235 
    self.success = success
12236 
 
12237 
  def read(self, iprot):
12238 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12239 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12240 
      return
12241 
    iprot.readStructBegin()
12242 
    while True:
12243 
      (fname, ftype, fid) = iprot.readFieldBegin()
12244 
      if ftype == TType.STOP:
12245 
        break
12246 
      if fid == 0:
12247 
        if ftype == TType.STRING:
12248 
          self.success = iprot.readString();
12249 
        else:
12250 
          iprot.skip(ftype)
12251 
      else:
12252 
        iprot.skip(ftype)
12253 
      iprot.readFieldEnd()
12254 
    iprot.readStructEnd()
12255 
 
12256 
  def write(self, oprot):
12257 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12258 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12259 
      return
12260 
    oprot.writeStructBegin('getLastNdaySaleForItem_result')
12261 
    if self.success is not None:
12262 
      oprot.writeFieldBegin('success', TType.STRING, 0)
12263 
      oprot.writeString(self.success)
12264 
      oprot.writeFieldEnd()
12265 
    oprot.writeFieldStop()
12266 
    oprot.writeStructEnd()
12267 
 
12268 
  def validate(self):
12269 
    return
12270 
 
12271 
 
12272 
  def __repr__(self):
12273 
    L = ['%s=%r' % (key, value)
12274 
      for key, value in self.__dict__.iteritems()]
12275 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12276 
 
12277 
  def __eq__(self, other):
12278 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12279 
 
12280 
  def __ne__(self, other):
12281 
    return not (self == other)
8182 amar.kumar 12282 
 
8282 kshitij.so 12283 
class addOrUpdateAmazonFbaInventory_args:
12284 
  """
12285 
  Attributes:
12286 
   - amazonfbainventorysnapshot
12287 
  """
12288 
 
12289 
  thrift_spec = (
12290 
    None, # 0
12291 
    (1, TType.STRUCT, 'amazonfbainventorysnapshot', (AmazonFbaInventorySnapshot, AmazonFbaInventorySnapshot.thrift_spec), None, ), # 1
12292 
  )
12293 
 
12294 
  def __init__(self, amazonfbainventorysnapshot=None,):
12295 
    self.amazonfbainventorysnapshot = amazonfbainventorysnapshot
12296 
 
12297 
  def read(self, iprot):
12298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12300 
      return
12301 
    iprot.readStructBegin()
12302 
    while True:
12303 
      (fname, ftype, fid) = iprot.readFieldBegin()
12304 
      if ftype == TType.STOP:
12305 
        break
12306 
      if fid == 1:
12307 
        if ftype == TType.STRUCT:
12308 
          self.amazonfbainventorysnapshot = AmazonFbaInventorySnapshot()
12309 
          self.amazonfbainventorysnapshot.read(iprot)
12310 
        else:
12311 
          iprot.skip(ftype)
12312 
      else:
12313 
        iprot.skip(ftype)
12314 
      iprot.readFieldEnd()
12315 
    iprot.readStructEnd()
12316 
 
12317 
  def write(self, oprot):
12318 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12319 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12320 
      return
12321 
    oprot.writeStructBegin('addOrUpdateAmazonFbaInventory_args')
12322 
    if self.amazonfbainventorysnapshot is not None:
12323 
      oprot.writeFieldBegin('amazonfbainventorysnapshot', TType.STRUCT, 1)
12324 
      self.amazonfbainventorysnapshot.write(oprot)
12325 
      oprot.writeFieldEnd()
12326 
    oprot.writeFieldStop()
12327 
    oprot.writeStructEnd()
12328 
 
12329 
  def validate(self):
12330 
    return
12331 
 
12332 
 
12333 
  def __repr__(self):
12334 
    L = ['%s=%r' % (key, value)
12335 
      for key, value in self.__dict__.iteritems()]
12336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12337 
 
12338 
  def __eq__(self, other):
12339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12340 
 
12341 
  def __ne__(self, other):
12342 
    return not (self == other)
12343 
 
12344 
class addOrUpdateAmazonFbaInventory_result:
12345 
 
12346 
  thrift_spec = (
12347 
  )
12348 
 
12349 
  def read(self, iprot):
12350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12352 
      return
12353 
    iprot.readStructBegin()
12354 
    while True:
12355 
      (fname, ftype, fid) = iprot.readFieldBegin()
12356 
      if ftype == TType.STOP:
12357 
        break
12358 
      else:
12359 
        iprot.skip(ftype)
12360 
      iprot.readFieldEnd()
12361 
    iprot.readStructEnd()
12362 
 
12363 
  def write(self, oprot):
12364 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12365 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12366 
      return
12367 
    oprot.writeStructBegin('addOrUpdateAmazonFbaInventory_result')
12368 
    oprot.writeFieldStop()
12369 
    oprot.writeStructEnd()
12370 
 
12371 
  def validate(self):
12372 
    return
12373 
 
12374 
 
12375 
  def __repr__(self):
12376 
    L = ['%s=%r' % (key, value)
12377 
      for key, value in self.__dict__.iteritems()]
12378 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12379 
 
12380 
  def __eq__(self, other):
12381 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12382 
 
12383 
  def __ne__(self, other):
12384 
    return not (self == other)
12385 
 
8182 amar.kumar 12386 
class addUpdateHoldInventory_args:
12387 
  """
12388 
  Attributes:
12389 
   - itemId
12390 
   - warehouseId
12391 
   - holdQuantity
12392 
   - source
12393 
  """
12394 
 
12395 
  thrift_spec = (
12396 
    None, # 0
12397 
    (1, TType.I64, 'itemId', None, None, ), # 1
12398 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12399 
    (3, TType.I64, 'holdQuantity', None, None, ), # 3
12400 
    (4, TType.I64, 'source', None, None, ), # 4
12401 
  )
12402 
 
12403 
  def __init__(self, itemId=None, warehouseId=None, holdQuantity=None, source=None,):
12404 
    self.itemId = itemId
12405 
    self.warehouseId = warehouseId
12406 
    self.holdQuantity = holdQuantity
12407 
    self.source = source
12408 
 
12409 
  def read(self, iprot):
12410 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12411 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12412 
      return
12413 
    iprot.readStructBegin()
12414 
    while True:
12415 
      (fname, ftype, fid) = iprot.readFieldBegin()
12416 
      if ftype == TType.STOP:
12417 
        break
12418 
      if fid == 1:
12419 
        if ftype == TType.I64:
12420 
          self.itemId = iprot.readI64();
12421 
        else:
12422 
          iprot.skip(ftype)
12423 
      elif fid == 2:
12424 
        if ftype == TType.I64:
12425 
          self.warehouseId = iprot.readI64();
12426 
        else:
12427 
          iprot.skip(ftype)
12428 
      elif fid == 3:
12429 
        if ftype == TType.I64:
12430 
          self.holdQuantity = iprot.readI64();
12431 
        else:
12432 
          iprot.skip(ftype)
12433 
      elif fid == 4:
12434 
        if ftype == TType.I64:
12435 
          self.source = iprot.readI64();
12436 
        else:
12437 
          iprot.skip(ftype)
12438 
      else:
12439 
        iprot.skip(ftype)
12440 
      iprot.readFieldEnd()
12441 
    iprot.readStructEnd()
12442 
 
12443 
  def write(self, oprot):
12444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12446 
      return
12447 
    oprot.writeStructBegin('addUpdateHoldInventory_args')
12448 
    if self.itemId is not None:
12449 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12450 
      oprot.writeI64(self.itemId)
12451 
      oprot.writeFieldEnd()
12452 
    if self.warehouseId is not None:
12453 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12454 
      oprot.writeI64(self.warehouseId)
12455 
      oprot.writeFieldEnd()
12456 
    if self.holdQuantity is not None:
12457 
      oprot.writeFieldBegin('holdQuantity', TType.I64, 3)
12458 
      oprot.writeI64(self.holdQuantity)
12459 
      oprot.writeFieldEnd()
12460 
    if self.source is not None:
12461 
      oprot.writeFieldBegin('source', TType.I64, 4)
12462 
      oprot.writeI64(self.source)
12463 
      oprot.writeFieldEnd()
12464 
    oprot.writeFieldStop()
12465 
    oprot.writeStructEnd()
12466 
 
12467 
  def validate(self):
12468 
    return
12469 
 
12470 
 
12471 
  def __repr__(self):
12472 
    L = ['%s=%r' % (key, value)
12473 
      for key, value in self.__dict__.iteritems()]
12474 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12475 
 
12476 
  def __eq__(self, other):
12477 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12478 
 
12479 
  def __ne__(self, other):
12480 
    return not (self == other)
12481 
 
12482 
class addUpdateHoldInventory_result:
9762 amar.kumar 12483 
  """
12484 
  Attributes:
12485 
   - cex
12486 
  """
8182 amar.kumar 12487 
 
12488 
  thrift_spec = (
9762 amar.kumar 12489 
    None, # 0
12490 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
8182 amar.kumar 12491 
  )
12492 
 
9762 amar.kumar 12493 
  def __init__(self, cex=None,):
12494 
    self.cex = cex
12495 
 
8182 amar.kumar 12496 
  def read(self, iprot):
12497 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12498 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12499 
      return
12500 
    iprot.readStructBegin()
12501 
    while True:
12502 
      (fname, ftype, fid) = iprot.readFieldBegin()
12503 
      if ftype == TType.STOP:
12504 
        break
9762 amar.kumar 12505 
      if fid == 1:
12506 
        if ftype == TType.STRUCT:
12507 
          self.cex = InventoryServiceException()
12508 
          self.cex.read(iprot)
12509 
        else:
12510 
          iprot.skip(ftype)
8182 amar.kumar 12511 
      else:
12512 
        iprot.skip(ftype)
12513 
      iprot.readFieldEnd()
12514 
    iprot.readStructEnd()
12515 
 
12516 
  def write(self, oprot):
12517 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12518 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12519 
      return
12520 
    oprot.writeStructBegin('addUpdateHoldInventory_result')
9762 amar.kumar 12521 
    if self.cex is not None:
12522 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
12523 
      self.cex.write(oprot)
12524 
      oprot.writeFieldEnd()
8182 amar.kumar 12525 
    oprot.writeFieldStop()
12526 
    oprot.writeStructEnd()
12527 
 
12528 
  def validate(self):
12529 
    return
12530 
 
12531 
 
12532 
  def __repr__(self):
12533 
    L = ['%s=%r' % (key, value)
12534 
      for key, value in self.__dict__.iteritems()]
12535 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12536 
 
12537 
  def __eq__(self, other):
12538 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12539 
 
12540 
  def __ne__(self, other):
12541 
    return not (self == other)
8282 kshitij.so 12542 
 
12543 
class getAmazonFbaItemInventory_args:
12544 
  """
12545 
  Attributes:
12546 
   - itemId
12547 
  """
12548 
 
12549 
  thrift_spec = (
12550 
    None, # 0
12551 
    (1, TType.I64, 'itemId', None, None, ), # 1
12552 
  )
12553 
 
12554 
  def __init__(self, itemId=None,):
12555 
    self.itemId = itemId
12556 
 
12557 
  def read(self, iprot):
12558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12560 
      return
12561 
    iprot.readStructBegin()
12562 
    while True:
12563 
      (fname, ftype, fid) = iprot.readFieldBegin()
12564 
      if ftype == TType.STOP:
12565 
        break
12566 
      if fid == 1:
12567 
        if ftype == TType.I64:
12568 
          self.itemId = iprot.readI64();
12569 
        else:
12570 
          iprot.skip(ftype)
12571 
      else:
12572 
        iprot.skip(ftype)
12573 
      iprot.readFieldEnd()
12574 
    iprot.readStructEnd()
12575 
 
12576 
  def write(self, oprot):
12577 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12578 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12579 
      return
12580 
    oprot.writeStructBegin('getAmazonFbaItemInventory_args')
12581 
    if self.itemId is not None:
12582 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12583 
      oprot.writeI64(self.itemId)
12584 
      oprot.writeFieldEnd()
12585 
    oprot.writeFieldStop()
12586 
    oprot.writeStructEnd()
12587 
 
12588 
  def validate(self):
12589 
    return
12590 
 
12591 
 
12592 
  def __repr__(self):
12593 
    L = ['%s=%r' % (key, value)
12594 
      for key, value in self.__dict__.iteritems()]
12595 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12596 
 
12597 
  def __eq__(self, other):
12598 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12599 
 
12600 
  def __ne__(self, other):
12601 
    return not (self == other)
12602 
 
12603 
class getAmazonFbaItemInventory_result:
12604 
  """
12605 
  Attributes:
12606 
   - success
12607 
  """
12608 
 
12609 
  thrift_spec = (
11173 vikram.rag 12610 
    (0, TType.LIST, 'success', (TType.STRUCT,(AmazonFbaInventorySnapshot, AmazonFbaInventorySnapshot.thrift_spec)), None, ), # 0
8282 kshitij.so 12611 
  )
12612 
 
12613 
  def __init__(self, success=None,):
12614 
    self.success = success
12615 
 
12616 
  def read(self, iprot):
12617 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12618 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12619 
      return
12620 
    iprot.readStructBegin()
12621 
    while True:
12622 
      (fname, ftype, fid) = iprot.readFieldBegin()
12623 
      if ftype == TType.STOP:
12624 
        break
12625 
      if fid == 0:
11173 vikram.rag 12626 
        if ftype == TType.LIST:
12627 
          self.success = []
12628 
          (_etype247, _size244) = iprot.readListBegin()
12629 
          for _i248 in xrange(_size244):
12630 
            _elem249 = AmazonFbaInventorySnapshot()
12631 
            _elem249.read(iprot)
12632 
            self.success.append(_elem249)
12633 
          iprot.readListEnd()
8282 kshitij.so 12634 
        else:
12635 
          iprot.skip(ftype)
12636 
      else:
12637 
        iprot.skip(ftype)
12638 
      iprot.readFieldEnd()
12639 
    iprot.readStructEnd()
12640 
 
12641 
  def write(self, oprot):
12642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12644 
      return
12645 
    oprot.writeStructBegin('getAmazonFbaItemInventory_result')
12646 
    if self.success is not None:
11173 vikram.rag 12647 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12648 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
12649 
      for iter250 in self.success:
12650 
        iter250.write(oprot)
12651 
      oprot.writeListEnd()
8282 kshitij.so 12652 
      oprot.writeFieldEnd()
12653 
    oprot.writeFieldStop()
12654 
    oprot.writeStructEnd()
12655 
 
12656 
  def validate(self):
12657 
    return
12658 
 
12659 
 
12660 
  def __repr__(self):
12661 
    L = ['%s=%r' % (key, value)
12662 
      for key, value in self.__dict__.iteritems()]
12663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12664 
 
12665 
  def __eq__(self, other):
12666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12667 
 
12668 
  def __ne__(self, other):
12669 
    return not (self == other)
12670 
 
8363 vikram.rag 12671 
class getAllAmazonFbaItemInventory_args:
8282 kshitij.so 12672 
 
12673 
  thrift_spec = (
12674 
  )
12675 
 
12676 
  def read(self, iprot):
12677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12679 
      return
12680 
    iprot.readStructBegin()
12681 
    while True:
12682 
      (fname, ftype, fid) = iprot.readFieldBegin()
12683 
      if ftype == TType.STOP:
12684 
        break
12685 
      else:
12686 
        iprot.skip(ftype)
12687 
      iprot.readFieldEnd()
12688 
    iprot.readStructEnd()
12689 
 
12690 
  def write(self, oprot):
12691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12693 
      return
8363 vikram.rag 12694 
    oprot.writeStructBegin('getAllAmazonFbaItemInventory_args')
8282 kshitij.so 12695 
    oprot.writeFieldStop()
12696 
    oprot.writeStructEnd()
12697 
 
12698 
  def validate(self):
12699 
    return
12700 
 
12701 
 
12702 
  def __repr__(self):
12703 
    L = ['%s=%r' % (key, value)
12704 
      for key, value in self.__dict__.iteritems()]
12705 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12706 
 
12707 
  def __eq__(self, other):
12708 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12709 
 
12710 
  def __ne__(self, other):
12711 
    return not (self == other)
12712 
 
8363 vikram.rag 12713 
class getAllAmazonFbaItemInventory_result:
8282 kshitij.so 12714 
  """
12715 
  Attributes:
12716 
   - success
12717 
  """
12718 
 
12719 
  thrift_spec = (
12720 
    (0, TType.LIST, 'success', (TType.STRUCT,(AmazonFbaInventorySnapshot, AmazonFbaInventorySnapshot.thrift_spec)), None, ), # 0
12721 
  )
12722 
 
12723 
  def __init__(self, success=None,):
12724 
    self.success = success
12725 
 
12726 
  def read(self, iprot):
12727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12729 
      return
12730 
    iprot.readStructBegin()
12731 
    while True:
12732 
      (fname, ftype, fid) = iprot.readFieldBegin()
12733 
      if ftype == TType.STOP:
12734 
        break
12735 
      if fid == 0:
12736 
        if ftype == TType.LIST:
12737 
          self.success = []
11173 vikram.rag 12738 
          (_etype254, _size251) = iprot.readListBegin()
12739 
          for _i255 in xrange(_size251):
12740 
            _elem256 = AmazonFbaInventorySnapshot()
12741 
            _elem256.read(iprot)
12742 
            self.success.append(_elem256)
8282 kshitij.so 12743 
          iprot.readListEnd()
12744 
        else:
12745 
          iprot.skip(ftype)
12746 
      else:
12747 
        iprot.skip(ftype)
12748 
      iprot.readFieldEnd()
12749 
    iprot.readStructEnd()
12750 
 
12751 
  def write(self, oprot):
12752 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12753 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12754 
      return
8363 vikram.rag 12755 
    oprot.writeStructBegin('getAllAmazonFbaItemInventory_result')
8282 kshitij.so 12756 
    if self.success is not None:
12757 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12758 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11173 vikram.rag 12759 
      for iter257 in self.success:
12760 
        iter257.write(oprot)
8282 kshitij.so 12761 
      oprot.writeListEnd()
12762 
      oprot.writeFieldEnd()
12763 
    oprot.writeFieldStop()
12764 
    oprot.writeStructEnd()
12765 
 
12766 
  def validate(self):
12767 
    return
12768 
 
12769 
 
12770 
  def __repr__(self):
12771 
    L = ['%s=%r' % (key, value)
12772 
      for key, value in self.__dict__.iteritems()]
12773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12774 
 
12775 
  def __eq__(self, other):
12776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12777 
 
12778 
  def __ne__(self, other):
12779 
    return not (self == other)
8363 vikram.rag 12780 
 
12781 
class getOursGoodWarehouseIdsForLocation_args:
12782 
  """
12783 
  Attributes:
12784 
   - state_id
12785 
  """
12786 
 
12787 
  thrift_spec = (
12788 
    None, # 0
12789 
    (1, TType.I64, 'state_id', None, None, ), # 1
12790 
  )
12791 
 
12792 
  def __init__(self, state_id=None,):
12793 
    self.state_id = state_id
12794 
 
12795 
  def read(self, iprot):
12796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12798 
      return
12799 
    iprot.readStructBegin()
12800 
    while True:
12801 
      (fname, ftype, fid) = iprot.readFieldBegin()
12802 
      if ftype == TType.STOP:
12803 
        break
12804 
      if fid == 1:
12805 
        if ftype == TType.I64:
12806 
          self.state_id = iprot.readI64();
12807 
        else:
12808 
          iprot.skip(ftype)
12809 
      else:
12810 
        iprot.skip(ftype)
12811 
      iprot.readFieldEnd()
12812 
    iprot.readStructEnd()
12813 
 
12814 
  def write(self, oprot):
12815 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12816 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12817 
      return
12818 
    oprot.writeStructBegin('getOursGoodWarehouseIdsForLocation_args')
12819 
    if self.state_id is not None:
12820 
      oprot.writeFieldBegin('state_id', TType.I64, 1)
12821 
      oprot.writeI64(self.state_id)
12822 
      oprot.writeFieldEnd()
12823 
    oprot.writeFieldStop()
12824 
    oprot.writeStructEnd()
12825 
 
12826 
  def validate(self):
12827 
    return
12828 
 
12829 
 
12830 
  def __repr__(self):
12831 
    L = ['%s=%r' % (key, value)
12832 
      for key, value in self.__dict__.iteritems()]
12833 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12834 
 
12835 
  def __eq__(self, other):
12836 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12837 
 
12838 
  def __ne__(self, other):
12839 
    return not (self == other)
12840 
 
12841 
class getOursGoodWarehouseIdsForLocation_result:
12842 
  """
12843 
  Attributes:
12844 
   - success
12845 
  """
12846 
 
12847 
  thrift_spec = (
12848 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12849 
  )
12850 
 
12851 
  def __init__(self, success=None,):
12852 
    self.success = success
12853 
 
12854 
  def read(self, iprot):
12855 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12856 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12857 
      return
12858 
    iprot.readStructBegin()
12859 
    while True:
12860 
      (fname, ftype, fid) = iprot.readFieldBegin()
12861 
      if ftype == TType.STOP:
12862 
        break
12863 
      if fid == 0:
12864 
        if ftype == TType.LIST:
12865 
          self.success = []
11173 vikram.rag 12866 
          (_etype261, _size258) = iprot.readListBegin()
12867 
          for _i262 in xrange(_size258):
12868 
            _elem263 = iprot.readI64();
12869 
            self.success.append(_elem263)
8363 vikram.rag 12870 
          iprot.readListEnd()
12871 
        else:
12872 
          iprot.skip(ftype)
12873 
      else:
12874 
        iprot.skip(ftype)
12875 
      iprot.readFieldEnd()
12876 
    iprot.readStructEnd()
12877 
 
12878 
  def write(self, oprot):
12879 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12880 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12881 
      return
12882 
    oprot.writeStructBegin('getOursGoodWarehouseIdsForLocation_result')
12883 
    if self.success is not None:
12884 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12885 
      oprot.writeListBegin(TType.I64, len(self.success))
11173 vikram.rag 12886 
      for iter264 in self.success:
12887 
        oprot.writeI64(iter264)
8363 vikram.rag 12888 
      oprot.writeListEnd()
12889 
      oprot.writeFieldEnd()
12890 
    oprot.writeFieldStop()
12891 
    oprot.writeStructEnd()
12892 
 
12893 
  def validate(self):
12894 
    return
12895 
 
12896 
 
12897 
  def __repr__(self):
12898 
    L = ['%s=%r' % (key, value)
12899 
      for key, value in self.__dict__.iteritems()]
12900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12901 
 
12902 
  def __eq__(self, other):
12903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12904 
 
12905 
  def __ne__(self, other):
12906 
    return not (self == other)
8955 vikram.rag 12907 
 
12908 
class getHoldInventoryDetailForItemForWarehouseIdExceptSource_args:
12909 
  """
12910 
  Attributes:
12911 
   - id
12912 
   - warehouse_id
12913 
   - source
12914 
  """
12915 
 
12916 
  thrift_spec = (
12917 
    None, # 0
12918 
    (1, TType.I64, 'id', None, None, ), # 1
12919 
    (2, TType.I64, 'warehouse_id', None, None, ), # 2
12920 
    (3, TType.I64, 'source', None, None, ), # 3
12921 
  )
12922 
 
12923 
  def __init__(self, id=None, warehouse_id=None, source=None,):
12924 
    self.id = id
12925 
    self.warehouse_id = warehouse_id
12926 
    self.source = source
12927 
 
12928 
  def read(self, iprot):
12929 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12930 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12931 
      return
12932 
    iprot.readStructBegin()
12933 
    while True:
12934 
      (fname, ftype, fid) = iprot.readFieldBegin()
12935 
      if ftype == TType.STOP:
12936 
        break
12937 
      if fid == 1:
12938 
        if ftype == TType.I64:
12939 
          self.id = iprot.readI64();
12940 
        else:
12941 
          iprot.skip(ftype)
12942 
      elif fid == 2:
12943 
        if ftype == TType.I64:
12944 
          self.warehouse_id = iprot.readI64();
12945 
        else:
12946 
          iprot.skip(ftype)
12947 
      elif fid == 3:
12948 
        if ftype == TType.I64:
12949 
          self.source = iprot.readI64();
12950 
        else:
12951 
          iprot.skip(ftype)
12952 
      else:
12953 
        iprot.skip(ftype)
12954 
      iprot.readFieldEnd()
12955 
    iprot.readStructEnd()
12956 
 
12957 
  def write(self, oprot):
12958 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12959 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12960 
      return
12961 
    oprot.writeStructBegin('getHoldInventoryDetailForItemForWarehouseIdExceptSource_args')
12962 
    if self.id is not None:
12963 
      oprot.writeFieldBegin('id', TType.I64, 1)
12964 
      oprot.writeI64(self.id)
12965 
      oprot.writeFieldEnd()
12966 
    if self.warehouse_id is not None:
12967 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 2)
12968 
      oprot.writeI64(self.warehouse_id)
12969 
      oprot.writeFieldEnd()
12970 
    if self.source is not None:
12971 
      oprot.writeFieldBegin('source', TType.I64, 3)
12972 
      oprot.writeI64(self.source)
12973 
      oprot.writeFieldEnd()
12974 
    oprot.writeFieldStop()
12975 
    oprot.writeStructEnd()
12976 
 
12977 
  def validate(self):
12978 
    return
12979 
 
12980 
 
12981 
  def __repr__(self):
12982 
    L = ['%s=%r' % (key, value)
12983 
      for key, value in self.__dict__.iteritems()]
12984 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12985 
 
12986 
  def __eq__(self, other):
12987 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12988 
 
12989 
  def __ne__(self, other):
12990 
    return not (self == other)
12991 
 
12992 
class getHoldInventoryDetailForItemForWarehouseIdExceptSource_result:
12993 
  """
12994 
  Attributes:
12995 
   - success
12996 
  """
12997 
 
12998 
  thrift_spec = (
12999 
    (0, TType.I64, 'success', None, None, ), # 0
13000 
  )
13001 
 
13002 
  def __init__(self, success=None,):
13003 
    self.success = success
13004 
 
13005 
  def read(self, iprot):
13006 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13007 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13008 
      return
13009 
    iprot.readStructBegin()
13010 
    while True:
13011 
      (fname, ftype, fid) = iprot.readFieldBegin()
13012 
      if ftype == TType.STOP:
13013 
        break
13014 
      if fid == 0:
13015 
        if ftype == TType.I64:
13016 
          self.success = iprot.readI64();
13017 
        else:
13018 
          iprot.skip(ftype)
13019 
      else:
13020 
        iprot.skip(ftype)
13021 
      iprot.readFieldEnd()
13022 
    iprot.readStructEnd()
13023 
 
13024 
  def write(self, oprot):
13025 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13026 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13027 
      return
13028 
    oprot.writeStructBegin('getHoldInventoryDetailForItemForWarehouseIdExceptSource_result')
13029 
    if self.success is not None:
13030 
      oprot.writeFieldBegin('success', TType.I64, 0)
13031 
      oprot.writeI64(self.success)
13032 
      oprot.writeFieldEnd()
13033 
    oprot.writeFieldStop()
13034 
    oprot.writeStructEnd()
13035 
 
13036 
  def validate(self):
13037 
    return
13038 
 
13039 
 
13040 
  def __repr__(self):
13041 
    L = ['%s=%r' % (key, value)
13042 
      for key, value in self.__dict__.iteritems()]
13043 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13044 
 
13045 
  def __eq__(self, other):
13046 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13047 
 
13048 
  def __ne__(self, other):
13049 
    return not (self == other)
9404 vikram.rag 13050 
 
13051 
class getSnapdealInventoryForItem_args:
13052 
  """
13053 
  Attributes:
13054 
   - item_id
13055 
  """
13056 
 
13057 
  thrift_spec = (
13058 
    None, # 0
13059 
    (1, TType.I64, 'item_id', None, None, ), # 1
13060 
  )
13061 
 
13062 
  def __init__(self, item_id=None,):
13063 
    self.item_id = item_id
13064 
 
13065 
  def read(self, iprot):
13066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13068 
      return
13069 
    iprot.readStructBegin()
13070 
    while True:
13071 
      (fname, ftype, fid) = iprot.readFieldBegin()
13072 
      if ftype == TType.STOP:
13073 
        break
13074 
      if fid == 1:
13075 
        if ftype == TType.I64:
13076 
          self.item_id = iprot.readI64();
13077 
        else:
13078 
          iprot.skip(ftype)
13079 
      else:
13080 
        iprot.skip(ftype)
13081 
      iprot.readFieldEnd()
13082 
    iprot.readStructEnd()
13083 
 
13084 
  def write(self, oprot):
13085 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13086 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13087 
      return
13088 
    oprot.writeStructBegin('getSnapdealInventoryForItem_args')
13089 
    if self.item_id is not None:
13090 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
13091 
      oprot.writeI64(self.item_id)
13092 
      oprot.writeFieldEnd()
13093 
    oprot.writeFieldStop()
13094 
    oprot.writeStructEnd()
13095 
 
13096 
  def validate(self):
13097 
    return
13098 
 
13099 
 
13100 
  def __repr__(self):
13101 
    L = ['%s=%r' % (key, value)
13102 
      for key, value in self.__dict__.iteritems()]
13103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13104 
 
13105 
  def __eq__(self, other):
13106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13107 
 
13108 
  def __ne__(self, other):
13109 
    return not (self == other)
13110 
 
13111 
class getSnapdealInventoryForItem_result:
13112 
  """
13113 
  Attributes:
13114 
   - success
13115 
  """
13116 
 
13117 
  thrift_spec = (
13118 
    (0, TType.STRUCT, 'success', (SnapdealInventoryItem, SnapdealInventoryItem.thrift_spec), None, ), # 0
13119 
  )
13120 
 
13121 
  def __init__(self, success=None,):
13122 
    self.success = success
13123 
 
13124 
  def read(self, iprot):
13125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13127 
      return
13128 
    iprot.readStructBegin()
13129 
    while True:
13130 
      (fname, ftype, fid) = iprot.readFieldBegin()
13131 
      if ftype == TType.STOP:
13132 
        break
13133 
      if fid == 0:
13134 
        if ftype == TType.STRUCT:
13135 
          self.success = SnapdealInventoryItem()
13136 
          self.success.read(iprot)
13137 
        else:
13138 
          iprot.skip(ftype)
13139 
      else:
13140 
        iprot.skip(ftype)
13141 
      iprot.readFieldEnd()
13142 
    iprot.readStructEnd()
13143 
 
13144 
  def write(self, oprot):
13145 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13146 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13147 
      return
13148 
    oprot.writeStructBegin('getSnapdealInventoryForItem_result')
13149 
    if self.success is not None:
13150 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13151 
      self.success.write(oprot)
13152 
      oprot.writeFieldEnd()
13153 
    oprot.writeFieldStop()
13154 
    oprot.writeStructEnd()
13155 
 
13156 
  def validate(self):
13157 
    return
13158 
 
13159 
 
13160 
  def __repr__(self):
13161 
    L = ['%s=%r' % (key, value)
13162 
      for key, value in self.__dict__.iteritems()]
13163 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13164 
 
13165 
  def __eq__(self, other):
13166 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13167 
 
13168 
  def __ne__(self, other):
13169 
    return not (self == other)
13170 
 
13171 
class addOrUpdateSnapdealInventoryForItem_args:
13172 
  """
13173 
  Attributes:
13174 
   - snapdealinventoryitem
13175 
  """
13176 
 
13177 
  thrift_spec = (
13178 
    None, # 0
13179 
    (1, TType.STRUCT, 'snapdealinventoryitem', (SnapdealInventoryItem, SnapdealInventoryItem.thrift_spec), None, ), # 1
13180 
  )
13181 
 
13182 
  def __init__(self, snapdealinventoryitem=None,):
13183 
    self.snapdealinventoryitem = snapdealinventoryitem
13184 
 
13185 
  def read(self, iprot):
13186 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13187 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13188 
      return
13189 
    iprot.readStructBegin()
13190 
    while True:
13191 
      (fname, ftype, fid) = iprot.readFieldBegin()
13192 
      if ftype == TType.STOP:
13193 
        break
13194 
      if fid == 1:
13195 
        if ftype == TType.STRUCT:
13196 
          self.snapdealinventoryitem = SnapdealInventoryItem()
13197 
          self.snapdealinventoryitem.read(iprot)
13198 
        else:
13199 
          iprot.skip(ftype)
13200 
      else:
13201 
        iprot.skip(ftype)
13202 
      iprot.readFieldEnd()
13203 
    iprot.readStructEnd()
13204 
 
13205 
  def write(self, oprot):
13206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13208 
      return
13209 
    oprot.writeStructBegin('addOrUpdateSnapdealInventoryForItem_args')
13210 
    if self.snapdealinventoryitem is not None:
13211 
      oprot.writeFieldBegin('snapdealinventoryitem', TType.STRUCT, 1)
13212 
      self.snapdealinventoryitem.write(oprot)
13213 
      oprot.writeFieldEnd()
13214 
    oprot.writeFieldStop()
13215 
    oprot.writeStructEnd()
13216 
 
13217 
  def validate(self):
13218 
    return
13219 
 
13220 
 
13221 
  def __repr__(self):
13222 
    L = ['%s=%r' % (key, value)
13223 
      for key, value in self.__dict__.iteritems()]
13224 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13225 
 
13226 
  def __eq__(self, other):
13227 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13228 
 
13229 
  def __ne__(self, other):
13230 
    return not (self == other)
13231 
 
13232 
class addOrUpdateSnapdealInventoryForItem_result:
13233 
 
13234 
  thrift_spec = (
13235 
  )
13236 
 
13237 
  def read(self, iprot):
13238 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13239 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13240 
      return
13241 
    iprot.readStructBegin()
13242 
    while True:
13243 
      (fname, ftype, fid) = iprot.readFieldBegin()
13244 
      if ftype == TType.STOP:
13245 
        break
13246 
      else:
13247 
        iprot.skip(ftype)
13248 
      iprot.readFieldEnd()
13249 
    iprot.readStructEnd()
13250 
 
13251 
  def write(self, oprot):
13252 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13253 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13254 
      return
13255 
    oprot.writeStructBegin('addOrUpdateSnapdealInventoryForItem_result')
13256 
    oprot.writeFieldStop()
13257 
    oprot.writeStructEnd()
13258 
 
13259 
  def validate(self):
13260 
    return
13261 
 
13262 
 
13263 
  def __repr__(self):
13264 
    L = ['%s=%r' % (key, value)
13265 
      for key, value in self.__dict__.iteritems()]
13266 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13267 
 
13268 
  def __eq__(self, other):
13269 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13270 
 
13271 
  def __ne__(self, other):
13272 
    return not (self == other)
13273 
 
13274 
class getNlcForWarehouse_args:
13275 
  """
13276 
  Attributes:
13277 
   - warehouse_id
13278 
   - item_id
13279 
  """
13280 
 
13281 
  thrift_spec = (
13282 
    None, # 0
13283 
    (1, TType.I64, 'warehouse_id', None, None, ), # 1
13284 
    (2, TType.I64, 'item_id', None, None, ), # 2
13285 
  )
13286 
 
13287 
  def __init__(self, warehouse_id=None, item_id=None,):
13288 
    self.warehouse_id = warehouse_id
13289 
    self.item_id = item_id
13290 
 
13291 
  def read(self, iprot):
13292 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13293 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13294 
      return
13295 
    iprot.readStructBegin()
13296 
    while True:
13297 
      (fname, ftype, fid) = iprot.readFieldBegin()
13298 
      if ftype == TType.STOP:
13299 
        break
13300 
      if fid == 1:
13301 
        if ftype == TType.I64:
13302 
          self.warehouse_id = iprot.readI64();
13303 
        else:
13304 
          iprot.skip(ftype)
13305 
      elif fid == 2:
13306 
        if ftype == TType.I64:
13307 
          self.item_id = iprot.readI64();
13308 
        else:
13309 
          iprot.skip(ftype)
13310 
      else:
13311 
        iprot.skip(ftype)
13312 
      iprot.readFieldEnd()
13313 
    iprot.readStructEnd()
13314 
 
13315 
  def write(self, oprot):
13316 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13317 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13318 
      return
13319 
    oprot.writeStructBegin('getNlcForWarehouse_args')
13320 
    if self.warehouse_id is not None:
13321 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 1)
13322 
      oprot.writeI64(self.warehouse_id)
13323 
      oprot.writeFieldEnd()
13324 
    if self.item_id is not None:
13325 
      oprot.writeFieldBegin('item_id', TType.I64, 2)
13326 
      oprot.writeI64(self.item_id)
13327 
      oprot.writeFieldEnd()
13328 
    oprot.writeFieldStop()
13329 
    oprot.writeStructEnd()
13330 
 
13331 
  def validate(self):
13332 
    return
13333 
 
13334 
 
13335 
  def __repr__(self):
13336 
    L = ['%s=%r' % (key, value)
13337 
      for key, value in self.__dict__.iteritems()]
13338 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13339 
 
13340 
  def __eq__(self, other):
13341 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13342 
 
13343 
  def __ne__(self, other):
13344 
    return not (self == other)
13345 
 
13346 
class getNlcForWarehouse_result:
13347 
  """
13348 
  Attributes:
13349 
   - success
13350 
  """
13351 
 
13352 
  thrift_spec = (
13353 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
13354 
  )
13355 
 
13356 
  def __init__(self, success=None,):
13357 
    self.success = success
13358 
 
13359 
  def read(self, iprot):
13360 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13361 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13362 
      return
13363 
    iprot.readStructBegin()
13364 
    while True:
13365 
      (fname, ftype, fid) = iprot.readFieldBegin()
13366 
      if ftype == TType.STOP:
13367 
        break
13368 
      if fid == 0:
13369 
        if ftype == TType.DOUBLE:
13370 
          self.success = iprot.readDouble();
13371 
        else:
13372 
          iprot.skip(ftype)
13373 
      else:
13374 
        iprot.skip(ftype)
13375 
      iprot.readFieldEnd()
13376 
    iprot.readStructEnd()
13377 
 
13378 
  def write(self, oprot):
13379 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13380 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13381 
      return
13382 
    oprot.writeStructBegin('getNlcForWarehouse_result')
13383 
    if self.success is not None:
13384 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
13385 
      oprot.writeDouble(self.success)
13386 
      oprot.writeFieldEnd()
13387 
    oprot.writeFieldStop()
13388 
    oprot.writeStructEnd()
13389 
 
13390 
  def validate(self):
13391 
    return
13392 
 
13393 
 
13394 
  def __repr__(self):
13395 
    L = ['%s=%r' % (key, value)
13396 
      for key, value in self.__dict__.iteritems()]
13397 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13398 
 
13399 
  def __eq__(self, other):
13400 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13401 
 
13402 
  def __ne__(self, other):
13403 
    return not (self == other)
9456 vikram.rag 13404 
 
9640 amar.kumar 13405 
class getHeldInventoryMapForItem_args:
13406 
  """
13407 
  Attributes:
13408 
   - item_id
13409 
   - warehouse_id
13410 
  """
13411 
 
13412 
  thrift_spec = (
13413 
    None, # 0
13414 
    (1, TType.I64, 'item_id', None, None, ), # 1
13415 
    (2, TType.I64, 'warehouse_id', None, None, ), # 2
13416 
  )
13417 
 
13418 
  def __init__(self, item_id=None, warehouse_id=None,):
13419 
    self.item_id = item_id
13420 
    self.warehouse_id = warehouse_id
13421 
 
13422 
  def read(self, iprot):
13423 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13424 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13425 
      return
13426 
    iprot.readStructBegin()
13427 
    while True:
13428 
      (fname, ftype, fid) = iprot.readFieldBegin()
13429 
      if ftype == TType.STOP:
13430 
        break
13431 
      if fid == 1:
13432 
        if ftype == TType.I64:
13433 
          self.item_id = iprot.readI64();
13434 
        else:
13435 
          iprot.skip(ftype)
13436 
      elif fid == 2:
13437 
        if ftype == TType.I64:
13438 
          self.warehouse_id = iprot.readI64();
13439 
        else:
13440 
          iprot.skip(ftype)
13441 
      else:
13442 
        iprot.skip(ftype)
13443 
      iprot.readFieldEnd()
13444 
    iprot.readStructEnd()
13445 
 
13446 
  def write(self, oprot):
13447 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13448 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13449 
      return
13450 
    oprot.writeStructBegin('getHeldInventoryMapForItem_args')
13451 
    if self.item_id is not None:
13452 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
13453 
      oprot.writeI64(self.item_id)
13454 
      oprot.writeFieldEnd()
13455 
    if self.warehouse_id is not None:
13456 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 2)
13457 
      oprot.writeI64(self.warehouse_id)
13458 
      oprot.writeFieldEnd()
13459 
    oprot.writeFieldStop()
13460 
    oprot.writeStructEnd()
13461 
 
13462 
  def validate(self):
13463 
    return
13464 
 
13465 
 
13466 
  def __repr__(self):
13467 
    L = ['%s=%r' % (key, value)
13468 
      for key, value in self.__dict__.iteritems()]
13469 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13470 
 
13471 
  def __eq__(self, other):
13472 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13473 
 
13474 
  def __ne__(self, other):
13475 
    return not (self == other)
13476 
 
13477 
class getHeldInventoryMapForItem_result:
13478 
  """
13479 
  Attributes:
13480 
   - success
13481 
  """
13482 
 
13483 
  thrift_spec = (
13484 
    (0, TType.MAP, 'success', (TType.I32,None,TType.I64,None), None, ), # 0
13485 
  )
13486 
 
13487 
  def __init__(self, success=None,):
13488 
    self.success = success
13489 
 
13490 
  def read(self, iprot):
13491 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13492 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13493 
      return
13494 
    iprot.readStructBegin()
13495 
    while True:
13496 
      (fname, ftype, fid) = iprot.readFieldBegin()
13497 
      if ftype == TType.STOP:
13498 
        break
13499 
      if fid == 0:
13500 
        if ftype == TType.MAP:
13501 
          self.success = {}
11173 vikram.rag 13502 
          (_ktype266, _vtype267, _size265 ) = iprot.readMapBegin()
13503 
          for _i269 in xrange(_size265):
13504 
            _key270 = iprot.readI32();
13505 
            _val271 = iprot.readI64();
13506 
            self.success[_key270] = _val271
9640 amar.kumar 13507 
          iprot.readMapEnd()
13508 
        else:
13509 
          iprot.skip(ftype)
13510 
      else:
13511 
        iprot.skip(ftype)
13512 
      iprot.readFieldEnd()
13513 
    iprot.readStructEnd()
13514 
 
13515 
  def write(self, oprot):
13516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13518 
      return
13519 
    oprot.writeStructBegin('getHeldInventoryMapForItem_result')
13520 
    if self.success is not None:
13521 
      oprot.writeFieldBegin('success', TType.MAP, 0)
13522 
      oprot.writeMapBegin(TType.I32, TType.I64, len(self.success))
11173 vikram.rag 13523 
      for kiter272,viter273 in self.success.items():
13524 
        oprot.writeI32(kiter272)
13525 
        oprot.writeI64(viter273)
9640 amar.kumar 13526 
      oprot.writeMapEnd()
13527 
      oprot.writeFieldEnd()
13528 
    oprot.writeFieldStop()
13529 
    oprot.writeStructEnd()
13530 
 
13531 
  def validate(self):
13532 
    return
13533 
 
13534 
 
13535 
  def __repr__(self):
13536 
    L = ['%s=%r' % (key, value)
13537 
      for key, value in self.__dict__.iteritems()]
13538 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13539 
 
13540 
  def __eq__(self, other):
13541 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13542 
 
13543 
  def __ne__(self, other):
13544 
    return not (self == other)
13545 
 
9495 vikram.rag 13546 
class addOrUpdateAllAmazonFbaInventory_args:
13547 
  """
13548 
  Attributes:
13549 
   - allamazonfbainventorysnapshot
13550 
  """
9456 vikram.rag 13551 
 
9495 vikram.rag 13552 
  thrift_spec = None
13553 
  def __init__(self, allamazonfbainventorysnapshot=None,):
13554 
    self.allamazonfbainventorysnapshot = allamazonfbainventorysnapshot
9456 vikram.rag 13555 
 
13556 
  def read(self, iprot):
13557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13559 
      return
13560 
    iprot.readStructBegin()
13561 
    while True:
13562 
      (fname, ftype, fid) = iprot.readFieldBegin()
13563 
      if ftype == TType.STOP:
13564 
        break
9495 vikram.rag 13565 
      if fid == -1:
13566 
        if ftype == TType.LIST:
13567 
          self.allamazonfbainventorysnapshot = []
11173 vikram.rag 13568 
          (_etype277, _size274) = iprot.readListBegin()
13569 
          for _i278 in xrange(_size274):
13570 
            _elem279 = AmazonFbaInventorySnapshot()
13571 
            _elem279.read(iprot)
13572 
            self.allamazonfbainventorysnapshot.append(_elem279)
9495 vikram.rag 13573 
          iprot.readListEnd()
13574 
        else:
13575 
          iprot.skip(ftype)
9456 vikram.rag 13576 
      else:
13577 
        iprot.skip(ftype)
13578 
      iprot.readFieldEnd()
13579 
    iprot.readStructEnd()
13580 
 
13581 
  def write(self, oprot):
13582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13584 
      return
9495 vikram.rag 13585 
    oprot.writeStructBegin('addOrUpdateAllAmazonFbaInventory_args')
13586 
    if self.allamazonfbainventorysnapshot is not None:
13587 
      oprot.writeFieldBegin('allamazonfbainventorysnapshot', TType.LIST, -1)
13588 
      oprot.writeListBegin(TType.STRUCT, len(self.allamazonfbainventorysnapshot))
11173 vikram.rag 13589 
      for iter280 in self.allamazonfbainventorysnapshot:
13590 
        iter280.write(oprot)
9495 vikram.rag 13591 
      oprot.writeListEnd()
13592 
      oprot.writeFieldEnd()
9456 vikram.rag 13593 
    oprot.writeFieldStop()
13594 
    oprot.writeStructEnd()
13595 
 
13596 
  def validate(self):
13597 
    return
13598 
 
13599 
 
13600 
  def __repr__(self):
13601 
    L = ['%s=%r' % (key, value)
13602 
      for key, value in self.__dict__.iteritems()]
13603 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13604 
 
13605 
  def __eq__(self, other):
13606 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13607 
 
13608 
  def __ne__(self, other):
13609 
    return not (self == other)
13610 
 
9495 vikram.rag 13611 
class addOrUpdateAllAmazonFbaInventory_result:
9456 vikram.rag 13612 
 
13613 
  thrift_spec = (
13614 
  )
13615 
 
13616 
  def read(self, iprot):
13617 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13618 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13619 
      return
13620 
    iprot.readStructBegin()
13621 
    while True:
13622 
      (fname, ftype, fid) = iprot.readFieldBegin()
13623 
      if ftype == TType.STOP:
13624 
        break
13625 
      else:
13626 
        iprot.skip(ftype)
13627 
      iprot.readFieldEnd()
13628 
    iprot.readStructEnd()
13629 
 
13630 
  def write(self, oprot):
13631 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13632 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13633 
      return
9495 vikram.rag 13634 
    oprot.writeStructBegin('addOrUpdateAllAmazonFbaInventory_result')
9456 vikram.rag 13635 
    oprot.writeFieldStop()
13636 
    oprot.writeStructEnd()
13637 
 
13638 
  def validate(self):
13639 
    return
13640 
 
13641 
 
13642 
  def __repr__(self):
13643 
    L = ['%s=%r' % (key, value)
13644 
      for key, value in self.__dict__.iteritems()]
13645 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13646 
 
13647 
  def __eq__(self, other):
13648 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13649 
 
13650 
  def __ne__(self, other):
13651 
    return not (self == other)
9482 vikram.rag 13652 
 
9495 vikram.rag 13653 
class addOrUpdateAllSnapdealInventory_args:
9482 vikram.rag 13654 
  """
13655 
  Attributes:
9495 vikram.rag 13656 
   - allsnapdealinventorysnapshot
9482 vikram.rag 13657 
  """
13658 
 
13659 
  thrift_spec = None
9495 vikram.rag 13660 
  def __init__(self, allsnapdealinventorysnapshot=None,):
13661 
    self.allsnapdealinventorysnapshot = allsnapdealinventorysnapshot
9482 vikram.rag 13662 
 
13663 
  def read(self, iprot):
13664 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13665 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13666 
      return
13667 
    iprot.readStructBegin()
13668 
    while True:
13669 
      (fname, ftype, fid) = iprot.readFieldBegin()
13670 
      if ftype == TType.STOP:
13671 
        break
13672 
      if fid == -1:
13673 
        if ftype == TType.LIST:
9495 vikram.rag 13674 
          self.allsnapdealinventorysnapshot = []
11173 vikram.rag 13675 
          (_etype284, _size281) = iprot.readListBegin()
13676 
          for _i285 in xrange(_size281):
13677 
            _elem286 = SnapdealInventoryItem()
13678 
            _elem286.read(iprot)
13679 
            self.allsnapdealinventorysnapshot.append(_elem286)
9482 vikram.rag 13680 
          iprot.readListEnd()
13681 
        else:
13682 
          iprot.skip(ftype)
13683 
      else:
13684 
        iprot.skip(ftype)
13685 
      iprot.readFieldEnd()
13686 
    iprot.readStructEnd()
13687 
 
13688 
  def write(self, oprot):
13689 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13690 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13691 
      return
9495 vikram.rag 13692 
    oprot.writeStructBegin('addOrUpdateAllSnapdealInventory_args')
13693 
    if self.allsnapdealinventorysnapshot is not None:
13694 
      oprot.writeFieldBegin('allsnapdealinventorysnapshot', TType.LIST, -1)
13695 
      oprot.writeListBegin(TType.STRUCT, len(self.allsnapdealinventorysnapshot))
11173 vikram.rag 13696 
      for iter287 in self.allsnapdealinventorysnapshot:
13697 
        iter287.write(oprot)
9482 vikram.rag 13698 
      oprot.writeListEnd()
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 
 
9495 vikram.rag 13718 
class addOrUpdateAllSnapdealInventory_result:
9482 vikram.rag 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
9495 vikram.rag 13741 
    oprot.writeStructBegin('addOrUpdateAllSnapdealInventory_result')
9482 vikram.rag 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)
9495 vikram.rag 13759 
 
13760 
class getSnapdealInventorySnapshot_args:
13761 
 
13762 
  thrift_spec = (
13763 
  )
13764 
 
13765 
  def read(self, iprot):
13766 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13767 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13768 
      return
13769 
    iprot.readStructBegin()
13770 
    while True:
13771 
      (fname, ftype, fid) = iprot.readFieldBegin()
13772 
      if ftype == TType.STOP:
13773 
        break
13774 
      else:
13775 
        iprot.skip(ftype)
13776 
      iprot.readFieldEnd()
13777 
    iprot.readStructEnd()
13778 
 
13779 
  def write(self, oprot):
13780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13782 
      return
13783 
    oprot.writeStructBegin('getSnapdealInventorySnapshot_args')
13784 
    oprot.writeFieldStop()
13785 
    oprot.writeStructEnd()
13786 
 
13787 
  def validate(self):
13788 
    return
13789 
 
13790 
 
13791 
  def __repr__(self):
13792 
    L = ['%s=%r' % (key, value)
13793 
      for key, value in self.__dict__.iteritems()]
13794 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13795 
 
13796 
  def __eq__(self, other):
13797 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13798 
 
13799 
  def __ne__(self, other):
13800 
    return not (self == other)
13801 
 
13802 
class getSnapdealInventorySnapshot_result:
13803 
  """
13804 
  Attributes:
13805 
   - success
13806 
  """
13807 
 
13808 
  thrift_spec = (
13809 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealInventoryItem, SnapdealInventoryItem.thrift_spec)), None, ), # 0
13810 
  )
13811 
 
13812 
  def __init__(self, success=None,):
13813 
    self.success = success
13814 
 
13815 
  def read(self, iprot):
13816 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13817 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13818 
      return
13819 
    iprot.readStructBegin()
13820 
    while True:
13821 
      (fname, ftype, fid) = iprot.readFieldBegin()
13822 
      if ftype == TType.STOP:
13823 
        break
13824 
      if fid == 0:
13825 
        if ftype == TType.LIST:
13826 
          self.success = []
11173 vikram.rag 13827 
          (_etype291, _size288) = iprot.readListBegin()
13828 
          for _i292 in xrange(_size288):
13829 
            _elem293 = SnapdealInventoryItem()
13830 
            _elem293.read(iprot)
13831 
            self.success.append(_elem293)
9495 vikram.rag 13832 
          iprot.readListEnd()
13833 
        else:
13834 
          iprot.skip(ftype)
13835 
      else:
13836 
        iprot.skip(ftype)
13837 
      iprot.readFieldEnd()
13838 
    iprot.readStructEnd()
13839 
 
13840 
  def write(self, oprot):
13841 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13842 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13843 
      return
13844 
    oprot.writeStructBegin('getSnapdealInventorySnapshot_result')
13845 
    if self.success is not None:
13846 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13847 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11173 vikram.rag 13848 
      for iter294 in self.success:
13849 
        iter294.write(oprot)
9495 vikram.rag 13850 
      oprot.writeListEnd()
13851 
      oprot.writeFieldEnd()
13852 
    oprot.writeFieldStop()
13853 
    oprot.writeStructEnd()
13854 
 
13855 
  def validate(self):
13856 
    return
13857 
 
13858 
 
13859 
  def __repr__(self):
13860 
    L = ['%s=%r' % (key, value)
13861 
      for key, value in self.__dict__.iteritems()]
13862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13863 
 
13864 
  def __eq__(self, other):
13865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13866 
 
13867 
  def __ne__(self, other):
13868 
    return not (self == other)
9761 amar.kumar 13869 
 
13870 
class getHoldInventoryDetails_args:
13871 
  """
13872 
  Attributes:
13873 
   - itemId
13874 
   - warehouseId
13875 
   - source
13876 
  """
13877 
 
13878 
  thrift_spec = (
13879 
    None, # 0
13880 
    (1, TType.I64, 'itemId', None, None, ), # 1
13881 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
13882 
    (3, TType.I64, 'source', None, None, ), # 3
13883 
  )
13884 
 
13885 
  def __init__(self, itemId=None, warehouseId=None, source=None,):
13886 
    self.itemId = itemId
13887 
    self.warehouseId = warehouseId
13888 
    self.source = source
13889 
 
13890 
  def read(self, iprot):
13891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13893 
      return
13894 
    iprot.readStructBegin()
13895 
    while True:
13896 
      (fname, ftype, fid) = iprot.readFieldBegin()
13897 
      if ftype == TType.STOP:
13898 
        break
13899 
      if fid == 1:
13900 
        if ftype == TType.I64:
13901 
          self.itemId = iprot.readI64();
13902 
        else:
13903 
          iprot.skip(ftype)
13904 
      elif fid == 2:
13905 
        if ftype == TType.I64:
13906 
          self.warehouseId = iprot.readI64();
13907 
        else:
13908 
          iprot.skip(ftype)
13909 
      elif fid == 3:
13910 
        if ftype == TType.I64:
13911 
          self.source = iprot.readI64();
13912 
        else:
13913 
          iprot.skip(ftype)
13914 
      else:
13915 
        iprot.skip(ftype)
13916 
      iprot.readFieldEnd()
13917 
    iprot.readStructEnd()
13918 
 
13919 
  def write(self, oprot):
13920 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13921 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13922 
      return
13923 
    oprot.writeStructBegin('getHoldInventoryDetails_args')
13924 
    if self.itemId is not None:
13925 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13926 
      oprot.writeI64(self.itemId)
13927 
      oprot.writeFieldEnd()
13928 
    if self.warehouseId is not None:
13929 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
13930 
      oprot.writeI64(self.warehouseId)
13931 
      oprot.writeFieldEnd()
13932 
    if self.source is not None:
13933 
      oprot.writeFieldBegin('source', TType.I64, 3)
13934 
      oprot.writeI64(self.source)
13935 
      oprot.writeFieldEnd()
13936 
    oprot.writeFieldStop()
13937 
    oprot.writeStructEnd()
13938 
 
13939 
  def validate(self):
13940 
    return
13941 
 
13942 
 
13943 
  def __repr__(self):
13944 
    L = ['%s=%r' % (key, value)
13945 
      for key, value in self.__dict__.iteritems()]
13946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13947 
 
13948 
  def __eq__(self, other):
13949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13950 
 
13951 
  def __ne__(self, other):
13952 
    return not (self == other)
13953 
 
13954 
class getHoldInventoryDetails_result:
13955 
  """
13956 
  Attributes:
13957 
   - success
13958 
  """
13959 
 
13960 
  thrift_spec = (
13961 
    (0, TType.LIST, 'success', (TType.STRUCT,(HoldInventoryDetail, HoldInventoryDetail.thrift_spec)), None, ), # 0
13962 
  )
13963 
 
13964 
  def __init__(self, success=None,):
13965 
    self.success = success
13966 
 
13967 
  def read(self, iprot):
13968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13970 
      return
13971 
    iprot.readStructBegin()
13972 
    while True:
13973 
      (fname, ftype, fid) = iprot.readFieldBegin()
13974 
      if ftype == TType.STOP:
13975 
        break
13976 
      if fid == 0:
13977 
        if ftype == TType.LIST:
13978 
          self.success = []
11173 vikram.rag 13979 
          (_etype298, _size295) = iprot.readListBegin()
13980 
          for _i299 in xrange(_size295):
13981 
            _elem300 = HoldInventoryDetail()
13982 
            _elem300.read(iprot)
13983 
            self.success.append(_elem300)
9761 amar.kumar 13984 
          iprot.readListEnd()
13985 
        else:
13986 
          iprot.skip(ftype)
13987 
      else:
13988 
        iprot.skip(ftype)
13989 
      iprot.readFieldEnd()
13990 
    iprot.readStructEnd()
13991 
 
13992 
  def write(self, oprot):
13993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13995 
      return
13996 
    oprot.writeStructBegin('getHoldInventoryDetails_result')
13997 
    if self.success is not None:
13998 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13999 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11173 vikram.rag 14000 
      for iter301 in self.success:
14001 
        iter301.write(oprot)
9761 amar.kumar 14002 
      oprot.writeListEnd()
14003 
      oprot.writeFieldEnd()
14004 
    oprot.writeFieldStop()
14005 
    oprot.writeStructEnd()
14006 
 
14007 
  def validate(self):
14008 
    return
14009 
 
14010 
 
14011 
  def __repr__(self):
14012 
    L = ['%s=%r' % (key, value)
14013 
      for key, value in self.__dict__.iteritems()]
14014 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14015 
 
14016 
  def __eq__(self, other):
14017 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14018 
 
14019 
  def __ne__(self, other):
14020 
    return not (self == other)
10050 vikram.rag 14021 
 
14022 
class addOrUpdateFlipkartInventorySnapshot_args:
14023 
  """
14024 
  Attributes:
14025 
   - flipkartInventorySnapshot
10450 vikram.rag 14026 
   - time
10050 vikram.rag 14027 
  """
14028 
 
10450 vikram.rag 14029 
  thrift_spec = (
14030 
    None, # 0
14031 
    (1, TType.LIST, 'flipkartInventorySnapshot', (TType.STRUCT,(FlipkartInventorySnapshot, FlipkartInventorySnapshot.thrift_spec)), None, ), # 1
14032 
    (2, TType.I64, 'time', None, None, ), # 2
14033 
  )
14034 
 
14035 
  def __init__(self, flipkartInventorySnapshot=None, time=None,):
10050 vikram.rag 14036 
    self.flipkartInventorySnapshot = flipkartInventorySnapshot
10450 vikram.rag 14037 
    self.time = time
10050 vikram.rag 14038 
 
14039 
  def read(self, iprot):
14040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14042 
      return
14043 
    iprot.readStructBegin()
14044 
    while True:
14045 
      (fname, ftype, fid) = iprot.readFieldBegin()
14046 
      if ftype == TType.STOP:
14047 
        break
10450 vikram.rag 14048 
      if fid == 1:
10050 vikram.rag 14049 
        if ftype == TType.LIST:
14050 
          self.flipkartInventorySnapshot = []
11173 vikram.rag 14051 
          (_etype305, _size302) = iprot.readListBegin()
14052 
          for _i306 in xrange(_size302):
14053 
            _elem307 = FlipkartInventorySnapshot()
14054 
            _elem307.read(iprot)
14055 
            self.flipkartInventorySnapshot.append(_elem307)
10050 vikram.rag 14056 
          iprot.readListEnd()
14057 
        else:
14058 
          iprot.skip(ftype)
10450 vikram.rag 14059 
      elif fid == 2:
14060 
        if ftype == TType.I64:
14061 
          self.time = iprot.readI64();
14062 
        else:
14063 
          iprot.skip(ftype)
10050 vikram.rag 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('addOrUpdateFlipkartInventorySnapshot_args')
14074 
    if self.flipkartInventorySnapshot is not None:
10450 vikram.rag 14075 
      oprot.writeFieldBegin('flipkartInventorySnapshot', TType.LIST, 1)
10050 vikram.rag 14076 
      oprot.writeListBegin(TType.STRUCT, len(self.flipkartInventorySnapshot))
11173 vikram.rag 14077 
      for iter308 in self.flipkartInventorySnapshot:
14078 
        iter308.write(oprot)
10050 vikram.rag 14079 
      oprot.writeListEnd()
14080 
      oprot.writeFieldEnd()
10450 vikram.rag 14081 
    if self.time is not None:
14082 
      oprot.writeFieldBegin('time', TType.I64, 2)
14083 
      oprot.writeI64(self.time)
14084 
      oprot.writeFieldEnd()
10050 vikram.rag 14085 
    oprot.writeFieldStop()
14086 
    oprot.writeStructEnd()
14087 
 
14088 
  def validate(self):
14089 
    return
14090 
 
14091 
 
14092 
  def __repr__(self):
14093 
    L = ['%s=%r' % (key, value)
14094 
      for key, value in self.__dict__.iteritems()]
14095 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14096 
 
14097 
  def __eq__(self, other):
14098 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14099 
 
14100 
  def __ne__(self, other):
14101 
    return not (self == other)
14102 
 
14103 
class addOrUpdateFlipkartInventorySnapshot_result:
14104 
 
14105 
  thrift_spec = (
14106 
  )
14107 
 
14108 
  def read(self, iprot):
14109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14111 
      return
14112 
    iprot.readStructBegin()
14113 
    while True:
14114 
      (fname, ftype, fid) = iprot.readFieldBegin()
14115 
      if ftype == TType.STOP:
14116 
        break
14117 
      else:
14118 
        iprot.skip(ftype)
14119 
      iprot.readFieldEnd()
14120 
    iprot.readStructEnd()
14121 
 
14122 
  def write(self, oprot):
14123 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14124 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14125 
      return
14126 
    oprot.writeStructBegin('addOrUpdateFlipkartInventorySnapshot_result')
14127 
    oprot.writeFieldStop()
14128 
    oprot.writeStructEnd()
14129 
 
14130 
  def validate(self):
14131 
    return
14132 
 
14133 
 
14134 
  def __repr__(self):
14135 
    L = ['%s=%r' % (key, value)
14136 
      for key, value in self.__dict__.iteritems()]
14137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14138 
 
14139 
  def __eq__(self, other):
14140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14141 
 
14142 
  def __ne__(self, other):
14143 
    return not (self == other)
14144 
 
14145 
class getFlipkartInventorySnapshot_args:
14146 
 
14147 
  thrift_spec = (
14148 
  )
14149 
 
14150 
  def read(self, iprot):
14151 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14152 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14153 
      return
14154 
    iprot.readStructBegin()
14155 
    while True:
14156 
      (fname, ftype, fid) = iprot.readFieldBegin()
14157 
      if ftype == TType.STOP:
14158 
        break
14159 
      else:
14160 
        iprot.skip(ftype)
14161 
      iprot.readFieldEnd()
14162 
    iprot.readStructEnd()
14163 
 
14164 
  def write(self, oprot):
14165 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14166 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14167 
      return
14168 
    oprot.writeStructBegin('getFlipkartInventorySnapshot_args')
14169 
    oprot.writeFieldStop()
14170 
    oprot.writeStructEnd()
14171 
 
14172 
  def validate(self):
14173 
    return
14174 
 
14175 
 
14176 
  def __repr__(self):
14177 
    L = ['%s=%r' % (key, value)
14178 
      for key, value in self.__dict__.iteritems()]
14179 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14180 
 
14181 
  def __eq__(self, other):
14182 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14183 
 
14184 
  def __ne__(self, other):
14185 
    return not (self == other)
14186 
 
14187 
class getFlipkartInventorySnapshot_result:
14188 
  """
14189 
  Attributes:
14190 
   - success
14191 
  """
14192 
 
14193 
  thrift_spec = (
14194 
    (0, TType.LIST, 'success', (TType.STRUCT,(FlipkartInventorySnapshot, FlipkartInventorySnapshot.thrift_spec)), None, ), # 0
14195 
  )
14196 
 
14197 
  def __init__(self, success=None,):
14198 
    self.success = success
14199 
 
14200 
  def read(self, iprot):
14201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14203 
      return
14204 
    iprot.readStructBegin()
14205 
    while True:
14206 
      (fname, ftype, fid) = iprot.readFieldBegin()
14207 
      if ftype == TType.STOP:
14208 
        break
14209 
      if fid == 0:
14210 
        if ftype == TType.LIST:
14211 
          self.success = []
11173 vikram.rag 14212 
          (_etype312, _size309) = iprot.readListBegin()
14213 
          for _i313 in xrange(_size309):
14214 
            _elem314 = FlipkartInventorySnapshot()
14215 
            _elem314.read(iprot)
14216 
            self.success.append(_elem314)
10050 vikram.rag 14217 
          iprot.readListEnd()
14218 
        else:
14219 
          iprot.skip(ftype)
14220 
      else:
14221 
        iprot.skip(ftype)
14222 
      iprot.readFieldEnd()
14223 
    iprot.readStructEnd()
14224 
 
14225 
  def write(self, oprot):
14226 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14227 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14228 
      return
14229 
    oprot.writeStructBegin('getFlipkartInventorySnapshot_result')
14230 
    if self.success is not None:
14231 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14232 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11173 vikram.rag 14233 
      for iter315 in self.success:
14234 
        iter315.write(oprot)
10050 vikram.rag 14235 
      oprot.writeListEnd()
14236 
      oprot.writeFieldEnd()
14237 
    oprot.writeFieldStop()
14238 
    oprot.writeStructEnd()
14239 
 
14240 
  def validate(self):
14241 
    return
14242 
 
14243 
 
14244 
  def __repr__(self):
14245 
    L = ['%s=%r' % (key, value)
14246 
      for key, value in self.__dict__.iteritems()]
14247 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14248 
 
14249 
  def __eq__(self, other):
14250 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14251 
 
14252 
  def __ne__(self, other):
14253 
    return not (self == other)
10097 kshitij.so 14254 
 
14255 
class getFlipkartlInventoryForItem_args:
14256 
  """
14257 
  Attributes:
14258 
   - item_id
14259 
  """
14260 
 
14261 
  thrift_spec = (
14262 
    None, # 0
14263 
    (1, TType.I64, 'item_id', None, None, ), # 1
14264 
  )
14265 
 
14266 
  def __init__(self, item_id=None,):
14267 
    self.item_id = item_id
14268 
 
14269 
  def read(self, iprot):
14270 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14271 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14272 
      return
14273 
    iprot.readStructBegin()
14274 
    while True:
14275 
      (fname, ftype, fid) = iprot.readFieldBegin()
14276 
      if ftype == TType.STOP:
14277 
        break
14278 
      if fid == 1:
14279 
        if ftype == TType.I64:
14280 
          self.item_id = iprot.readI64();
14281 
        else:
14282 
          iprot.skip(ftype)
14283 
      else:
14284 
        iprot.skip(ftype)
14285 
      iprot.readFieldEnd()
14286 
    iprot.readStructEnd()
14287 
 
14288 
  def write(self, oprot):
14289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14291 
      return
14292 
    oprot.writeStructBegin('getFlipkartlInventoryForItem_args')
14293 
    if self.item_id is not None:
14294 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
14295 
      oprot.writeI64(self.item_id)
14296 
      oprot.writeFieldEnd()
14297 
    oprot.writeFieldStop()
14298 
    oprot.writeStructEnd()
14299 
 
14300 
  def validate(self):
14301 
    return
14302 
 
14303 
 
14304 
  def __repr__(self):
14305 
    L = ['%s=%r' % (key, value)
14306 
      for key, value in self.__dict__.iteritems()]
14307 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14308 
 
14309 
  def __eq__(self, other):
14310 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14311 
 
14312 
  def __ne__(self, other):
14313 
    return not (self == other)
14314 
 
14315 
class getFlipkartlInventoryForItem_result:
14316 
  """
14317 
  Attributes:
14318 
   - success
14319 
  """
14320 
 
14321 
  thrift_spec = (
14322 
    (0, TType.STRUCT, 'success', (FlipkartInventorySnapshot, FlipkartInventorySnapshot.thrift_spec), None, ), # 0
14323 
  )
14324 
 
14325 
  def __init__(self, success=None,):
14326 
    self.success = success
14327 
 
14328 
  def read(self, iprot):
14329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14331 
      return
14332 
    iprot.readStructBegin()
14333 
    while True:
14334 
      (fname, ftype, fid) = iprot.readFieldBegin()
14335 
      if ftype == TType.STOP:
14336 
        break
14337 
      if fid == 0:
14338 
        if ftype == TType.STRUCT:
14339 
          self.success = FlipkartInventorySnapshot()
14340 
          self.success.read(iprot)
14341 
        else:
14342 
          iprot.skip(ftype)
14343 
      else:
14344 
        iprot.skip(ftype)
14345 
      iprot.readFieldEnd()
14346 
    iprot.readStructEnd()
14347 
 
14348 
  def write(self, oprot):
14349 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14350 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14351 
      return
14352 
    oprot.writeStructBegin('getFlipkartlInventoryForItem_result')
14353 
    if self.success is not None:
14354 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14355 
      self.success.write(oprot)
14356 
      oprot.writeFieldEnd()
14357 
    oprot.writeFieldStop()
14358 
    oprot.writeStructEnd()
14359 
 
14360 
  def validate(self):
14361 
    return
14362 
 
14363 
 
14364 
  def __repr__(self):
14365 
    L = ['%s=%r' % (key, value)
14366 
      for key, value in self.__dict__.iteritems()]
14367 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14368 
 
14369 
  def __eq__(self, other):
14370 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14371 
 
14372 
  def __ne__(self, other):
14373 
    return not (self == other)
10485 vikram.rag 14374 
 
14375 
class getStateMaster_args:
14376 
 
14377 
  thrift_spec = (
14378 
  )
14379 
 
14380 
  def read(self, iprot):
14381 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14382 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14383 
      return
14384 
    iprot.readStructBegin()
14385 
    while True:
14386 
      (fname, ftype, fid) = iprot.readFieldBegin()
14387 
      if ftype == TType.STOP:
14388 
        break
14389 
      else:
14390 
        iprot.skip(ftype)
14391 
      iprot.readFieldEnd()
14392 
    iprot.readStructEnd()
14393 
 
14394 
  def write(self, oprot):
14395 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14396 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14397 
      return
14398 
    oprot.writeStructBegin('getStateMaster_args')
14399 
    oprot.writeFieldStop()
14400 
    oprot.writeStructEnd()
14401 
 
14402 
  def validate(self):
14403 
    return
14404 
 
14405 
 
14406 
  def __repr__(self):
14407 
    L = ['%s=%r' % (key, value)
14408 
      for key, value in self.__dict__.iteritems()]
14409 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14410 
 
14411 
  def __eq__(self, other):
14412 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14413 
 
14414 
  def __ne__(self, other):
14415 
    return not (self == other)
14416 
 
14417 
class getStateMaster_result:
14418 
  """
14419 
  Attributes:
14420 
   - success
14421 
  """
14422 
 
14423 
  thrift_spec = (
12280 amit.gupta 14424 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRUCT,(StateInfo, StateInfo.thrift_spec)), None, ), # 0
10485 vikram.rag 14425 
  )
14426 
 
14427 
  def __init__(self, success=None,):
14428 
    self.success = success
14429 
 
14430 
  def read(self, iprot):
14431 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14432 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14433 
      return
14434 
    iprot.readStructBegin()
14435 
    while True:
14436 
      (fname, ftype, fid) = iprot.readFieldBegin()
14437 
      if ftype == TType.STOP:
14438 
        break
14439 
      if fid == 0:
14440 
        if ftype == TType.MAP:
14441 
          self.success = {}
11173 vikram.rag 14442 
          (_ktype317, _vtype318, _size316 ) = iprot.readMapBegin()
14443 
          for _i320 in xrange(_size316):
14444 
            _key321 = iprot.readI64();
12280 amit.gupta 14445 
            _val322 = StateInfo()
14446 
            _val322.read(iprot)
11173 vikram.rag 14447 
            self.success[_key321] = _val322
10485 vikram.rag 14448 
          iprot.readMapEnd()
14449 
        else:
14450 
          iprot.skip(ftype)
14451 
      else:
14452 
        iprot.skip(ftype)
14453 
      iprot.readFieldEnd()
14454 
    iprot.readStructEnd()
14455 
 
14456 
  def write(self, oprot):
14457 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14458 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14459 
      return
14460 
    oprot.writeStructBegin('getStateMaster_result')
14461 
    if self.success is not None:
14462 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12280 amit.gupta 14463 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.success))
11173 vikram.rag 14464 
      for kiter323,viter324 in self.success.items():
14465 
        oprot.writeI64(kiter323)
12280 amit.gupta 14466 
        viter324.write(oprot)
10485 vikram.rag 14467 
      oprot.writeMapEnd()
14468 
      oprot.writeFieldEnd()
14469 
    oprot.writeFieldStop()
14470 
    oprot.writeStructEnd()
14471 
 
14472 
  def validate(self):
14473 
    return
14474 
 
14475 
 
14476 
  def __repr__(self):
14477 
    L = ['%s=%r' % (key, value)
14478 
      for key, value in self.__dict__.iteritems()]
14479 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14480 
 
14481 
  def __eq__(self, other):
14482 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14483 
 
14484 
  def __ne__(self, other):
14485 
    return not (self == other)
10544 vikram.rag 14486 
 
14487 
class updateSnapdealStockAtEOD_args:
14488 
  """
14489 
  Attributes:
14490 
   - allsnapdealstock
14491 
  """
14492 
 
14493 
  thrift_spec = None
14494 
  def __init__(self, allsnapdealstock=None,):
14495 
    self.allsnapdealstock = allsnapdealstock
14496 
 
14497 
  def read(self, iprot):
14498 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14499 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14500 
      return
14501 
    iprot.readStructBegin()
14502 
    while True:
14503 
      (fname, ftype, fid) = iprot.readFieldBegin()
14504 
      if ftype == TType.STOP:
14505 
        break
14506 
      if fid == -1:
14507 
        if ftype == TType.LIST:
14508 
          self.allsnapdealstock = []
11173 vikram.rag 14509 
          (_etype328, _size325) = iprot.readListBegin()
14510 
          for _i329 in xrange(_size325):
14511 
            _elem330 = SnapdealStockAtEOD()
14512 
            _elem330.read(iprot)
14513 
            self.allsnapdealstock.append(_elem330)
10544 vikram.rag 14514 
          iprot.readListEnd()
14515 
        else:
14516 
          iprot.skip(ftype)
14517 
      else:
14518 
        iprot.skip(ftype)
14519 
      iprot.readFieldEnd()
14520 
    iprot.readStructEnd()
14521 
 
14522 
  def write(self, oprot):
14523 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14524 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14525 
      return
14526 
    oprot.writeStructBegin('updateSnapdealStockAtEOD_args')
14527 
    if self.allsnapdealstock is not None:
14528 
      oprot.writeFieldBegin('allsnapdealstock', TType.LIST, -1)
14529 
      oprot.writeListBegin(TType.STRUCT, len(self.allsnapdealstock))
11173 vikram.rag 14530 
      for iter331 in self.allsnapdealstock:
14531 
        iter331.write(oprot)
10544 vikram.rag 14532 
      oprot.writeListEnd()
14533 
      oprot.writeFieldEnd()
14534 
    oprot.writeFieldStop()
14535 
    oprot.writeStructEnd()
14536 
 
14537 
  def validate(self):
14538 
    return
14539 
 
14540 
 
14541 
  def __repr__(self):
14542 
    L = ['%s=%r' % (key, value)
14543 
      for key, value in self.__dict__.iteritems()]
14544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14545 
 
14546 
  def __eq__(self, other):
14547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14548 
 
14549 
  def __ne__(self, other):
14550 
    return not (self == other)
14551 
 
14552 
class updateSnapdealStockAtEOD_result:
14553 
 
14554 
  thrift_spec = (
14555 
  )
14556 
 
14557 
  def read(self, iprot):
14558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14560 
      return
14561 
    iprot.readStructBegin()
14562 
    while True:
14563 
      (fname, ftype, fid) = iprot.readFieldBegin()
14564 
      if ftype == TType.STOP:
14565 
        break
14566 
      else:
14567 
        iprot.skip(ftype)
14568 
      iprot.readFieldEnd()
14569 
    iprot.readStructEnd()
14570 
 
14571 
  def write(self, oprot):
14572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14574 
      return
14575 
    oprot.writeStructBegin('updateSnapdealStockAtEOD_result')
14576 
    oprot.writeFieldStop()
14577 
    oprot.writeStructEnd()
14578 
 
14579 
  def validate(self):
14580 
    return
14581 
 
14582 
 
14583 
  def __repr__(self):
14584 
    L = ['%s=%r' % (key, value)
14585 
      for key, value in self.__dict__.iteritems()]
14586 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14587 
 
14588 
  def __eq__(self, other):
14589 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14590 
 
14591 
  def __ne__(self, other):
14592 
    return not (self == other)
14593 
 
14594 
class updateFlipkartStockAtEOD_args:
14595 
  """
14596 
  Attributes:
14597 
   - allflipkartstock
14598 
  """
14599 
 
14600 
  thrift_spec = None
14601 
  def __init__(self, allflipkartstock=None,):
14602 
    self.allflipkartstock = allflipkartstock
14603 
 
14604 
  def read(self, iprot):
14605 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14606 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14607 
      return
14608 
    iprot.readStructBegin()
14609 
    while True:
14610 
      (fname, ftype, fid) = iprot.readFieldBegin()
14611 
      if ftype == TType.STOP:
14612 
        break
14613 
      if fid == -1:
14614 
        if ftype == TType.LIST:
14615 
          self.allflipkartstock = []
11173 vikram.rag 14616 
          (_etype335, _size332) = iprot.readListBegin()
14617 
          for _i336 in xrange(_size332):
14618 
            _elem337 = FlipkartStockAtEOD()
14619 
            _elem337.read(iprot)
14620 
            self.allflipkartstock.append(_elem337)
10544 vikram.rag 14621 
          iprot.readListEnd()
14622 
        else:
14623 
          iprot.skip(ftype)
14624 
      else:
14625 
        iprot.skip(ftype)
14626 
      iprot.readFieldEnd()
14627 
    iprot.readStructEnd()
14628 
 
14629 
  def write(self, oprot):
14630 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14631 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14632 
      return
14633 
    oprot.writeStructBegin('updateFlipkartStockAtEOD_args')
14634 
    if self.allflipkartstock is not None:
14635 
      oprot.writeFieldBegin('allflipkartstock', TType.LIST, -1)
14636 
      oprot.writeListBegin(TType.STRUCT, len(self.allflipkartstock))
11173 vikram.rag 14637 
      for iter338 in self.allflipkartstock:
14638 
        iter338.write(oprot)
10544 vikram.rag 14639 
      oprot.writeListEnd()
14640 
      oprot.writeFieldEnd()
14641 
    oprot.writeFieldStop()
14642 
    oprot.writeStructEnd()
14643 
 
14644 
  def validate(self):
14645 
    return
14646 
 
14647 
 
14648 
  def __repr__(self):
14649 
    L = ['%s=%r' % (key, value)
14650 
      for key, value in self.__dict__.iteritems()]
14651 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14652 
 
14653 
  def __eq__(self, other):
14654 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14655 
 
14656 
  def __ne__(self, other):
14657 
    return not (self == other)
14658 
 
14659 
class updateFlipkartStockAtEOD_result:
14660 
 
14661 
  thrift_spec = (
14662 
  )
14663 
 
14664 
  def read(self, iprot):
14665 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14666 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14667 
      return
14668 
    iprot.readStructBegin()
14669 
    while True:
14670 
      (fname, ftype, fid) = iprot.readFieldBegin()
14671 
      if ftype == TType.STOP:
14672 
        break
14673 
      else:
14674 
        iprot.skip(ftype)
14675 
      iprot.readFieldEnd()
14676 
    iprot.readStructEnd()
14677 
 
14678 
  def write(self, oprot):
14679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14681 
      return
14682 
    oprot.writeStructBegin('updateFlipkartStockAtEOD_result')
14683 
    oprot.writeFieldStop()
14684 
    oprot.writeStructEnd()
14685 
 
14686 
  def validate(self):
14687 
    return
14688 
 
14689 
 
14690 
  def __repr__(self):
14691 
    L = ['%s=%r' % (key, value)
14692 
      for key, value in self.__dict__.iteritems()]
14693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14694 
 
14695 
  def __eq__(self, other):
14696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14697 
 
14698 
  def __ne__(self, other):
14699 
    return not (self == other)
12363 kshitij.so 14700 
 
14701 
class getWanNlcForSource_args:
14702 
  """
14703 
  Attributes:
14704 
   - item_id
14705 
   - source
14706 
  """
14707 
 
14708 
  thrift_spec = (
14709 
    None, # 0
14710 
    (1, TType.I64, 'item_id', None, None, ), # 1
14711 
    (2, TType.I64, 'source', None, None, ), # 2
14712 
  )
14713 
 
14714 
  def __init__(self, item_id=None, source=None,):
14715 
    self.item_id = item_id
14716 
    self.source = source
14717 
 
14718 
  def read(self, iprot):
14719 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14720 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14721 
      return
14722 
    iprot.readStructBegin()
14723 
    while True:
14724 
      (fname, ftype, fid) = iprot.readFieldBegin()
14725 
      if ftype == TType.STOP:
14726 
        break
14727 
      if fid == 1:
14728 
        if ftype == TType.I64:
14729 
          self.item_id = iprot.readI64();
14730 
        else:
14731 
          iprot.skip(ftype)
14732 
      elif fid == 2:
14733 
        if ftype == TType.I64:
14734 
          self.source = iprot.readI64();
14735 
        else:
14736 
          iprot.skip(ftype)
14737 
      else:
14738 
        iprot.skip(ftype)
14739 
      iprot.readFieldEnd()
14740 
    iprot.readStructEnd()
14741 
 
14742 
  def write(self, oprot):
14743 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14744 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14745 
      return
14746 
    oprot.writeStructBegin('getWanNlcForSource_args')
14747 
    if self.item_id is not None:
14748 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
14749 
      oprot.writeI64(self.item_id)
14750 
      oprot.writeFieldEnd()
14751 
    if self.source is not None:
14752 
      oprot.writeFieldBegin('source', TType.I64, 2)
14753 
      oprot.writeI64(self.source)
14754 
      oprot.writeFieldEnd()
14755 
    oprot.writeFieldStop()
14756 
    oprot.writeStructEnd()
14757 
 
14758 
  def validate(self):
14759 
    return
14760 
 
14761 
 
14762 
  def __repr__(self):
14763 
    L = ['%s=%r' % (key, value)
14764 
      for key, value in self.__dict__.iteritems()]
14765 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14766 
 
14767 
  def __eq__(self, other):
14768 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14769 
 
14770 
  def __ne__(self, other):
14771 
    return not (self == other)
14772 
 
14773 
class getWanNlcForSource_result:
14774 
  """
14775 
  Attributes:
14776 
   - success
14777 
  """
14778 
 
14779 
  thrift_spec = (
14780 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
14781 
  )
14782 
 
14783 
  def __init__(self, success=None,):
14784 
    self.success = success
14785 
 
14786 
  def read(self, iprot):
14787 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14788 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14789 
      return
14790 
    iprot.readStructBegin()
14791 
    while True:
14792 
      (fname, ftype, fid) = iprot.readFieldBegin()
14793 
      if ftype == TType.STOP:
14794 
        break
14795 
      if fid == 0:
14796 
        if ftype == TType.DOUBLE:
14797 
          self.success = iprot.readDouble();
14798 
        else:
14799 
          iprot.skip(ftype)
14800 
      else:
14801 
        iprot.skip(ftype)
14802 
      iprot.readFieldEnd()
14803 
    iprot.readStructEnd()
14804 
 
14805 
  def write(self, oprot):
14806 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14807 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14808 
      return
14809 
    oprot.writeStructBegin('getWanNlcForSource_result')
14810 
    if self.success is not None:
14811 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
14812 
      oprot.writeDouble(self.success)
14813 
      oprot.writeFieldEnd()
14814 
    oprot.writeFieldStop()
14815 
    oprot.writeStructEnd()
14816 
 
14817 
  def validate(self):
14818 
    return
14819 
 
14820 
 
14821 
  def __repr__(self):
14822 
    L = ['%s=%r' % (key, value)
14823 
      for key, value in self.__dict__.iteritems()]
14824 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14825 
 
14826 
  def __eq__(self, other):
14827 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14828 
 
14829 
  def __ne__(self, other):
14830 
    return not (self == other)
14831 
 
14832 
class getAllAvailableAmazonFbaItemInventory_args:
14833 
 
14834 
  thrift_spec = (
14835 
  )
14836 
 
14837 
  def read(self, iprot):
14838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14840 
      return
14841 
    iprot.readStructBegin()
14842 
    while True:
14843 
      (fname, ftype, fid) = iprot.readFieldBegin()
14844 
      if ftype == TType.STOP:
14845 
        break
14846 
      else:
14847 
        iprot.skip(ftype)
14848 
      iprot.readFieldEnd()
14849 
    iprot.readStructEnd()
14850 
 
14851 
  def write(self, oprot):
14852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14854 
      return
14855 
    oprot.writeStructBegin('getAllAvailableAmazonFbaItemInventory_args')
14856 
    oprot.writeFieldStop()
14857 
    oprot.writeStructEnd()
14858 
 
14859 
  def validate(self):
14860 
    return
14861 
 
14862 
 
14863 
  def __repr__(self):
14864 
    L = ['%s=%r' % (key, value)
14865 
      for key, value in self.__dict__.iteritems()]
14866 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14867 
 
14868 
  def __eq__(self, other):
14869 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14870 
 
14871 
  def __ne__(self, other):
14872 
    return not (self == other)
14873 
 
14874 
class getAllAvailableAmazonFbaItemInventory_result:
14875 
  """
14876 
  Attributes:
14877 
   - success
14878 
  """
14879 
 
14880 
  thrift_spec = (
14881 
    (0, TType.LIST, 'success', (TType.STRUCT,(AmazonFbaInventorySnapshot, AmazonFbaInventorySnapshot.thrift_spec)), None, ), # 0
14882 
  )
14883 
 
14884 
  def __init__(self, success=None,):
14885 
    self.success = success
14886 
 
14887 
  def read(self, iprot):
14888 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14889 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14890 
      return
14891 
    iprot.readStructBegin()
14892 
    while True:
14893 
      (fname, ftype, fid) = iprot.readFieldBegin()
14894 
      if ftype == TType.STOP:
14895 
        break
14896 
      if fid == 0:
14897 
        if ftype == TType.LIST:
14898 
          self.success = []
14899 
          (_etype342, _size339) = iprot.readListBegin()
14900 
          for _i343 in xrange(_size339):
14901 
            _elem344 = AmazonFbaInventorySnapshot()
14902 
            _elem344.read(iprot)
14903 
            self.success.append(_elem344)
14904 
          iprot.readListEnd()
14905 
        else:
14906 
          iprot.skip(ftype)
14907 
      else:
14908 
        iprot.skip(ftype)
14909 
      iprot.readFieldEnd()
14910 
    iprot.readStructEnd()
14911 
 
14912 
  def write(self, oprot):
14913 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14914 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14915 
      return
14916 
    oprot.writeStructBegin('getAllAvailableAmazonFbaItemInventory_result')
14917 
    if self.success is not None:
14918 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14919 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
14920 
      for iter345 in self.success:
14921 
        iter345.write(oprot)
14922 
      oprot.writeListEnd()
14923 
      oprot.writeFieldEnd()
14924 
    oprot.writeFieldStop()
14925 
    oprot.writeStructEnd()
14926 
 
14927 
  def validate(self):
14928 
    return
14929 
 
14930 
 
14931 
  def __repr__(self):
14932 
    L = ['%s=%r' % (key, value)
14933 
      for key, value in self.__dict__.iteritems()]
14934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14935 
 
14936 
  def __eq__(self, other):
14937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14938 
 
14939 
  def __ne__(self, other):
14940 
    return not (self == other)
17990 kshitij.so 14941 
 
14942 
class updateItemAvailabilityForItemIds_args:
14943 
  """
14944 
  Attributes:
14945 
   - itemIds
14946 
  """
14947 
 
14948 
  thrift_spec = (
14949 
    None, # 0
14950 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
14951 
  )
14952 
 
14953 
  def __init__(self, itemIds=None,):
14954 
    self.itemIds = itemIds
14955 
 
14956 
  def read(self, iprot):
14957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14959 
      return
14960 
    iprot.readStructBegin()
14961 
    while True:
14962 
      (fname, ftype, fid) = iprot.readFieldBegin()
14963 
      if ftype == TType.STOP:
14964 
        break
14965 
      if fid == 1:
14966 
        if ftype == TType.LIST:
14967 
          self.itemIds = []
14968 
          (_etype349, _size346) = iprot.readListBegin()
14969 
          for _i350 in xrange(_size346):
14970 
            _elem351 = iprot.readI64();
14971 
            self.itemIds.append(_elem351)
14972 
          iprot.readListEnd()
14973 
        else:
14974 
          iprot.skip(ftype)
14975 
      else:
14976 
        iprot.skip(ftype)
14977 
      iprot.readFieldEnd()
14978 
    iprot.readStructEnd()
14979 
 
14980 
  def write(self, oprot):
14981 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14982 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14983 
      return
14984 
    oprot.writeStructBegin('updateItemAvailabilityForItemIds_args')
14985 
    if self.itemIds is not None:
14986 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
14987 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
14988 
      for iter352 in self.itemIds:
14989 
        oprot.writeI64(iter352)
14990 
      oprot.writeListEnd()
14991 
      oprot.writeFieldEnd()
14992 
    oprot.writeFieldStop()
14993 
    oprot.writeStructEnd()
14994 
 
14995 
  def validate(self):
14996 
    return
14997 
 
14998 
 
14999 
  def __repr__(self):
15000 
    L = ['%s=%r' % (key, value)
15001 
      for key, value in self.__dict__.iteritems()]
15002 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15003 
 
15004 
  def __eq__(self, other):
15005 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15006 
 
15007 
  def __ne__(self, other):
15008 
    return not (self == other)
15009 
 
15010 
class updateItemAvailabilityForItemIds_result:
15011 
  """
15012 
  Attributes:
15013 
   - success
15014 
  """
15015 
 
15016 
  thrift_spec = (
15017 
    (0, TType.BOOL, 'success', None, None, ), # 0
15018 
  )
15019 
 
15020 
  def __init__(self, success=None,):
15021 
    self.success = success
15022 
 
15023 
  def read(self, iprot):
15024 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15025 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15026 
      return
15027 
    iprot.readStructBegin()
15028 
    while True:
15029 
      (fname, ftype, fid) = iprot.readFieldBegin()
15030 
      if ftype == TType.STOP:
15031 
        break
15032 
      if fid == 0:
15033 
        if ftype == TType.BOOL:
15034 
          self.success = iprot.readBool();
15035 
        else:
15036 
          iprot.skip(ftype)
15037 
      else:
15038 
        iprot.skip(ftype)
15039 
      iprot.readFieldEnd()
15040 
    iprot.readStructEnd()
15041 
 
15042 
  def write(self, oprot):
15043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15045 
      return
15046 
    oprot.writeStructBegin('updateItemAvailabilityForItemIds_result')
15047 
    if self.success is not None:
15048 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15049 
      oprot.writeBool(self.success)
15050 
      oprot.writeFieldEnd()
15051 
    oprot.writeFieldStop()
15052 
    oprot.writeStructEnd()
15053 
 
15054 
  def validate(self):
15055 
    return
15056 
 
15057 
 
15058 
  def __repr__(self):
15059 
    L = ['%s=%r' % (key, value)
15060 
      for key, value in self.__dict__.iteritems()]
15061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15062 
 
15063 
  def __eq__(self, other):
15064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15065 
 
15066 
  def __ne__(self, other):
15067 
    return not (self == other)
19247 kshitij.so 15068 
 
15069 
class addVendorItemPricingInBulk_args:
15070 
  """
15071 
  Attributes:
15072 
   - vendorItemPricingList
15073 
  """
15074 
 
15075 
  thrift_spec = (
15076 
    None, # 0
15077 
    (1, TType.LIST, 'vendorItemPricingList', (TType.STRUCT,(VendorItemPricing, VendorItemPricing.thrift_spec)), None, ), # 1
15078 
  )
15079 
 
15080 
  def __init__(self, vendorItemPricingList=None,):
15081 
    self.vendorItemPricingList = vendorItemPricingList
15082 
 
15083 
  def read(self, iprot):
15084 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15085 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15086 
      return
15087 
    iprot.readStructBegin()
15088 
    while True:
15089 
      (fname, ftype, fid) = iprot.readFieldBegin()
15090 
      if ftype == TType.STOP:
15091 
        break
15092 
      if fid == 1:
15093 
        if ftype == TType.LIST:
15094 
          self.vendorItemPricingList = []
15095 
          (_etype356, _size353) = iprot.readListBegin()
15096 
          for _i357 in xrange(_size353):
15097 
            _elem358 = VendorItemPricing()
15098 
            _elem358.read(iprot)
15099 
            self.vendorItemPricingList.append(_elem358)
15100 
          iprot.readListEnd()
15101 
        else:
15102 
          iprot.skip(ftype)
15103 
      else:
15104 
        iprot.skip(ftype)
15105 
      iprot.readFieldEnd()
15106 
    iprot.readStructEnd()
15107 
 
15108 
  def write(self, oprot):
15109 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15110 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15111 
      return
15112 
    oprot.writeStructBegin('addVendorItemPricingInBulk_args')
15113 
    if self.vendorItemPricingList is not None:
15114 
      oprot.writeFieldBegin('vendorItemPricingList', TType.LIST, 1)
15115 
      oprot.writeListBegin(TType.STRUCT, len(self.vendorItemPricingList))
15116 
      for iter359 in self.vendorItemPricingList:
15117 
        iter359.write(oprot)
15118 
      oprot.writeListEnd()
15119 
      oprot.writeFieldEnd()
15120 
    oprot.writeFieldStop()
15121 
    oprot.writeStructEnd()
15122 
 
15123 
  def validate(self):
15124 
    return
15125 
 
15126 
 
15127 
  def __repr__(self):
15128 
    L = ['%s=%r' % (key, value)
15129 
      for key, value in self.__dict__.iteritems()]
15130 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15131 
 
15132 
  def __eq__(self, other):
15133 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15134 
 
15135 
  def __ne__(self, other):
15136 
    return not (self == other)
15137 
 
15138 
class addVendorItemPricingInBulk_result:
15139 
  """
15140 
  Attributes:
15141 
   - success
15142 
  """
15143 
 
15144 
  thrift_spec = (
15145 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
15146 
  )
15147 
 
15148 
  def __init__(self, success=None,):
15149 
    self.success = success
15150 
 
15151 
  def read(self, iprot):
15152 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15153 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15154 
      return
15155 
    iprot.readStructBegin()
15156 
    while True:
15157 
      (fname, ftype, fid) = iprot.readFieldBegin()
15158 
      if ftype == TType.STOP:
15159 
        break
15160 
      if fid == 0:
15161 
        if ftype == TType.LIST:
15162 
          self.success = []
15163 
          (_etype363, _size360) = iprot.readListBegin()
15164 
          for _i364 in xrange(_size360):
15165 
            _elem365 = iprot.readI64();
15166 
            self.success.append(_elem365)
15167 
          iprot.readListEnd()
15168 
        else:
15169 
          iprot.skip(ftype)
15170 
      else:
15171 
        iprot.skip(ftype)
15172 
      iprot.readFieldEnd()
15173 
    iprot.readStructEnd()
15174 
 
15175 
  def write(self, oprot):
15176 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15177 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15178 
      return
15179 
    oprot.writeStructBegin('addVendorItemPricingInBulk_result')
15180 
    if self.success is not None:
15181 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15182 
      oprot.writeListBegin(TType.I64, len(self.success))
15183 
      for iter366 in self.success:
15184 
        oprot.writeI64(iter366)
15185 
      oprot.writeListEnd()
15186 
      oprot.writeFieldEnd()
15187 
    oprot.writeFieldStop()
15188 
    oprot.writeStructEnd()
15189 
 
15190 
  def validate(self):
15191 
    return
15192 
 
15193 
 
15194 
  def __repr__(self):
15195 
    L = ['%s=%r' % (key, value)
15196 
      for key, value in self.__dict__.iteritems()]
15197 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15198 
 
15199 
  def __eq__(self, other):
15200 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15201 
 
15202 
  def __ne__(self, other):
15203 
    return not (self == other)
15204 
 
15205 
class addInventoryInBulk_args:
15206 
  """
15207 
  Attributes:
15208 
   - bulkInventoryList
15209 
  """
15210 
 
15211 
  thrift_spec = (
15212 
    None, # 0
15213 
    (1, TType.LIST, 'bulkInventoryList', (TType.STRUCT,(BulkAddInventory, BulkAddInventory.thrift_spec)), None, ), # 1
15214 
  )
15215 
 
15216 
  def __init__(self, bulkInventoryList=None,):
15217 
    self.bulkInventoryList = bulkInventoryList
15218 
 
15219 
  def read(self, iprot):
15220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15222 
      return
15223 
    iprot.readStructBegin()
15224 
    while True:
15225 
      (fname, ftype, fid) = iprot.readFieldBegin()
15226 
      if ftype == TType.STOP:
15227 
        break
15228 
      if fid == 1:
15229 
        if ftype == TType.LIST:
15230 
          self.bulkInventoryList = []
15231 
          (_etype370, _size367) = iprot.readListBegin()
15232 
          for _i371 in xrange(_size367):
15233 
            _elem372 = BulkAddInventory()
15234 
            _elem372.read(iprot)
15235 
            self.bulkInventoryList.append(_elem372)
15236 
          iprot.readListEnd()
15237 
        else:
15238 
          iprot.skip(ftype)
15239 
      else:
15240 
        iprot.skip(ftype)
15241 
      iprot.readFieldEnd()
15242 
    iprot.readStructEnd()
15243 
 
15244 
  def write(self, oprot):
15245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15247 
      return
15248 
    oprot.writeStructBegin('addInventoryInBulk_args')
15249 
    if self.bulkInventoryList is not None:
15250 
      oprot.writeFieldBegin('bulkInventoryList', TType.LIST, 1)
15251 
      oprot.writeListBegin(TType.STRUCT, len(self.bulkInventoryList))
15252 
      for iter373 in self.bulkInventoryList:
15253 
        iter373.write(oprot)
15254 
      oprot.writeListEnd()
15255 
      oprot.writeFieldEnd()
15256 
    oprot.writeFieldStop()
15257 
    oprot.writeStructEnd()
15258 
 
15259 
  def validate(self):
15260 
    return
15261 
 
15262 
 
15263 
  def __repr__(self):
15264 
    L = ['%s=%r' % (key, value)
15265 
      for key, value in self.__dict__.iteritems()]
15266 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15267 
 
15268 
  def __eq__(self, other):
15269 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15270 
 
15271 
  def __ne__(self, other):
15272 
    return not (self == other)
15273 
 
15274 
class addInventoryInBulk_result:
15275 
  """
15276 
  Attributes:
15277 
   - cex
15278 
  """
15279 
 
15280 
  thrift_spec = (
15281 
    None, # 0
15282 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
15283 
  )
15284 
 
15285 
  def __init__(self, cex=None,):
15286 
    self.cex = cex
15287 
 
15288 
  def read(self, iprot):
15289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15291 
      return
15292 
    iprot.readStructBegin()
15293 
    while True:
15294 
      (fname, ftype, fid) = iprot.readFieldBegin()
15295 
      if ftype == TType.STOP:
15296 
        break
15297 
      if fid == 1:
15298 
        if ftype == TType.STRUCT:
15299 
          self.cex = InventoryServiceException()
15300 
          self.cex.read(iprot)
15301 
        else:
15302 
          iprot.skip(ftype)
15303 
      else:
15304 
        iprot.skip(ftype)
15305 
      iprot.readFieldEnd()
15306 
    iprot.readStructEnd()
15307 
 
15308 
  def write(self, oprot):
15309 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15310 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15311 
      return
15312 
    oprot.writeStructBegin('addInventoryInBulk_result')
15313 
    if self.cex is not None:
15314 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15315 
      self.cex.write(oprot)
15316 
      oprot.writeFieldEnd()
15317 
    oprot.writeFieldStop()
15318 
    oprot.writeStructEnd()
15319 
 
15320 
  def validate(self):
15321 
    return
15322 
 
15323 
 
15324 
  def __repr__(self):
15325 
    L = ['%s=%r' % (key, value)
15326 
      for key, value in self.__dict__.iteritems()]
15327 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15328 
 
15329 
  def __eq__(self, other):
15330 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15331 
 
15332 
  def __ne__(self, other):
15333 
    return not (self == other)
19413 amit.gupta 15334 
 
15335 
class getItemLocationAvailabilityCache_args:
15336 
  """
15337 
  Attributes:
15338 
   - itemLocations
15339 
  """
15340 
 
15341 
  thrift_spec = (
15342 
    None, # 0
15343 
    (1, TType.LIST, 'itemLocations', (TType.STRUCT,(ItemLocationAvailability, ItemLocationAvailability.thrift_spec)), None, ), # 1
15344 
  )
15345 
 
15346 
  def __init__(self, itemLocations=None,):
15347 
    self.itemLocations = itemLocations
15348 
 
15349 
  def read(self, iprot):
15350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15352 
      return
15353 
    iprot.readStructBegin()
15354 
    while True:
15355 
      (fname, ftype, fid) = iprot.readFieldBegin()
15356 
      if ftype == TType.STOP:
15357 
        break
15358 
      if fid == 1:
15359 
        if ftype == TType.LIST:
15360 
          self.itemLocations = []
15361 
          (_etype377, _size374) = iprot.readListBegin()
15362 
          for _i378 in xrange(_size374):
15363 
            _elem379 = ItemLocationAvailability()
15364 
            _elem379.read(iprot)
15365 
            self.itemLocations.append(_elem379)
15366 
          iprot.readListEnd()
15367 
        else:
15368 
          iprot.skip(ftype)
15369 
      else:
15370 
        iprot.skip(ftype)
15371 
      iprot.readFieldEnd()
15372 
    iprot.readStructEnd()
15373 
 
15374 
  def write(self, oprot):
15375 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15376 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15377 
      return
15378 
    oprot.writeStructBegin('getItemLocationAvailabilityCache_args')
15379 
    if self.itemLocations is not None:
15380 
      oprot.writeFieldBegin('itemLocations', TType.LIST, 1)
15381 
      oprot.writeListBegin(TType.STRUCT, len(self.itemLocations))
15382 
      for iter380 in self.itemLocations:
15383 
        iter380.write(oprot)
15384 
      oprot.writeListEnd()
15385 
      oprot.writeFieldEnd()
15386 
    oprot.writeFieldStop()
15387 
    oprot.writeStructEnd()
15388 
 
15389 
  def validate(self):
15390 
    return
15391 
 
15392 
 
15393 
  def __repr__(self):
15394 
    L = ['%s=%r' % (key, value)
15395 
      for key, value in self.__dict__.iteritems()]
15396 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15397 
 
15398 
  def __eq__(self, other):
15399 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15400 
 
15401 
  def __ne__(self, other):
15402 
    return not (self == other)
15403 
 
15404 
class getItemLocationAvailabilityCache_result:
15405 
  """
15406 
  Attributes:
15407 
   - success
15408 
  """
15409 
 
15410 
  thrift_spec = (
15411 
    (0, TType.LIST, 'success', (TType.STRUCT,(ItemLocationAvailability, ItemLocationAvailability.thrift_spec)), None, ), # 0
15412 
  )
15413 
 
15414 
  def __init__(self, success=None,):
15415 
    self.success = success
15416 
 
15417 
  def read(self, iprot):
15418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15420 
      return
15421 
    iprot.readStructBegin()
15422 
    while True:
15423 
      (fname, ftype, fid) = iprot.readFieldBegin()
15424 
      if ftype == TType.STOP:
15425 
        break
15426 
      if fid == 0:
15427 
        if ftype == TType.LIST:
15428 
          self.success = []
15429 
          (_etype384, _size381) = iprot.readListBegin()
15430 
          for _i385 in xrange(_size381):
15431 
            _elem386 = ItemLocationAvailability()
15432 
            _elem386.read(iprot)
15433 
            self.success.append(_elem386)
15434 
          iprot.readListEnd()
15435 
        else:
15436 
          iprot.skip(ftype)
15437 
      else:
15438 
        iprot.skip(ftype)
15439 
      iprot.readFieldEnd()
15440 
    iprot.readStructEnd()
15441 
 
15442 
  def write(self, oprot):
15443 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15444 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15445 
      return
15446 
    oprot.writeStructBegin('getItemLocationAvailabilityCache_result')
15447 
    if self.success is not None:
15448 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15449 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
15450 
      for iter387 in self.success:
15451 
        iter387.write(oprot)
15452 
      oprot.writeListEnd()
15453 
      oprot.writeFieldEnd()
15454 
    oprot.writeFieldStop()
15455 
    oprot.writeStructEnd()
15456 
 
15457 
  def validate(self):
15458 
    return
15459 
 
15460 
 
15461 
  def __repr__(self):
15462 
    L = ['%s=%r' % (key, value)
15463 
      for key, value in self.__dict__.iteritems()]
15464 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15465 
 
15466 
  def __eq__(self, other):
15467 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15468 
 
15469 
  def __ne__(self, other):
15470 
    return not (self == other)
15471 
 
15472 
class getItemLocationAvailabilityCacheByItemId_args:
15473 
  """
15474 
  Attributes:
15475 
   - itemIds
15476 
  """
15477 
 
15478 
  thrift_spec = (
15479 
    None, # 0
15480 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
15481 
  )
15482 
 
15483 
  def __init__(self, itemIds=None,):
15484 
    self.itemIds = itemIds
15485 
 
15486 
  def read(self, iprot):
15487 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15488 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15489 
      return
15490 
    iprot.readStructBegin()
15491 
    while True:
15492 
      (fname, ftype, fid) = iprot.readFieldBegin()
15493 
      if ftype == TType.STOP:
15494 
        break
15495 
      if fid == 1:
15496 
        if ftype == TType.LIST:
15497 
          self.itemIds = []
15498 
          (_etype391, _size388) = iprot.readListBegin()
15499 
          for _i392 in xrange(_size388):
15500 
            _elem393 = iprot.readI64();
15501 
            self.itemIds.append(_elem393)
15502 
          iprot.readListEnd()
15503 
        else:
15504 
          iprot.skip(ftype)
15505 
      else:
15506 
        iprot.skip(ftype)
15507 
      iprot.readFieldEnd()
15508 
    iprot.readStructEnd()
15509 
 
15510 
  def write(self, oprot):
15511 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15512 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15513 
      return
15514 
    oprot.writeStructBegin('getItemLocationAvailabilityCacheByItemId_args')
15515 
    if self.itemIds is not None:
15516 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
15517 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
15518 
      for iter394 in self.itemIds:
15519 
        oprot.writeI64(iter394)
15520 
      oprot.writeListEnd()
15521 
      oprot.writeFieldEnd()
15522 
    oprot.writeFieldStop()
15523 
    oprot.writeStructEnd()
15524 
 
15525 
  def validate(self):
15526 
    return
15527 
 
15528 
 
15529 
  def __repr__(self):
15530 
    L = ['%s=%r' % (key, value)
15531 
      for key, value in self.__dict__.iteritems()]
15532 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15533 
 
15534 
  def __eq__(self, other):
15535 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15536 
 
15537 
  def __ne__(self, other):
15538 
    return not (self == other)
15539 
 
15540 
class getItemLocationAvailabilityCacheByItemId_result:
15541 
  """
15542 
  Attributes:
15543 
   - success
15544 
  """
15545 
 
15546 
  thrift_spec = (
15547 
    (0, TType.LIST, 'success', (TType.STRUCT,(ItemLocationAvailability, ItemLocationAvailability.thrift_spec)), None, ), # 0
15548 
  )
15549 
 
15550 
  def __init__(self, success=None,):
15551 
    self.success = success
15552 
 
15553 
  def read(self, iprot):
15554 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15555 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15556 
      return
15557 
    iprot.readStructBegin()
15558 
    while True:
15559 
      (fname, ftype, fid) = iprot.readFieldBegin()
15560 
      if ftype == TType.STOP:
15561 
        break
15562 
      if fid == 0:
15563 
        if ftype == TType.LIST:
15564 
          self.success = []
15565 
          (_etype398, _size395) = iprot.readListBegin()
15566 
          for _i399 in xrange(_size395):
15567 
            _elem400 = ItemLocationAvailability()
15568 
            _elem400.read(iprot)
15569 
            self.success.append(_elem400)
15570 
          iprot.readListEnd()
15571 
        else:
15572 
          iprot.skip(ftype)
15573 
      else:
15574 
        iprot.skip(ftype)
15575 
      iprot.readFieldEnd()
15576 
    iprot.readStructEnd()
15577 
 
15578 
  def write(self, oprot):
15579 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15580 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15581 
      return
15582 
    oprot.writeStructBegin('getItemLocationAvailabilityCacheByItemId_result')
15583 
    if self.success is not None:
15584 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15585 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
15586 
      for iter401 in self.success:
15587 
        iter401.write(oprot)
15588 
      oprot.writeListEnd()
15589 
      oprot.writeFieldEnd()
15590 
    oprot.writeFieldStop()
15591 
    oprot.writeStructEnd()
15592 
 
15593 
  def validate(self):
15594 
    return
15595 
 
15596 
 
15597 
  def __repr__(self):
15598 
    L = ['%s=%r' % (key, value)
15599 
      for key, value in self.__dict__.iteritems()]
15600 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15601 
 
15602 
  def __eq__(self, other):
15603 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15604 
 
15605 
  def __ne__(self, other):
15606 
    return not (self == other)
15607 
 
15608 
class getItemPincodeAvailability_args:
15609 
  """
15610 
  Attributes:
19416 amit.gupta 15611 
   - itempricing
19413 amit.gupta 15612 
   - pincode
15613 
  """
15614 
 
15615 
  thrift_spec = (
15616 
    None, # 0
19416 amit.gupta 15617 
    (1, TType.MAP, 'itempricing', (TType.I64,None,TType.I64,None), None, ), # 1
19413 amit.gupta 15618 
    (2, TType.STRING, 'pincode', None, None, ), # 2
15619 
  )
15620 
 
19416 amit.gupta 15621 
  def __init__(self, itempricing=None, pincode=None,):
15622 
    self.itempricing = itempricing
19413 amit.gupta 15623 
    self.pincode = pincode
15624 
 
15625 
  def read(self, iprot):
15626 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15627 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15628 
      return
15629 
    iprot.readStructBegin()
15630 
    while True:
15631 
      (fname, ftype, fid) = iprot.readFieldBegin()
15632 
      if ftype == TType.STOP:
15633 
        break
15634 
      if fid == 1:
19416 amit.gupta 15635 
        if ftype == TType.MAP:
15636 
          self.itempricing = {}
15637 
          (_ktype403, _vtype404, _size402 ) = iprot.readMapBegin()
19413 amit.gupta 15638 
          for _i406 in xrange(_size402):
19416 amit.gupta 15639 
            _key407 = iprot.readI64();
15640 
            _val408 = iprot.readI64();
15641 
            self.itempricing[_key407] = _val408
15642 
          iprot.readMapEnd()
19413 amit.gupta 15643 
        else:
15644 
          iprot.skip(ftype)
15645 
      elif fid == 2:
15646 
        if ftype == TType.STRING:
15647 
          self.pincode = iprot.readString();
15648 
        else:
15649 
          iprot.skip(ftype)
15650 
      else:
15651 
        iprot.skip(ftype)
15652 
      iprot.readFieldEnd()
15653 
    iprot.readStructEnd()
15654 
 
15655 
  def write(self, oprot):
15656 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15657 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15658 
      return
15659 
    oprot.writeStructBegin('getItemPincodeAvailability_args')
19416 amit.gupta 15660 
    if self.itempricing is not None:
15661 
      oprot.writeFieldBegin('itempricing', TType.MAP, 1)
15662 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.itempricing))
15663 
      for kiter409,viter410 in self.itempricing.items():
15664 
        oprot.writeI64(kiter409)
15665 
        oprot.writeI64(viter410)
15666 
      oprot.writeMapEnd()
19413 amit.gupta 15667 
      oprot.writeFieldEnd()
15668 
    if self.pincode is not None:
15669 
      oprot.writeFieldBegin('pincode', TType.STRING, 2)
15670 
      oprot.writeString(self.pincode)
15671 
      oprot.writeFieldEnd()
15672 
    oprot.writeFieldStop()
15673 
    oprot.writeStructEnd()
15674 
 
15675 
  def validate(self):
15676 
    return
15677 
 
15678 
 
15679 
  def __repr__(self):
15680 
    L = ['%s=%r' % (key, value)
15681 
      for key, value in self.__dict__.iteritems()]
15682 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15683 
 
15684 
  def __eq__(self, other):
15685 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15686 
 
15687 
  def __ne__(self, other):
15688 
    return not (self == other)
15689 
 
15690 
class getItemPincodeAvailability_result:
15691 
  """
15692 
  Attributes:
15693 
   - success
15694 
  """
15695 
 
15696 
  thrift_spec = (
15697 
    (0, TType.STRING, 'success', None, None, ), # 0
15698 
  )
15699 
 
15700 
  def __init__(self, success=None,):
15701 
    self.success = success
15702 
 
15703 
  def read(self, iprot):
15704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15706 
      return
15707 
    iprot.readStructBegin()
15708 
    while True:
15709 
      (fname, ftype, fid) = iprot.readFieldBegin()
15710 
      if ftype == TType.STOP:
15711 
        break
15712 
      if fid == 0:
15713 
        if ftype == TType.STRING:
15714 
          self.success = iprot.readString();
15715 
        else:
15716 
          iprot.skip(ftype)
15717 
      else:
15718 
        iprot.skip(ftype)
15719 
      iprot.readFieldEnd()
15720 
    iprot.readStructEnd()
15721 
 
15722 
  def write(self, oprot):
15723 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15724 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15725 
      return
15726 
    oprot.writeStructBegin('getItemPincodeAvailability_result')
15727 
    if self.success is not None:
15728 
      oprot.writeFieldBegin('success', TType.STRING, 0)
15729 
      oprot.writeString(self.success)
15730 
      oprot.writeFieldEnd()
15731 
    oprot.writeFieldStop()
15732 
    oprot.writeStructEnd()
15733 
 
15734 
  def validate(self):
15735 
    return
15736 
 
15737 
 
15738 
  def __repr__(self):
15739 
    L = ['%s=%r' % (key, value)
15740 
      for key, value in self.__dict__.iteritems()]
15741 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15742 
 
15743 
  def __eq__(self, other):
15744 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15745 
 
15746 
  def __ne__(self, other):
15747 
    return not (self == other)